我的梦想就是站在万人仰慕的高度，俯视曾经看低我的人。

173. 二叉搜索树迭代器^[1]

题目：实现一个二叉搜索树迭代器类 BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：

• BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
• boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
• int next()将指针向右移动，然后返回指针处的数字。

注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。

你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

输入：
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]

输出：
[null, 3, 7, true, 9, true, 15, true, 20, false]

解释：
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next();    // 返回 3
bSTIterator.next();    // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 20
bSTIterator.hasNext(); // 返回 False

提示：树中节点的数目在范围 [1, 10^5] 内，0 <= Node.val <= 10^6，最多调用 10^5 次 hasNext 和 next 操作。

---

分析：BST 的中序遍历的节点值是按非降序排序的。每次迭代 next() 返回当前最小元素，因此可以利用队列 （Queue） 结构存储中序遍历的结点，在每次迭代时抛出队列的首元素；且只要队列中有元素，hashNext() 就不会为 false 。

Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class BSTIterator {
    private int n;
    private LinkedList<TreeNode> linkedList = new LinkedList<>();

    public BSTIterator(TreeNode root) {
        inOrder(root);
        this.n = linkedList.size();
    }
    //中序遍历的迭代版
    private void inOrder(TreeNode root) {
        if (root != null) {
            inOrder(root.left);
            linkedList.addLast(root);
            inOrder(root.right);
        }
    }

    public int next() {
        --this.n;
        return linkedList.isEmpty() ? -1 : linkedList.pollFirst().val;
    }

    public boolean hasNext() {
        return this.n > 0;
    }
}

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator obj = new BSTIterator(root);
 * int param_1 = obj.next();
 * boolean param_2 = obj.hasNext();
 */

• 构造方法的时间复杂度为 O(N)，空间复杂度为 O(N)，N 为结点数；next() 方法的时复为 O(1)，hasNext() 方法的时复为 O(1)。

---

进阶：你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高度。

分析^[2]：当 BST 迭代器仅需要判断一个比较小的元素（假设是最小元素）是否存在时，上面的方法也需要先遍历存储所有节点，其时间复杂度 O(N)。如何避免提前遍历所有节点——将迭代器设置成遍历过程中求 next 节点：

1. 将递归转换成迭代（利用栈）；
2. 迭代思路：栈中仅保留左节点。

Java代码：

class BSTIterator {
   private LinkedList<TreeNode> stack = new LinkedList<>();
   
   // 构造方法：将根节点和它的左节点以及左节点的左节点都入栈
   public BSTIterator(TreeNode root) {
       pushStack(root);
   }

   private void pushStack(TreeNode root) {
       do {
           stack.addLast(root);
           root = root.left;
       } while (root != null);
   }
   // 栈顶出栈即为最小元素，然后入栈「出栈节点的右子树」的根节点及其所有左节点。
   public int next() {
       // if(stack.isEmpty()) return -1;
       int returnVal = stack.peekLast().val;
       TreeNode rightSubTree = stack.pollLast().right;
       if (rightSubTree != null) pushStack(rightSubTree);
       return returnVal;
   }

   public boolean hasNext() {
       return !stack.isEmpty();
   }
}

• 时间复杂度均摊为 O(1)，空间复杂度为 O(h)，因为栈中只保留了左节点，栈中元素最多的时候，就是树的高度。

参考资料

[1]

二叉搜索树迭代器: https://leetcode-cn.com/problems/binary-search-tree-iterator/

[2]

分析: https://leetcode-cn.com/problems/binary-search-tree-iterator/solution/fu-xue-ming-zhu-dan-diao-zhan-die-dai-la-dkrm/