BST Iterator Design in DSA Java - Build from Scratch

BST Iterator Design

📖 Scenario: Imagine you have a large collection of numbers stored in a special tree called a Binary Search Tree (BST). You want to look at these numbers one by one in order from smallest to largest, but you don't want to look at all of them at once because there are too many. You need a tool that helps you move through the tree step-by-step, remembering where you left off.

🎯 Goal: Build a BST Iterator in Java that lets you move through the BST numbers in order, one at a time. You will create the tree, set up the iterator, write the logic to get the next smallest number, and finally print the numbers as you move through the tree.

📋 What You'll Learn

Create a BST with the exact nodes given

Create a stack to help with the iterator

Implement the next() method to return the next smallest number

Implement the hasNext() method to check if more numbers are left

Print the numbers in ascending order using the iterator

💡 Why This Matters

🌍 Real World

BST iterators are used in databases and search engines to efficiently access sorted data without loading everything at once.

💼 Career

Understanding BST iterators helps in roles involving data structure optimization, coding interviews, and building efficient software that handles large sorted datasets.

1

Create the BST nodes

Create a class called TreeNode with an integer val, and two TreeNode references called left and right. Then create the BST with these exact nodes and connections:
root with value 7,
root.left with value 3,
root.right with value 15,
root.right.left with value 9,
root.right.right with value 20.

DSA Java

// Define TreeNode class and create the BST nodes as described
// Your code here

Hint

Remember to create the TreeNode class first, then build the tree by linking nodes exactly as described.

2

Set up the BST Iterator stack

Create a class called BSTIterator with a Stack<TreeNode> called stack. Add a constructor that takes a TreeNode root and calls a helper method pushLeft(TreeNode node) to push all left children of root onto the stack.

DSA Java

class BSTIterator {
    Stack stack = new Stack();

    BSTIterator(TreeNode root) {
        // Call pushLeft with root
        // Your code here
    }

    private void pushLeft(TreeNode node) {
        // Your code here
    }
}

Hint

Use a loop to push all left nodes starting from root onto the stack.

3

Implement next() and hasNext() methods

Inside the BSTIterator class, implement the method int next() that pops the top node from the stack, calls pushLeft on its right child, and returns the popped node's value. Also implement boolean hasNext() that returns true if the stack is not empty, otherwise false.

DSA Java

class BSTIterator {
    Stack stack = new Stack();

    BSTIterator(TreeNode root) {
        pushLeft(root);
    }

    private void pushLeft(TreeNode node) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
    }

    int next() {
        // Your code here
    }

    boolean hasNext() {
        // Your code here
    }
}

Hint

Pop the top node, push all left children of its right child, then return the node's value. Check if stack is empty for hasNext.

4

Print all BST values in ascending order using the iterator

Create a BSTIterator object called iterator with root. Use a while loop with iterator.hasNext() to print each value returned by iterator.next() on the same line separated by spaces.

DSA Java

BSTIterator iterator = new BSTIterator(root);
// Use a while loop to print all values in ascending order
// Your code here

Hint

Use a while loop to keep calling next() and print the values until hasNext() is false.

Practice

1. What is the main purpose of a BST Iterator in the context of a Binary Search Tree?

easy

A. To traverse the BST in ascending order without recursion

B. To insert new nodes into the BST

C. To delete nodes from the BST

D. To balance the BST automatically

Solution

1. Step 1: Understand BST Iterator functionality

   A BST Iterator is designed to traverse the tree in sorted order, typically ascending, without using recursion explicitly.

2. Step 2: Identify the main purpose

   It provides a way to get the next smallest element efficiently, which matches To traverse the BST in ascending order without recursion.

3. Final Answer:

   To traverse the BST in ascending order without recursion -> Option A

4. Quick Check:

   BST Iterator = Ascending traversal [OK]

Hint: BST Iterator returns next smallest element in sorted order [OK]

Common Mistakes:

• Confusing iterator with insertion or deletion operations
• Thinking it balances the tree automatically
• Assuming it uses recursion internally

2. Which of the following is the correct method signature for the next() method in a BST Iterator class in Java?

easy

A. public Node next()

B. public void next()

C. public int next()

D. public boolean next()

Solution

1. Step 1: Understand the return type of next()

   The next() method returns the next smallest integer value from the BST, so it should return an int.

2. Step 2: Match method signature

   public int next() matches the expected signature: public int next().

3. Final Answer:

   public int next() -> Option C

4. Quick Check:

   next() returns int value [OK]

Hint: next() returns next smallest int value from BST [OK]

Common Mistakes:

• Using void return type for next()
• Returning boolean instead of int
• Returning Node instead of int value

3. Given the following BST Iterator code snippet, what will be the output sequence of next() calls?

BSTIterator iterator = new BSTIterator(root); // BST with nodes 3, 7, 9
System.out.print(iterator.next() + ", ");
System.out.print(iterator.next() + ", ");
System.out.print(iterator.next());

medium

A. 7, 3, 9

B. 3, 7, 9

C. 9, 7, 3

D. 3, 9, 7

Solution

1. Step 1: Understand BST in-order traversal order

   BST in-order traversal returns nodes in ascending order: 3, 7, 9.

2. Step 2: Trace next() calls

   Each next() call returns the next smallest element, so the output is 3, then 7, then 9.

3. Final Answer:

   3, 7, 9 -> Option B

4. Quick Check:

   In-order traversal = 3,7,9 [OK]

Hint: next() returns ascending BST values in order [OK]

Common Mistakes:

• Assuming next() returns descending order
• Mixing up node values order
• Confusing next() with hasNext()

4. Identify the bug in this BST Iterator next() method implementation:

public int next() {
    TreeNode node = stack.pop();
    if (node.right != null) {
        pushLeft(node.right);
    }
    return node.val;
}

private void pushLeft(TreeNode node) {
    while (node != null) {
        stack.push(node);
        node = node.left;
    }
}

medium

A. The next() method should return node.right.val instead of node.val

B. The pushLeft method should push right children instead of left

C. The stack is not initialized before use

D. The next() method should check if stack is empty before popping

Solution

1. Step 1: Analyze next() method stack usage

   Calling stack.pop() without checking if stack is empty can cause runtime error if no elements remain.

2. Step 2: Identify missing safety check

   Proper implementation should check stack emptiness before popping to avoid exceptions.

3. Final Answer:

   The next() method should check if stack is empty before popping -> Option D

4. Quick Check:

   Check stack empty before pop [OK]

Hint: Always check stack not empty before pop in next() [OK]

Common Mistakes:

• Ignoring stack empty check causing exceptions
• Misunderstanding pushLeft logic
• Returning wrong node value

5. You want to design a BST Iterator that supports peek() to see the next smallest element without advancing the iterator. Which approach correctly extends the standard BST Iterator design?

hard

A. Store the next smallest element in a variable during next() and return it in peek() without popping stack

B. Use an extra stack to store all nodes and pop from it in peek()

C. Modify next() to return the top of the stack without popping it, and peek() pops the stack

D. Traverse the entire BST in constructor and store values in a list for peek() and next()

Solution

1. Step 1: Understand peek() requirement

   peek() should return next smallest element without advancing iterator, so it must not pop stack.

2. Step 2: Identify correct approach

   Storing next smallest element in a variable during next() allows peek() to return it without changing stack state, matching Store the next smallest element in a variable during next() and return it in peek() without popping stack.

3. Final Answer:

   Store the next smallest element in a variable during next() and return it in peek() without popping stack -> Option A

4. Quick Check:

   peek() returns next without advancing [OK]

Hint: Cache next element to support peek() without stack pop [OK]

Common Mistakes:

• Popping stack in peek() advancing iterator
• Using extra stack unnecessarily
• Precomputing all values losing iterator benefits