एक द्विआधारी खोज वृक्ष में विलोपन

Question

एक द्विआधारी खोज वृक्ष में विलोपन

वोट

5

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

हटाए जाने से, मेरा मतलब ए नोट से सभी नोड्स बी में मौजूद हटाएँ: बी जरूरी ए के एक सबट्री नहीं है

उदाहरण के लिए:
एक:

      50   
     / \  
    10  75  
   /   / \  
  1   60   90

बी:

     10
     / \
    1   75

जिसके परिणामस्वरूप पेड़ होना चाहिए:

: दो दृष्टिकोण मेरे मन में आए
A1:
नोड * deleteTree (नोड * एक, नोड * बी);
पेड़ बी की जड़ पेड़ एक से इस नोड (सामान्य BST विलोपन विधि द्वारा) को हटाएँ लो। अगला को दो भागों में विभाजित समस्या - बी के बाईं सबट्री और बी के अधिकार सबट्री सबट्री, recurse से प्रत्येक के लिए के लिए। बाईं सबट्री के लिए, नोड जो नोड जो नष्ट कर दिया गया पर कब्जा कर लिया रूट के रूप में पेड़ ए के लिए सही सबट्री के लिए पेड़ ए के लिए रूट के रूप में सर्वर चाहिए काम करना चाहिए, नष्ट कर दिया नोड के लिए inorder उत्तराधिकारी

A2: अन्य दृष्टिकोण एक छोटे से अजीब है। मैं पेड़ ए के inorder और अग्रिम आदेश ट्रावर्सल का पता लगाएं और प्रत्यावर्तन के साथ द्विआधारी खोज का उपयोग कर (हम न अग्रिम आदेश को संशोधित) पेड़ बी में सभी नोड्स को नष्ट पाते हैं। अंत में inorder (शेष) और अग्रिम आदेश (अपरिवर्तित) से हमारे BST recostruct।

एक समस्या: BST के लिए एक कारगर तरीका का पता लगाएं।
समस्या बी: किसी भी बाइनरी पेड़ (न केवल BST) के लिए एक कारगर तरीका का पता लगाएं।

algorithm binary-tree binary-search-tree

31/08/2011 को 10:06
का स्रोत उपयोगकर्ता letsc

अन्य भाषाओं में...

2 जवाब

वोट

0

जिस तरह से मैं इसे देख, तुम क्यों ख का एक inorder ट्रावर्सल नहीं करते हैं। फिर, जब तक सरणी खाली नहीं है, एक नियमित सरणी सूचकांक के मूल्य के लिए एक से हटाना है। Traversal हे (एन) और हटाने के लिए प्रत्येक सूचकांक हो जाएगा ओ (logn)। पूरी तरह से, इस आपरेशन ओ (nlogn) हो जाएगा।

31/08/2011 को 10:27
का स्रोत उपयोगकर्ता Dhruv Gairola

Mu Qiao · Accepted Answer · 2011-08-31 14:12

समस्या एक

मुझे लगता है दो पेड़ों संतुलित हैं।

void deleteTree(node* A, node* B)
{
    if(A == NULL || B == NULL)
        return;

    if(A->data == B->data)
    {
        deleteTree(A->left, B->left);
        deleteTree(A->right, B->right);
        removeNode(A); // Normal BST remove
    }
    else if(A->data > B->data)
    {
        Node* right = B->right;
        B->right = NULL;
        deleteTree(A->left, B);
        deleteTree(A, right);
    }
    else // (A->data < B->data)
    {
        Node* left = B->left;
        B->left = NULL;
        deleteTree(A->right, B);
        deleteTree(A, left);
    }
}

समय जटिलता:

T(N) = 2 * T(N / 2) + O(1)

तो कुल मिलाकर जटिलता है हे (एन) मास्टर प्रमेय के अनुसार। अंतरिक्ष जटिलता है हे (1) । एक दोष मैं बी विलुप्त है

पुनश्च: मैं हाथ में एक BST कार्यान्वयन तो मैं आप के लिए कोड का परीक्षण नहीं कर सकते हैं की जरूरत नहीं है। लेकिन मुझे लगता है विचार सही है।

समस्या बी

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