Finden Sie den Nachfolger ohne Abstammungszeiger

Wenn Sie keinen Zugriff auf den Zeiger auf den Knoten Elternteil haben, dann müssen Sie wissen, wer der Vater ist. Wenn Sie es nicht wissen, wie könnte man in den Baum hinauf?

Inspiriert von Sheldon-Lösung, das ist die nicht-rekursive Version der Lösung.

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;

Ich fand eine elegante Lösung für in Ordnung Nachfolger ohne Abstammungszeiger hier -> http://www.geeksforgeeks.org/archives/9999

Idee ist,

1. Wenn der Knoten rechten Unterbaum hat, dann ist sein Nachfolger das kleinste Element in dem rechten Teilbaum

1. Wenn der rechte Unterbaum des Knotens leer ist, dann ist sein Nachfolger eines seiner Vorfahren, die gefunden werden können top-down ohne Abstammungszeiger, mit dem folgenden Algorithmus:

lassen zunächst root current_node, succ_node = null;

case1: Wenn das Suchelement weniger als current_node ist, dann ist das aktuelle Element ist ein potentieller Nachfolger - Ort succ_node am current_node und die current_node seines linken Knoten bewegen (da das Suchelement in dem linken Teilbaum ist)

case2 Wird das Suchelement größer ist dann current_node, es ist keine potentieller Nachfolger (Wie kann ein geringeres Element den Nachfolger sein?). So keine Notwendigkeit, legen Sie die succ_node hier, aber die current_node nach rechts bewegen.

halten den Prozess zu wiederholen, bis Sie null erreichen oder das Element selbst und gibt die succ_node.

Eine rekursive Java-Lösung aussehen könnte, die folgende Art und Weise:

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

Als Kunde geben wir einfach in den Wert des Knotens, von dem wir den Nachfolger wissen wollen. Dann starten wir von der Wurzel suchen, bis wir den Wert fanden wir gesucht hatten. Nun gibt es zwei Fälle:

1. Wenn der aktuelle Knoten hat ein Recht, Kind, dann der Nachfolger das kleinste Element in der rechten Unterbaum des aktuellen Knotens
2. Ansonsten war es der Knoten p (Abstammungszeiger), die nur aktualisiert wurde, wenn wir innerhalb des Baumes links ging