Mise en œuvre d'un itérateur sur un arbre de recherche binaire

Comme TokenMacGuy mentionné, vous pouvez utiliser une pile stockés dans l'itérateur.
Voici un test rapide de mise en œuvre de ce en Java:

/**
 * An iterator that iterates through a tree using in-order tree traversal
 * allowing a sorted sequence.
 *
 */
public class Iterator {

    private Stack<Node> stack = new Stack<>();
    private Node current;

    private Iterator(Node argRoot) {
        current = argRoot;
    }

    public Node next() {
        while (current != null) {
            stack.push(current);
            current = current.left;
        }

        current = stack.pop();
        Node node = current;
        current = current.right;

        return node;
    }

    public boolean hasNext() {
        return (!stack.isEmpty() || current != null);
    }

    public static Iterator iterator(Node root) {
        return new Iterator(root);
    }
}

Autre variante serait de parcourir l'arbre au moment de la construction et de sauver la traversée dans une liste. Vous pouvez utiliser l'itérateur liste par la suite.

L'arbre transversal, depuis Wikipédia:

Tous les échantillons d'œuvre, il faudra de la pile des appels de l'espace proportionnel à la hauteur de l'arbre. Dans un mal équilibré arbre, cela peut être tout à fait considérable.

Nous pouvons retirer la pile de l'exigence par le maintien de parent pointeurs dans chaque nœud, ou par le filetage de l'arbre. Dans le cas de l'utilisation de threads, ce qui lui permettra de grandement améliorée afinde de la traversée, bien que la récupération du nœud parent requis pour la précommande et postorder traversée sera plus lente qu'une simple pile en fonction de l'algorithme.

Dans l'article il y a quelques pseudo-code de l'itération avec O(1) de l'état, qui peut être facilement adapté à un itérateur.

Si vous utilisez la pile, vous n'réaliser "Supplémentaire de l'utilisation de la mémoire O(h), h est la hauteur de l'arbre".
Cependant, si vous souhaitez utiliser uniquement les O(1) de la mémoire supplémentaire, vous avez besoin d'enregistrer le
Voici l'analyse:
- Si le nœud actuel a la droite de l'enfant: trouver min de sous-arbre droit
- C'nœud actuel n'a pas le droit de l'enfant, vous avez besoin de chercher à partir de la racine, et de garder à jour la plus basse de l'ancêtre, qui est le plus bas de son prochain nœud

public class Solution {
//@param root: The root of binary tree.
TreeNode current;
TreeNode root;
TreeNode rightMost;
public Solution(TreeNode root) {
if(root==null) return;
this.root = root;
current = findMin(root);
rightMost = findMax(root);
}
//@return: True if there has next node, or false
public boolean hasNext() {
if(current!=null && rightMost!=null && current.val<=rightMost.val)    return true; 
else return false;
}
//O(1) memory.
public TreeNode next() {
//1. if current has right child: find min of right sub tree
TreeNode tep = current;
current = updateNext();
return tep;
}
public TreeNode updateNext(){
if(!hasNext()) return null;
if(current.right!=null) return findMin(current.right);
//2. current has no right child
//if cur < root , go left; otherwise, go right
int curVal = current.val;
TreeNode post = null;
TreeNode tepRoot = root;
while(tepRoot!=null){
if(curVal<tepRoot.val){
post = tepRoot;
tepRoot = tepRoot.left;
}else if(curVal>tepRoot.val){
tepRoot = tepRoot.right;
}else {
current = post;
break;
}
}
return post;
}
public TreeNode findMin(TreeNode node){
while(node.left!=null){
node = node.left;
}
return node;
}
public TreeNode findMax(TreeNode node){
while(node.right!=null){
node = node.right;
}
return node;
}
}

Par définition, il n'est pas possible pour next() et hasNext() pour exécuter en O(1) fois. Lorsque vous êtes à la recherche à un nœud particulier dans un BST, vous n'avez aucune idée de la hauteur et la structure des autres nœuds sont, par conséquent, vous ne pouvez pas "sauter" à la bonne nœud suivant.

Cependant, l'espace de la complexité peut être réduite à O(1) (sauf pour la mémoire de la BST lui-même). Voici la façon dont je voudrais le faire en C:

struct node{
int value;
struct node *left, *right, *parent;
int visited;
};
struct node* iter_next(struct node* node){
struct node* rightResult = NULL;
if(node==NULL)
return NULL;
while(node->left && !(node->left->visited))
node = node->left;
if(!(node->visited))
return node;
//move right
rightResult = iter_next(node->right);
if(rightResult)
return rightResult;
while(node && node->visited)
node = node->parent;
return node;
}

Le truc, c'est d'avoir à la fois un lien parent, et visité un drapeau pour chaque nœud. À mon avis, nous pouvons affirmer que ce n'est pas un espace supplémentaire de l'utilisation, il est tout simplement partie de la structure de nœud. Et évidemment, iter_next() doit être appelé sans que l'état de l'arbre de modification de structure (bien sûr), mais aussi que le "visité" les drapeaux de ne pas changer les valeurs.

Ici, c'est le testeur de fonction qui s'appelle iter_next() et imprime la valeur à chaque fois pour cet arbre:

                  27
/     \
20      62
/ \    / \
15  25  40  71
\  /
16 21
int main(){
//right root subtree
struct node node40 = {40, NULL, NULL, NULL, 0};
struct node node71 = {71, NULL, NULL, NULL, 0};
struct node node62 = {62, &node40, &node71, NULL, 0};
//left root subtree
struct node node16 = {16, NULL, NULL, NULL, 0};
struct node node21 = {21, NULL, NULL, NULL, 0};
struct node node15 = {15, NULL, &node16, NULL, 0};
struct node node25 = {25, &node21, NULL, NULL, 0};
struct node node20 = {20, &node15, &node25, NULL, 0};
//root
struct node node27 = {27, &node20, &node62, NULL, 0};
//set parents
node16.parent = &node15;
node21.parent = &node25;
node15.parent = &node20;
node25.parent = &node20;
node20.parent = &node27;
node40.parent = &node62;
node71.parent = &node62;
node62.parent = &node27;
struct node *iter_node = &node27;
while((iter_node = iter_next(iter_node)) != NULL){
printf("%d ", iter_node->value);
iter_node->visited = 1;
}
printf("\n");
return 1;
}

Qui permet d'imprimer les valeurs dans l'ordre de tri:

15 16 20 21 25 27 40 62 71