Najít nástupce bez použití nadřazený ukazatel

Nemáte-li mít přístup k ukazatel nadřazeného uzlu, pak je třeba vědět, kdo je otec. Pokud nechcete vědět, jak byste mohli jít do stromu?

Inspirovaný Sheldon roztok, to je non-rekurzivní verze řešení.

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;

Zjistil jsem, elegantní řešení pro in-pořadí nástupce bez mateřské ukazatelem zde -> http://www.geeksforgeeks.org/archives/9999

myšlenka je

1. Pokud je uzel má právo sub-strom, pak jeho nástupce je nejmenší prvek v pravém podstromu

1. Pokud uzel má pravdu sub-strom je prázdný, pak jeho nástupce je jedním z jeho předků, které lze nalézt shora dolů bez nadřazeného ukazatel, podle následujícího algoritmu:

nechat nejprve current_node být root, succ_node = null;

Případ 1: Není-li vyhledávací prvek je menší než current_node, pak je aktuální prvek je potenciální nástupce - místo succ_node na current_node a přesunout current_node k jeho levé uzlu (protože hledání element je v levém podstromu)

Případ 2: Pokud je hledání element je větší než current_node, není jeho potenciální nástupce (Jak může být menší element být nástupce?). Takže není třeba umístit succ_node tady, ale přesunout current_node doprava.

neustále opakují proces, dokud se nedostanete null nebo samotný prvek a vrátí succ_node.

Rekurzivní řešení Java může vypadat následujícím způsobem:

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

Jako klient se jednoduše složit v hodnotě uzlu, ze kterého chceme znát nástupce. Pak jsme začít hledat od kořenu až jsme našli hodnotu, kterou hledali. Nyní existují dva případy:

1. Je-li aktuální uzel má pravý dítě, pak nástupce nejmenší prvek v pravém podstromu aktuálního uzlu
2. Jinak bylo uzel p (rodič pointer), který byl aktualizován pouze tehdy, když jsme šli vlevo ve stromu