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.
1import java.util.Stack;
2
3class BSTIterator {
4 private Stack<TreeNode> stack;
5
6 public
This Java solution leverages the Stack class for its internal stack implementation. The constructor pre-fills the stack with left-path nodes from the root. `next()` pops the stack to get the next smallest element and processes any right subtree by adding its left children to the stack. hasNext() checks the stack to see if more elements remain.
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.
This Java version relies on the Morris traversal's light footprint, enabling in-order visits with constant additional space. Each `next` extracts subsequent node values and addresses altered tree pointers. `hasNext` continuously ascertains whether further nodes exist for processing.