Trova il successore senza utilizzare il puntatore genitore

Se non si ha accesso al puntatore al nodo padre, allora avete bisogno di sapere chi è il padre. Se non lo sai, come si potrebbe salire nella struttura?

Ispirato da una soluzione di Sheldon, questa è la versione non ricorsiva della soluzione.

if (right[x]  != NIL)
    return min(right[x]);
else
{
    candidate = NIL;
    y = root; 
    while  (y!= x) // y is used as a probe

        if (key[x] < key[y])
            {
            candidate = y;
            y = y ->left;

             }
        else
            y = y->right;
}
return candidate;

Ho trovato una soluzione elegante per il successore in ordine senza puntatore genitore qui -> http://www.geeksforgeeks.org/archives/9999

idea è

1.if il nodo ha diritto di sub-tree, allora il suo successore è l'elemento meno nella destra sottoalbero

1. Se destra sottoalbero del nodo è vuota, allora il suo successore è uno dei suoi antenati, che possono essere trovati dall'alto senza puntatore genitore, con il seguente algoritmo:

lasciare inizialmente current_node essere radice, succ_node = null;

Caso 1: Se l'elemento di ricerca è inferiore a current_node, quindi l'elemento corrente è un potenziale successore - posto succ_node al current_node e spostare il current_node al suo nodo di sinistra (perché l'elemento di ricerca è nel sottoalbero sinistro)

case2: Se l'elemento di ricerca è maggiore di current_node, non è un potenziale successore (Come può un elemento minore sarà il successore?). Quindi nessun bisogno di mettere la succ_node qui, ma spostare il current_node a destra.

continua a ripetere il processo fino a raggiungere nullo o l'elemento stesso e restituire il succ_node.

Una soluzione Java ricorsiva potrebbe apparire nel modo seguente:

public Integer successor(Integer value) {
    Node n = succ(root, value, null);
    if (null != n) {
       return n.value;
    }
    return null;
}

private Node succ(Node n, Integer x, Node p) {
    if (null == n) {
        return null;
    }

    if (x < n.value) {
        return succ(n.left, x, n);
    } else if (x > n.value) {
        return succ(n.right, x, p);
    }
    if (null != n.right) {
        return min(n.right);
    }
    return p;
}

Come cliente abbiamo semplicemente passare il valore del nodo da cui si vuole conoscere il successore. Poi iniziamo a cercare dalla radice finché non abbiamo trovato il valore che stavamo cercando. Ora ci sono due casi:

1. Se il nodo corrente ha un figlio destro, poi il successore del più piccolo elemento nel sottoalbero destro del nodo corrente
2. In caso contrario, è stato il nodo p (puntatore genitore), che è stato aggiornato solo quando siamo andati a sinistra all'interno della struttura