Implementarea unui iterator peste un arbore binar de căutare

Arborele parcurgeri , de la Wikipedia:

Toate implementarile de probă va necesita spațiu de apel stiva proporțională cu înălțimea copacului. Într-un copac prost echilibrat, acest lucru poate fi destul de considerabile.

Putem elimina cerința stivei prin menținerea indicii-mamă în fiecare nod, sau prin filetare copac. În cazul utilizării fire, acest lucru va permite mult îmbunătățit inordine parcurgeri, cu toate că recuperarea nodului părinte necesar pentru precomandă și postordine parcurgeri va fi mai lentă decât un algoritm bazat stiva simplu.

În articol există unele pseudocod pentru iterația cu O (1) de stat, care poate fi ușor adaptat la un iterator.

Ok, știu că acest lucru este vechi, dar am fost întrebat acest lucru într-un interviu cu Microsoft un timp înapoi și am decis să lucreze pe ea un pic. Am testat acest lucru și funcționează destul de bine.

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

};

După cum sa menționat TokenMacGuy puteți utiliza o stivă stocată în iterator. Iată o implementare rapidă a testat acest lucru în 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);
    }
}

Alte variații ar fi să traverseze copac la timpul de construcție și a salva traversal într-o listă. Puteți utiliza lista iterator după aceea.

Ce zici, folosind o primă metodă de căutare adâncime. Obiectul iterator doar trebuie să aibă un teanc de noduri deja vizitate.

Dacă utilizați stivă, veți obține doar „utilizarea memoriei Extra O (h), h este înălțimea copacului“. Cu toate acestea, dacă doriți să utilizați numai O (1) memorie suplimentară, aveți nevoie pentru a înregistra Iată analiza: - În cazul în care nodul curent are copil drept: găsi min de sub-copac dreapta - Este nodul curent nu are nici un copil drept, aveți nevoie să-l caute de la rădăcină și să păstreze actualizarea este cel mai mic strămoș, care este cel mai mic nodul următor

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

Utilizați O (1) spațiu, ceea ce înseamnă că nu vom folosi O (h) stivă.

A incepe:

1. hasNext ()? current.val <= endNode.val pentru a verifica dacă arborele este complet traversată.

2. Găsiți min prin cele mai din stânga: Ne putem uita alwasy pentru stanga cel mai mult pentru a găsi următoarea valoare minimă.

3. După ce a lăsat-min mai este verificat (denumiți - o current). Următoarea min va fi de 2 cazuri: Dacă current.right = nul, putem păstra în căutarea pentru cel mai din stânga a copilului current.right lui, ca viitoare min!. Sau, trebuie să privim înapoi pentru părinte. Utilizați arbore binar de căutare pentru a găsi nodul curent părinte.

Notă : atunci când faci binar de căutare pentru părinte, asigurați - vă că acesta îndeplinește parent.left = curent.

Deoarece: Dacă parent.right == curent, care trebuie să-mamă a fost vizitat înainte. În arbore binar de căutare, știm că parent.val <parent.right.val. Trebuie să săriți peste acest caz special, deoarece aceasta conduce la ifinite bucla.

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

Prin definiție, nu este posibil pentru următorul () și hasNext () pentru a rula în O (1) timp. Când sunteți în căutarea la un anumit nod într-un BST, nu ai nici o idee despre înălțimea și structura celelalte noduri sunt, prin urmare, nu puteți doar „sari“ la nodul corect următor.

Cu toate acestea, complexitatea spațiului poate fi redus la O (1) (cu excepția memoriei pentru BST în sine). Aici este modul în care mi-ar face în 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;
}

Trucul este de a avea atât o legătură părinte, și un steag vizitat pentru fiecare nod. În opinia mea, putem argumenta că acest lucru nu este utilizarea spațiului suplimentar, aceasta este pur și simplu o parte a structurii nodului. Și, evident, iter_next () trebuie să fie numit fără starea structurii arborelui în schimbare (desigur), dar, de asemenea, că „vizitat“ steaguri nu se schimbă valorile.

Aici este funcția tester care iter_next () apeluri și imprimă valoarea de fiecare dată pentru acest copac:

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

Care va imprima valorile în ordine sortata:

15 16 20 21 25 27 40 62 71