Binary Search Tree Iterator - Practice Coding Problems

Binary Search Tree Iterator - Problem

Binary Search Tree Iterator

Design and implement an iterator that traverses a Binary Search Tree (BST) in sorted order. Your iterator should behave like a "cursor" that moves through the tree's elements from smallest to largest.

What you need to implement:

BSTIterator(TreeNode root) - Initialize the iterator with the BST's root
next() - Return the next smallest number in the BST
hasNext() - Check if there are more elements to iterate

Key Requirements:
• The iterator should traverse in in-order (sorted) sequence
• next() and hasNext() should run in average O(1) time
• Use O(h) memory at most, where h is the height of the tree

Example: For BST [7, 3, 15, null, null, 9, 20], the iterator should return: 3, 7, 9, 15, 20

Input & Output

example_1.py — Basic BST Iterator

$ Input: BSTIterator iterator = new BSTIterator([7, 3, 15, null, null, 9, 20]); iterator.next(); // return 3 iterator.next(); // return 7 iterator.hasNext(); // return True iterator.next(); // return 9 iterator.hasNext(); // return True iterator.next(); // return 15 iterator.next(); // return 20 iterator.hasNext(); // return False

› Output: 3, 7, True, 9, True, 15, 20, False

💡 Note: The BST has nodes [3, 7, 9, 15, 20] in sorted order. The iterator returns them one by one and correctly indicates when no more elements exist.

example_2.py — Single Node BST

$ Input: BSTIterator iterator = new BSTIterator([42]); iterator.hasNext(); // return True iterator.next(); // return 42 iterator.hasNext(); // return False

› Output: True, 42, False

💡 Note: For a single-node BST, hasNext() initially returns true, next() returns the only value, then hasNext() returns false.

example_3.py — Left-Skewed BST

$ Input: BSTIterator iterator = new BSTIterator([3, 1, null, null, 2]); iterator.next(); // return 1 iterator.next(); // return 2 iterator.next(); // return 3 iterator.hasNext(); // return False

› Output: 1, 2, 3, False

💡 Note: Even for unbalanced trees, the iterator maintains in-order traversal sequence correctly.

Visualization

Tap to expand

Understanding the Visualization

Setup Bookmarks

Place bookmarks on all shelves along the leftmost path - these represent the stack initialization with left-spine nodes.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Amortized O(1) for next() and O(1) for hasNext(). Each node visited exactly once across all operations.

✓ Linear Growth

Space Complexity

O(h)

Stack stores at most h nodes where h is height of tree (left-spine path)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
0 ≤ Node.val ≤ 10⁶
At most 10⁵ calls will be made to hasNext and next
Follow-up: Could you implement next() and hasNext() to run in average O(1) time and use O(h) memory, where h is the height of the tree?

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 in LinkedIn 22

The optimal solution uses a stack-based approach that maintains the left-spine path of the BST. This achieves O(1) amortized time for both operations while using only O(h) space, where h is the tree height. The key insight is that we only need to track the path to the next smallest element, not store all elements upfront.

Common Approaches

Approach	Time	Space	Notes
✓ Precompute All Values (Array Storage)	O(n)	O(n)	Store all BST values in sorted order during initialization
Controlled Stack-Based Iterator (Optimal)	O(1)	O(h)	Use stack to maintain left-spine path for efficient on-demand traversal

Precompute All Values (Array Storage) — Algorithm Steps

During initialization, perform complete in-order traversal of BST
Store all values in an array in sorted order
Keep a pointer/index to track current position
next() returns array[index] and increments index
hasNext() checks if index < array.length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize with BST

Start with the binary search tree

In-order Traversal

Traverse tree in-order and store all values in array

Array Iteration

Use simple array indexing for next() and hasNext()

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

typedef struct {
    int* values;
    int size;
    int index;
    int capacity;
} BSTIterator;

void inorder(struct TreeNode* node, BSTIterator* obj) {
    if (node) {
        inorder(node->left, obj);
        if (obj->size >= obj->capacity) {
            obj->capacity *= 2;
            obj->values = realloc(obj->values, obj->capacity * sizeof(int));
        }
        obj->values[obj->size++] = node->val;
        inorder(node->right, obj);
    }
}

BSTIterator* bSTIteratorCreate(struct TreeNode* root) {
    BSTIterator* obj = malloc(sizeof(BSTIterator));
    obj->capacity = 1000;
    obj->values = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    obj->index = 0;
    inorder(root, obj);
    return obj;
}

int bSTIteratorNext(BSTIterator* obj) {
    return obj->values[obj->index++];
}

bool bSTIteratorHasNext(BSTIterator* obj) {
    return obj->index < obj->size;
}

void bSTIteratorFree(BSTIterator* obj) {
    free(obj->values);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for initialization traversal, O(1) for next() and hasNext()

✓ Linear Growth

Space Complexity

O(n)

Array stores all n elements of the BST

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
0 ≤ Node.val ≤ 10⁶
At most 10⁵ calls will be made to hasNext and next
Follow-up: Could you implement next() and hasNext() to run in average O(1) time and use O(h) memory, where h is the height of the tree?

68.2K Views

High Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Precompute All Values (Array Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler