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

Arbre traversal , de Wikipedia:

Toutes les implémentations d'échantillons requièrent de l'espace de pile d'appel proportionnelle à la hauteur de l'arbre. Dans un arbre mal équilibré, cela peut être tout à fait considérable.

Nous pouvons supprimer l'exigence de la pile en maintenant les pointeurs de parents dans chaque noeud, ou en enfilant l'arbre. Dans le cas de l'utilisation de threads, cela permettra grandement améliorée afinde traversal, bien récupérer le nœud parent requis pour pré-commande et postorder traversal sera plus lent qu'un algorithme simple basé pile.

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

Ok, je sais que c'est vieux, mais on m'a demandé dans une interview avec Microsoft un certain temps et j'ai décidé de travailler un peu. Je l'ai testé et il fonctionne très bien.

template <typename E>
class BSTIterator
{  
  BSTNode<E> * m_curNode;
  std::stack<BSTNode<E>*> m_recurseIter;

public:
    BSTIterator( BSTNode<E> * binTree )
    {       
        BSTNode<E>* root = binTree;

        while(root != NULL)
        {
            m_recurseIter.push(root);
            root = root->GetLeft();
        }

        if(m_recurseIter.size() > 0)
        {
            m_curNode = m_recurseIter.top();
            m_recurseIter.pop();
        }
        else
            m_curNode = NULL;
    }

    BSTNode<E> & operator*() { return *m_curNode; }

    bool operator==(const BSTIterator<E>& other)
    {
        return m_curNode == other.m_curNode;
    }

    bool operator!=(const BSTIterator<E>& other)
    {
        return !(*this == other);
    }

    BSTIterator<E> & operator++() 
    { 
        if(m_curNode->GetRight())
        {
            m_recurseIter.push(m_curNode->GetRight());

            if(m_curNode->GetRight()->GetLeft())
                m_recurseIter.push(m_curNode->GetRight()->GetLeft());
        }

        if( m_recurseIter.size() == 0)
        {
            m_curNode = NULL;
            return *this;
        }       

        m_curNode = m_recurseIter.top();
        m_recurseIter.pop();

        return *this;       
    }

    BSTIterator<E> operator++ ( int )
    {
        BSTIterator<E> cpy = *this;     

        if(m_curNode->GetRight())
        {
            m_recurseIter.push(m_curNode->GetRight());

            if(m_curNode->GetRight()->GetLeft())
                m_recurseIter.push(m_curNode->GetRight()->GetLeft());
        }

        if( m_recurseIter.size() == 0)
        {
            m_curNode = NULL;
            return *this;
        }       

        m_curNode = m_recurseIter.top();
        m_recurseIter.pop();

        return cpy;
    }

};

Comme mentionné TokenMacGuy vous pouvez utiliser une pile stockée dans le iterator. Voici une mise en œuvre rapide de ce test 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 variation serait de traverser l'arbre au moment de la construction et enregistrer le traversal dans une liste. Vous pouvez utiliser la liste iterator par la suite.

Qu'en est-il en utilisant une première technique de recherche en profondeur. L'objet iterator juste doit avoir une pile des noeuds déjà visités.

Si vous utilisez la pile, vous obtenez seulement « utilisation de la mémoire supplémentaire O (h), h est la hauteur de l'arbre ». Toutefois, si vous souhaitez utiliser uniquement O (1) de la mémoire supplémentaire, vous devez enregistrer la voici l'analyse: - Si le nœud actuel a droit de l'enfant: trouver min d'arbre à droite sous - Il nœud courant n'a pas d'enfant à droite, vous avez besoin à chercher de la racine, et garder à jour son ancêtre le plus bas, ce qui est son plus bas noeud suivant

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

Utiliser O (1) l'espace, ce qui signifie que nous n'utiliserons O (h) empilement.

Pour commencer:

1. hasNext ()? current.val <= endNode.val pour vérifier si l'arbre est entièrement parcouru.

2. Trouvez min par les plus à gauche: Nous pouvons alwasy chercher le plus à gauche pour trouver la prochaine valeur minimale.

3. Une fois est cochée le plus à gauche min (nommez current). Suivant min sera de 2 cas: Si current.right = null, nous pouvons continuer à chercher le plus à gauche de l' enfant current.right, en suivant min. Ou, nous devons regarder en arrière pour les parents. Utilisez arbre binaire de recherche pour trouver le noeud parent de courant.

Remarque : lorsque vous effectuez une recherche binaire pour les parents, assurez - vous qu'il satisfait parent.left = courant.

Parce que: Si parent.right == actuel, qui doit mère a été visité. Dans l'arbre de recherche binaire, nous savons que parent.val <parent.right.val. Nous devons sauter ce cas particulier, car elle conduit à boucle ifinite.

public class BSTIterator {
    public TreeNode root;
    public TreeNode current;
    public TreeNode endNode;
    //@param root: The root of binary tree.
    public BSTIterator(TreeNode root) {
        if (root == null) {
            return;
        }
        this.root = root;
        this.current = root;
        this.endNode = root;

        while (endNode != null && endNode.right != null) {
            endNode = endNode.right;
        }
        while (current != null && current.left != null) {
            current = current.left;
        }
    }

    //@return: True if there has next node, or false
    public boolean hasNext() {
        return current != null && current.val <= endNode.val;
    }

    //@return: return next node
    public TreeNode next() {
        TreeNode rst = current;
        //current node has right child
        if (current.right != null) {
            current = current.right;
            while (current.left != null) {
                current = current.left;
            }
        } else {//Current node does not have right child.
            current = findParent();
        }
        return rst;
    }

    //Find current's parent, where parent.left == current.
    public TreeNode findParent(){
        TreeNode node = root;
        TreeNode parent = null;
        int val = current.val;
        if (val == endNode.val) {
            return null;
        }
        while (node != null) {
            if (val < node.val) {
                parent = node;
                node = node.left;
            } else if (val > node.val) {
                node = node.right;
            } else {//node.val == current.val
                break;
            }
        }
        return parent;
    }
}

Par définition, il est impossible pour le prochain () et hasNext () pour exécuter en O (1) temps. Lorsque vous êtes à la recherche d'un noeud particulier dans un BST, vous avez aucune idée de la hauteur et de la structure des autres noeuds sont donc vous ne pouvez pas « sauter » au noeud suivant correct.

Cependant, la complexité de l'espace peut être réduite à O (1) (à l'exception de la mémoire pour le BST lui-même). Voici la façon dont je le ferais 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;
}

L'astuce est d'avoir à la fois un lien parent, et un drapeau visité pour chaque noeud. À mon avis, nous pouvons affirmer que ce n'est pas l'utilisation de l'espace supplémentaire, il est tout simplement partie de la structure du noeud. Et évidemment, iter_next () doit être appelée sans l'état de la structure de l'arbre changeant (bien sûr), mais aussi que les drapeaux « visité » ne changent pas les valeurs.

Voici la fonction testeur iter_next appelle () 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;
}

Ce qui permet d'imprimer les valeurs de l'ordre de tri:

15 16 20 21 25 27 40 62 71