आंशिक रूप से आदेशित की जाने वाली प्राथमिकताओं के लिए प्राथमिकता कतार

16

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

क्या कोई ढेर डेटा संरचना है जो आंशिक आदेश देने के साथ काम करेगी? या इसके साथ काम करने के लिए नियमित प्राथमिकता कतार का एक संशोधन? एल्गोरिथ्म के लिए आम पसंद मुझे साधारण बाइनरी या 4-एरी हीप है, लेकिन यह आंशिक आदेश देने के साथ काम नहीं करता है।

प्राथमिकता मान समर्थन:

ऑपरेशन का उपयोग करके आंशिक आदेश देना $\preccurlyeq$ । यह आंशिक आदेश है, तो यह संभव है कि $a \preccurlyeq b$ गलत है और $b \preccurlyeq a$ भी गलत है। मैं लिखने के $a \not\lesseqgtr b$ उस मामले में।
$\inf(x_i)$ $y$ $y \preccurlyeq x_i$ $n$ $O(n)$
आंशिक आदेश देने के लिए एक रैखिक विस्तार को परिभाषित किया जा सकता है। प्राथमिकता कतार के लिए इसका उपयोग करना आसान तरीका है क्योंकि एल्गोरिथ्म उस तरह से काम करता है। लेकिन आदेश प्रदर्शन को प्रभावित करता है और सम्मिलन का क्रम ऐसा लगता है कि यह सबसे खराब मामलों से बचने में सबसे अच्छा होना चाहिए।

इसके अतिरिक्त मैं जिस एल्गोरिथ्म का उपयोग करना चाहता हूं, उसे कतार में सभी प्राथमिकताओं को जानने की जरूरत है।

प्राथमिकताओं के कुछ वास्तविक-विश्व अर्थ हैं, लेकिन परिवर्तन के अधीन हैं, इसलिए यह अन्य गुणों पर भरोसा करने के लिए व्यवहार्य नहीं लगता है जो उनके पास हो सकते हैं।

नोट: बाइनरी हीट्स आंशिक ऑर्डरिंग के साथ काम नहीं करते हैं। , और साथ एक बाइनरी हीप मान लें , जहां और और । वे उस क्रम में तैनात हैं, इसलिए $a$ $b$ $c$ $a \preccurlyeq c$ $a \not\lesseqgtr b$ $a \not\lesseqgtr c$

     a (0)
   /   \
 b (1)   c (2)

अब d डाला गया है। अगला मुक्त स्थिति 3 है, का बायां बच्चा , इसलिए हम प्राप्त करते हैं $b$

        a (0)
      /   \
    b (1)   c (2)
  /
d (3)

यदि (जिसका मतलब संक्रामिता से है, लेकिन के बारे में कुछ नहीं कहा और ) और , तो के साथ बदली नहीं प्राप्त करता है है, क्योंकि यह कम नहीं है। लेकिन यह वास्तव में से कम है , लेकिन इसके साथ इसकी तुलना नहीं की जाती है, इसलिए अब मुख्य ढेर अपरिवर्तनीय नहीं है; शीर्ष न्यूनतम नहीं है। $d \preccurlyeq a$ $d \preccurlyeq c$ $d$ $b$ $d \not\lesseqgtr b$ $d$ $b$ $a$

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

नोट: ऑर्डर करना आंशिक है और जबकि इसके लिए एक रैखिक विस्तार को परिभाषित करने के तरीके हैं, टाइमस्टैम्प जोड़ना और द्वितीयक मानदंड के रूप में इसका उपयोग करना उनमें से एक नहीं है। मान लीजिए हम टाइमस्टैम्प सौंपा प्रत्येक के लिए और आदेश परिभाषित के रूप में iff या ( और । तो फिर लगता है हम अलग है , $t(a)$ $a$ $\preccurlyeq'$ $a \preccurlyeq' b$ $a \preccurlyeq b$ $b \not\preccurlyeq a$ $t(a) \le t(b)$ $a$ $b$ , , जैसे कि और । फिर और , लेकिन है, इसलिए संबंध सकर्मक नहीं है और इसलिए सभी को एक एक आदेश नहीं है। इस तरह का विस्तार केवल कमजोर आदेशों के लिए काम करता है, लेकिन आंशिक रूप से नहीं। $c$ $t(a) \le t(b) \le t(c)$ $c \le a$ $a \preccurlyeq' b$ $b \preccurlyeq' c$ $c \preccurlyeq' a$

संपादित करें: मुझे एहसास हुआ कि न केवल किसी भी सेट को परिभाषित करने के लिए अनंत है, लेकिन मुझे वास्तव में कतार में वर्तमान में कुशलता से तत्वों को प्राप्त करने में सक्षम होने की आवश्यकता है। इसलिए मैं अब इस बात पर विचार कर रहा हूं कि क्या कुछ सामान्य ढेर संरचना में उपप्रकार वाले विशेष नोड्स को जोड़ने से मदद मिलेगी।

data-structures priority-queues

— जान हुदेक
स्रोत

क्या आपने अनुक्रमित प्राथमिकता कतार पर विचार किया है?

@hulkmeister: क्या आप यह समझा सकते हैं कि कतार में अनुक्रमित होने से यह आंशिक क्रम के साथ काम करता है (नहीं, सादा बाइनरी हीप आंशिक आदेश के साथ काम नहीं करता है)?

1

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

1

@hulkmeister: खैर, समस्या इससे कहीं ज्यादा गहरी है। जब कोई नया आइटम डाला जाता है, तो प्राथमिकता कतार सामान्य रूप से कुछ तत्व के साथ तुलना करती है। लेकिन अगर वे अतुलनीय हैं, तो यह आसानी से नहीं पता है कि इसे कहां डालना है। और सूचकांक के साथ असंतुलन काम नहीं करेगा, क्योंकि सूचकांक बदल जाता है और क्योंकि यह संभवत: प्राथमिकता के अनुरूप कुल ऑर्डर नहीं देगा।

क्या आप इस यौगिक प्रकार के कुछ उदाहरण दे सकते हैं, और जब यह अतुलनीय है? क्या इन 'अतुलनीय' मूल्यों पर विचार करना संभव है? यदि हां, तो आप उन्हें प्रविष्टि के क्रम में एक ही नोड में संग्रहीत कर सकते हैं।

3

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

यह विचार अनिवार्य रूप से आंशिक रूप से निर्धारित सेट का एक टोपोलॉजिकल ऑर्डर खोजने के लिए है। यही कारण है, एक कुल आदेश ' ' है कि इस तरह $\le_T$ । सिर्फ एक lexicographical क्रम 'का उपयोग करें: एक उत्पाद आदेश का उपयोग कर वैक्टर के लिए, यह काफी आसान है ,' है, जिसकी पहली "घटक" सभी उत्पाद आदेश के लिए इस्तेमाल किया घटकों का योग (घटकों के बाकी अनिवार्य रूप से मनमाने ढंग से हो रहा है तो आप भी एक कमजोर क्रम से चिपक सकते हैं)। हम तो देख सकते हैं कि $\mathbf{a}\le\mathbf{b}\implies \mathbf{a}\le_T\mathbf{b}$ $\le_S$ और

a < b ⟹ \forall_{i} (a_{i} \leq b_{i}) and \exists_{i} (a_{i} < b_{i}) ⟹ (\sum_{i} a_{i}) < (\sum_{i} b_{i}) ⟹ a \leq_{S} b

$\mathbf{a}<\mathbf{b}\implies \forall_i(a_i\le b_i)\text{ and }\exists_i(a_i<b_i)\implies(\sum_i a_i)<(\sum_i b_i)\implies\mathbf{a}\le_S\mathbf{b}$

और इस प्रकार है कि

a = b ⟹ \forall_{i} (a_{i} = b_{i}) ⟹ (\sum_{i} a_{i}) = (\sum_{i} b_{i}) ⟹ a \leq_{S} b,

$\mathbf{a}=\mathbf{b}\implies \forall_i(a_i=b_i)\implies(\sum_i a_i)=(\sum_i b_i)\implies\mathbf{a}\le_S\mathbf{b},$

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

a \leq b ⟹ a \leq_{S} b

$\mathbf{a}\le\mathbf{b}\implies\mathbf{a}\le_S\mathbf{b}$

— सूर्यकांत मणि
स्रोत

कई और विकल्प हैं। कम से कम गैर-नकारात्मक गुणांकों के साथ न्यूनतम, अधिकतम, किसी भी रैखिक संयोजन के घटकों में से एक का उपयोग करना। विस्तार की पसंद प्रभावित करती है कि ओवरलेइंग एल्गोरिदम कितनी तेजी से होगा।

— Jan Hudec

2

आपके आंशिक आदेश को पूरा करने में क्या गलत है?

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

यदि आप 'सबसे पहले' पसंद करते हैं, तो आपका आदेश प्रभावी रूप से पूरा हो गया है; 'अतुलनीय' आइटम उम्र के हिसाब से तुलनीय हैं।

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

3

यह बहुत अच्छा होगा अगर इसे आंशिक आदेश देने का एक रैखिक विस्तार किया जा सके। लेकिन ऐसा नहीं है। चलो 3 अलग-अलग मान, क्रम में नहीं डाला गया एक , ख , ग , जैसे कि सी ≤ एक और ख या तो साथ अतुलनीय है। में टाइमस्टैम्प भरण साथ विस्तार एक ≤ 'बी और बी ≤' ग , तो संक्रामिता से अब एक से कम होना चाहिए ग , लेकिन उस के विपरीत है वास्तविक आदेश।

शायद आपने इसे कमजोर आदेश देने के साथ भ्रमित किया। अतुलनीय तत्वों को कमजोर करने के क्रम में समतुल्य कक्षाएं बनती हैं, जिससे आप मनमाना अतिरिक्त मानदंड जोड़ सकते हैं। आंशिक आदेश के लिए आप नहीं कर सकते।

1

EDIT: यह एक दिलचस्प समस्या लगती है, और मैंने इसके बारे में थोड़ा शोध किया था। मेरा सुझाव है कि आप निम्नलिखित पढ़ें:

डारेल रेमंड। आंशिक आदेश डेटाबेस, पीएचडी थीसिस, वाटरलू विश्वविद्यालय।

मेरा सुझाव है कि आप इस पत्र को पढ़ें: दास्कलाकिस, कॉन्स्टेंटिनोस, एट अल। "सॉर्टिंग और पोज़ में चयन।" 40.3 (2011) कम्प्यूटिंग पर SIAM जर्नल: 597-622।

लेखक यहां चेनमर्ज़ नामक एक डेटा संरचना प्रस्तुत करते हैं जो एक पोज़ को स्वीकार करता है और चैन में पोज़ की एक श्रृंखला अपघटन । डेटा संरचना का आकार । लेखक में चलने वाले मिनिमस को खोजने के लिए एक एल्गोरिथ्म प्रस्तुत करता है जहां पोज़ की चौड़ाई पर एक ऊपरी बाध्य है। .. मुझे लगा कि शायद यह दिलचस्प है। $q$ $O(n q)$ $O(w n)$ $w$

नोट: मैंने एक पिछला भोला उत्तर हटा दिया। कृपया इसे देखने के लिए संपादन पर क्लिक करें।

— AJed
स्रोत

0

मेरी शब्दावली का उपयोग गलत हो सकता है। आप जो भी समस्या पाते हैं, उसे ठीक करने के लिए कृपया मेरे उत्तर को सीधे संपादित करें।

पहले, पारस्परिक रूप से अतुलनीय सेट को इनपुट से पता लगाने की आवश्यकता होती है।

उदाहरण के लिए, 5 वस्तुएं हो सकती हैं a, b, c, d, e, लेकिन उनके आंशिक क्रमबद्ध रूप से दो डिस्कनेक्ट किए गए रेखांकन हैं:

a ≤ b ≤ c
d ≤ e
लेकिन किसी भी के {a, b, c}साथ अतुलनीय है {d, e}।

इससे पहले कि वस्तुओं को एक उपयुक्त डेटा संरचना में संग्रहीत किया जा सके, इन पारस्परिक रूप से अतुलनीय सेटों को पहले पता लगाया जाना चाहिए। यह एक संघ खोज एल्गोरिथ्म के साथ किया जा सकता है

दक्षता के लिए, एक नई वस्तु के सम्मिलन के लिए "मौजूदा वस्तुओं की सूची जो इस महत्वपूर्ण वस्तु के साथ तुलनीय है" को खोजने का एक कुशल तरीका होना चाहिए।

अब, प्रत्येक सबसेट (क्रमशः {a, b, c}और {d, e}) के भीतर, मिनीमा को अच्छी तरह से परिभाषित किया जाना चाहिए। (प्रत्येक सबसेट के लिए आंशिक आदेश देने के कारण एक या अधिक मिनीमा हो सकता है ।)

मैं इसे एक निर्देशित चक्रीय ग्राफ के रूप में देखता हूं । उसे ढेर में फिट करने की कोशिश विनाशकारी लगती है।

इस समग्र डेटा संरचना से मिनीमा निकालने के लिए, अगला कदम सभी सबसेट्स से सभी मिनीमा की सूची प्राप्त करना है, जल्द से जल्द टाइमस्टैम्प के साथ एक को चुनें, और इस ऑब्जेक्ट को हटा दें और वापस कर दें।

— rwong
स्रोत

दुर्भाग्य से मैं तुलनात्मक वस्तुओं की सूची को कुशलता से खोजने का तरीका नहीं देखता।

आंशिक रूप से ऑर्डर किए गए सेट को वास्तव में निर्देशित चक्रीय ग्राफ के रूप में देखा जा सकता है। लेकिन एक आसन्न तालिका (कार्य, वास्तव में) द्वारा दिए गए आसन्न सूची के बजाय। आसन्न सूची द्वारा दिए गए पोसेट का मिनिमा खोजना आसान है, लेकिन आसन्न तालिका के लिए यह एक समस्या है।

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

1

आपको लगता है कि हेस आरेख एक प्रकार का वृक्ष (समान रूप से पथ रेखांकन) का एक जंगल है, लेकिन सवाल पहले से ही बताता है कि यह एक उत्पाद क्रम है, इसलिए एक बहु-आयामी जाली है।

— पीटर टेलर

0

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

यहाँ कुछ स्यूडोकोड है।

class PartialOrderPriorityQueue
   q <- empty list
   method insert (n):
     for i <- 0 to (q.length - 1):
       if q[i] <= n:
         t <- q[i]
         q[i] <- n
         n <- t
     q.append(n)

   method pop():
     return q.remove(0)

— जेरेमी सूची
स्रोत

-1

सामान्य हील व्यवहार वापस करने के लिए नए मूल्य संलग्न करने के लिए है, और फिर अपने माता पिता की तुलना में अधिक है, जबकि झारना।

यदि आप एक तुलना लिखते हैं जो माता-पिता के लिए समान है और बच्चे के लिए तुलनीय मामला नहीं है, क्योंकि माता-पिता बच्चे की तुलना में अधिक है , तो अभी भी सही बिंदु पर समाप्त होना चाहिए।

क्या यह आपके उद्देश्यों के लिए पर्याप्त रूप से स्थिर आदेश के रूप में गिना जाता है?

स्पष्ट करने के लिए, अपनी टिप्पणी से उदाहरण लें: a> b , और c , a या b से तुलना करने योग्य नहीं है :

a फिर b फिर c => a, b, c ... यह पहले से ही ढेर क्रम में है, और कुछ भी कभी भी ऊपर-नीचे नहीं होता है
बी, ए, सी => ए, बी, सी ... a को इसकी सही जगह तक भेजा जाता है, और फिर से हम सही ढेर क्रम में हैं
a, c, b => a, c, b ... b sift up नहीं कर सकता क्योंकि यह c के साथ तुलनीय नहीं है, लेकिन यह आपको FIFO क्रम में छोड़ देता है जैसा आपने पूछा
c, b, a => c, a, b ... a और b सही सापेक्ष क्रम में हैं, लेकिन न तो c से आगे निकल सकते हैं क्योंकि उनकी तुलना इसके साथ नहीं की जा सकती है

इसलिए, परिणाम सम्मिलन के आदेश पर निर्भर करता है - ऐसा लगता है कि आप जो पूछते हैं, वह मेल खाता है, लेकिन मुझे यकीन नहीं है कि क्या यह वास्तव में आप चाहते हैं। यदि ऐसा नहीं है, तो क्या आप उस परिणाम को दिखा सकते हैं जिसे आप देखने की आशा करते हैं?

ठीक है, इसलिए आपकी टिप्पणी (और आपके प्रश्न को संपादित करें) से, आप चाहते हैं कि "तुलनीय" तत्व "गैर-तुलनीय" लोगों को छलांग दें और यदि कोई है, तो आदेश के तहत सही स्थान ढूंढें। मैंने इस बारे में पूछा क्योंकि मुझे यकीन नहीं था कि कैसे व्याख्या की जाए

यदि कुछ तत्व अतुलनीय हैं, तो यह उन्हें उस क्रम में लौटाता है जिस क्रम में उन्हें डाला गया था

(d और b आपके संपादन में जोड़ीदार अतुलनीय हैं, लेकिन आप नहीं उन्हें उस क्रम में चाहते हैं जो उन्हें सम्मिलित किया गया था)।

मेरा अगला प्रश्न "तुलनीय" और "गैर-तुलनीय" तत्वों के बीच के संबंध के बारे में रहा होगा, लेकिन मुझे लगता है कि आपने अब खुलासा किया है कि वे उत्पाद क्रम में वैक्टर हैं (यह स्पष्ट नहीं था कि कुछ तत्व जोड़ीदार थे- सब कुछ के साथ अतुलनीय , जैसे NaN, या क्या)।

इसलिए, यदि मैं आपका नया उदाहरण लेता हूं और वेक्टर मान निर्दिष्ट करता हूं, तो क्या यह सही है कि यह एक ऐसा उदाहरण है जहां b किसी और चीज के लिए तुलनीय नहीं है:

        a (1,1)
      /      \
    b (0,4)   c (3,3)
  /
d (2,2)

और इसे इस तरह करना चाहिए:

        a (1,1)
      /      \
    d (2,2)   c (3,3)
  /
b (0,4)

?

— निकम्मा
स्रोत

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

खैर, यह अभी तक सबूत नहीं है। अभी तक आदेश की परवाह न करें और सबूत दें कि इस तरह के ढेर में हमेशा शीर्ष पर न्यूनतम तत्व होता है (नोट: (अधिक) आम सम्मेलन और एल्गोरिथम की वास्तविक आवश्यकता शीर्ष पर न्यूनतम है , इसलिए यदि a> b , b पहले आता है) )।

वास्तव में मुझे संदेह है कि प्रति-उदाहरण है। मान लीजिए कि a , b और c ढेर में हैं, and b और , c , a , शीर्ष है, b बचा हुआ बच्चा है, c सही बच्चा है। अब d आता है कि d and c और a और b के साथ अतुलनीय है । यह बी के बच्चे के रूप में डाला जाता है , कम नहीं है और वहां रहता है। अब e आता है जो c ( e (इस प्रकार ) e ) भी है और b के लिए अतुलनीय है । इसलिए ई सही बच्चे के रूप में जाता है b केऔर रहता है। अब एक निकालें (ठीक है, एक न्यूनतम है), ई यह जगह में बदली और नीचे sifted हो जाता है। यह b से अतुलनीय है , लेकिन c से कम है , इसलिए c के साथ स्वैप होता है । अब c , WRONG , d । C निकालें ।

यदि आपको पिछली टिप्पणी में कोई गलती दिखती है (जिसे असमानता का एक रूप होना चाहिए, जो कि संक्रामकता के कारण पकड़ना पड़ता है और मैं इसे याद करता हूं), तो आपके पास अभी भी एक मौका होगा। अन्यथा यह काम नहीं करेगा।

1

ठीक है, यहां तक कि सरल काउंटर-उदाहरण। मान लीजिए एक , ख और ग ढेर में हैं, एक ≤ ग , ख या तो साथ अतुलनीय है। a। शीर्ष, b बाएं बच्चा है, c दायां बच्चा है। d इसलिए आता है कि d ( a (इस प्रकार d and c ) और b के साथ अतुलनीय है । अगला मुफ्त स्लॉट बी और डी के बाएं बच्चे के रूप में अतुलनीय है, इसलिए यह वहां रहता है। अब ए , गलत , डी ≤ ए निकालें । ध्यान दें कि क्या एक ≤ सीया नहीं, कोई फर्क नहीं पड़ता, स्थिति वही है अगर वे अतुलनीय थे।