[LeetCode] 1586. Binary Search Tree Iterator II

Implement the BSTIterator class that represents an iterator over the in-order traversal of a binary search tree (BST):

• BSTIterator(TreeNode root) Initializes an object of the BSTIterator class. The root of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.
• boolean hasNext() Returns true if there exists a number in the traversal to the right of the pointer, otherwise returns false.
• int next() Moves the pointer to the right, then returns the number at the pointer.
• boolean hasPrev() Returns true if there exists a number in the traversal to the left of the pointer, otherwise returns false.
• int prev() Moves the pointer to the left, then returns the number at the pointer.

Notice that by initializing the pointer to a non-existent smallest number, the first call to next() will return the smallest element in the BST.

You may assume that next() and prev() calls will always be valid. That is, there will be at least a next/previous number in the in-order traversal when next()/prev() is called.

Follow up: Could you solve the problem without precalculating the values of the tree?

Example 1:

Input
["BSTIterator", "next", "next", "prev", "next", "hasNext", "next", "next", "next", "hasNext", "hasPrev", "prev", "prev"]
[[[7, 3, 15, null, null, 9, 20]], [null], [null], [null], [null], [null], [null], [null], [null], [null], [null], [null], [null]]
Output
[null, 3, 7, 3, 7, true, 9, 15, 20, false, true, 15, 9]

Explanation
// The underlined element is where the pointer currently is.
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]); // state is  [3, 7, 9, 15, 20]
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 3
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 7
bSTIterator.prev(); // state becomes [3, 7, 9, 15, 20], return 3
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 7
bSTIterator.hasNext(); // return true
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 9
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 15
bSTIterator.next(); // state becomes [3, 7, 9, 15, 20], return 20
bSTIterator.hasNext(); // return false
bSTIterator.hasPrev(); // return true
bSTIterator.prev(); // state becomes [3, 7, 9, 15, 20], return 15
bSTIterator.prev(); // state becomes [3, 7, 9, 15, 20], return 9

Constraints:

• The number of nodes in the tree is in the range [1, 105].
• 0 <= Node.val <= 106
• At most 105 calls will be made to hasNext, next, hasPrev, and prev.

二叉搜索樹迭代器II。

實現二叉搜索樹（BST）的中序遍歷迭代器 BSTIterator 類：

BSTIterator(TreeNode root) 初始化 BSTIterator 類的實例。二叉搜索樹的根節點 root 作為構造函數的參數傳入。內部指針使用一個不存在於樹中且小於樹中任意值的數值來初始化。
boolean hasNext() 如果當前指針在中序遍歷序列中，存在右側數值，返回 true ，否則返回 false 。
int next() 將指針在中序遍歷序列中向右移動，然后返回移動后指針所指數值。
boolean hasPrev() 如果當前指針在中序遍歷序列中，存在左側數值，返回 true ，否則返回 false 。
int prev() 將指針在中序遍歷序列中向左移動，然后返回移動后指針所指數值。
注意，雖然我們使用樹中不存在的最小值來初始化內部指針，第一次調用 next() 需要返回二叉搜索樹中最小的元素。

你可以假設 next() 和 prev() 的調用總是有效的。即，當 next()/prev() 被調用的時候，在中序遍歷序列中一定存在下一個/上一個元素。

進階：你可以不提前遍歷樹中的值來解決問題嗎？

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/binary-search-tree-iterator-ii
著作權歸領扣網絡所有。商業轉載請聯系官方授權，非商業轉載請注明出處。

題目是173題的版本二，題設差不多，也是遍歷BST，但是本題需要額外輸出一個prev，既中序遍歷的前一個節點。同時本題的 followup 是問你能否不提前遍歷樹中的值來解決問題。

既然是遍歷二叉搜索樹那么一定還是逃不掉中序遍歷的思想。但是這道題的 followup 是問能否不提前遍歷，所以我們可以一邊遍歷一邊得出需要的值，同時用一個 list 存住已經遍歷過的值。具體的做法是，首先先按照中序遍歷的前半段，不斷地把當前節點入棧，並一直往左子樹走，直到走到最小的左子節點位為止。

hasNext() 函數問的是當前節點之后是否還有節點，我們一般判斷的邏輯是 stack 是否為空，但是本題我們可以先判斷下一個節點是否已經被存儲在 list 中了（因為題目會反復問你 prev 和 next 是否存在），如果不在，再判斷 stack 是否為空。

next() 函數，如果 list 中存在 index + 1，則輸出這個節點值；如果如果 list 中不存在 index + 1，但是 hasNext() 為true的話，就說明下一個節點還未從 stack 中彈出，我們把它從 stack 中彈出並且加入 list。記得index++。

hasPrev() 和 prev() 就比較簡單了，因為是往前看，所以直接去判斷 inRange 是否合法和去 list 里面找相應 index 即可。

時間O(n)

空間O(n)

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 {
    Stack<TreeNode> stack = new Stack<>();
    List<TreeNode> list = new ArrayList<>();
    int index = -1;

    private void pushLeft(TreeNode root) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
    }

    private boolean inRange(int i) {
        return i >= 0 && i < list.size();
    }

    public BSTIterator(TreeNode root) {
        pushLeft(root);
    }

    public boolean hasNext() {
        if (inRange(index + 1)) {
            return true;
        }
        return !stack.isEmpty();
    }

    public int next() {
        int nextVal = 0;
        if (inRange(index + 1)) {
            nextVal = list.get(index + 1).val;
        } else {
            TreeNode next = stack.pop();
            pushLeft(next.right);
            list.add(next);
            nextVal = next.val;
        }
        index++;
        return nextVal;
    }

    public boolean hasPrev() {
        return inRange(index - 1);
    }

    public int prev() {
        return list.get(--index).val;
    }
}

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

 

相關題目

173. Binary Search Tree Iterator

1586. Binary Search Tree Iterator II

LeetCode 題目總結