Sponsored
Sponsored
This approach involves using a stack to simulate the in-order traversal of a binary search tree (BST). The stack is used to keep track of nodes to visit next, starting from the leftmost node (the smallest element). Each time next() is called, the stack pops one node, processes it, and then adds right child nodes to the stack to maintain the in-order sequence. This approach takes advantage of the tree's properties to efficiently traverse it.
Time Complexity: The average time complexity is O(1) for next() and hasNext() methods, though next() can take up to O(h) time in the worst case, where h is the height of the tree.
Space Complexity: O(h) due to the depth of the stack, where h is the height of the tree.
1using System.Collections.Generic;
2
3public class BSTIterator {
4 private Stack<TreeNode> stack;
5
6 public BSTIterator(TreeNode root) {
7 stack = new Stack<TreeNode>();
8 PushLeftNodes(root);
9 }
10
11 private void PushLeftNodes(TreeNode node) {
12 while (node != null) {
13 stack.Push(node);
14 node = node.left;
}
}
public int Next() {
TreeNode node = stack.Pop();
int result = node.val;
if (node.right != null) {
PushLeftNodes(node.right);
}
return result;
}
public bool HasNext() {
return stack.Count > 0;
}
}
The C# solution employs a Stack for managing tree traversal. The BSTIterator constructor fills the stack along the leftmost nodes of the root. Calling Next() processes the current node and transitions to the next node in order, while HasNext() simply checks for elements in the stack.
Morris Traversal is an in-order tree traversal technique that doesn't require stack or recursion, thus using O(1) auxiliary space. It temporarily modifies the tree structure to maintain caching pointers, ensuring nodes are revisited as necessary. Once traversal completes, the tree reverts to its original form.
Time Complexity: O(1) on average, with O(n) total time for n nodes.
Space Complexity: O(1) without recourse to stack/recursion.
1
The C solution utilizes Morris traversal to achieve an in-order sequence without extra space. The iterator temporarily modifies the tree with connections called threads to track nodes. As the `next` method works through the tree, each accessed node prints its value and advances by fixing connections afterward. The `hasNext` method merely checks if the tree traversal has completed.