Come trovare il rango di un nodo in un albero AVL?

Rango è il numero di nodi dell'albero sub sinistra più uno, ed è calcolato per ogni nodo. Credo rango non è un concetto specifico per alberi AVL - può essere calcolato per ogni albero binario.

Select è proprio di fronte a rango. Un rango è dato e si deve restituire un corrispondente nodo che rango.

Il seguente codice eseguirà il calcolo Classifica:

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

Ecco il codice che ho scritto e ho lavorato bene per AVL albero per ottenere il rango di un valore particolare. differenza è solo che si utilizza un nodo come parametro e ho usato una chiave di un parametro. è possibile modificare questo come modo tuo. Codice d'esempio:

    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] Se si desidera avviare il vostro rank da 0 allora inizializzare rango variabile = 0. è sicuramente dovrebbe aver implementato le countNodes metodo () per eseguire questo codice.

Ecco quello che ho fatto. Nel mio programma di rango di un elemento è definito come il 1+ (senza di elementi maggiori di quell'elemento). Si può notare che l'elemento non è tenuta alla presentazione nella struttura.

Algoritmo per trovare Classifica:

1.In la struttura ad albero tenere traccia dei non di elementi in un albero secondario tra cui la radice. Così il capo della volontà albero elementi totali nella struttura.

2.Compare l'elemento con un nodo, se è più piccolo del nodo, poi ci sono (1 + No.of elementi figlio destro) Elementi superiore la chiave element.Add al totale e ricorsivamente ricercare l'elemento nel figlio sinistro.

3. Se l'elemento è maggiore del nodo principale, allora basta cercare l'elemento in modo ricorsivo nel bambino a destra. (Non c'è bisogno di aggiungere nulla dal momento che stiamo trascurando l'albero a sinistra, in cui tutti gli elementi sono meno della data chiave)

4.Terminate l'algo quando si trova l'elemento vengono raggiunti null.

Il dato programma non restituisce alcun di elementi superiore alla data chiave. 1+ il valore restituito è la posizione.

frammento di codice:

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

Spero che questo ti aiuti :)