Hogyan lehet megtalálni a rangot egy csomópont egy AVL-fa?

Helyezett a csomópontok száma a bal al fa plusz egy, és kiszámítjuk minden egyes csomóponthoz. Hiszem rang nem olyan fogalom sajátos AVL fák - kiszámítható bármely bináris fa.

Select éppen ellentétes a rangsorban. A rank van adva, és vissza kell térni egy csomópont megfelelő, hogy rangsorolja.

A következő kód végrehajtja rank számítás:

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));
        }
}

Itt a kód írtam és jól dolgozott AVL fa, hogy a rangot egy bizonyos értéket. különbség csak akkor használható egy csomóponti paramétert és én használt kulcsfontosságú paraméter. módosíthatja ezt a maga módján. Minta kód:

    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;
}

[NB] Ha meg szeretné kezdeni a rangot 0 inicializálja változó rang = 0. akkor feltétlenül kell hajtania az eljárás countNodes (), hogy végre ezt a kódot.

Itt van, amit tettem. Az én programot rangot egy elem definíciója 1+ (nincs az elemek nagyobb elem). Akkor itt megjegyezni, hogy az elem nem kell bemutatni a fán.

Algoritmust találni helyezés:

1.In fastruktúrája nyomon követheti a nem az elemek egy al-fa, beleértve a gyökér. Tehát a fejét a fa tartalmaz összesen elemek a fa.

2.Compare az elemet egy csomópont, ha ez kisebb, mint a csomópont van, akkor (1 + létszám elemek helyes gyerek) elemek nagyobb, mint a kulcs element.Add ez a teljes és rekurzív keresés az elemet a bal gyermek.

3.Ha az elem nagyobb, mint a gyökér, akkor csak keressen az elem rekurzívan a jobb gyermek. (Nem kell hozzá semmit, mert mi elhanyagoljuk a bal fa, amelyben az összes elem kisebb, mint a megadott kulcs)

4.Terminate az algo, ha megtalálja az elem elérésekor null.

Az adott program nem ad vissza az elem nagyobb, mint az adott gombot. 1+ a visszaadott érték a rangsorban.

kódrészlet:

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);
   }

Remélem ez segít :)