Binary Search Tree Iterator

二叉搜索树迭代器实现
本文介绍了一种二叉搜索树迭代器的实现方法,该迭代器能够按顺序访问二叉搜索树中的所有节点。文章提供了一个使用栈来保存遍历路径的类,通过不断将左子节点压入栈中直到为空,再从栈顶取出节点并遍历其右子树的方式实现了迭代器的hasNext和next方法。
 1 /**
 2  * Definition for binary tree
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 
11 public class BSTIterator {
12     private Stack<TreeNode> stack;
13     
14     private void initialNode(TreeNode root) {
15         while (root != null) {
16             stack.push(root);
17             root = root.left;
18         }
19     }
20     public BSTIterator(TreeNode root) {
21         stack = new Stack<>();
22         initialNode(root);
23     }
24 
25     /** @return whether we have a next smallest number */
26     public boolean hasNext() {
27         return stack.size() > 0;
28     }
29 
30     /** @return the next smallest number */
31     public int next() {
32         TreeNode root = stack.pop();
33         if (root.right != null) {
34             initialNode(root.right);
35         }
36         return root.val;
37     }
38 }
39 
40 /**
41  * Your BSTIterator will be called like this:
42  * BSTIterator i = new BSTIterator(root);
43  * while (i.hasNext()) v[f()] = i.next();
44  */

 

转载于:https://www.cnblogs.com/shuashuashua/p/5650327.html

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!
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值