Binary Search Tree Iterator

本文介绍了一种在二叉搜索树(BST)上实现迭代器的方法,该迭代器能够返回树中下一个最小的数值。文章详细展示了如何通过栈结构保存树节点,以确保平均时间复杂度为O(1),空间复杂度为O(h),其中h为树的高度。

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.

 

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class BSTIterator {
public:
	stack<TreeNode*> StackMinNode;
	BSTIterator(TreeNode *root) {
		TreeNode* Curnode = root;
		while (Curnode)
		{
			StackMinNode.push(Curnode);
			Curnode = Curnode->left;
		}
	}

	/** @return whether we have a next smallest number */
	bool hasNext() {
		if (StackMinNode.empty())
			return false;
		else
			return true;
	}

	/** @return the next smallest number */
	int next() {
		TreeNode* tmp = StackMinNode.top();
		StackMinNode.pop();
		int val = tmp->val;
		tmp = tmp->right;
		while (tmp)
		{
			StackMinNode.push(tmp);
			tmp = tmp->left;
		}
		return val;
	}
};


 

### 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、付费专栏及课程。

余额充值