लगभग समान आकार के साथ treap जैसी डेटा संरचनाओं का तेज़ जुड़ना

Question

यह देखते हुए दो AVL पेड़ और और एक मूल्य ऐसी है कि , यह आसान एक नया AVL पेड़ युक्त निर्माण करने के लिए है और में मानों और समय में , जहाँ एक पेड़ की ऊँचाई को दर्शाता है (जब तक पेड़ अपनी ऊँचाई को संग्रहीत करते हैं)।टी 2 टी आर ∀ एक्स ∈ टी 1 , ∀ y ∈ टी 2 , एक्स < टी आर < y टी आर टी 1 टी 2 हे ( 1 + | ज ( टी 1 ) - एच ( टी 2 ) | ) ज ( टी ) $T_1$$T_2$$t_r$$\forall x \in T_1, \forall y \in T_2, x < t_r < y$$t_r$$T_1$$T_2$$O(1+|h(T_1) - h(T_2)|)$$h(T)$$T$

यह लाल-काले पेड़ों के लिए भी संभव है, और मैं कई अन्य प्रकार के संतुलित पेड़ों को भी मानता हूं।

क्या यह ट्रीप्स या ट्रेप-जैसी डेटा संरचनाओं के लिए संभव है? क्या होगा अगर हम छोड़ देते हैं ?$t_r$

अल्गोरिद्मिका में ट्रेप्स पेपर दिखाता है कि अपेक्षित समय में ऐसा कैसे करें। यदि लगभग एक ही आकार (या रूट प्राथमिकता) के साथ ओ (1) अपेक्षित ट्रीप्स (या ट्रेप-जैसी डेटा संरचनाओं) पर प्रदर्शन करने का एक तरीका है, तो मुझे लगता है कि बूटस्ट्रैपिंग के कपलान और टारजन की एक चाल का उपयोग करना संभव हो सकता है। डबल-लॉगरिदमिक जुड़ने के साथ ट्रेप्स (या ट्रेप-जैसी डेटा संरचनाएं) बनाने के लिए रीढ़।$O(\min(h(T_1),h(T_2)))$

Comments

यहाँ कुछ Haskell कोड मैंने लिखे हैं जो AVL पेड़ों के लगभग समान आकार के साथ तेजी से जुड़ते हुए दिखाई देते हैं

— jbapple

मुझे संदेह है कि यह संभव है, क्योंकि ऐसा लगता है (एक सबूत के बिना) कि नए नोड की अपेक्षित गहराई (मान t_r युक्त) उस स्थिति में भी स्थिर से अधिक है जहां h (T_1) = h (T_2) है।

— त्सुयोशी इतो

Tsuyoshi Ito: मैं मानता हूं, यदि आप नए नोड को उसी तरह प्राथमिकता देते हैं जैसे आप अन्य नोड्स को प्राथमिकता देते हैं। क्या होगा यदि आप इसे रूट नोड्स की तुलना में अधिक होने की गारंटी देने वाली प्राथमिकता देते हैं? यह प्राथमिकताओं के आईआईडी प्रकृति को नष्ट कर देता है, लेकिन क्या होगा यदि आप तब अन्य प्राथमिकताओं को शिफ्ट के रूप में चिह्नित करते हैं, किसी भी तरह, लगातार लाल-काले पेड़ों के रास्ते अंतिम छोर पर चिह्नित होते हैं? या क्या होगा यदि कोई केवल एक ट्रीप की पत्तियों में मूल्यों को संग्रहीत करता है, और एक t_r के बिना एक सम्मिलित करता है?

— जप्पल

N वंशज के साथ treaps में नोड्स मैं संभावना 1 / n के साथ वंशज छोड़ दिया है। यह समान रूप से आकार के treaps के लिए भी लंबे मर्ज के समय में योगदान दे सकता है - एक नई जड़ का चयन करने के लिए इसे नेविगेट करने की आवश्यकता होती है, जो कि पेड़ में औसत गहराई थीटा (lg n) के बाद से, Theta (lg n) समय भी लेती है। क्या होगा अगर n वंशज के साथ एक treap नोड में मैंने संभावना (n choose i) / 2 ^ n वाले बच्चों को छोड़ दिया है, और मान केवल B + -ट्री की तरह पत्तियों पर संग्रहीत हैं। फिर दो समान आकार के जुड़ने से अपेक्षा में एक पेड़ से दूसरे में तत्वों की एक छोटी संख्या का पुनर्वितरण होता है।

— जब्बाल

यदि मेरी गणना सही है, तो प्रत्याशित तत्वों की अपेक्षित संख्या थीटा (sqrt n) है, जो यह मानते हुए कि बाकी सब कुछ काम किया जा सकता है (जैसे उंगली खोज संपत्ति), अभी भी उम्मीद में थेटा (lg n) समय लगेगा। एक समान वितरण का उपयोग करने के बारे में क्या?

— जब्बाल

Answer 1

नहीं, यह संभव नहीं है कि साधारण ट्रीप्स के साथ ऐसा करें यदि प्राथमिकताएं यादृच्छिक हैं।

सटीक दावा मैं बनाती हूँ कि यादृच्छिक प्राथमिकताओं के साथ दो समान रूप से आकार treaps पर इस तरह के एक मर्ज को अपडेट करना होगा करने के लिए है उम्मीद में संकेत दिए गए।$\Theta(\log n)$

यहाँ एक मोटे सबूत स्केच है:

ऑपरेशन करने की अपेक्षा में आपको इंगित करने वाले बिंदुओं की संख्या पर विचार करना होगा। यह एक साबित करने के लिए आसान है के लिए बाध्य करता है, तो हम न डालें टी आर लेकिन सिर्फ विलय टी 1 और टी 2 । पर विचार करें सही रीढ़ एस 1 के टी 1 और बाईं रीढ़ एस 2 के टी 2 । एस 1 लाल और एस 2 नीले रंग के तत्वों को रंग दें। आदेश एस 1 ∪ एस $\Theta(\log n)$$t_r$$T_1$$T_2$$S_1$$T_1$$S_2$$T_2$$S_1$$S_2$$S_1 \cup S_2$प्राथमिकता से। हमें इस क्रम में हर बार रंग बदलने के लिए एक पॉइंटर बदलना होगा। चूंकि दोनों कांटा आकार उच्च संभावना के साथ, और प्राथमिकताओं यादृच्छिक हैं, यह देखने के लिए कि अनुक्रम में रंग परिवर्तन की # भी है बहुत मुश्किल नहीं है Θ ( लॉग एन ) । इसलिए हम अद्यतन करने की आवश्यकता Θ ( लॉग एन ) (जोड़े बिना मर्ज के लिए संकेत टी आर )।$\Theta(\log n)$$\Theta(\log n)$$\Theta(\log n)$$t_r$

अब मर्ज करते समय को जोड़ने से वास्तव में ज्यादा मदद नहीं मिलती है। उस स्थिति में सूचक परिवर्तनों की संख्या निम्न प्रकार से बांधी जा सकती है: क्रम S 1 poin S 2 ∪ { t r } प्राथमिकता से। अनुक्रम में t r से कम सब कुछ हटाएँ । फिर परिणामी अनुक्रम में रंग का परिवर्तन हमारा निचला भाग है। चूंकि t r में यादृच्छिक प्राथमिकता होती है , इसलिए अंतिम treap में इस पर लिखी गई सबट्री की अपेक्षित ऊँचाई O ( 1 ) होती है , इसलिए इसमें S 1 का O ( 1 ) नोड होता है।$t_r$$S_1 \cup S_2 \cup \{t_r\}$$t_r$$t_r$$O(1)$$O(1)$ अपेक्षा से कम प्राथमिकता के साथ, इसलिए हमने t r जोड़ते समय अपने निचले बाउंड मेंकेवल O ( 1 ) पॉइंटर परिवर्तनखो दिया।$S_1 \cup S_2$$O(1)$$t_r$

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

Comments

हां, मैं "treap-like" डेटा संरचना की तलाश कर रहा हूं। हालाँकि मैंने टिप्पणियों और मेरे अशुद्ध उत्तर में जितना उल्लेख किया है, मैंने इसे शीर्षक या प्रश्न में नहीं रखा है।

— jbapple

आपके उत्तर के लिए धन्यवाद। मैंने प्रश्न के शीर्षक और पाठ को बदल दिया है ताकि कम अस्पष्ट हो।

— jbapple

Answer 2

अपडेट: इस जॉइन ऑपरेशन के गलत होने के अपडेट के लिए नीचे देखें

यहाँ एक संभव समाधान का एक बहुत ही मोटा स्केच है:

मुझे लगता है कि मेरे पास एक प्रकार का बेतरतीब ढंग से संतुलित बी + -ट्री का उपयोग करके इस समस्या का समाधान हो सकता है। ट्रेप्स की तरह, इन पेड़ों का एक अनूठा प्रतिनिधित्व है। Treaps के विपरीत, वे कई बार कुछ चाबियाँ संग्रहीत करते हैं। यह ठीक करना संभव हो सकता है कि बेंट एट अल के "बायस्ड सर्च ट्रीज़" से एक चाल का उपयोग करके प्रत्येक कुंजी को केवल उच्चतम (यानी, निकटतम-से-रूट) स्तर पर संग्रहीत किया जाए, जिसमें वह दिखाई दे)

अनूठे मूल्यों के एक निर्धारित सेट के लिए एक पेड़ को पहले प्रत्येक मूल्य को बिट्स की एक धारा के साथ जोड़कर बनाया जाता है, उसी तरह एक ट्रीप में प्रत्येक मूल्य एक प्राथमिकता के साथ जुड़ा हुआ है। पेड़ में प्रत्येक नोड में एक कुंजी और एक बिट स्ट्रीम दोनों होते हैं। गैर-पत्ती के नोड्स होते हैं, इसके अलावा, एक प्राकृतिक संख्या उस नोड पर निहित पेड़ की ऊंचाई को दर्शाती है। आंतरिक नोड्स में बच्चों की कोई गैर-शून्य संख्या हो सकती है। बी + -ट्रीज की तरह, जड़ से पत्ती तक प्रत्येक गैर-आत्म-प्रतिच्छेद पथ समान लंबाई है।

प्रत्येक आंतरिक नोड में होता है (जैसे B + -Trees में) इसके वंशजों की सबसे बड़ी कुंजी k । हर एक को भी एक प्राकृतिक संख्या में शामिल हैं मैं पेड़ पर निहित की ऊंचाई का संकेत वी , और के साथ जुड़े बिट्स की धारा कश्मीर से मैं + 1 वें आगे सा। पेड़ पर निहित में हर कुंजी तो वी अपने बिट स्ट्रीम में एक ही पहली बिट है, के हर बच्चे को वी एक पत्ता है और मैं है 1 । अन्यथा, v के बच्चे आंतरिक नोड्स होते हैं, जिनमें से सभी में एक ही i बिट होता है जो उनकी कुंजी से जुड़ा होता है।$v$$k$$i$$v$$k$$i+1$$v$$v$$i$$1$$v$$i$

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

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

A 0...
B 00..
C 10..
D 0...
E 0011
F 1...
G 110.
H 0001


        ____H____
       /         \
      E           H
      |          / \
    __E__       G   H
   /  |  \      |   |
  B   C   E     G   H
 / \  |  / \   / \  |
A   B C D   E F   G H

किसी विशेष आंतरिक नोड के प्रत्येक बच्चे की बिट स्ट्रीम के पहले स्थान पर एक ही बिट है। इसे जनक का "रंग" कहा जाता है - 0 लाल है, 1 हरा है। बच्चे को एक "स्वाद" होता है जो उसकी बिट स्ट्रीम की पहली बिट पर निर्भर करता है - 0 चेरी है, 1 मिंट है। पत्तों में स्वाद होता है, लेकिन कोई रंग नहीं। परिभाषा के अनुसार, एक चेरी नोड में एक हरे माता-पिता नहीं हो सकते हैं, और एक टकसाल नोड में लाल माता-पिता नहीं हो सकते हैं।

बिट धाराओं में बिट्स को मानते हुए समान वितरण से IID होते हैं, नोड के अभिभावकों की संख्या का PMF 2 1 - n ( n - $n$$2^{1-n}$ और अपेक्षित मान(n+1)/2 है। सभी के लिएn≥2, यह है≤${n-1}\choose{i-1}$$(n+1)/2$$n \geq 2$, इसलिए अपेक्षित पेड़ की ऊंचाईहे(lgn)।$\leq \frac{3}{4}n$$O(\lg n)$

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

$1/2$$1/2$$O(1)$$1/4$, और बाद के पुनरावर्ती कॉल हमेशा विभिन्न रंगों वाले पेड़ों पर होते हैं, इसलिए एक ही विश्लेषण लागू होता है।

$1/2$$O(1)$

$O(1)$

a 01110
b 110..
c 10...
d 00000

जिस पेड़ [a,b]को ऊंचाई 2 से बनाया गया है, उस पेड़ [c,d]को ऊंचाई 2 से बनाया गया है, और जिस पेड़ को बनाया गया है joinEqual (tree [a,b]) (tree [c,d])उसकी ऊंचाई 3 है। हालांकि, जिस पेड़ को बनाया गया है [a,b,c,d]उसकी ऊंचाई 5 है।

यह कोड मैंने इस त्रुटि को खोजने के लिए उपयोग किया है ।