Binary Tree iterator Algorithm

Binary Tree pre-order, middle-order, and subsequent traversal are basic issues in algorithms and data structures. Recursive Binary Tree traversal algorithms are even more typical applications.

Assume that the Binary Tree node is defined as follows:

 
 

  
  
struct Node { 
  
  
    int value; 
  
  
    Node *left; 
  
  
    Node *right; 
  
  
} 
 
 

 
 

  
  
void inorder_traverse(Node *node) { 
  
  
    if (NULL != node->left) { 
  
  
        inorder_traverse(node->left); 
  
  
    } 
  
  
    do_something(node); 
  
  
    if (NULL != node->right) { 
  
  
        inorder_traverse(node->right); 
  
  
    } 
  
  
} 
  
  
 
 
 

The pre-order and post-order traversal algorithms are similar.

However, Traversal Algorithms alone are not enough. In many applications, we also need to abstract the traversal itself. If there is a sum function, we hope it can be applied to different data structures, such as linked lists, arrays, and Binary Trees. At this time, we can abstract the concept of Iterator, throughThe iterator decouples the algorithm from the data structure.So that the general algorithm can be applied to different types of data structures. We can define the sum function:

 
 

  
  
int sum(Iterator it) 
 
 

As a linear structure, the linked list has a simple and intuitive implementation of its iterator, while the implementation of the Binary Tree iterator is not so easy. We cannot directly convert recursive traversal into an iterator. This is because the recursive traversal process of the binary tree is automatically performed by the compiler on the call stack. Programmers lack sufficient control over this process. In this case, if we can control the inbound and outbound stack of the entire call stack, will it achieve the purpose of control? Let's take a look at the non-recursive algorithm of binary tree traversal:

 
 

  
  
Void inorder_traverse_nonrecursive (Node * node ){
  
  
Stack stack;
  
  
Do {
  
  
// Node indicates the child tree to be processed. The left child is pushed down to the stack layer by layer, which corresponds to the left subtree recursion of the recursive algorithm.
  
  
While (NULL! = Node ){
  
  
Stack. push (node );
  
  
Node = node-> left;
  
  
}
  
  
Do {
  
  
Node * top = stack. top ();
  
  
Stack. pop (); // The top of the pop-up stack, corresponding to the function returned by the recursive algorithm
  
  
Do_something (top );
  
  
If (NULL! = Top-> right ){
  
  
Node = top-> right; // set the current subtree to the right child of the node that has just been traversed.
  
  
Break;
  
  
}
  
  
}
  
  
While (! Stack. empty ());
  
  
}
  
  
While (! Stack. empty ());
  
  
}
 
 

Through the stack-based non-recursive algorithm, we have obtained control over the traversal process. How can we encapsulate it as an iterator? The key here is that the process of understanding traversal is represented by the stack state, so it is clear that the iterator should contain a stack structure, and each iteration is a stack operation. Assume that the iterator interface is:

 
 

  
  
class Iterator { 
  
  
    public: 
  
  
        virtual Node* next() = 0; 
  
  
}; 
 
 

The following is an implementation of the ordinal traversal iterator in a binary tree:

 
 

  
  
class InorderIterator : public Iterator { 
  
  
    public: 
  
  
        InorderIterator(Node *node) { 
  
  
            Node *current = node; 
  
  
            while (NULL != current) { 
  
  
                mStack.push(current); 
  
  
                current = current->left; 
  
  
            } 
  
  
        } 
  
  
        virtual Node* next() { 
  
  
            if (mStack.empty()) { 
  
  
                return NULL; 
  
  
            } 
  
  
            Node *top = mStack.top(); 
  
  
            mStack.pop(); 
  
  
            if (NULL != top->right) { 
  
  
                Node *current = top->right; 
  
  
                while (NULL != current) { 
  
  
                    mStack.push(current); 
  
  
                    current = current->left; 
  
  
                } 
  
  
            } 
  
  
            return top; 
  
  
         } 
  
  
    private: 
  
  
        std::stack<Node*> mStack; 
  
  
}; 
 
 

Next, let's take a look at the time and space complexity of this iterator. Obviously, since the stack needs to store at most all nodes, the space complexity is O (n. So what is the time complexity? One next () call can also perform n stack operations at most, and the entire traversal process requires n next () calls (), so is the time complexity of the entire iterator O (n ^ 2? The answer is no! Because each node only goes into and out of the stack once, the time complexity of the entire iteration process is still O (n ). In fact, this is exactly the same as the time-space complexity of recursive traversal.

In addition to the explicit use of stacks to control the code execution sequence, there are more direct practices in languages C # And Python that support yield semantics. The following Python Implementation of sequential traversal based on yield Binary Tree:

 
 

  
  
// Python 
  
  
def inorder(t): 
  
  
    if t: 
  
  
        for x in inorder(t.left): 
  
  
            yield x 
  
  
        yield t.label 
  
  
        for x in inorder(t.right): 
  
  
            yield x 
 
 

A common explanation of the difference between yield and return is that the system retains the function call status when yield returns. The next time this function is called, it will continue to be executed from the last execution point, this is a process control semantics that is completely different from Stack semantics. We know that Python interpreters are written in C, but C does not support yield semantics. How does the interpreter support yield? With the above experience of transforming recursive traversal into iterative traversal, I believe you have guessed that the Python interpreter must have performed some transformation on the yield code. If you can implement recursion and non-recursion, try to write a Compilation Program to convert yield code to non-yield code.