Binary Search Tree Iterator

本文介绍了一种在二叉搜索树(BST)上进行迭代的高效算法实现。该算法利用栈来保存遍历路径,使得next()和hasNext()操作能在平均O(1)时间内完成,内存使用为O(h),其中h为树的高度。通过这种方式,可以按升序访问BST的所有元素。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >



Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.

Calling next() will return the next smallest number in the BST.

Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.




/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class BSTIterator {
public:
    BSTIterator(TreeNode *root) {
        while (root) {
            s.push(root);
            root = root->left;
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        return !s.empty();
    }

    /** @return the next smallest number */
    int next() {
        TreeNode *n = s.top();
        s.pop();
        int res = n->val;
        if (n->right) {
            n = n->right;
            while (n) {
                s.push(n);
                n = n->left;
            }
        }
        return res;
    }
private:
    stack<TreeNode*> s;
};

/**
 * Your BSTIterator will be called like this:
 * BSTIterator i = BSTIterator(root);
 * while (i.hasNext()) cout << i.next();
 */

05-20
### LeetCode 510: Binary Search Tree Iterator LeetCode Problem 510 is titled **Binary Search Tree Iterator**, which involves designing an iterator over a binary search tree (BST). The goal is to implement the `BSTIterator` class that initializes with the root of a BST and supports two operations: 1. `next()`: Returns the next smallest number in the BST. 2. `hasNext()`: Returns whether there exists a next smallest number. The solution should run in average O(1) time complexity per operation, using O(h) memory where h is the height of the tree[^1]. #### Approach Using Inorder Traversal To solve this problem efficiently, one can use an iterative inorder traversal approach leveraging a stack data structure. This method ensures that each node's value is processed in ascending order due to the properties of a BST. Here’s how it works: - Initialize a stack during construction (`__init__`) and populate it by traversing as far left from the given root as possible. - For every call to `next()`, pop the top element off the stack, then push all its right subtree nodes onto the stack following the same rule—traverse down the leftmost path starting at any new node added. - Use the `hasNext()` function simply to check if the stack still contains elements; if so, more values remain unprocessed. Below is Python code implementing such functionality: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class BSTIterator: def __init__(self, root: TreeNode): self.stack = [] self._leftmost_in_order(root) def _leftmost_in_order(self, root: TreeNode): while root: self.stack.append(root) root = root.left def next(self) -> int: top_node = self.stack.pop() if top_node.right: self._leftmost_in_order(top_node.right) return top_node.val def hasNext(self) -> bool: return len(self.stack) > 0 ``` This implementation guarantees both methods operate within acceptable performance bounds specified earlier[^2]. Additionally, since stacks only store references along paths leading toward potential future results rather than entire trees themselves, space usage remains proportional solely based on heights instead of total sizes involved here too!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值