कैसे एक AVL पेड़ में एक नोड के पद को खोजने के लिए?

रैंक वाम उप पेड़ प्लस वन में नोड्स की संख्या है, और हर नोड के लिए गणना की जाती है। मेरा मानना ​​है कि रैंक एक अवधारणा AVL पेड़ के लिए विशिष्ट नहीं है - यह किसी भी द्विआधारी पेड़ के लिए गणना की जा सकती।

चयन सिर्फ रैंक करने के लिए विपरीत है। एक रैंक दिया जाता है और आप एक नोड मिलान कि रैंक वापस लौटाना होगा।

निम्नलिखित कोड रैंक गणना प्रदर्शन करेंगे:

void InitRank(struct TreeNode *Node)
{
        if(!Node)
        {
                return;
        }
        else
        {       Node->rank = 1 + NumeberofNodeInTree(Node->LChild);
                InitRank(Node->LChild);
                InitRank(Node->RChild);
        }

}


int NumeberofNodeInTree(struct TreeNode *Node)
{
        if(!Node)
        {
                return 0;
        }
        else
        {
                  return(1+NumeberofNodeInTree(Node->LChild)+NumeberofNodeInTree(Node->RChild));
        }
}

यहाँ कोड मैं लिखा था और ठीक से काम किया AVL ट्री एक विशेष मान की रैंक पाने के लिए है। अंतर केवल आपके पैरामीटर के रूप में एक नोड प्रयोग किया जाता है और मैं एक महत्वपूर्ण एक पैरामीटर का उपयोग किया। आप अपने खुद के तरीके के रूप में इस संशोधित कर सकते हैं। नमूना कोड:

    public int rank(int data){
    return rank(data,root);
}

private int rank(int data, AVLNode r){
    int rank=1;
    while(r != null){
        if(data<r.data)
            r = r.left;
        else if(data > r.data){
            rank += 1+ countNodes(r.left);
            r = r.right;
        }
        else{
            r.rank=rank+countNodes(r.left);
            return r.rank;
        }
    }
    return 0;
}

[एनबी] क्या आप तो चर रैंक प्रारंभ = 0 0 से अपनी रैंक प्रारंभ करना चाहते हैं। आप निश्चित रूप से विधि countNodes () इस कोड को निष्पादित करने के लिए लागू किया जाना चाहिए था।

यहाँ मैं क्या किया है है। मेरे कार्यक्रम में एक तत्व के पद 1+ (उस तत्व से अधिक तत्वों का कोई) के रूप में परिभाषित किया गया है। आप यहाँ नोट कर सकते हैं कि तत्व पेड़ में मौजूद नहीं है।

एल्गोरिथ्म रैंक को खोजने के लिए:

वृक्ष संरचना 1.In जड़ सहित एक उप पेड़ में तत्वों का कोई पर नज़र रखें। तो पेड़ इच्छा के सिर पेड़ में कुल तत्व शामिल हैं।

एक नोड के साथ तत्व 2.Compare, अगर यह नोड से छोटी है, तो (1 + संख्या सही बच्चे में तत्वों) तत्वों से अधिक कुंजी की कुल करने के लिए इसे element.Add कर रहे हैं और रिकर्सिवली में तत्व खोज बाईं बच्चे।

3. यदि तत्व रूट नोड से अधिक होता है तो बस रिकर्सिवली तत्व खोज सही बच्चे में। (कुछ भी जोड़ने की आवश्यकता के बाद से हम छोड़ दिया पेड़ की उपेक्षा कर रहे हैं, जिसमें सभी तत्वों को किसी कुंजी की तुलना में कम कर रहे हैं)

algo 4.Terminate जब आप पाते हैं तत्व अशक्त में पहुँच रहे हैं।

दिए गए कार्यक्रम को देखते हुए प्रमुख से अधिक तत्वों का कोई देता है। 1 + दिए गए मान रैंक है।

सांकेतिक टुकड़ा:

int AVLUtils::rank(Node *root,long long val)
  {
    int n_ele_greater=0;
    int rank =0;

    if(root == NULL)
    return 0;
   if(val < root->key)
     {
    n_ele_greater = 1+this->n_elements(root->right_child)+this->rank(root->left_child,val);
     }
   else if(val > root->key)
     {
    n_ele_greater=this->rank(root->right_child,val);
    }

    else if(val == root->key)
    {
    return(this->n_elements(root->right_child));
    }
    return(n_ele_greater);
   }

उम्मीद है की यह मदद करेगा :)