पुनरावृत्ति क्रंमोत्तर पार BST?

वोट
-1

मैं दो सवाल, 1) किसी भी पुनरावर्ती एल्गोरिदम के लिए, वहाँ एक पुनरावृत्ति एल्गोरिथ्म मौजूद है, यह सही है? मुझे लगता है कि यह सही है, क्योंकि आप बस ढेर का उपयोग करने के explicit.And यह इस सवाल में पुष्टि की है यात्रा करने के लिए प्रत्यावर्तन से जाने के लिए रास्ता

2) शायद ऊपर की तरह एक ही सवाल है, मैं वास्तव में लगता है कि पुनरावृत्ति समाधान स्पष्ट या यहाँ तक कि पुनरावर्ती एल्गोरिदम के साथ लिखने के लिए आसान है न। उदाहरण के लिए: एक क्रंमोत्तर (LRN) या inorder (LNR) BST पार के लिए, आप इसे कैसे पुनरावृत्ति विधि के साथ लिख सकता है? इन दोनों मामलों में, यह ढेर में डालने के लिए पहली वस्तु को खोजने के लिए आसान नहीं है। वहीं मुझे अटक मिल गया है।

कोई सुझाव? असल में, मेरा उद्देश्य उपरोक्त प्रश्न के रूप में एक ही है, एक सामान्य पैटर्न पुनरावृत्ति वालों के लिए पुनरावर्ती एल्गोरिदम को बदलने के लिए खोजने की कोशिश।

24/05/2011 को 08:45
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


1 जवाब

वोट
0

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

एक पुनरावर्ती संस्करण में प्रत्येक समारोह कॉल समारोह कॉल के साथ जुड़े नोड यात्रा करने के लिए करना चाहता है। समारोह में इस तरह कोडित है कि सक्रियण फ्रेम एक नोड के लिए इसी प्रणाली ढेर (है कि इस प्रक्रिया के ढेर क्षेत्र) पर सहेजा जाता है इससे पहले कि यह अपने मुख्य काम कर सकते हैं, यानी नोड पर जाएँ। यह इसलिए है कि हम नोड में ही जाकर से पहले नोड के बाईं सबट्री यात्रा करना चाहते हैं क्योंकि।

बाद छोड़ दिया सबट्री का दौरा किया है, आंतरिक ढेर और हमारे नोड के लिए एक यात्रा से एक ही पॉपिंग भाषा वातावरण में हमारे बचाया नोड परिणामों के फ्रेम के लिए एक वापसी अब अनुमति दी है।

हम इस पर जोर दे और एक स्पष्ट ढेर साथ पॉपिंग नकल करने के लिए किया है।

template<class T>
void inorder(node<T> *root)
{
    // The stack stores the parent nodes who have to be traversed after their
    // left sub-tree has been traversed
    stack<node<T>*> s;

    // points to the currently processing node
    node<T>* cur = root;

    // Stack-not-empty implies that trees represented by nodes in the stack
    // have their right sub-tree un-traversed
    // cur-not-null implies that the tree represented by 'cur' has its root
    //   node and left sub-tree un-traversed
    while (cur != NULL || !s.empty())
    {
        if (cur != NULL)
        {
            for (; cur->l != NULL; cur = cur->l) // traverse to the leftmost child because every other left child will have a left subtree
                s.push(cur);
            visit(cur); // visit him. At this point the left subtree and the parent is visited
            cur = cur->r; // set course to visit the right sub-tree
        }
        else
        {// the right sub-tree is empty. cur was set in the last iteration to the right subtree
            node<T> *parent = s.top();
            s.pop();
            visit(parent);
            cur = parent->r;
        }
    }
}

इस को समझने के लिए सबसे अच्छा तरीका है प्रत्येक कॉल और पुनरावर्ती संस्करण की वापसी पर कागज पर आंतरिक ढेर के कामकाज आकर्षित करने के लिए है।

24/05/2011 को 15:31
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more