क्या कोई स्थिर ढेर है?

Question

क्या एक प्राथमिकता कतार डेटा संरचना है जो निम्नलिखित कार्यों का समर्थन करती है?

• डालें (x, p) : प्राथमिकता p के साथ एक नया रिकॉर्ड x जोड़ें
• StableExtractMin () : प्रविष्टि को क्रम से तोड़कर न्यूनतम प्राथमिकता के साथ रिकॉर्ड लौटाएं और हटाएं ।

इस प्रकार, डालने के बाद (ए, 1), इंसर्ट (b, 2), इन्सर्ट (c, 1), इन्सर्ट (d, 2), StableExtractMin का एक क्रम a, उसके बाद c, b, फिर d को वापस करेगा।

स्पष्ट रूप से कोई भी वास्तविक प्राथमिकता के रूप में जोड़ी को संग्रहीत करके किसी भी प्राथमिकता कतार डेटा संरचना का उपयोग कर सकता है , लेकिन मुझे डेटा संरचनाओं में दिलचस्पी है जो स्पष्ट रूप से सम्मिलन समय (या सम्मिलन क्रम) को संग्रहीत नहीं करते हैं , स्थिर छँटाई के अनुरूप ।$(p, time)$

समतुल्य रूप से (?): क्या हेप्सोर्ट का एक स्थिर संस्करण है जिसे अतिरिक्त स्थान की आवश्यकता नहीं है ?$\Omega(n)$

Comments

मुझे लगता है कि आपका मतलब है "ए, फिर सी, फिर बी, फिर डी"?

— रॉस स्नाइडर

रिकॉर्ड्स की लिंक की गई सूची के साथ ढेर + संतुलित बाइनरी ट्री प्राथमिकता के आधार पर संबंधित लिंक की सूची पर काम नहीं करेगा? मुझे किसकी याद आ रही है?

— आर्यभट्ट

Moron: वह सम्मिलन क्रम को स्पष्ट रूप से संग्रहीत कर रहा है, जो कि वास्तव में मैं बचना चाहता हूं। मैंने समस्या कथन को स्पष्ट किया (और रॉस का टाइपो तय किया)।

— जेफ

Answer 1

बेंटी-सैक्स विधि एक काफी प्राकृतिक स्थिर प्राथमिकता कतार देती है।

सॉर्ट किए गए सरणियों अनुक्रम में अपना डेटा । का आकार । प्रत्येक सरणी एक काउंटर भी बनाए । सरणी प्रविष्टियों में डेटा होता है।एक मैं 2 मैं ग मैं एक मैं [ ग मैं ] , ... , एक मैं [ 2 मैं - 1 $A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

प्रत्येक , में सभी तत्वों को तुलना में हाल ही में जोड़ा गया था और प्रत्येक तत्वों के भीतर नए तत्वों के आगे पुराने तत्वों को रखकर टूटे हुए संबंधों के साथ मूल्य का आदेश दिया गया है। ध्यान दें कि इसका मतलब है कि हम और को मर्ज कर सकते हैं और इस ऑर्डर को संरक्षित कर सकते हैं। (मर्ज के दौरान संबंधों के मामले में, से तत्व लें ।)एक मैं एक मैं + 1 एक मैं एक मैं एक मैं + 1 एक मैं + $i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

एक मूल्य के सम्मिलित करने के लिए , छोटी से छोटी खोजने के ऐसा है कि 0 तत्वों, मर्ज शामिल और , इस में स्टोर और सेट उचित रूप से।मैं एक मैं एक 0 , ... , एक मैं - 1 एक्स ए मैं सी 0 , ... , ग $x$$i$$A_i$$A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

न्यूनतम निकालने के लिए, सबसे बड़ा इंडेक्स जैसे कि में पहला तत्व और increment पर न्यूनतम है ।A i [ c i ] i c $i$$A_i[c_i]$$i$$c_i$

मानक तर्क द्वारा, यह प्रति ऑपरेशन के लिए परिशोधन समय देता है और ऊपर वर्णित आदेश के कारण स्थिर है।$O(\log n)$

सम्मिलन और अर्क के एक अनुक्रम के लिए , यह सरणी प्रविष्टियों (खाली सरणियाँ न रखें) प्लस बहीखाता पद्धति के शब्दों का उपयोग करता है। यह सवाल के मिहाई संस्करण का जवाब नहीं देता है, लेकिन यह दर्शाता है कि स्थिर बाधा को बहुत अधिक स्थान की आवश्यकता नहीं है। विशेष रूप से, यह दिखाता है कि आवश्यक स्थान पर कोई लोअर-बाउंड नहीं है।n O ( लॉग एन ) Ω ( n $n$$n$$O(\log n)$$\Omega(n)$

अपडेट: रॉल्फ फगरबर्ग बताते हैं कि यदि हम अशक्त (गैर-डेटा) मूल्यों को संग्रहीत कर सकते हैं, तो इस पूरे डेटा संरचना को आकार की एक सरणी में पैक किया जा सकता है , जहां अब तक सम्मिलन की संख्या है।$n$$n$

पहले, ध्यान दें कि हम उस क्रम में एक सरणी में पैक कर सकते हैं ( साथ पहले, इसके बाद यदि यह गैर-रिक्त है, और इसी तरह)। इस की संरचना पूरी तरह से के बाइनरी प्रतिनिधित्व द्वारा एन्कोडेड है , अब तक सम्मिलित तत्वों की संख्या। की बाइनरी प्रतिनिधित्व करते हैं स्थिति में एक 1 है , तो को घेरता है , सरणी स्थान अन्यथा यह कोई सरणी स्थानों पर कब्जा होगा।A k A k - 1 n n i A i 2 $A_k,\ldots,A_0$$A_k$$A_{k-1}$$n$$n$$i$$A_i$$2^i$

सम्मिलित करते समय, , और हमारे सरणी की लंबाई, 1 से बढ़ जाती है, और हम प्लस नए तत्व को मौजूदा इन-प्लेस स्थिर विलय एल्गोरिदम का उपयोग करके मर्ज कर सकते हैं ।ए 0 , … , ए $n$$A_0,\ldots,A_i$

अब, जहाँ हम शून्य मान का उपयोग करते हैं, काउंटरों से छुटकारा पाने में है । में , हम पहले मूल्य, जिसके बाद स्टोर शून्य मान, शेष के बाद मान। एक एक्स्ट्रेक्ट-मिन के दौरान, हम अभी भी जांच करके समय में निकालने का मान पा सकते हैं । जब हम में यह मान पाते हैं, तो हम को null करने के लिए सेट करते हैं और फिर पर बाइनरी खोज करते हैं। पहले a-null value को खोजने के लिए और और स्वैप करते हैं ।A i c i 2 i - c i - 1 O ( log n ) A 0 [ 0 ] , … , A k [ 0 ] A i [ 0 ] A i [ 0 ] A i A i [ c i ] A i [ 0 ] A i [ c i$c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

अंतिम परिणाम: संपूर्ण संरचना को एक सरणी के साथ लागू किया जा सकता है, जिसकी लंबाई प्रत्येक सम्मिलन और एक काउंटर के साथ वृद्धि होती है, , जो सम्मिलन की संख्या को गिनता है।$n$

Comments

यह O (n) अर्क के बाद किसी दिए गए इंस्टेंट पर संभावित O (n) अतिरिक्त स्थान का उपयोग करता है, नहीं? इस बिंदु पर आप प्राथमिकता को भी संग्रहीत कर सकते हैं ...

— मेहरदाद

Answer 2

मुझे यकीन नहीं है कि आपकी बाधाएं क्या हैं; निम्नलिखित योग्यता है? किसी सरणी में डेटा संग्रहीत करें, जिसे हम एक अंतर्निहित बाइनरी ट्री (जैसे एक बाइनरी हीप) के रूप में व्याख्या करते हैं, लेकिन इसके आंतरिक नोड्स के बजाय पेड़ के निचले स्तर पर डेटा आइटम के साथ। पेड़ का प्रत्येक आंतरिक नोड अपने दो बच्चों से कॉपी किए गए मानों को छोटा करता है; संबंधों के मामले में, बाएं बच्चे को कॉपी करें।

न्यूनतम खोजने के लिए, पेड़ की जड़ को देखें।

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

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

हालांकि, यह सवाल का मिहाइ के कड़े संस्करण का जवाब नहीं है, क्योंकि यह दो बार उतनी ही मेमोरी का उपयोग करता है जितना कि एक सच्चे निहित डेटा संरचना को करना चाहिए, भले ही हम लज़ीज़ को हटाने की अंतरिक्ष लागत को अनदेखा कर दें।

Comments

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

— जोनाथन ग्रेहल

Answer 3

निम्नलिखित आपकी समस्या की एक वैध व्याख्या है:

आपको A [1..N] के किसी भी सहायक जानकारी के साथ N कुंजियों को स्टोर करना होगा, जैसे कि आप समर्थन कर सकते हैं: * इन्सर्ट * डिलीट मिन, जो कई मिनिमा होने पर सबसे पहले डाला गया तत्व चुनता है

यह काफी कठिन प्रतीत होता है, यह देखते हुए कि अधिकांश अंतर्निहित डेटा संरचनाएं कुछ तत्वों के स्थानीय क्रम में एन्कोडिंग बिट्स की चाल खेलते हैं। यहां यदि कई लोग समान हैं, तो उनके आदेश को संरक्षित किया जाना चाहिए, इसलिए ऐसी कोई भी चाल संभव नहीं है।

दिलचस्प।

Comments

मुझे लगता है कि यह एक टिप्पणी होनी चाहिए, जवाब नहीं, क्योंकि यह वास्तव में मूल प्रश्न का उत्तर नहीं देता है । (आप इसे हटा सकते हैं और इसे टिप्पणी के रूप में जोड़ सकते हैं।)

— जुका सूमेला

हाँ, यह वेबसाइट थोड़ी हास्यास्पद है। हमारे पास प्रतिष्ठा, बोनस, पुरस्कार, टिप्पणी करने के सभी प्रकार हैं जो मुझे समझ नहीं सकते हैं। काश कि यह बच्चों के खेल की तरह कम होता।

— मिहई

मुझे लगता है कि टिप्पणी पोस्ट करने के लिए उसे और अधिक प्रतिनिधि चाहिए। यही समस्या है।

— सुरेश वेंकट

@ सुरेश: ओह, ठीक है, मुझे याद नहीं था। हम वास्तव में इस तरह की स्थिति को कैसे संभालने वाले हैं (यानी, एक नए उपयोगकर्ता को एक प्रश्न का उत्तर देने से पहले स्पष्टीकरण मांगने की आवश्यकता है)?

— जुका सूमेला

कोई आसान रास्ता नहीं है। मैंने इसे अक्सर MO पर देखा है। मिहाई को दोबारा प्राप्त करने में कोई परेशानी नहीं होगी, अगर इसके मिहाई मुझे लगता है कि यह :) है

— सुरेश वेंकट

Answer 4

संक्षिप्त उत्तर: आप नहीं कर सकते।

थोड़ा लंबा जवाब:

आप की आवश्यकता होगी स्टोर करने के लिए जो आप समान प्राथमिकताओं के बीच भेद करने की अनुमति देगा अपने प्रवेश की "उम्र" अतिरिक्त स्थान। और अगर आप की आवश्यकता होगी Ω ( एन ) जानकारी है कि तेजी से सम्मिलन और retrievals की अनुमति देगा के लिए जगह। साथ ही आपका पेलोड (मूल्य और प्राथमिकता)।$\Omega(n)$$\Omega(n)$

और, आपके द्वारा संग्रहीत प्रत्येक पेलोड के लिए, आप पते में कुछ जानकारी को छिपाने में सक्षम होंगे (उदाहरण के अर्थ है Y, X से पुराना है)। लेकिन उस "छिपी" जानकारी में, आप या तो "उम्र", या "तेज पुनर्प्राप्ति" जानकारी छिपाएंगे। दोनों नहीं।$addr(X) < addr(Y)$

---

बहुत ही लंबा जवाब

नोट: दूसरे भाग का बहुत अंत स्केच है, जैसा कि उल्लेख किया गया है। अगर कुछ गणित आदमी एक बेहतर संस्करण प्रदान कर सकता है, तो मैं आभारी रहूंगा।

आइए रिकॉर्ड (मूल्य और प्राथमिकता) मशीन शब्दों के साथ एक्स-बिट मशीन (32 या 64-बिट कहो) पर शामिल होने वाले डेटा की मात्रा के बारे में सोचते हैं ।$P$

आप संभावित रिकॉर्ड का एक सेट है कि आंशिक रूप से आदेश दिया है: और ( एक , 1 ) = ( एक , 1 ) , लेकिन आप तुलना नहीं कर सकते ( एक , 1 ) और ( ख , 1 ) ।$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

हालाँकि, आप अपने रिकॉर्ड के सेट से दो गैर-तुलनीय मूल्यों की तुलना करने में सक्षम होना चाहते हैं, जब वे सम्मिलित किए गए थे। इसलिए आपके पास यहां मानों का एक और सेट है: जिन्हें सम्मिलित किया गया है, और आप इसे एक आंशिक क्रम के साथ बढ़ाना चाहते हैं: iff X को Y से पहले डाला गया था ।$X < Y$$X$$Y$

बुरी से बुरी हालत में, अपनी स्मृति प्रपत्र के रिकॉर्ड के साथ भरा जाएगा (साथ ? हर एक के लिए अलग) है, तो आप जो एक तय करने के लिए चला जाता है में प्रविष्टि समय पर पूरी तरह भरोसा करना होगा पहले बाहर।$(?,1)$$?$

• सम्मिलन का समय (संरचना में अभी भी अन्य रिकॉर्ड के सापेक्ष) के लिए सूचना के बिट्स (P-byte पेलोड और मेमोरी के 2 X सुलभ बाइट्स) की आवश्यकता होती है।$X - log_2(P)$$2^X$
• पेलोड (आपके रिकॉर्ड के मूल्य और प्राथमिकता) में जानकारी के मशीन शब्दों की आवश्यकता होती है ।$P$

इसका मतलब है कि आपको किसी भी तरह से स्टोर किए गए प्रत्येक रिकॉर्ड के लिए अतिरिक्त बिट्स की जानकारी को स्टोर करना होगा। और वह के हे ( एन ) के लिए एन रिकॉर्ड।$X - log_2(P)$$O(n)$$n$

अब, प्रत्येक मेमोरी "सेल" हमें कितनी जानकारी प्रदान करती है?

• बिट्स ऑफ़ डेटा ( W मशीन की चौड़ाई होने के कारण)।$W$$W$
• पता के एक्स बिट्स।$X$

अब, मान लेते हैं कि ( 1 (पेलोड कम से कम एक मशीन शब्द चौड़ा (आमतौर पर एक ऑक्टेट) है)। इसका मतलब है कि एक्स - एल ओ जी 2 ( पी ) < एक्स , इसलिए हम सेल के पते में प्रविष्टि आदेश की जानकारी फिट कर सकते हैं। एक स्टैक में यही हो रहा है: सबसे कम पते वाली कोशिकाएं पहले स्टैक में प्रवेश करती हैं (और अंतिम निकल जाएगी)।$P \geq 1$$X - log_2(P) < X$

इसलिए, हमारी सभी जानकारी को संग्रहीत करने के लिए, हमारे पास दो संभावनाएँ हैं:

• पते में प्रविष्टि क्रम और मेमोरी में पेलोड स्टोर करें।
• मेमोरी में दोनों को स्टोर करें और कुछ अन्य उपयोग के लिए एड्रेस फ्री छोड़ दें।

जाहिर है, कचरे से बचने के लिए, हम पहले समाधान का उपयोग करेंगे।

---

अब संचालन के लिए। मुझे लगता है आप चाहते हैं:

• के साथ हे ( एल ओ जी एन ) समय जटिलता।$Insert(task, priority)$$O(log n)$
• के साथ हे ( एल ओ जी एन ) समय जटिलता।$StableExtractMin()$$O(log n)$

आइये :$StableExtractMin()$

वास्तव में सामान्य एल्गोरिथ्म इस तरह से जाता है:

1. न्यूनतम प्राथमिकता और न्यूनतम "प्रविष्टि समय" के साथ रिकॉर्ड का पता लगाएं ।$O(log n)$
2. इसे में संरचना से निकालें ।$O(log n)$
3. इसे लौटा दो।

उदाहरण के लिए, एक ढेर के मामले में, यह थोड़ा अलग तरीके से आयोजित किया जाएगा, लेकिन काम समान है: 1. में न्यूनतम रिकॉर्ड का पता लगाएं 2. इसे ओ ( 1 ) में संरचना से निकालें 3. ठीक करें सब कुछ इतना है कि अगली बार # 1 और # 2 अभी भी ओ ( 1 ) हैं "अर्थात ढेर को ठीक करें"। यह "ओ (लॉग एन)" में किया जाना चाहिए 4. तत्व वापस लौटाएं।$0(1)$$O(1)$$O(1)$

सामान्य एल्गोरिथ्म में वापस जा रहे हैं, हम देखते हैं कि समय में रिकॉर्ड खोजने के लिए , हमें 2 ( एक्स - एल ओ जी 2 ( पी ) ) उम्मीदवारों के बीच सही एक का चयन करने के लिए एक तेज़ तरीका चाहिए (सबसे खराब ) मामला, स्मृति पूर्ण है)।$O(log n)$$2^(X - log_2(P))$

इसका मतलब यह है कि हमें उस तत्व को पुनः प्राप्त करने के लिए सूचना के बिट्स को संग्रहीत करने की आवश्यकता है (प्रत्येक बिट उम्मीदवार स्थान को bisects करता है, इसलिए हमारे पास O ( l o g n n ) द्विभाजन है, जिसका अर्थ O ( l o) है g n ) समय जटिलता)।$X - log_2(P)$$O(log n)$$O(log n)$

जानकारी के इन बिट्स को तत्व के पते के रूप में संग्रहीत किया जा सकता है (हीप में, मिनट एक निश्चित पते पर है), या, उदाहरण के लिए पॉइंटर्स के साथ (एक बाइनरी सर्च ट्री में (पॉइंटर्स के साथ), आपको का पालन करने की आवश्यकता है ( l o g n ) औसतन मिनट के लिए)।$O(log n)$

अब, उस तत्व को हटाते समय, हमें अगले मिनट के रिकॉर्ड को बढ़ाने की आवश्यकता होगी , ताकि अगली बार पुनर्प्राप्ति की अनुमति देने के लिए उसके पास सही मात्रा में जानकारी हो , इसलिए उसके पास X - l o g 2 है ( पी ) जानकारी के बिट्स इसे अन्य उम्मीदवारों से भेदभाव करते हैं।$O(log n)$$X - log_2(P)$

यही है, अगर यह पहले से ही पर्याप्त जानकारी नहीं है, तो आपको कुछ जोड़ना होगा। एक (गैर-संतुलित) बाइनरी सर्च ट्री में, जानकारी पहले से ही है: आपको एलिमेंट को डिलीट करने के लिए एक NULL पॉइंटर लगाना होगा, और आगे किसी भी ऑपरेशन के बिना BST में खोजा जा सकेगा औसतन समय।$O(log n)$

$X - log_2(P)$$O(log n)$

सम्मिलन एल्गोरिथ्म को आमतौर पर केवल इस जानकारी के भाग को अपडेट करने की आवश्यकता होती है, मुझे नहीं लगता कि इसे तेजी से प्रदर्शन करने के लिए अधिक (मेमोरी-वार) खर्च होंगे।

---

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

Comments

क्या आपने वास्तव में अपना उत्तर CW बनाने का इरादा किया था?

— सुरेश वेंकट

हाँ। मेरा उत्तर 100% सही नहीं है, जैसा कि भीतर कहा गया है, और यह अच्छा होगा यदि कोई भी इसे सही कर सकता है, भले ही मैं एसओ पर नहीं हो या जो भी हो। ज्ञान बांटना चाहिए, ज्ञान परिवर्तनशील होना चाहिए। लेकिन हो सकता है कि मैंने सीडब्ल्यू के उपयोग को गलत समझा हो, यदि हां, तो कृपया मुझे बताएं :)। संपादित करें: वूप्स, वास्तव में मुझे अभी पता चला है कि मुझे सीडब्ल्यू पदों से कोई प्रतिनिधि नहीं मिलेगा और यह कि सामग्री किसी भी तरह से सीसी-विकी लाइसेंस प्राप्त है ... बहुत बुरा :)।

— सुजैन डुपरॉन

Answer 5

यदि आप अपनी प्राथमिकता कतार को संतुलित बाइनरी ट्री (एक लोकप्रिय विकल्प) के रूप में लागू करते हैं, तो आपको बस यह सुनिश्चित करना होगा कि जब आप पेड़ में कोई तत्व जोड़ते हैं, तो यह समान प्राथमिकता वाले किसी भी तत्व के बाईं ओर डाला जाता है।
इस तरह, सम्मिलन आदेश पेड़ की संरचना में ही एन्कोडेड है।

Comments

लेकिन यह संकेत के लिए O (n) स्थान जोड़ता है, जो मुझे लगता है कि प्रश्नकर्ता क्या बचना चाहता है?

— जेरेमी

Answer 6

मुझे नहीं लगता कि यह संभव है

ठोस मामला:

       x
    x    x
  x  x  1  x
1  x  

सभी x> 1 के साथ मिनट ढेर

heapifying अंततः कुछ इस तरह से एक विकल्प दे देंगे

       x
    1    1
  x  x  x  x
x  x  

अब कौन सा 1 रूट के लिए प्रचार करने के लिए?