Hoe tot de rang van een knooppunt in een AVL boom te vinden?

Rank is het aantal knooppunten in het linker sub boom plus één, en wordt berekend voor elke node. Ik geloof rang is geen concept specifiek voor AVL bomen - het kan worden berekend voor een binaire boom.

Select ligt tegenover te rangschikken. Een rang wordt gegeven en je moet een knooppunt matching die rang terugkeren.

De volgende code zal rang berekening uit te voeren:

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

Hier is de code die ik schreef en werkte prima voor AVL Tree tot de rang van een bepaalde waarde te krijgen. verschil is alleen dat je gebruikt een knooppunt als parameter en ik gebruikte een belangrijke parameter. u kunt dit wijzigen als je eigen manier. Voorbeeldcode:

    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] Als u wilt uw rang starten vanaf 0, dan initialiseren variabele rang = 0. u zeker de methode countNodes () om deze code uit te voeren moet zijn omgezet.

Hier is wat ik heb gedaan. In mijn programma de rangschikking van een element wordt gedefinieerd als 1 + (aantal elementen groter is dan dat element). U kunt hier op te merken dat het element niet in de boom hoeft te presenteren.

Algoritme om rang te vinden:

1.In de boomstructuur bijhouden van de Aantal elementen in een substructuur met root. Dus het hoofd van de boom wil bevat totale elementen in de boom.

2.Compare het element met een knooppunt indien hij kleiner is dan het knooppunt, dan zijn er (1 + No.of elementen rechterkind) elementen groter is dan de sleutel element.Add aan het totale en recursief doorzocht het element in de linker kind.

3. Als het element groter is dan de root node dan gewoon zoeken op het element recursief in de juiste kind. (Geen noodzaak om iets toe te voegen, omdat we de linker boom verwaarlozen, waarin alle elementen kleiner zijn dan de opgegeven toets)

4.Terminate de algo als je merkt dat het element zijn nul bereikt.

Het gegeven programma had geen van de elementen groter is dan de bepaalde sleutel. 1+ de geretourneerde waarde is de rangschikking.

code snippet:

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

Ik hoop dat dit helpt :)