Vind de opvolger zonder gebruik te maken ouder pointer

Als u geen toegang tot de aanwijzer naar het bovenliggende knooppunt hebt dan moet je weten wie de vader is. Als je het niet weet, hoe kon je omhoog gaat in de boom?

Geïnspireerd door de oplossing Sheldon's, dit is de niet-recursieve versie van de oplossing.

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;

Ik vond een elegante oplossing voor in-order opvolger zonder ouder pointer hier -> http://www.geeksforgeeks.org/archives/9999

idee is

1.Als het knooppunt juiste subboom, dan zijn opvolger is het minst element in de rechter subboom

1. Als rechter deelboom van het knooppunt leeg is, dan zijn opvolger is één van zijn voorouders, te vinden bovenaf zonder ouder pointer, met het volgende algoritme:

Laat aanvankelijk HUIDIGE wortel, succ_node = null;

Scenario 1: Als het zoekelement minder dan HUIDIGE is, wordt de huidige element een mogelijke opvolger - plaats succ_node de HUIDIGE en beweeg de HUIDIGE links daarvan knooppunt (omdat het zoekelement in de linker deelboom)

Scenario 2: Als de zoektocht element groter is dan HUIDIGE, het is niet een potentiële opvolger (Hoe kan een mindere element zijn opvolger?). Dus geen noodzaak om de succ_node hier te plaatsen, maar haal de HUIDIGE naar rechts.

blijven herhalen het proces totdat u null bereiken of het element zelf en de terugkeer van de succ_node.

Een recursieve Java oplossing zou kunnen kijken op de volgende manier:

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 een klant passeren we gewoon in de waarde van het knooppunt van waaruit we willen de opvolger te leren kennen. Dan kunnen we beginnen zoeken vanaf de wortel tot we de waarde die we zochten gevonden. Nu zijn er twee gevallen:

1. Als het huidige knooppunt heeft het recht kind, dan is de opvolger van het kleinste element in de rechter deelboom de huidige node
2. Anders was het knooppunt p (ouder pointer), die alleen werd bijgewerkt toen we vertrokken in de boom