LeetCode173. 二叉搜索树迭代器(超实用的解法！！！！）

https://leetcode-cn.com/problems/binary-search-tree-iterator/

题意

实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。
调用 next() 将返回二叉搜索树中的下一个最小的数。

BSTIterator iterator = new BSTIterator(root);
iterator.next();    // 返回 3
iterator.next();    // 返回 7
iterator.hasNext(); // 返回 true
iterator.next();    // 返回 9
iterator.hasNext(); // 返回 true
iterator.next();    // 返回 15
iterator.hasNext(); // 返回 true
iterator.next();    // 返回 20
iterator.hasNext(); // 返回 false

提示：

next() 和 hasNext() 操作的时间复杂度是 O(1)，并使用 O(h) 内存，其中 h 是树的高度。
你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 中至少存在一个下一个最小的数。

题解

题目要求实现两个函数，该死的是，要求next()和hasNext()方法的时间复杂度为O(1)，不过想了一下，感觉这个也不难啊，我用个数组事先按从小到大装起来不就完事儿了嘛。但是又没想到啊，这空间复杂度又要求O(h)（h是二叉树的高度，h=logn, n是节点数），按之前的方法做，空间复杂度就到了O(n)，已经是超出题目要求了，那怎么办 ？“怎么办？？” 那当然是我的题目我做主了，就这么干，这电脑怎么知道我超了呢，小样。上代码。

//1.常规做法，没有满足O(h)的空间复杂度，h=logn
class BSTIterator {
    int index=-1;
    private ArrayList<Integer> list=new ArrayList<>();
    public BSTIterator(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        TreeNode p=root;
        while(p!=null||!stack.isEmpty()){
            if(null!=p){
                stack.push(p);
                p=p.left;
            }else{
                p=stack.pop();
                list.add(p.val);
                p=p.right;
            }
        }
    }

    public int next() {
        return list.get(++index);
    }

    public boolean hasNext() {
        return list.size()>index+1;
    }
}

当然这不是标准答案。
这道题真正的解法是先将树最左侧节点都依次装入栈中，先找到最小的那个元素，出栈输出，再考虑在这个元素之后最小的元素又是什么，而由二叉搜索树的性质可知，在该元素之后最小的元素有几可能：

1. 该节点有右节点，那么下一个元素就在右子树的最左端。如5之后最小的节点是7。此时也需要对右子树最左侧的元素依次入栈，以便寻找下下个元素。
   

2. 该节点没有右节点，且其是父节点的左节点，那么下一个最小的显然就是它的父节点，也就是在它之前入栈的节点，也就是现在的栈顶元素。如1的下一个节点就是5.
   

3. 该节点没有右节点，且其是父节点的右节点。如13的下一个节点，此时他的下一个节点还是此时的栈顶元素的15（因为11访问过后已经出栈了）
   
   而每一个节点都是遵从这个规则的，所以只需要重复循环这个逻辑寻找下一个节点即可。此外，栈的大小也满足了O(h)的空间复杂度。

/**
 * 使用栈记录子链
 */
class BSTIterator {

    private Stack<TreeNode> stack=new Stack<>();
    private TreeNode node=null;
    public BSTIterator(TreeNode root) {
        pushLeftNode(root);
    }

    public int next() {
        node=stack.pop();
        if(null!=node.right){
            pushLeftNode(node.right);
        }
        return node.val;
    }

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

    //将最左端所有元素入栈
    private void pushLeftNode(TreeNode root){
        while(root!=null){
            stack.push(root);
            root=root.left;
        }
    }
}

另外，在next()方法中需要对右子树的左链进行入栈操作，时间复杂度并非O(1)，但考虑一下均摊复杂度，对所有节点的遍历的复杂度是O(n)，而每次寻找next的操作一共需执行n次，这样均摊下来，复杂度就是O(1)了。