剑指 Offer II 055. 二叉搜索树迭代器(173. 二叉搜索树迭代器)

题目：

思路：

【1】利用数组来实现迭代器的方式

【2】单调栈的方式

代码展示：

单调栈的方式：

//时间16 ms击败96.48%
//内存45.6 MB击败13.31%
//时间复杂度：显然，初始化和调用 hasNext() 都只需要 O(1) 的时间。
//每次调用 next() 函数最坏情况下需要 O(n) 的时间；
//但考虑到 n 次调用 next() 函数总共会遍历全部的 n 个节点，
//因此总的时间复杂度为 O(n)，因此单次调用平均下来的均摊复杂度为 O(1)。
//空间复杂度：O(n)，其中 n 是二叉树的节点数量。空间复杂度取决于栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。
class BSTIterator {
    private TreeNode cur;
    private Deque<TreeNode> stack;

    public BSTIterator(TreeNode root) {
        cur = root;
        stack = new LinkedList<TreeNode>();
    }
    
    public int next() {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        cur = stack.pop();
        int ret = cur.val;
        cur = cur.right;
        return ret;
    }
    
    public boolean hasNext() {
        return cur != null || !stack.isEmpty();
    }
}

 

利用数组来实现迭代器的方式：

//时间16 ms击败96.48%
//内存45.8 MB击败5.13%
//时间复杂度：初始化需要 O(n) 的时间，其中 n 为树中节点的数量。随后每次调用只需要 O(1) 的时间。
//空间复杂度：O(n)，因为需要保存中序遍历的全部结果。
/**
 * 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 idx;
    private List<Integer> arr;

    public BSTIterator(TreeNode root) {
        idx = 0;
        arr = new ArrayList<Integer>();
        inorderTraversal(root, arr);
    }

    public int next() {
        return arr.get(idx++);
    }

    public boolean hasNext() {
        return idx < arr.size();
    }

    private void inorderTraversal(TreeNode root, List<Integer> arr) {
        if (root == null) {
            return;
        }
        inorderTraversal(root.left, arr);
        arr.add(root.val);
        inorderTraversal(root.right, arr);
    }
}

/**
 * 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();
 */