सारांश
Type BST (*) Heap
Insert average log(n) 1
Insert worst log(n) log(n) or n (***)
Find any worst log(n) n
Find max worst 1 (**) 1
Create worst n log(n) n
Delete worst log(n) log(n)
इस तालिका में सभी औसत समय सम्मिलित करने के अलावा उनके सबसे खराब समय के समान हैं।
*: इस उत्तर में हर जगह, BST == संतुलित BST, क्योंकि असंतुलित रूप से असमान रूप से चूसता है**: इस उत्तर में समझाया गया एक मामूली संशोधन का उपयोग करना***: log(n)पॉइंटर ट्री हीप के लिए, nडायनेमिक ऐरे हीप के लिए
एक बीएसटी पर बाइनरी हीप के फायदे
बाइनरी हीप पर बीएसटी का लाभ
मनमाने तत्वों की तलाश है O(log(n))। यह बीएसटी की हत्यारा विशेषता है।
ढेर के लिए, यह O(n)सामान्य रूप से है, सबसे बड़े तत्व को छोड़कर O(1)।
BST पर ढेर का "गलत" फायदा
ढेर को O(1)अधिकतम, BST ढूंढना है O(log(n))।
यह एक सामान्य गलत धारणा है, क्योंकि सबसे बड़े तत्व का ट्रैक रखने के लिए एक BST को संशोधित करना तुच्छ है, और जब भी उस तत्व को बदला जा सकता है, तो इसे अपडेट करें: एक बड़ा एक स्वैप के सम्मिलन पर, हटाने पर दूसरा सबसे बड़ा लगता है। क्या हम ढेर ऑपरेशन का अनुकरण करने के लिए बाइनरी सर्च ट्री का उपयोग कर सकते हैं? ( Yeo द्वारा उल्लिखित )।
वास्तव में, यह BSTs की तुलना में ढेर की एक सीमा है: केवल सबसे बड़ी तत्व के लिए कुशल खोज है।
औसत बाइनरी हीप इन्सर्ट है O(1)
सूत्रों का कहना है:
सहज तर्क:
- नीचे के पेड़ के स्तर में शीर्ष स्तर की तुलना में अधिक तत्व होते हैं, इसलिए नए तत्वों को तल पर जाना लगभग निश्चित है
- हीप सम्मिलन नीचे से शुरू होता है , BST शीर्ष से शुरू होना चाहिए
एक बाइनरी हीप में, किसी दिए गए इंडेक्स पर मूल्य बढ़ाना भी O(1)उसी कारण से है। लेकिन अगर आप ऐसा करना चाहते हैं, तो यह संभावना है कि आप ढेर के संचालन पर एक अतिरिक्त इंडेक्स अप-टू-डेट रखना चाहते हैं कि मिन-हीप आधारित प्राथमिकता कतार के लिए ओ (लॉगन) कमी-कुंजी संचालन कैसे लागू किया जाए? उदाहरण के लिए दिज्क्स्त्र। बिना किसी अतिरिक्त समय के खर्च संभव।
जीसीसी सी ++ मानक पुस्तकालय वास्तविक हार्डवेयर पर बेंचमार्क सम्मिलित करते हैं
मैंने C ++ std::set( रेड-ब्लैक ट्री BST ) और std::priority_queue( डायनेमिक ऐरे हीप ) को यह देखने के लिए सम्मिलित किया कि क्या मैं इन्सर्ट टाइम के बारे में सही था, और यही मुझे मिला:
- बेंचमार्क कोड
- प्लॉट स्क्रिप्ट
- प्लॉट डेटा
- Ubuntu 19.04, GCC 8.3.0 पर लेनोवो थिंकपैड P51 लैपटॉप में CPU के साथ परीक्षण किया गया: Intel Core i7-7820HQ CPU (4 कोर / 8 धागे, 2.90 GHz आधार, 8 MB कैश), RAM: 2x सैमसंग M472A2K43BB1-CRC (2x 16GiB) , 2400 एमबीपीएस), एसएसडी: सैमसंग MZVLB512HAJQ-000L7 (512GB, 3,000 MB / s)
तो स्पष्ट रूप से:
ढेर डालने का समय मूल रूप से स्थिर है।
हम स्पष्ट रूप से डायनामिक ऐरे रिसाइज़ पॉइंट्स देख सकते हैं। चूँकि हम हर 10k आवेषण पर औसत होते हैं , सिस्टम शोर के ऊपर कुछ भी देखने में सक्षम होने के लिए , उन चोटियों वास्तव में दिखाए गए की तुलना में 10k गुना बड़ा है!
ज़ूम किया गया ग्राफ़ अनिवार्य रूप से केवल सरणी आकार बिंदुओं को बाहर करता है, और दिखाता है कि लगभग सभी आवेषण 25 नैनोसेकंड के नीचे आते हैं।
BST लॉगरिदमिक है। सभी आवेषण औसत ढेर डालने की तुलना में बहुत धीमी हैं।
BST बनाम हैशमैप पर विस्तृत विश्लेषण: क्या डेटा संरचना std के अंदर :: C ++ में मैप है?
GCC C ++ मानक पुस्तकालय gem5 पर बेंचमार्क डालें
मणि 5 एक पूर्ण प्रणाली सिम्युलेटर है, और इसलिए इसके साथ एक असीम रूप से सटीक घड़ी प्रदान करता है m5 dumpstats। इसलिए मैंने व्यक्तिगत आवेषण के लिए समय का अनुमान लगाने के लिए इसका उपयोग करने की कोशिश की।
व्याख्या:
ढेर अभी भी स्थिर है, लेकिन अब हम अधिक विस्तार से देखते हैं कि कुछ लाइनें हैं, और प्रत्येक उच्च रेखा अधिक विरल है।
यह उच्च और उच्च आवेषण के लिए मेमोरी एक्सेस लेटेंसी के अनुरूप होता है।
TODO मैं वास्तव में BST की पूरी तरह से व्याख्या नहीं कर सकता क्योंकि यह इतना लघुगणक और कुछ अधिक स्थिर नहीं दिखता है।
इस अधिक विस्तार के साथ हालांकि हम देख सकते हैं कि कुछ अलग रेखाएं भी देख सकते हैं, लेकिन मुझे यकीन नहीं है कि वे क्या प्रतिनिधित्व करते हैं: मैं उम्मीद करूंगा कि नीचे की रेखा पतली हो सकती है, क्योंकि हम शीर्ष नीचे सम्मिलित करते हैं?
अराजकता 64 HPI CPU पर इस बिल्डरोट सेटअप के साथ बेंचमार्क ।
BST को किसी एरे पर कुशलता से लागू नहीं किया जा सकता है
हीप संचालन को केवल एकल ट्री ब्रांच को ऊपर या नीचे करने की आवश्यकता होती है, इसलिए O(log(n))सबसे खराब स्थिति स्वैप, O(1)औसत।
BST को संतुलित रखने के लिए पेड़ के घुमावों की आवश्यकता होती है, जो एक और के लिए शीर्ष तत्व को बदल सकते हैं, और पूरे सरणी को चारों ओर घुमाने की आवश्यकता होगी ( O(n))।
हीप्स को एक एरे पर कुशलता से लागू किया जा सकता है
वर्तमान सूचकांक से माता-पिता और बच्चों के अनुक्रमित की गणना की जा सकती है जैसा कि यहां दिखाया गया है ।
BST की तरह कोई भी संतुलन कार्य नहीं कर रहे हैं।
Delete min सबसे चिंताजनक ऑपरेशन है क्योंकि इसे टॉप डाउन करना है। लेकिन यह हमेशा यहां बताए गए ढेर की एक भी शाखा "पेरकोलेटिंग डाउन" द्वारा किया जा सकता है । यह ओ (लॉग (एन)) सबसे खराब स्थिति की ओर जाता है, क्योंकि ढेर हमेशा अच्छी तरह से संतुलित होता है।
यदि आप अपने द्वारा हटाए गए प्रत्येक के लिए एक एकल नोड सम्मिलित कर रहे हैं, तो आप स्पर्शोन्मुख ओ (1) औसत आवेषण का लाभ खो देते हैं जो कि हटने पर हावी होते हैं, और आप बीएसटी का उपयोग कर सकते हैं। दिज्क्स्ट्रा हालांकि प्रत्येक हटाने के लिए कई बार नोड्स अपडेट करता है, इसलिए हम ठीक हैं।
डायनेमिक ऐरे ढेर बनाम पॉइंटर ट्री ढेर
हीप्स को पॉइंटर हीप्स के शीर्ष पर कुशलता से लागू किया जा सकता है: क्या कुशल पॉइंटर-आधारित बाइनरी हीप कार्यान्वयन करना संभव है?
गतिशील सरणी कार्यान्वयन अधिक स्थान कुशल है। मान लीजिए कि प्रत्येक ढेर तत्व में सिर्फ एक सूचक होता है struct:
पेड़ के कार्यान्वयन को प्रत्येक तत्व के लिए तीन बिंदुओं को संचय करना चाहिए: माता-पिता, बाएं बच्चे और दाएं बच्चे। तो मेमोरी का उपयोग हमेशा होता है 4n(3 ट्री पॉइंटर्स + 1 structपॉइंटर)।
ट्री बीएसटी को आगे भी संतुलन की जानकारी की आवश्यकता होगी, जैसे कि काले-लाल-नेस।
डायनामिक एरे का कार्यान्वयन 2nएक दोहरीकरण के बाद आकार का हो सकता है । तो औसतन यह होने जा रहा है 1.5n।
दूसरी ओर, पेड़ के ढेर में सबसे खराब स्थिति होती है, क्योंकि इसके आकार को दोगुना करने के लिए बैकिंग डायनामिक सरणी की नकल करना O(n)सबसे खराब स्थिति होती है, जबकि पेड़ का ढेर प्रत्येक नोड के लिए नए छोटे आवंटन करता है।
फिर भी, बैकिंग सरणी दोहरीकरण को O(1)परिशोधन किया जाता है, इसलिए यह अधिकतम विलंबता पर विचार करने के लिए नीचे आता है। यहाँ उल्लेख किया ।
दर्शन
BST एक माता-पिता और सभी वंशजों के बीच एक वैश्विक संपत्ति बनाए रखते हैं (बाएं छोटे, दाएं बड़े)।
BST का शीर्ष नोड मध्य तत्व है, जिसे बनाए रखने के लिए वैश्विक ज्ञान की आवश्यकता होती है (यह जानकर कि कितने छोटे और बड़े तत्व हैं)।
यह वैश्विक संपत्ति बनाए रखने के लिए अधिक महंगा है (लॉग एन डालें), लेकिन अधिक शक्तिशाली खोज (लॉग एन खोज) देता है।
माता-पिता माता-पिता और प्रत्यक्ष बच्चों (माता-पिता> बच्चों) के बीच एक स्थानीय संपत्ति बनाए रखते हैं।
एक ढेर का शीर्ष नोड बड़ा तत्व है, जिसे केवल आपके माता-पिता को जानने (बनाए रखने) के लिए स्थानीय ज्ञान की आवश्यकता होती है।
BST बनाम हीप बनाम हैशमैप की तुलना:
BST: या तो एक उचित हो सकता है:
- अनियंत्रित सेट (एक संरचना जो यह निर्धारित करती है कि कोई तत्व पहले डाला गया था या नहीं)। लेकिन हैशमैप ओ (1) एमर्टाइज़्ड इंसर्ट के कारण बेहतर होता है।
- छँटाई मशीन। लेकिन ढेर आमतौर पर उस पर बेहतर होता है, यही कारण है कि हीप्सोर्ट पेड़ के प्रकार की तुलना में अधिक व्यापक रूप से जाना जाता है
ढेर: सिर्फ एक छँटाई मशीन है। एक कुशल अनियंत्रित सेट नहीं हो सकता, क्योंकि आप केवल सबसे छोटे / सबसे बड़े तत्व के लिए तेजी से जांच कर सकते हैं।
हैश मैप: केवल एक अनियंत्रित सेट हो सकता है, एक कुशल छँटाई मशीन नहीं, क्योंकि हैशिंग किसी भी क्रम को मिलाता है।
संदेह से जुड़ी सूची
एक दोगुनी लिंक की गई सूची को ढेर के सबसेट के रूप में देखा जा सकता है, जहां पहले आइटम की सबसे बड़ी प्राथमिकता होती है, तो आइए उनकी तुलना यहां भी करें:
- प्रविष्टि:
- स्थान:
- दोगुनी लिंक की गई सूची: सम्मिलित आइटम या तो पहले या अंतिम होने चाहिए, क्योंकि हमारे पास केवल उन तत्वों के संकेत हैं।
- बाइनरी हीप: डाला गया आइटम किसी भी स्थिति में समाप्त हो सकता है। लिंक की गई सूची की तुलना में कम प्रतिबंधात्मक।
- समय:
- दोगुनी लिंक की गई सूची:
O(1)सबसे खराब स्थिति चूंकि हमारे पास आइटम के लिए संकेत हैं, और अपडेट वास्तव में सरल है
- बाइनरी हीप:
O(1)औसत, इस प्रकार लिंक की गई सूची से भी बदतर। अधिक सामान्य सम्मिलन की स्थिति के लिए ट्रेडऑफ़।
- खोज:
O(n)दोनों के लिए
इसके लिए एक उपयोग का मामला तब है जब ढेर की कुंजी वर्तमान टाइमस्टैम्प है: उस स्थिति में, नई प्रविष्टियां हमेशा सूची की शुरुआत में जाएंगी। तो हम भी सटीक टाइमस्टैम्प को पूरी तरह से भूल सकते हैं, और सूची में स्थिति को प्राथमिकता के रूप में रख सकते हैं।
इसका उपयोग LRU कैश को लागू करने के लिए किया जा सकता है । वैसे ही जैसे डिज्कस्ट्रा की तरह ढेर अनुप्रयोगों के लिए , आप सूची का इसी नोड के लिए कुंजी से एक अतिरिक्त hashmap रखने के लिए है, जो नोड जल्दी से अद्यतन करने के लिए खोजने के लिए चाहते हैं।
विभिन्न बैलेंस्ड BST की तुलना
हालांकि एसिम्प्टोटिक सम्मिलित हैं और सभी डेटा संरचनाओं के लिए बार-बार मिलते हैं जिन्हें आमतौर पर "संतुलित BSTs" के रूप में वर्गीकृत किया जाता है जो मैंने अब तक एक ही देखा है, अलग-अलग BBST में अलग-अलग ट्रेड-ऑफ़ हैं। मैंने अभी तक इसका पूरी तरह से अध्ययन नहीं किया है, लेकिन इन ट्रेड-ऑफ को संक्षेप में प्रस्तुत करना अच्छा होगा:
- लाल-काला पेड़ । 2019 तक सबसे अधिक इस्तेमाल किया जाने वाला BBST है, उदाहरण के लिए, यह GCC 8.3.0 C ++ कार्यान्वयन द्वारा उपयोग किया जाने वाला एक है
- एवीएल पेड़ । BST की तुलना में थोड़ा अधिक संतुलित होने की अपील करता है, इसलिए यह थोड़ा और अधिक महंगे खोजने की कीमत पर विलंबता का पता लगाने के लिए बेहतर हो सकता है। विकी संक्षेप में बताता है: "AVL के पेड़ों की तुलना अक्सर लाल-काले पेड़ों से की जाती है क्योंकि दोनों ही समान संचालन के सेट का समर्थन करते हैं और बुनियादी कार्यों के लिए [समान] समय लेते हैं। लुक-सघन अनुप्रयोगों के लिए, AVL पेड़ लाल-काले पेड़ों की तुलना में तेज़ होते हैं क्योंकि वे अधिक सख्ती से संतुलित हैं। लाल-काले पेड़ों के समान, एवीएल के पेड़ ऊंचाई-संतुलित हैं। दोनों सामान्य रूप से, किसी भी म्यू <1/2 के लिए न तो वजन-संतुलित और न ही मु-संतुलित हैं; अर्थात, सहोदर नोड्स बेहद हो सकते हैं। वंशजों की अलग-अलग संख्या। ”
- WAVL । मूल कागज पुनर्संतुलन और रोटेशन कार्यों पर सीमा के मामले में उस संस्करण के फायदे का उल्लेख है।
यह सभी देखें
CS पर समान प्रश्न: /cs/27860/whats-the-difference-between-a-binary-search-tree-and-a-binary-heap