Encuentra el sucesor sin utilizar puntero padre

Si no tiene acceso al puntero al nodo padre, entonces usted necesita saber quién es el padre. Si no lo saben, cómo se puede ir arriba en el árbol?

Inspirado por la solución de Sheldon, esta es la versión no recursiva de la solución.

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;

He encontrado una solución elegante para sucesor en orden y sin puntero padre aquí -> http://www.geeksforgeeks.org/archives/9999

idea es

1. Si el nodo tiene sub-árbol de la derecha, a continuación, su sucesor es el elemento más pequeño en el derecho de sub-árbol

1. Si el derecho de sub-árbol del nodo está vacío, entonces su sucesor es uno de sus antepasados, que se pueden encontrar de arriba hacia abajo y sin puntero del padre, con el siguiente algoritmo:

dejar que inicialmente current_node ser root, succ_node = null;

Caso 1: Si el elemento de búsqueda es inferior a current_node, entonces el elemento actual es un sucesor potencial - lugar succ_node en el current_node y mover el current_node a su nodo izquierda (porque el elemento de búsqueda se encuentra en el subárbol izquierdo)

Caso 2: Si el elemento de búsqueda es mayor que current_node, no es un potencial sucesor (¿Cómo puede ser un elemento menor del sucesor?). Por lo tanto no hay necesidad de colocar el succ_node aquí, pero mover el current_node a derecha.

seguir repitiendo el proceso hasta llegar a un valor nulo o el propio elemento y devolver el succ_node.

Una solución de Java recursivo podía mirar la siguiente manera:

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

Como cliente simplemente pase en el valor del nodo desde el que queremos conocer el sucesor. Entonces comenzamos a buscar desde la raíz hasta que encontramos el valor que buscábamos. Ahora bien, hay dos casos:

1. Si el nodo actual tiene un hijo derecho, entonces el sucesor, el elemento más pequeño en el subárbol derecho del nodo actual
2. De lo contrario, era el nodo p (puntero padre), que sólo se actualiza cuando se fue a la izquierda dentro del árbol