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