Binary Search Tree Iterator II - Practice Coding Problems

Binary Search Tree Iterator II - Problem

Design a bidirectional iterator for a Binary Search Tree (BST) that can traverse both forward and backward through the tree's in-order sequence.

You need to implement the BSTIterator class with the following methods:

BSTIterator(TreeNode root): Initialize the iterator. The pointer starts at a position before the smallest element.
boolean hasNext(): Returns true if there's a next element in the forward direction.
int next(): Moves the pointer forward and returns the current element.
boolean hasPrev(): Returns true if there's a previous element in the backward direction.
int prev(): Moves the pointer backward and returns the current element.

Key Points:

The iterator traverses the BST in in-order sequence (left → root → right)
Initial position is before the smallest element, so first next() returns the minimum value
You can assume all calls to next() and prev() are valid

Example: For BST [7,3,15,null,null,9,20], the in-order sequence is [3,7,9,15,20]

Input & Output

example_1.py — Basic BST Iterator

$ Input: root = [7,3,15,null,null,9,20] Operations: ["BSTIterator","next","next","hasNext","next","hasNext","next","next","hasNext"]

› Output: [null,3,7,true,9,true,15,20,false]

💡 Note: Initialize iterator with BST. The in-order sequence is [3,7,9,15,20]. Start before 3, then next() calls return 3,7,9,15,20 in sequence.

example_2.py — Bidirectional Movement

$ Input: root = [7,3,15,null,null,9,20] Operations: ["BSTIterator","next","next","prev","next","next"]

› Output: [null,3,7,3,7,9]

💡 Note: After getting 3,7 with next(), prev() goes back to 3. Then next() returns 7,9. Shows bidirectional capability.

example_3.py — Edge Cases

$ Input: root = [1] Operations: ["BSTIterator","hasNext","next","hasNext","hasPrev","prev","hasPrev"]

› Output: [null,true,1,false,true,1,false]

💡 Note: Single node tree. hasNext() is true initially, next() returns 1, then hasNext() false. Can go back with prev().

Visualization

Tap to expand

Understanding the Visualization

Initialize Bookmarks

Set up two bookmark stacks - one for 'pages to read forward' and one for 'pages already read'

Forward Navigation

Move current page to 'read' stack, add new reachable pages to 'forward' stack

Backward Navigation

Move current page back to 'forward' stack, add reachable pages to 'read' stack

State Management

Each operation maintains the correct state for both directions efficiently

Key Takeaway

🎯 Key Insight: Two stacks simulate the recursive call stack of in-order traversal, providing O(1) amortized operations with optimal O(h) space usage.

Time & Space Complexity

Time Complexity

⏱️

O(1) amortized per operation

Each node is pushed and popped at most twice across all operations

✓ Linear Growth

Space Complexity

O(h)

Two stacks storing at most h nodes each where h is tree height

✓ 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, next, hasPrev, and prev
All calls to next() and prev() are guaranteed to be valid

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses two stacks to maintain traversal state for both directions. One stack handles forward traversal by storing the path to the next smaller elements, while another handles backward traversal. This achieves O(1) amortized time for all operations with only O(h) space complexity, where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Store All Values)	O(n) initialization, O(1) per operation	O(n)	Pre-compute entire in-order traversal and store in array with pointer
Two Stacks (Optimal)	O(1) amortized per operation	O(h)	Use two stacks to simulate in-order traversal state for bidirectional movement

Brute Force (Store All Values) — Algorithm Steps

During initialization, perform in-order traversal and store all values in array
Initialize pointer to -1 (before first element)
For next(): increment pointer and return array[pointer]
For prev(): decrement pointer and return array[pointer]
For hasNext()/hasPrev(): check if pointer can move in respective direction

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Traverse entire tree and store values: [3,7,9,15,20], pointer = -1

First next()

pointer moves to 0, returns values[0] = 3

Another next()

pointer moves to 1, returns values[1] = 7

Call prev()

pointer moves back to 0, returns values[0] = 3

Code -

solution.c — C

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

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

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

void inorder(TreeNode* node, BSTIterator* obj) {
    if (!node) return;
    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(TreeNode* root) {
    BSTIterator* obj = malloc(sizeof(BSTIterator));
    obj->capacity = 100;
    obj->values = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    obj->pointer = -1;
    inorder(root, obj);
    return obj;
}

bool bSTIteratorHasNext(BSTIterator* obj) {
    return obj->pointer + 1 < obj->size;
}

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

bool bSTIteratorHasPrev(BSTIterator* obj) {
    return obj->pointer > 0;
}

int bSTIteratorPrev(BSTIterator* obj) {
    obj->pointer--;
    return obj->values[obj->pointer];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n) initialization, O(1) per operation

Initial traversal takes O(n), but each next/prev call is constant time

✓ Linear Growth

Space Complexity

O(n)

Store all n values in array plus O(h) recursion stack for traversal

⚡ 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, next, hasPrev, and prev
All calls to next() and prev() are guaranteed to be valid

23.6K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Brute Force (Store All Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler