Leetcode: Binary Search Tree Iterator

We essentailly do an in-order traversal (中序遍历) of the tree since the in-order traversal results in a sorted list of node items. 

def traverse_binary_tree(node, callback):
    if node is None:
        return
    traverse_binary_tree(node.leftChild, callback)
    callback(node.value)
    traverse_binary_tree(node.rightChild, callback)

But here, we should not use recursive (递归) since it will output the ordered list at one time. Alternatively, we interatively (迭代) output the next smallest element with the help of a Stack. In a binary search tree, we always has the value of left node < the value of parent node <= the value of the right node. Therefore, we iteratively visit the nodes on the left path of a given a starting node and push them into the stack. Everytime, we pop the smallest node n, and we need to push all the nodes on the left path starting from the right node of n, namely, n.right.  

Take the following binary search tree as an example. We start from root node 8, we push 8, 3, 1 into the stack. 

If we call hasNext(), we just need to check if the stack is empty or not. 

If we call next(), we pop the top node in the stack, that is node 1. The nodes in the stack is 8, 3.  We further check if node 1 has any right nodes since all its right nodes should be smaller than its parent node 3. Since node 1 does not have right nodes, the next smallest element is node 3. 

Now if we call next(), we pop node 3. The stack contains 8.  Since node 3 has right node, we then push all the nodes on the left path starting from node 6, that are 6 and 4. Now the stack includes 8, 6, 4. We can see we will always keep the smallest node on the top of the stack. 

 

Initially, we push(8), push(3), push(1) --> 8, 3, 1, then for every next() cal, the status of the stack is:

pop(1) --> 8, 3

pop(3), push(6), push(4) --> 8, 6, 4

pop(4) --> 8, 6

pop(6), push(7) --> 8, 7

 

Here is java code:

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
// we use a Stack to keep the 

public class BSTIterator {
    //Stack<TreeNode> s = new LinkedList<TreeNode>();
    Deque<TreeNode> s = new ArrayDeque<TreeNode>();
    public BSTIterator(TreeNode root) {
        TreeNode n = root;
        while(n!=null){
            s.push(n);
            n = n.left;
        }
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        if(s.isEmpty())
            return false;
        return true;
    }

    /** @return the next smallest number */
    public int next() {
        TreeNode n1 = s.pop();
        TreeNode l = n1.right;
        while(l != null){
            s.push(l);
            l = l.left;
        }
        return n1.val;
    }
}

/**
 * Your BSTIterator will be called like this:
 * BSTIterator i = new BSTIterator(root);
 * while (i.hasNext()) v[f()] = i.next();
 */