2013-03-26 6 views
6

ऐसा लगता है कि बाइनरी पेड़ पर ढेर का एकमात्र लाभ बाइनरी पेड़ में ओ (लॉग (2) एन) की बजाय ओ (1) की जटिलता में ढेर में सबसे छोटी वस्तु को ढूंढना है।प्राथमिकता कतार लागू करते समय बाइनरी पेड़ के बजाय ढेर का उपयोग क्यों करें?

प्राथमिकता कतार लागू करते समय आपको डेटा संरचना से प्रत्येक छोटी वस्तु को हटाने की आवश्यकता है। एक पेड़ से छोटी वस्तु को हटाने और ओ की जटिलता में किए गए ढेर दोनों (लॉग (2) एन)। एक पेड़ से आइटम हटाना Althogh अधिक जटिल हो सकता है। बच्चों को बिना किसी बच्चे के बहुत आसानी से हटा देना।

मेरा प्रश्न है कि प्राथमिकता कतार लागू करते समय बाइनरी पेड़ (जो इस मामले में आसान है) के बजाय ढेर का उपयोग क्यों करें?

+0

यदि आपने सरणी के बजाय नोड संरचना का उपयोग करके एक ढेर लागू किया है, तो मैं विश्वास करूँगा कि आप क्या कह रहे हैं :)। –

+0

एक हीप लागू करने के लिए एक बहुत ही सरल डेटा संरचना है ... –

उत्तर

10

सबसे बुरे मामले जटिलता (मुझे यकीन है कि अगर यह जावा में इस तरह से लागू किया है, लेकिन मुझे ऐसा लगता है नहीं कर रहा हूँ) होगा ओ (एन) हो जब बाइनरी पेड़ एक सरणी में एकजुट हो जाता है जबकि ढेर में यह रहता है ओ (लॉग (एन))। आप लाल बालों या एवीएल जैसे संतुलित बाइनरी पेड़ों का उपयोग कर सकते हैं, लेकिन फिर यह अधिक जटिल हो जाता है और अधिक स्मृति की आवश्यकता होती है।

0

सबसे पहले बाइनरी पेड़ हैं (उनमें से कुछ काफी कठिन हैं, उनमें से कुछ केवल औसत O(log n) प्रदान करते हैं), और ढेर उनमें से एक है।

दूसरा: अधिकांश पेड़ों पर संचालन O(log n) है, वे अधिक जटिल हैं, निरंतर कारक है।

ढेर को लगातार अतिरिक्त मेमोरी की आवश्यकता होती है, जबकि पेड़ों को आम तौर पर प्रत्येक नोड में पॉइंटर्स स्टोर करने की आवश्यकता होती है।

वैसे, ढेर काफी आसान है और केवल सरणियों का उपयोग द्विआधारी पेड़ के मामले में

+0

आप वास्तव में केवल एक तीर का उपयोग कर बाइनरी पेड़ को लागू कर सकते हैं, बिना पॉइंटर्स की आवश्यकता के ढेर। और यदि यह एक पूर्ण बाइनरी पेड़ है तो यह – gordonk

+0

@gordonk को भी बर्बाद नहीं करता है, लेकिन आपको बच्चों के पॉइंटर्स (इंडिविटीज) को स्टोर करने के लिए अधिक सरणी की आवश्यकता होगी, है ना? और यादृच्छिक हटाने के बाद आप क्या करेंगे? किसी भी बदलाव से उन बिंदुओं को – RiaD

+0

को एक बाइनरी पेड़ में अमान्य के रूप में लागू किया जाएगा, आपको केवल रूट तत्व की अनुक्रमणिका की आवश्यकता होती है, अन्य सभी इंडेक्स जिन्हें आप इससे प्राप्त कर सकते हैं। माता-पिता नोड मानते हुए इंडेक्स I है, बाएं बच्चे के पास हमेशा इंडेक्स (2i + 1) और सही बच्चा इंडेक्स (2i + 2) होगा। बेशक एक अपूर्ण बाइनरी पेड़ के लिए यह अंतरिक्ष की बर्बादी का थोड़ा सा है, लेकिन इसके फायदे हैं। – gordonk

5

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

5

आपका पहली पसंद प्रत्याशित पहुँच पैटर्न पर निर्भर होना चाहिए, और आप कितना डेटा भंडारण होने की संभावना कर रहे हैं: ...

  • वहाँ कभी नहीं अधिक डेटा है कि अगर (30 कम से कम एन, कहते हैं), एक unsorted सरणी ठीक हो जाएगा;
  • यदि आप लगभग कभी भी जोड़ना, हटाना या अपडेट नहीं करना चाहते हैं, तो एक सॉर्टेड सरणी ठीक होगी;
  • यदि एन कम है, कहें, 1 मिलियन, और आप केवल शीर्ष तत्व (पहले स्थान पर या आखिरी स्थान पर) के लिए खोज रहे हैं, तो ढेर (विशेष रूप से यदि आप अक्सर चुने गए तत्वों को अपडेट कर रहे हैं) यादृच्छिक रूप से, जैसा कि आप में एक कैश के लिए एक एलआरयू (कम से कम हाल ही में उपयोग की गई) कतार में करते हैं, कहते हैं, क्योंकि औसतन अद्यतन ओ (लॉग) (एन) के बजाय ओ (1) है)
  • यदि एन से कम है, तो कहें, 1 मिलियन, और आप सुनिश्चित नहीं हैं कि आप खोज रहे हैं, एक संतुलित पेड़ (कहें, लाल-काला या एवीएल) ठीक होगा;
  • यदि एन बड़ा है (1 मिलियन और ऊपर, कहें), तो आप शायद बी-पेड़ या एक ट्राई के साथ बेहतर हो जाएं (संतुलित द्विआधारी पेड़ का प्रदर्शन "एक चट्टान से गिरने" के बाद होता है पर्याप्त: मेमोरी एक्सेस बहुत बिखरे हुए होते हैं, और कैश मिस वास्तव में चोट लगने लगते हैं)

...लेकिन मैं विकल्प को जितना संभव हो उतना खोलने की सलाह देता हूं, ताकि आप कम से कम एक विकल्प को बेंचमार्क कर सकें और यदि यह बेहतर प्रदर्शन करता है तो इसे स्विच कर सकते हैं।

पिछले बीस वर्षों में, मैंने केवल दो अनुप्रयोगों पर काम किया है जहां एक ही चीज के लिए ढेर सबसे अच्छा विकल्प था (एक बार एलआरयू के लिए, और एक बार एक बुरा संचालन-अनुसंधान अनुप्रयोग में, यादृच्छिक रूप से परेशान के-आयामी के लिए additivity बहाल करना हाइपरक्यूब, जहां हाइपरक्यूब में अधिकांश कोशिकाएं अलग-अलग ढेर में दिखाई देती हैं और स्मृति प्रीमियम पर होती है)। हालांकि, उन दो मौकों पर, उन्होंने विकल्पों की तुलना में काफी बेहतर प्रदर्शन किया: शाब्दिक रूप से संतुलित पेड़ों या बी-पेड़ों की तुलना में दर्जनों बार तेज।

पिछले पैराग्राफ में उल्लिखित हाइपरक्यूब समस्या के लिए, मेरी टीम के नेतृत्व वाले विचार लाल-काले पेड़ ढेर से बेहतर प्रदर्शन करेंगे, लेकिन बेंचमार्किंग से पता चला है कि लाल-काले पेड़ धीमे थे (जैसा कि मुझे याद है, वे थे लगभग बीस गुना धीमी), और हालांकि बी-पेड़ काफी तेजी से थे, हालांकि ढेर उन्हें आराम से हराते थे।

ढेर की महत्वपूर्ण विशेषता, ऊपर वर्णित दोनों मामलों में, न्यूनतम मूल्य की ओ (1) लुकअप नहीं थी, बल्कि यादृच्छिक रूप से चुने गए तत्व के लिए ओ (1) औसत अद्यतन समय ।

-जेम्स Barbetti (ठीक है, मैंने सोचा कि मैं था। लेकिन कैप्चा मुझे बता रहता है मैं मानव नहीं कर रहा हूँ) यदि आप एक खोज या तलाशी अभियान एक बहुत तो एक संतुलित द्विआधारी पेड़ पसंद किया जाता है का उपयोग करते हैं

0

। रेखा खंडों का चौराहे कोड इस कारण से ढेर के बजाय संतुलित पेड़ का उपयोग करता है।

संबंधित मुद्दे