Trouver le successeur sans utiliser le pointeur parent

Si vous n'avez pas accès au pointeur vers le nœud parent, vous devez savoir qui est le père. Si vous ne savez pas, comment pourriez-vous aller dans l'arbre?

Inspiré par la solution de Sheldon, c'est la version non-récurrente de la solution.

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;

J'ai trouvé une solution élégante pour successeur en ordre sans pointeur parent ici -> http://www.geeksforgeeks.org/archives/9999

L'idée est

1. Si le noeud a droit sous-arbre, puis son successeur est le plus petit élément dans le sous-arbre droit

1. Si le droit de nœud sous-arbre est vide, son successeur est l'un de ses ancêtres, qui se trouve haut vers le bas sans pointeur parent, avec l'algorithme suivant:

laissez d'abord être current_node racine, succ_node = null;

Cas1: Si l'élément de recherche est inférieure à current_node, alors l'élément courant est un successeur potentiel - lieu succ_node au current_node et déplacer le current_node à son noeud gauche (parce que l'élément de recherche est dans le sous-arbre gauche)

affaire2: Si l'élément de recherche est supérieure à current_node, ne est pas un successeur potentiel (Comment un élément moins le successeur?). Donc pas besoin de placer le succ_node, mais déplacer le current_node à droite.

ne cesse de répéter le processus jusqu'à ce que vous atteignez nul ou l'élément lui-même et renvoyer le succ_node.

Une solution Java récursive pourrait ressembler la manière suivante:

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

En tant que client, nous passons simplement de la valeur du noeud à partir duquel nous voulons connaître le successeur. Ensuite, nous commençons la recherche de la racine jusqu'à ce que nous avons trouvé la valeur que nous recherchions. Maintenant, il y a deux cas:

1. Si le nœud actuel a un enfant à droite, puis le successeur le plus petit élément sous-arbre droit du noeud courant
2. Dans le cas contraire, il était le nœud p (pointeur parent), qui a été mis à jour que lorsque nous sommes allés à gauche dans l'arbre