二叉搜索树迭代器_二叉树迭代器

一、需求

• 实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器；

• 调用 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 中至少存在一个下一个最小的数(将这下一个最小的数看作一个整体)。

二、扁平化二叉树

2.1  思路分析

1. 所谓扁平化二叉树就是把二叉树拉直，我们将BST的中序遍历存储到集合中，这样集合中的元素是升序排序，通过一个索引指向"下一个最小元素"；
2. 注意该方法的均摊时间复杂度为O(1)，空间复杂度为O(N)，不符合题目要求的O(h)内存；

2.2  代码实现

class BSTIterator {
    List<Integer> res;
    int index;
    public BSTIterator(TreeNode root) {
        res = new ArrayList<>();
        index = 0;
        infixOrder(root);
    }
    
    public int next() {
        int tmp = res.get(index);
        index++;
        return tmp;
    }
    
    public boolean hasNext() {
        if(index < res.size()) {
            return true;
        } else {
            return false;
        }
    }
 
    public void infixOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        infixOrder(root.left);
        res.add(root.val);
        infixOrder(root.right);
    }
}

2.3  复杂度分析

• 均摊时间复杂度为O(1)，执行1次构造方法、N次next()、N次hasNext()总的操作次数3N，平均操作次数为3，故均摊时间复杂度为O(1)；
• 空间复杂度为O(N)，集合存储BST的中序遍历消耗O(N)的额外空间；

三、迭代法

3.1  思路分析

1. 在这里我们利用迭代法获得中序遍历的思想，在迭代过程中进行处理，而不是像方法2等递归结束后再进行处理；
2. 利用栈结构实现，定义一个方法，功能是将当前节点及其左子树入栈；

3.2  代码实现

class BSTIterator {
    Deque<TreeNode> stack;
    public BSTIterator(TreeNode root) {
        stack = new ArrayDeque<>();
        addLeftTree(root);
    }
    
    public int next() {
        TreeNode node = stack.pop();
        if(node.right != null) {
            addLeftTree(node.right);
        }
        return node.val;
    }
    
    public boolean hasNext() {
        return stack.size() > 0;
    }
 
    private void addLeftTree(TreeNode node) {
        while(node != null) {
            stack.push(node);
            node = node.left;
        }
    }
}

3.3  复杂度分析

• 均摊时间复杂度为O(1)；
• 空间复杂度为$O(log_2N)$，消耗的空间相当于树的深度h；

四、学习地址

作者：LeetCode

链接：https://leetcode-cn.com/problems/binary-search-tree-iterator/solution/er-cha-sou-suo-shu-die-dai-qi-by-leetcode/