LeetCode题练习与总结：二叉搜索树迭代器--173

一直学习永不止步

于 2024-07-25 04:00:00 发布

阅读量751

点赞数 8

分类专栏： LeetCode Java 中等文章标签： LeetCode Java 栈树二叉搜索树二叉树迭代器

本文链接：https://blog.csdn.net/weixin_62860386/article/details/140587590

版权

LeetCode 同时被 3 个专栏收录

241 篇文章 0 订阅

订阅专栏

Java

226 篇文章 0 订阅

订阅专栏

中等

136 篇文章 0 订阅

订阅专栏

一、题目描述

实现一个二叉搜索树迭代器类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 操作

二、解题思路

要实现一个二叉搜索树的中序遍历迭代器，我们可以使用一个栈来模拟中序遍历的过程。中序遍历的顺序是“左-根-右”，因此我们需要将所有左子节点依次入栈，直到没有左子节点为止。每次调用 next() 方法时，我们从栈中弹出一个节点，并处理该节点的右子树（如果有的话），将右子树的所有左子节点依次入栈。

以下是具体的步骤：

初始化时，将根节点及其所有左子节点依次入栈。
next() 方法：弹出栈顶元素，这是下一个中序遍历的节点。如果弹出的节点有右子节点，则将右子节点及其所有左子节点依次入栈。
hasNext() 方法：检查栈是否为空，如果栈不为空，说明还有下一个节点。

三、具体代码

import java.util.Stack;

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 Stack<TreeNode> stack;

    public BSTIterator(TreeNode root) {
        stack = new Stack<>();
        pushLeft(root);
    }
    
    public int next() {
        TreeNode node = stack.pop();
        pushLeft(node.right);
        return node.val;
    }
    
    public boolean hasNext() {
        return !stack.isEmpty();
    }

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

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

四、时间复杂度和空间复杂度

1. 时间复杂度

初始化 BSTIterator 的时间复杂度：在构造函数中，我们调用 pushLeft 方法，该方法会将给定节点的所有左子节点依次入栈。在最坏的情况下，如果二叉搜索树退化成一条链，我们需要遍历整个树的所有节点，时间复杂度为 O(n)，其中 n 是树中节点的数量。
next() 方法的时间复杂度：每次调用 next() 方法时，我们首先弹出一个节点，然后处理其右子树。由于每个节点最多只会被访问一次（入栈一次，出栈一次），因此对 next() 的所有调用总共需要 O(n) 的时间。
hasNext() 方法的时间复杂度： hasNext() 方法只是检查栈是否为空，这是一个 O(1) 的操作。

综上所述，整体的时间复杂度是 O(n)，其中 n 是树中节点的数量。

2. 空间复杂度

初始化 BSTIterator 的空间复杂度：在构造函数中，我们使用了一个栈来存储节点。在最坏的情况下（即树是完全不平衡的），栈的大小将等于树的高度，即 O(h)，其中 h 是树的高度。
next() 方法与 hasNext() 方法：这两个方法的空间复杂度都是 O(1)，因为它们不涉及额外的空间分配。

因此，整体的空间复杂度是 O(h)，其中 h 是树的高度。在平均情况下，对于平衡的二叉搜索树，空间复杂度将是 O(log n)，其中 n 是树中节点的数量。在最坏的情况下，如果树退化成一条链，空间复杂度将是 O(n)。