जब दो बच्चों के साथ एक नोड को हटाने, आप या तो अपने इन-आदेश उत्तराधिकारी नोड या उसके आदेश पूर्ववर्ती नोड चुन सकते हैं। इस मामले में यह जो है कि यह नोड के इन-आदेश पूर्ववर्ती नोड रही है इसका मतलब छोड़ दिया उप पेड़ में सबसे बड़ा मान (अपनी बाईं उप पेड़ की सबसे-दाएं बच्चे अर्थ), ढूँढने है।
एक बार जब आप प्रतिस्थापन नोड मिल जाए, आप वास्तव में नहीं है को नष्ट नोड हटाए जाने के लिए। इसके बजाय आप उत्तराधिकारी नोड से मान ले और नोड आप हटाना चाहते हैं कि मूल्य की दुकान। उसके बाद, आप उत्तराधिकारी नोड को हटा दें। ऐसा करने में आप द्विआधारी खोज पेड़ संपत्ति के बाद से आप यह सुनिश्चित करें कि आपके द्वारा चयनित नोड है कि मूल नोड के बाएं उप पेड़ के सभी बच्चों के मूल्यों की तुलना में कम है एक मूल्य होगा हो सकता है की रक्षा, और अधिक से अधिक है कि मूल्यों की तुलना मूल नोड के अधिकार उप पेड़ में सभी बच्चों के।
संपादित करें
अपने प्रश्न थोड़ा और अधिक पढ़ने के बाद, मुझे लगता है कि मैं इस समस्या मिल गया है।
आमतौर पर क्या आप के अलावा है deleteसमारोह एक है replaceसमारोह है कि प्रश्न में नोड बदल देता है। मुझे लगता है कि आप कोड की इस पंक्ति को बदलने की जरूरत:
FindParent(largestValue).Right <- 0
सेवा मेरे:
FindParent(largestValue).Right <- largestValue.Left
तो largestValueनोड एक छोड़ दिया बच्चे को नहीं है, तो आप बस मिल nullया 0। यह एक छोड़ दिया बच्चा है करता है, कि बच्चे के लिए एक स्थानापन्न हो जाता है largestValueनोड। तो तुम सही हो; कोड को ध्यान में परिदृश्य नहीं ले करता है largestValueनोड एक छोड़ दिया बच्चे को हो सकता है।
एक और संपादित करें
जब से तुम केवल एक टुकड़ा पोस्ट किया है, मुझे यकीन है कि क्या कोड के संदर्भ है नहीं कर रहा हूँ। लेकिन पोस्ट करने से स्निपेट समस्या आप सुझाव है (गलत नोड की जगह) है लगता है। आम तौर पर, तीन मामलों रहे हैं, लेकिन मैं लगता है कि आपकी स्निपेट में टिप्पणी कहते हैं //Case 4(ताकि शायद कुछ अन्य संदर्भ है)।
इससे पहले, मैं तथ्य यह है कि उल्लेख deleteआम तौर पर एक के साथ आता है replace। तो अगर आप को खोजने के largestValueनोड, आप इसे दो साधारण मामलों (कोई बच्चों के साथ नोड, और एक बच्चे के साथ नोड) के अनुसार हटा दें। आप दो बच्चों के साथ एक नोड को हटाने के लिए छद्म कोड देख रहे तो अगर, यह है कि क्या करना है:
get largestValue from nodeToRemove.Left
nodeToRemove.Value <- largestValue.Value
//now replace largestValue with largestValue.Left
if largestValue = largestValue.Parent.Left then
largestValue.Parent.Left <- largestValue.Left //is largestValue a left child?
else //largestValue must be a right child
largestValue.Parent.Right <- largestValue.Left
if largestValue.Left is not null then
largestValue.Left.Parent <- largestValue.Parent
मैं यह अजीब है कि एक डाटा संरचनाओं और एल्गोरिदम किताब की इस भाग छोड़ना होगा लगता है, इसलिए मैं यह करने के लिए आसान बनाने के लिए पुस्तक की उपलब्धता लगता है आगे (के बाद से वहाँ तीन मानक मामलों रहे हैं) के लिए कुछ और मामलों में हटाए जाने को विभाजित करने के लिए इच्छुक हूँ समझना।
कि इसके बाद के संस्करण कोड काम करता है साबित करने के लिए निम्न पेड़ पर विचार करें:
8
/ \
7 9
मान लीजिए कि आप को नष्ट करना चाहते हैं 8। आप खोजने की कोशिश largestValueसे nodeToRemove.Left। यह आपको देता है 7के बाद से बाईं उप पेड़ केवल एक ही बच्चा है।
तो फिर तुम कार्य करें:
nodeToRemove.Value <- largestValue.Value
जिसका मतलब है:
8.value <- 7.Value
या
8.Value <- 7
तो अब अपने पेड़ इस तरह दिखता है:
7
/ \
7 9
आप प्रतिस्थापन नोड से छुटकारा पाने की जरूरत है और इसलिए आप को बदलने के लिए जा रहे हैं largestValueके साथ largestValue.Left(जो null)। तो सबसे पहले आपको पता लगाना बच्चे की तरह क्या 7है:
if largestValue = largestValue.Parent.Left then
जिसका मतलब है:
if 7 = 7.Parent.Left then
या:
if 7 = 8.Left then
चूंकि 7यह है 8की बाईं बच्चे, प्रतिस्थापित करने की आवश्यकता 8.Leftके साथ 7.Right( largestValue.Parent.Left <- largestValue.Left)। के बाद से 7कोई संतान नहीं है, 7.Leftरिक्त है। तो largestValue.Parent.Leftशून्य पर (जो प्रभावी रूप से अपने बाएँ बच्चे को हटाता है) सौंप दिया जाता है। तो इसका मतलब है कि आप निम्नलिखित पेड़ के साथ अंत:
7
\
9
