Loading...
墨滴

SuperMP

2021/04/20  阅读:22  主题:默认主题

Leetcode刷题 | 第111题:二叉搜索树迭代器

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

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/

SuperMP

2021/04/20  阅读:22  主题:默认主题

作者介绍

SuperMP