LeetCode OJ：Binary Search Tree Iterator（二叉搜索树迭代器）

Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.

Calling next() will return the next smallest number in the BST

Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.

相当于遍历二叉搜索树，借助栈即可实现：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class BSTIterator {
private:
    stack<TreeNode *> stk;
    TreeNode * node;
public:
    BSTIterator(TreeNode *root) {
        node = root;
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        return (node || !stk.empty());
    }

    /** @return the next smallest number */
    int next() {
        TreeNode * res = NULL;
        if(node == NULL){
            res = stk.top();
            stk.pop();
            node = res->right;
        }else{
            while(node->left != NULL){
                stk.push(node);
                node = node->left;
            }
            res = node;
            node = node->right;
        }
        return res->val;
    }
};

/**
 * Your BSTIterator will be called like this:
 * BSTIterator i = BSTIterator(root);
 * while (i.hasNext()) cout << i.next();
 */

 或者可以看看另一种做法，就是在构造迭代器的时候就将第一个最小的值准备好，不过二者的思路大体是一样的：

class BSTIterator {
private:
    stack<TreeNode *> s;
public:
    BSTIterator(TreeNode *root) {
        while(root){
            s.push(root);
            root == root->left;
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        return !s.empty();
    }

    /** @return the next smallest number */
    int next() {
        TreeNode * n = s.top();
        ret = n.val;
        s.pop();
        n = n->right;
        while(n){
            s.push(n);
            n = n->left;
        }
        return res;
    }
};

或者就是直接的开始的时候就进行中序遍历，然后装入一个队列，需要的时候直接pop就可以了：

class BSTIterator {
public:
    queue<int> q;
    map<TreeNode *, bool> m;
    stack<TreeNode *> s;
    
    BSTIterator(TreeNode *root) {
        if(root)
            s.push(root);
        while(!s.empty()){
            TreeNode * t = s.top();
            if(t->left && m[t->left] == false){
                s.push(t->left);
                m[t->left] = true;  //表示这条路已经报错过了，下次走的不经过这里
                continue;
            }
            q.push(t->val);
            s.pop();
            if(t->right && m[t->right] == false){
                s.push(t->right);
                m[t->right] = true;
            }
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        if(!q.empty())
            return true;
        return false;
    }

    /** @return the next smallest number */
    int next() {
        if(hasNext()){
            int t = q.front();
            q.pop();
            return t; 
        }
    }
};

 java版本的如下所示，首先是用一个Stack来实现的：

public class BSTIterator {
    Stack<TreeNode> s;
    TreeNode n;    
    public BSTIterator(TreeNode root) {
        s = new Stack<TreeNode>();
        n = root;
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return n != null || !s.isEmpty();
    }

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

另一个的版本也如下所示，同样是将所有的数字再构造的时候就中序遍历完成，然后的hasNext以及next就非常简单了。

public class BSTIterator {
    Queue<Integer> queue;
    Stack<TreeNode> stack;
    HashMap<TreeNode, Integer> map; //表示这个Node是否已经在queue存在着了，0表示没有，1表示已经存在了 
    public BSTIterator(TreeNode root) { //对象构造的时候将所有的值就全部的装入了一个队列中
        queue = new LinkedList<Integer>();
        stack = new Stack<TreeNode>();
        map = new HashMap<TreeNode, Integer>();
        TreeNode node;
        if(root == null)
            return;
        stack.push(root);
        while(!stack.isEmpty()){
            node = stack.peek();
            while(node.left != null && !map.containsKey(node.left)){
                stack.push(node.left);
                map.put(node.left, 1);
                node = node.left;
            }
            queue.add(node.val);
            stack.pop();
            if(node.right != null && !map.containsKey(node.right)){
                stack.push(node.right);
                map.put(node.right, 1);
            }
        }
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return !queue.isEmpty();
    }

    /** @return the next smallest number */
    public int next() {
        return queue.poll();
    }
}