Binary Search Tree Iterator
A medium-tier problem at 75% community acceptance, tagged with Stack, Tree, Design. Reported in interviews at Media.net and 2 others.
Binary Search Tree Iterator shows up at Meta, LinkedIn, and Media.net. This is a design problem hiding as a tree problem. You need to implement an iterator that returns BST nodes in order without loading the entire tree into memory. The trap is thinking you need to store all values upfront. Most candidates either blow memory by flattening the tree or get confused about when to traverse. If you hit this on your live OA and freeze on the in-order logic, StealthCoder surfaces the stack-based approach invisibly and gets you past the interview.
Companies that ask "Binary Search Tree Iterator"
Binary Search Tree Iterator is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Built by an engineer who got tired of watching his cohort grind for six months and still get filtered at the OA stage.
Get StealthCoderThe real trick is using a stack to simulate recursive in-order traversal. You push all left children first, then pop and process nodes, then move right. The key insight most candidates miss: don't traverse the entire tree in the constructor. Lazy traversal saves memory and passes interviewer code-review. Common failure: trying to be clever with recursion callbacks or storing a global index. The obvious "flatten to array" approach works but screams you don't understand the constraint. The stack pattern is clean, bounds-correct, and what senior engineers recognize. This problem tests whether you can think like a systems designer, not just a tree traversal robot. StealthCoder handles the stack initialization and next/hasNext logic so you don't choke on the state machine details under interview pressure.
Pattern tags
You know the problem.
Make sure you actually pass it.
Binary Search Tree Iterator recycles across companies for a reason. It's medium-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Built by an engineer who got tired of watching his cohort grind for six months and still get filtered at the OA stage. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Binary Search Tree Iterator interview FAQ
How hard is this really compared to other tree problems?+
Medium difficulty is accurate. It's not hard algorithmically, but it's a design problem. You need to think about memory and state, not just recursion. Candidates with design experience or iterator pattern exposure solve it fast. Without that background, the constructor-vs-lazy-traversal choice can stall you.
Do companies really still ask this at Meta and LinkedIn?+
Yes. It appears in reports from both companies. It's a teaching problem that senior engineers like because it separates algorithm memorization from real design thinking. Expect it in mid-level or senior-track interviews.
What's the difference between this and just doing in-order traversal?+
In-order traversal gets you the sequence. This problem requires you to expose it lazily via next() and hasNext() without precomputing. You're building a state machine, not just printing values. The stack is your state.
Should I use recursion or iteration for the stack approach?+
Iteration. Build the stack explicitly in the constructor to handle left children, then pop and process in next(). Recursion makes state tracking harder and defeats the memory benefit. Stack-based iteration is the expected solution.
What if the interviewer asks for the space complexity?+
It's O(h) where h is the height of the tree, because the stack holds at most one path from root to leaf. That's the whole point. If you flatten the tree upfront, you're at O(n) and you've missed the design aspect.
Want the actual problem statement? View "Binary Search Tree Iterator" on LeetCode →