हीपसॉर्ट

कंप्यूटर विज्ञान में, हीप्सॉर्ट एक तुलनात्मक सॉर्ट|तुलना-आधारित छँटाई एल्गोरिथ्म है। हीप्सॉर्ट को एक बेहतर चयन प्रकार के रूप में सोचा जा सकता है: चयन प्रकार की तरह, हीप्सॉर्ट अपने इनपुट को एक क्रमबद्ध और एक अवर्गीकृत क्षेत्र में विभाजित करता है, और यह इसमें से सबसे बड़े तत्व को निकालकर और इसे क्रमबद्ध क्षेत्र में डालकर अवर्गीकृत क्षेत्र को पुनरावृत्त रूप से छोटा करता है। चयन प्रकार के विपरीत, हीपसॉर्ट अवर्गीकृत क्षेत्र के रैखिक-समय स्कैन के साथ समय बर्बाद नहीं करता है; बल्कि, हीप सॉर्ट प्रत्येक चरण में सबसे बड़े तत्व को अधिक तेज़ी से ढूंढने के लिए हीप (डेटा संरचना) डेटा संरचना में अवर्गीकृत क्षेत्र को बनाए रखता है। हालाँकि अधिकांश मशीनों पर अच्छी तरह से कार्यान्वित जल्दी से सुलझाएं की तुलना में इसका अभ्यास कुछ हद तक धीमा है, लेकिन इसमें अधिक अनुकूल सबसे खराब स्थिति का लाभ है $O(n log n)$ रनटाइम (और इस तरह परिचय द्वारा फ़ॉलबैक के रूप में उपयोग किया जाता है, इससे यह पता चलता है कि क्विकॉर्ट खराब हो रहा है)। हीपसॉर्ट एक इन-प्लेस एल्गोरिदम है, लेकिन यह एक स्थिर सॉर्ट नहीं है।

हीपसॉर्ट का आविष्कार 1964 में जे. डब्ल्यू. जे. विलियम्स द्वारा किया गया था। यह ढेर का जन्म भी था, जिसे विलियम्स ने पहले ही अपने आप में एक उपयोगी डेटा संरचना के रूप में प्रस्तुत किया था। उसी वर्ष, रॉबर्ट डब्ल्यू फ़्लॉइड ने एक उन्नत संस्करण प्रकाशित किया जो वृक्षविन्यास एल्गोरिदम में अपने पहले के शोध को जारी रखते हुए, किसी सरणी को उसी स्थान पर सॉर्ट कर सकता था।

सिंहावलोकन
हीपसॉर्ट एल्गोरिदम को दो भागों में विभाजित किया जा सकता है।

पहले चरण में, डेटा से एक हीप (डेटा संरचना) बनाया जाता है (देखें)। ). ढेर को अक्सर एक पूर्ण बाइनरी ट्री #बाइनरी ट्री के प्रकार के लेआउट के साथ एक सरणी में रखा जाता है। संपूर्ण बाइनरी ट्री, बाइनरी ट्री संरचना को सरणी सूचकांकों में मैप करता है; प्रत्येक सरणी सूचकांक एक नोड का प्रतिनिधित्व करता है; नोड के मूल, बाईं चाइल्ड शाखा, या दाईं चाइल्ड शाखा का सूचकांक सरल अभिव्यक्ति हैं। शून्य-आधारित सरणी के लिए, रूट नोड को इंडेक्स 0 पर संग्रहीत किया जाता है; अगर  तो, वर्तमान नोड का सूचकांक है   iParent(i) = फ़्लोर((i-1) / 2) जहां फ़्लोर फ़ंक्शन एक वास्तविक संख्या को सबसे बड़े अग्रणी पूर्णांक में मैप करता है।  iLeftChild(i) = 2*i + 1  iRightChild(i) = 2*i + 2 

दूसरे चरण में, ढेर (ढेर की जड़) से सबसे बड़े तत्व को बार-बार हटाकर और उसे सरणी में डालकर एक क्रमबद्ध सरणी बनाई जाती है। ढेर की संपत्ति को बनाए रखने के लिए प्रत्येक निष्कासन के बाद ढेर को अद्यतन किया जाता है। एक बार जब सभी ऑब्जेक्ट ढेर से हटा दिए जाते हैं, तो परिणाम एक क्रमबद्ध सरणी होता है।

हीपसॉर्ट को जगह पर ही निष्पादित किया जा सकता है। सरणी को दो भागों में विभाजित किया जा सकता है, क्रमबद्ध सरणी और ढेर। सरणियों के रूप में ढेरों का भंडारण बाइनरी हीप#हीप कार्यान्वयन का आरेख है। प्रत्येक निष्कर्षण के बाद ढेर के अपरिवर्तनीय को संरक्षित किया जाता है, इसलिए एकमात्र लागत निष्कर्षण की होती है।

एल्गोरिथम
हीपसॉर्ट एल्गोरिदम में सूची को पहले बाइनरी ढेर  में बदलकर तैयार करना शामिल है। फिर एल्गोरिदम बार-बार सूची के पहले मान को अंतिम मान के साथ स्वैप करता है, ढेर ऑपरेशन में विचार किए गए मानों की सीमा को एक से कम करता है, और नए पहले मान को ढेर में उसकी स्थिति में स्थानांतरित करता है। यह तब तक दोहराया जाता है जब तक कि माने गए मानों की सीमा लंबाई में एक मान न हो जाए।

चरण हैं:
 * 1) बुलाएं buildMaxHeap सूची पर कार्य करें। के रूप में भी जाना जाता है heapify, यह एक सूची से एक ढेर बनाता है $O(n)$ संचालन.
 * 2) सूची के पहले तत्व को अंतिम तत्व से बदलें। सूची की सुविचारित सीमा को एक से कम करें।
 * 3) बुलाएं siftDown नए पहले तत्व को ढेर में उसके उपयुक्त सूचकांक में स्थानांतरित करने के लिए सूची पर कार्य करें।
 * 4) चरण (2) पर जाएं जब तक कि सूची की मानी गई सीमा एक तत्व न हो। वह buildMaxHeap ऑपरेशन एक बार चलाया जाता है, और है $O(n)$ प्रदर्शन में. वह siftDown फ़ंक्शन है $O(log n)$, और कहा जाता है $n$ बार. इसलिए, इस एल्गोरिदम का प्रदर्शन है $O(n + n log n) = O(n log n)$.

छद्मकोड
स्यूडोकोड में एल्गोरिदम को लागू करने का एक सरल तरीका निम्नलिखित है। ऐरे प्रोग्रामिंग भाषाओं (सरणी) की तुलना हैं|शून्य-आधारित और  सरणी के दो तत्वों का आदान-प्रदान करने के लिए उपयोग किया जाता है। 'नीचे' गति का अर्थ है जड़ से पत्तियों की ओर, या निम्न सूचकांक से उच्चतर की ओर। ध्यान दें कि सॉर्ट के दौरान, सबसे बड़ा तत्व ढेर के मूल में होता है , जबकि सॉर्ट के अंत में, सबसे बड़ा तत्व अंदर है.

प्रक्रिया heapsort(a, count) है इनपुट: एक अव्यवस्थित सरणी a लंबाई गिनती (सरणी ए में ढेर बनाएं ताकि सबसे बड़ा मान मूल पर हो) ढेर लगाना(ए, गिनती) (निम्नलिखित लूप लूप अपरिवर्तनीय को बनाए रखता है कि a[0:end] एक ढेर है और प्रत्येक तत्व     अंत से परे अपने से पहले की हर चीज़ से बड़ा है (इसलिए एक[अंत:गिनती] क्रमबद्ध क्रम में है)) अंत ← गिनती - 1 जबकि अंत > 0 करें (a[0] मूल और सबसे बड़ा मान है। स्वैप इसे क्रमबद्ध तत्वों के सामने ले जाता है।) स्वैप (ए[अंत], ए[0]) (ढेर का आकार एक से कम हो गया है) अंत ← अंत - 1 (स्वैप ने ढेर संपत्ति को बर्बाद कर दिया, इसलिए इसे पुनर्स्थापित करें) सिफ्टडाउन(ए, 0, अंत)

सॉर्टिंग रूटीन दो सबरूटीन्स का उपयोग करता है,  और. पहला सामान्य इन-प्लेस हीप निर्माण रूटीन है, जबकि दूसरा कार्यान्वयन के लिए एक सामान्य सबरूटीन है. ('ए' के ​​तत्वों को यथास्थान ढेर क्रम में रखें) 'प्रक्रिया' ढेर लगाना(ए, गिनती) 'है' (प्रारंभ को अंतिम मूल नोड के 'ए' में सूचकांक सौंपा गया है) (0-आधारित सरणी में अंतिम तत्व सूचकांक गिनती-1 पर है; उस तत्व का मूल तत्व ढूंढें) प्रारंभ ← iParent(गिनती-1) 'जबकि' प्रारंभ ≥ 0 'करें' (सूचकांक 'प्रारंभ' पर नोड को उचित स्थान पर इस प्रकार छान लें कि सभी नोड नीचे हों         प्रारंभ सूचकांक ढेर क्रम में हैं) सिफ्टडाउन(ए, प्रारंभ, गिनती - 1) (अगले मूल नोड पर जाएँ) प्रारंभ ← प्रारंभ - 1 (रूट को छानने के बाद सभी नोड्स/तत्व ढेर क्रम में हैं) (उस ढेर की मरम्मत करें जिसका मूल तत्व सूचकांक 'प्रारंभ' पर है, यह मानते हुए कि उसके बच्चों पर निहित ढेर वैध हैं) 'प्रक्रिया' सिफ्टडाउन(ए, प्रारंभ, अंत) 'है' जड़ ← प्रारंभ 'जबकि' iLeftChild(root) ≤ अंत 'do' (जबकि रूट में कम से कम एक बच्चा है) बच्चा ← iLeftChild(root) (रूट का बायां बच्चा) स्वैप ← रूट (स्वैप करने के लिए बच्चे का ट्रैक रखता है) 'अगर' एक[स्वैप] <ए[बच्चा] 'तो' अदला-बदली ← बच्चा (यदि कोई सही बच्चा है और वह बच्चा बड़ा है) 'यदि' बच्चा+1 ≤ अंत 'और' ए[स्वैप] < ए[बच्चा+1] 'तब' स्वैप ← बच्चा + 1 'अगर' स्वैप = रूट 'तब' (मूल में सबसे बड़ा तत्व होता है। चूँकि हम मान लेते हैं कि मूल में ढेर हैं             बच्चे वैध हैं, इसका मतलब है कि हमारा काम हो गया।) 'वापस करना' 'अन्य' स्वैप(ए[रूट], ए[स्वैप]) रूट ← स्वैप (अब बच्चे को छानना जारी रखने के लिए दोहराएँ)  ई> प्रक्रिया को ढेर (डेटा संरचना) स्थापित करने के लिए क्रमिक रूप से नीचे की ओर छानकर नीचे से ऊपर तक ढेर बनाने के रूप में सोचा जा सकता है। एक वैकल्पिक संस्करण (नीचे दिखाया गया है) जो ढेर को ऊपर से नीचे बनाता है और ऊपर की ओर छानता है, समझने में आसान हो सकता है। यह   संस्करण को एक खाली ढेर से शुरू करने और क्रमिक रूप से तत्वों को सम्मिलित करने के रूप में देखा जा सकता है, जबकि   ऊपर दिया गया संस्करण संपूर्ण इनपुट सरणी को पूर्ण लेकिन टूटे हुए ढेर के रूप में मानता है और अंतिम गैर-तुच्छ उप-ढेर (यानी, अंतिम मूल नोड) से शुरू करके इसकी मरम्मत करता है।

यह भी  heapify बाइनरी हीप का संस्करण#एक ढेर बनाना|है $O(n)$ समय जटिलता, जबकि   नीचे दिया गया संस्करण है $O(n log n)$ प्रत्येक तत्व को एक समय में एक खाली ढेर में डालने के साथ इसकी समानता के कारण समय की जटिलता। यह प्रति-सहज ज्ञान युक्त प्रतीत हो सकता है क्योंकि, एक नज़र में, यह स्पष्ट है कि पूर्व अपने लॉगरिदमिक-टाइम सिफ्टिंग फ़ंक्शन में बाद वाले की तुलना में केवल आधी कॉल करता है; यानी, वे केवल एक स्थिर कारक से भिन्न प्रतीत होते हैं, जो कभी भी स्पर्शोन्मुख विश्लेषण को प्रभावित नहीं करता है।

जटिलता में इस अंतर के पीछे के अंतर्ज्ञान को समझने के लिए, किसी एक के दौरान होने वाले स्वैप की संख्या पर ध्यान दें siftUp कॉल उस नोड की गहराई के साथ बढ़ती है जिस पर कॉल की जाती है। मूल बात यह है कि एक ढेर में उथले नोड्स की तुलना में कई (तेजी से कई) अधिक गहरे नोड होते हैं, ताकि नीचे या उसके पास नोड्स पर किए गए कॉल की लगभग रैखिक संख्या पर siftUp का पूर्ण लॉगरिदमिक रनिंग-टाइम हो सके ढेर का. दूसरी ओर, किसी एक सिफ्टडाउन कॉल के दौरान होने वाले स्वैप की संख्या घट जाती है क्योंकि जिस नोड पर कॉल की जाती है उसकी गहराई बढ़ जाती है। इस प्रकार, जब    प्रारंभ होता है और कॉल कर रहा है   नीचे और सबसे असंख्य नोड-परतों पर, प्रत्येक सिफ्टिंग कॉल में, अधिक से अधिक, उस नोड की ऊंचाई (ढेर के नीचे से) के बराबर कई स्वैप लगेंगे, जिस पर सिफ्टिंग कॉल की जाती है। दूसरे शब्दों में, लगभग आधी कॉलें siftDown में अधिकतम केवल एक स्वैप होगा, फिर लगभग एक चौथाई कॉल में अधिकतम दो स्वैप होंगे, आदि।

हीपसॉर्ट एल्गोरिदम में ही है $O(n log n)$ heapify के किसी भी संस्करण का उपयोग करके समय जटिलता।

प्रक्रिया heapify(a,count) है (अंत को रूट के पहले (बाएं) बच्चे का सूचकांक सौंपा गया है) अंत := 1 जबकि अंत <गिनती (सूचकांक के अंत में नोड को उचित स्थान पर इस प्रकार छान लें कि ऊपर के सभी नोड हों         अंतिम सूचकांक ढेर क्रम में हैं) सिफ्टअप (ए, 0, अंत) अंत := अंत + 1 (अंतिम नोड को छानने के बाद सभी नोड ढेर क्रम में हैं) प्रक्रिया siftUp(a, प्रारंभ, अंत) है इनपुट: स्टार्ट उस सीमा को दर्शाता है कि ढेर को कितनी दूर तक छानना है। अंत छानने के लिए नोड है। बच्चा:=समाप्त जबकि बच्चा > प्रारंभ करें अभिभावक := iअभिभावक(बच्चा) यदि एक[अभिभावक] < एक[बच्चा] तो (अधिकतम-ढेर क्रम से बाहर) अदला-बदली(एक[अभिभावक], एक[बच्चा]) बच्चा := माता-पिता (अभी माता-पिता को छानना जारी रखने के लिए दोहराएँ) अन्य वापस करना

ध्यान दें कि विपरीत  वहां पहुंचें जहां, प्रत्येक स्वैप के बाद, आपको केवल कॉल करने की आवश्यकता है   टूटे हुए ढेर को ठीक करने के लिए सबरूटीन;   अकेले सबरूटीन टूटे हुए ढेर को ठीक नहीं कर सकता। स्वैप के बाद हर बार कॉल करके ढेर का निर्माण करना पड़ता है   प्रक्रिया के बाद से siftUp मानता है कि स्वैप किया जा रहा तत्व अपने अंतिम स्थान पर समाप्त होता है, जबकि siftDown ढेर में नीचे की वस्तुओं के निरंतर समायोजन की अनुमति देता है जब तक कि अपरिवर्तनीय संतुष्ट न हो जाए। उपयोग के लिए समायोजित स्यूडोकोड   दृष्टिकोण नीचे दिया गया है.

प्रक्रिया heapsort(a, count) है इनपुट: एक अव्यवस्थित सरणी a लंबाई गिनती (सरणी ए में ढेर बनाएं ताकि सबसे बड़ा मान मूल पर हो) ढेर लगाना(ए, गिनती) (निम्नलिखित लूप लूप अपरिवर्तनीय को बनाए रखता है कि a[0:end] एक ढेर है और प्रत्येक तत्व     अंत से परे अपने से पहले की हर चीज़ से बड़ा है (इसलिए एक[अंत:गिनती] क्रमबद्ध क्रम में है)) अंत ← गिनती - 1 जबकि अंत > 0 करें (a[0] मूल और सबसे बड़ा मान है। स्वैप इसे क्रमबद्ध तत्वों के सामने ले जाता है।) स्वैप (ए[अंत], ए[0]) (स्वैप के बाद ढेर की संपत्ति बर्बाद होने के बाद siftUp का उपयोग करके ढेर का पुनर्निर्माण करें) ढेर लगाना(ए, अंत) (ढेर का आकार एक से कम करें) अंत ← अंत - 1

फ़्लॉइड का ढेर निर्माण
बुनियादी एल्गोरिदम का सबसे महत्वपूर्ण बदलाव, जो सभी व्यावहारिक कार्यान्वयन में शामिल है, फ़्लॉइड द्वारा एक ढेर-निर्माण एल्गोरिदम है जो चलता है $O(n)$ समय और बाइनरी हीप#इंसर्ट के बजाय बाइनरी हीप#एक्सट्रैक्ट का उपयोग करता है, जिससे सिफ्टअप को लागू करने की आवश्यकता से बचा जा सकता है।

एक तुच्छ ढेर से शुरू करने और बार-बार पत्तियों को जोड़ने के बजाय, फ्लोयड का एल्गोरिदम पत्तियों से शुरू होता है, यह देखते हुए कि वे अपने आप में तुच्छ लेकिन वैध ढेर हैं, और फिर माता-पिता को जोड़ता है। तत्व से प्रारंभ $n/2$ और पीछे की ओर काम करते हुए, प्रत्येक आंतरिक नोड को नीचे छानकर एक वैध ढेर की जड़ बना दिया जाता है। अंतिम चरण पहले तत्व को छानना है, जिसके बाद संपूर्ण सरणी ढेर संपत्ति का पालन करती है।

फ्लोयड के हीप-निर्माण चरण के हीपसॉर्ट के दौरान तुलनाओं की सबसे खराब स्थिति वाली संख्या के बराबर मानी जाती है $2n − 2s_{2}(n) − e_{2}(n)$, कहाँ $s_{2}(n)$ बाइनरी प्रतिनिधित्व में 1 बिट्स की संख्या है $n$ और $e_{2}(n)$ अनुवर्ती 0 बिट्स की संख्या है। फ्लोयड के हीप-कंस्ट्रक्शन एल्गोरिदम के मानक कार्यान्वयन के कारण डेटा का आकार सीपीयू कैश से अधिक हो जाने पर बड़ी संख्या में कैश मिस हो जाता है। ऊपर वाले स्तर पर आगे बढ़ने से पहले सभी उपहीप्स को एक स्तर पर संयोजित करने के बजाय, जितनी जल्दी हो सके सबहीप्स को मिलाकर, गहराई-पहले क्रम में विलय करके बड़े डेटा सेट पर बेहतर प्रदर्शन प्राप्त किया जा सकता है।

बॉटम-अप हीप्सॉर्ट
बॉटम-अप हीप्सॉर्ट एक प्रकार है जो एक महत्वपूर्ण कारक के लिए आवश्यक तुलनाओं की संख्या को कम कर देता है। जबकि साधारण हीप्सॉर्ट की आवश्यकता होती है $2n log_{2} n + O(n)$ तुलना सबसे ख़राब स्थिति में और औसतन, बॉटम-अप वैरिएंट की आवश्यकता है $n log_{2}n + O(1)$ औसतन तुलना, और $1.5n log_{2}n + O(n)$ सबसे खराब स्थिति में।

यदि तुलना सस्ती है (जैसे पूर्णांक कुंजियाँ) तो अंतर महत्वहीन है, क्योंकि टॉप-डाउन हीप्सॉर्ट उन मानों की तुलना करता है जो पहले ही मेमोरी से लोड किए जा चुके हैं। हालाँकि, यदि तुलना के लिए फ़ंक्शन कॉल या अन्य जटिल तर्क की आवश्यकता होती है, तो बॉटम-अप हीप्सॉर्ट लाभप्रद है।

यह सुधार करके पूरा किया गया है  प्रक्रिया। परिवर्तन से रैखिक-समय ढेर-निर्माण चरण में कुछ हद तक सुधार होता है, लेकिन दूसरे चरण में अधिक महत्वपूर्ण है। सामान्य हीप्सॉर्ट की तरह, दूसरे चरण का प्रत्येक पुनरावृत्ति ढेर के शीर्ष को निकालता है, $a[0]$, और इसके द्वारा छोड़े गए अंतर को भरता है $a[end]$, फिर इस बाद वाले तत्व को ढेर के नीचे छानता है। लेकिन यह तत्व ढेर के सबसे निचले स्तर से आता है, जिसका अर्थ है कि यह ढेर में सबसे छोटे तत्वों में से एक है, इसलिए इसे वापस नीचे ले जाने के लिए छानने वाले को कई कदम उठाने पड़ेंगे। सामान्य हीपसॉर्ट में, सिफ्ट-डाउन के प्रत्येक चरण में न्यूनतम तीन तत्वों को खोजने के लिए दो तुलनाओं की आवश्यकता होती है: नया नोड और उसके दो बच्चे।

इसके बजाय बॉटम-अप हीपसॉर्ट प्रत्येक स्तर पर केवल एक तुलना का उपयोग करके पेड़ के पत्ते के स्तर तक सबसे बड़े बच्चों का मार्ग ढूंढता है (जैसे कि वह −∞ डाल रहा हो)। दूसरी तरह से कहें तो उसे एक पत्ता मिलता है जिसमें यह गुण होता है कि वह और उसके सभी पूर्वज अपने भाई-बहनों से बड़े या उनके बराबर हैं। (समान कुंजियों के अभाव में, यह पत्ता अद्वितीय है।) फिर, इस पत्ते से, यह सम्मिलित करने के लिए उस पथ में सही स्थिति के लिए ऊपर की ओर खोज करता है (प्रति स्तर एक तुलना का उपयोग करके) $a[end]$. यह वही स्थान है जो सामान्य हीपसॉर्ट खोजता है, और सम्मिलित करने के लिए समान संख्या में एक्सचेंजों की आवश्यकता होती है, लेकिन उस स्थान को खोजने के लिए कम तुलनाओं की आवश्यकता होती है। क्योंकि यह नीचे तक जाता है और फिर वापस ऊपर आता है, इसे कुछ लेखकों द्वारा बाउंस के साथ हीपसॉर्ट कहा जाता है। फ़ंक्शन लीफ़सर्च(ए, आई, एंड) है जे ← मैं जबकि iRightChild(j) ≤ अंत करो (निर्धारित करें कि j के दो बच्चों में से कौन बड़ा है) यदि a[iRightChild(j)] > a[iLeftChild(j)] तो जे ← iRightChild(j) अन्य जे ← iLeftChild(j) (अंतिम स्तर पर, केवल एक ही बच्चा हो सकता है) यदि iLeftChild(j) ≤ समाप्त हो तो जे ← iLeftChild(j) वापसी जे

का वापसी मूल्य  संशोधित में प्रयोग किया जाता है   दिनचर्या:

प्रक्रिया siftDown(a, i,end) है जे ← पत्ती खोज(ए, आई, अंत) जबकि a[i] > a[j] करते हैं j ← iParent(j) x ← a[j] ए[जे] ← ए[आई] जबकि j > मैं करता हूँ स्वैप एक्स, ए[आईपेरेंट(जे)] j ← iParent(j)

बॉटम-अप हीपसॉर्ट को ≥16000 आकार के सरणियों पर बीटिंग क्विकसॉर्ट (तीन धुरी चयन के मध्य के साथ) के रूप में घोषित किया गया था।

2008 में इस एल्गोरिथ्म के पुनर्मूल्यांकन से पता चला कि यह पूर्णांक कुंजियों के लिए सामान्य हीपसॉर्ट से अधिक तेज़ नहीं है, संभवतः इसलिए क्योंकि आधुनिक शाखा भविष्यवाणी पूर्वानुमानित तुलनाओं की लागत को कम कर देती है जिससे बॉटम-अप हीपसॉर्ट बचने का प्रबंधन करता है। एक और परिशोधन चयनित पत्ते के पथ में एक द्विआधारी खोज करता है, और सबसे खराब स्थिति में सॉर्ट करता है $(n+1)(log_{2}(n+1) + log_{2} log_{2}(n+1) + 1.82) + O(log_{2}n)$ तुलना, तुलनात्मक प्रकार के निकट#किसी सूची को क्रमबद्ध करने के लिए आवश्यक तुलनाओं की संख्या|सूचना-सैद्धांतिक निचली सीमा $n log_{2}n − 1.4427n$ तुलना. एक वैरिएंट जो प्रति आंतरिक नोड दो अतिरिक्त बिट्स का उपयोग करता है (एन-तत्व ढेर के लिए कुल एन-1 बिट्स) यह जानकारी कैश करने के लिए कि कौन सा बच्चा बड़ा है (तीन मामलों को संग्रहीत करने के लिए दो बिट्स की आवश्यकता होती है: बाएं, दाएं और अज्ञात) से कम उपयोग करता है $n log_{2}n + 1.1n$ तुलना करता है.

अन्य विविधताएँ

 * त्रिगुट ढेर ्सॉर्ट बाइनरी हीप के बजाय टर्नरी हीप का उपयोग करता है; अर्थात्, ढेर में प्रत्येक तत्व के तीन बच्चे हैं। इसे प्रोग्राम करना अधिक जटिल है, लेकिन यह लगातार कई गुना कम स्वैप और तुलनात्मक संचालन करता है। ऐसा इसलिए है क्योंकि टर्नरी हीप में प्रत्येक सिफ्ट-डाउन चरण के लिए तीन तुलनाओं और एक स्वैप की आवश्यकता होती है, जबकि बाइनरी हीप में दो तुलनाओं और एक स्वैप की आवश्यकता होती है। एक टर्नरी ढेर कवर में दो स्तर 32=9 तत्व, बाइनरी हीप में तीन स्तरों के समान तुलनाओं के साथ अधिक काम करते हैं, जो केवल 2 को कवर करते हैं3=8. यह मुख्य रूप से अकादमिक रुचि का है, या एक छात्र अभ्यास के रूप में, क्योंकि अतिरिक्त जटिलता मामूली बचत के लायक नहीं है, और बॉटम-अप हीपसॉर्ट दोनों को मात देता है।
 * मेमोरी-अनुकूलित हीपसॉर्ट बच्चों की संख्या को और अधिक बढ़ाकर हीपसॉर्ट के संदर्भ स्थान में सुधार करता है। इससे तुलनाओं की संख्या बढ़ जाती है, लेकिन चूंकि सभी बच्चों को मेमोरी में लगातार संग्रहीत किया जाता है, इसलिए हीप ट्रैवर्सल के दौरान एक्सेस की गई कैश लाइनों की संख्या कम हो जाती है, जिससे शुद्ध प्रदर्शन में सुधार होता है।
 * जगह से बाहर हीप्सॉर्ट  सबसे खराब स्थिति को समाप्त करके बॉटम-अप हीप्सॉर्ट में सुधार करता है, गारंटी देता है $n log_{2}n + O(n)$ तुलना. जब अधिकतम लिया जाता है, तो रिक्त स्थान को अवर्गीकृत डेटा मान से भरने के बजाय, इसे a से भरें $−∞$ प्रहरी मूल्य, जो कभी भी वापस ऊपर नहीं लौटता। यह पता चला है कि इसे इन-प्लेस (और गैर-पुनरावर्ती) क्विकहेप्सॉर्ट एल्गोरिदम में एक आदिम के रूप में उपयोग किया जा सकता है। सबसे पहले, आप एक क्विकसॉर्ट-जैसा विभाजन पास करते हैं, लेकिन सरणी में विभाजित डेटा के क्रम को उलट देते हैं। मान लीजिए (सामान्यता की हानि के बिना) कि छोटा विभाजन धुरी से बड़ा है, जिसे सरणी के अंत में जाना चाहिए, लेकिन हमारा उलटा विभाजन चरण इसे शुरुआत में रखता है। छोटे विभाजन से एक ढेर बनाएं और उस पर जगह से बाहर हीप्सॉर्ट करें, निकाले गए मैक्सिमा को सरणी के अंत से मूल्यों के साथ बदलें। ये धुरी से कम हैं, अर्थात ढेर में किसी भी मूल्य से कम हैं, इसलिए इस रूप में कार्य करें $−∞$ प्रहरी मान. एक बार जब हीपसॉर्ट पूरा हो जाता है (और धुरी को सरणी के अब-क्रमबद्ध अंत से ठीक पहले ले जाया जाता है), विभाजन का क्रम उलट दिया गया है, और सरणी की शुरुआत में बड़े विभाजन को उसी तरह से क्रमबद्ध किया जा सकता है। (क्योंकि कोई नॉन- पूँछ प्रत्यावर्तन  नहीं है, यह क्विकसॉर्ट को भी खत्म कर देता है $O(log n)$ स्टैक उपयोग।)
 * स्मूथसॉर्ट एल्गोरिदम 1981 में एड्सगर डब्ल्यू डिज्क्स्ट्रा द्वारा विकसित हीप्सॉर्ट का एक रूप है। हीप्सॉर्ट की तरह, स्मूथसॉर्ट की ऊपरी सीमा है $O(n log n)$. स्मूथसॉर्ट का लाभ यह है कि यह करीब आता है $O(n)$ समय यदि अनुकूली प्रकार है, जबकि हीपसॉर्ट औसत है $O(n log n)$ प्रारंभिक क्रमबद्ध स्थिति की परवाह किए बिना। इसकी जटिलता के कारण, स्मूथसॉर्ट का उपयोग शायद ही कभी किया जाता है।
 * लेवकोपोलोस और पीटरसन कार्टेशियन पेड़ों के ढेर के आधार पर ढेरों की विविधता का वर्णन करें। सबसे पहले, एक कार्टेशियन पेड़ इनपुट से बनाया गया है $O(n)$ समय, और इसकी जड़ को 1-तत्व बाइनरी ढेर में रखा गया है। फिर हम बार-बार बाइनरी हीप से न्यूनतम निकालते हैं, पेड़ के मूल तत्व को आउटपुट करते हैं, और उसके बाएं और दाएं बच्चों (यदि कोई हो) को बाइनरी हीप में जोड़ते हैं, जो स्वयं कार्टेशियन पेड़ हैं। जैसा कि वे दिखाते हैं, यदि इनपुट पहले से ही लगभग सॉर्ट किया गया है, तो कार्टेशियन पेड़ बहुत असंतुलित होंगे, कुछ नोड्स में बाएं और दाएं बच्चे होंगे, जिसके परिणामस्वरूप बाइनरी ढेर छोटा रहेगा, और एल्गोरिदम को अधिक तेज़ी से सॉर्ट करने की अनुमति मिलेगी $O(n log n)$ उन इनपुट के लिए जो पहले से ही लगभग क्रमबद्ध हैं।
 * Weak heap#Weak-heap sort जैसे कई वेरिएंट की आवश्यकता होती है $n log_{2} n+O(1)$ सबसे खराब स्थिति में तुलना, सैद्धांतिक न्यूनतम के करीब, प्रति नोड राज्य के एक अतिरिक्त बिट का उपयोग करना। हालाँकि यह अतिरिक्त बिट एल्गोरिदम को वास्तव में सही जगह पर नहीं रखता है, यदि इसके लिए तत्व के अंदर जगह मिल सकती है, तो ये एल्गोरिदम सरल और कुशल हैं, लेकिन फिर भी बाइनरी हीप्स की तुलना में धीमी है यदि कुंजी तुलनाएं इतनी सस्ती हैं (उदाहरण के लिए पूर्णांक कुंजी) कि एक स्थिर कारक कोई मायने नहीं रखता।
 * काटाजाइनेन के अंतिम हेप्सॉर्ट को किसी अतिरिक्त भंडारण की आवश्यकता नहीं है, प्रदर्शन करता है $n log_{2} n+O(1)$ तुलना, और समान संख्या में तत्व चलते हैं। हालाँकि, यह और भी अधिक जटिल है और तब तक उचित नहीं है जब तक तुलनाएँ बहुत महंगी न हों।

अन्य प्रकारों से तुलना
हीप्सॉर्ट मुख्य रूप से क्विकसॉर्ट के साथ प्रतिस्पर्धा करता है, जो एक और बहुत ही कुशल सामान्य प्रयोजन इन-प्लेस तुलना-आधारित सॉर्ट एल्गोरिदम है।

हीपसॉर्ट के प्राथमिक लाभ इसके सरल, गैर-रिकर्सन (कंप्यूटर विज्ञान) कोड, न्यूनतम सहायक भंडारण आवश्यकता और विश्वसनीय रूप से अच्छा प्रदर्शन हैं: इसके सबसे अच्छे और सबसे खराब मामले एक-दूसरे के एक छोटे स्थिर कारक के भीतर हैं, और तुलना प्रकार#तुलना की संख्या किसी सूची को क्रमबद्ध करना आवश्यक है. जबकि यह इससे बेहतर नहीं कर सकता $O(n log n)$ पूर्व-सॉर्ट किए गए इनपुट के लिए, यह क्विकसॉर्ट से प्रभावित नहीं होता है $O(n^{2})$ सबसे खराब स्थिति, या तो। (सावधानीपूर्वक कार्यान्वयन से उत्तरार्द्ध से बचा जा सकता है, लेकिन यह क्विकॉर्ट को और अधिक जटिल बनाता है, और सबसे लोकप्रिय समाधानों में से एक, इंट्रोसॉर्ट, इस उद्देश्य के लिए हीप्सॉर्ट का उपयोग करता है।)

इसका प्राथमिक नुकसान इसके संदर्भ की खराब स्थानीयता और इसकी स्वाभाविक रूप से क्रमिक प्रकृति है; अंतर्निहित पेड़ तक पहुंच व्यापक रूप से बिखरी हुई है और अधिकतर यादृच्छिक है, और इसे समानांतर एल्गोरिदम में बदलने का कोई सीधा तरीका नहीं है।

यह इसे अंतः स्थापित प्रणाली, वास्तविक समय कंप्यूटिंग और दुर्भावनापूर्ण रूप से चुने गए इनपुट से संबंधित सिस्टम में लोकप्रिय बनाता है, जैसे लिनक्स कर्नेल. यह किसी भी एप्लिकेशन के लिए एक अच्छा विकल्प है, जिसे सॉर्ट करने पर टोंटी (कंप्यूटिंग)  की उम्मीद नहीं होती है।

एक अच्छी तरह से कार्यान्वित क्विकसॉर्ट आमतौर पर हीपसॉर्ट की तुलना में 2-3 गुना तेज होता है। हालाँकि क्विकॉर्ट के लिए कम तुलनाओं की आवश्यकता होती है, यह एक मामूली कारक है। (दोगुने तुलनाओं का दावा करने वाले परिणाम टॉप-डाउन संस्करण को माप रहे हैं; देखें .) क्विकसॉर्ट का मुख्य लाभ इसके संदर्भ का बेहतर स्थानीयता है: विभाजन अच्छे स्थानिक इलाके के साथ एक रैखिक स्कैन है, और पुनरावर्ती उपखंड में अच्छा अस्थायी इलाका है। अतिरिक्त प्रयास के साथ, क्विकॉर्ट को ज्यादातर शाखा-मुक्त कोड में भी लागू किया जा सकता है, और समानांतर में उप-विभाजन को सॉर्ट करने के लिए कई सीपीयू का उपयोग किया जा सकता है। इस प्रकार, जब अतिरिक्त प्रदर्शन कार्यान्वयन प्रयास को उचित ठहराता है तो क्विकॉर्ट को प्राथमिकता दी जाती है।

दूसरा प्रमुख $O(n log n)$ सॉर्टिंग एल्गोरिदम मर्ज़ सॉर्ट  है, लेकिन यह शायद ही कभी हीपसॉर्ट के साथ सीधे प्रतिस्पर्धा करता है क्योंकि यह इन-प्लेस नहीं है। मर्ज सॉर्ट की आवश्यकता के लिए $Ω(n)$ अतिरिक्त स्थान (इनपुट का लगभग आधा आकार) आमतौर पर उन स्थितियों को छोड़कर निषेधात्मक है जहां मर्ज सॉर्ट का स्पष्ट लाभ होता है:
 * जब एक स्थिर प्रकार की आवश्यकता होती है
 * (आंशिक रूप से) पूर्व-क्रमबद्ध इनपुट का लाभ उठाते समय
 * लिंक की गई सूचियों को क्रमबद्ध करना (जिस स्थिति में मर्ज सॉर्ट के लिए न्यूनतम अतिरिक्त स्थान की आवश्यकता होती है)
 * समानांतर छँटाई; मर्ज सॉर्ट क्विकॉर्ट की तुलना में और भी बेहतर तरीके से समानांतर होता है और आसानी से रैखिक गति  के करीब पहुंच सकता है
 * बाहरी छँटाई; मर्ज सॉर्ट में संदर्भ का उत्कृष्ट स्थान है

उदाहरण
मान लीजिए कि {6, 5, 3, 1, 8, 7, 2, 4 } वह सूची है जिसे हम सबसे छोटे से सबसे बड़े तक क्रमबद्ध करना चाहते हैं। (ध्यान दें, 'बिल्डिंग द हीप' चरण के लिए: बड़े नोड छोटे नोड पैरेंट के नीचे नहीं रहते हैं। उन्हें पैरेंट के साथ स्वैप किया जाता है, और फिर यदि किसी अन्य स्वैप की आवश्यकता होती है, तो पुनरावर्ती रूप से जांच की जाती है, ताकि हीप बाइनरी ट्री पर बड़ी संख्या को छोटी संख्या से ऊपर रखा जा सके। .)

संदर्भ

 * Chapters 6 and 7 Respectively: Heapsort and Priority Queues
 * A PDF of Dijkstra's original paper on Smoothsort
 * Heaps and Heapsort Tutorial by David Carlson, St. Vincent College
 * Chapters 6 and 7 Respectively: Heapsort and Priority Queues
 * A PDF of Dijkstra's original paper on Smoothsort
 * Heaps and Heapsort Tutorial by David Carlson, St. Vincent College
 * Heaps and Heapsort Tutorial by David Carlson, St. Vincent College

बाहरी संबंध

 * – graphical demonstration
 * Courseware on Heapsort from Univ. Oldenburg – With text, animations and interactive exercises
 * NIST's Dictionary of Algorithms and Data Structures: Heapsort
 * Heapsort implemented in 12 languages
 * Sorting revisited by Paul Hsieh
 * A PowerPoint presentation demonstrating how Heap sort works that is for educators.
 * Open Data Structures – Section 11.1.3 – Heap-Sort, Pat Morin