BST Iterator Design in DSA C# - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of a BST Iterator?

A BST Iterator allows us to traverse a Binary Search Tree (BST) in sorted order (in-order traversal) efficiently, providing next smallest elements one by one without traversing the whole tree at once.

beginner

In BST Iterator design, why do we use a stack?

We use a stack to simulate the in-order traversal iteratively. The stack keeps track of nodes to visit next, allowing us to return the next smallest element efficiently without recursion.

intermediate

What does the 'Next()' method do in a BST Iterator?

The 'Next()' method returns the next smallest element in the BST. It pops the top node from the stack, processes it, and pushes all left descendants of the popped node's right child onto the stack.

beginner

How does the 'HasNext()' method work in a BST Iterator?

'HasNext()' checks if there are more nodes to visit by verifying if the stack is not empty. If the stack has nodes, it means there are still elements left in the BST to iterate over.

intermediate

What is the time complexity of 'Next()' and 'HasNext()' methods in a BST Iterator?

'Next()' and 'HasNext()' methods both run in average O(1) time. Although 'Next()' may take O(h) time in worst case (h = tree height), amortized over all nodes, it is O(1). 'HasNext()' is always O(1).

What data structure is commonly used inside a BST Iterator to track nodes?

A Stack

B Queue

C Linked List

D Array

A stack is used to simulate the in-order traversal iteratively by storing nodes to visit next.

What traversal order does a BST Iterator follow to return elements?

A Level-order

B Post-order

C Pre-order

D In-order

BST Iterator returns elements in sorted order using in-order traversal.

What does the 'HasNext()' method return when the stack is empty?

A True

B False

C Throws error

D Returns null

'HasNext()' returns false when the stack is empty, meaning no more elements to iterate.

When 'Next()' is called, what nodes are pushed onto the stack after popping the top node?

A All left child's right descendants

B All left child's left descendants

C All right child's left descendants

D All right child's right descendants

After popping, 'Next()' pushes all left descendants of the popped node's right child onto the stack.

What is the average time complexity of the 'Next()' method in a BST Iterator?

A O(1)

B O(h)

C O(n)

D O(log n)

'Next()' runs in average O(1) time amortized over all nodes, even though worst case is O(h).

Explain how a BST Iterator uses a stack to return the next smallest element.

Think about simulating in-order traversal without recursion.

Describe the roles of 'Next()' and 'HasNext()' methods in a BST Iterator.

Focus on how these methods interact with the stack.

Practice

1. What is the main purpose of a BST Iterator in data structures?

easy

A. To insert new nodes into the BST

B. To balance the BST automatically

C. To delete nodes from the BST

D. To traverse the BST in ascending order without recursion

Solution

1. Step 1: Understand BST Iterator functionality

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

2. Step 2: Identify the main purpose

   Among the options, only traversing in ascending order without recursion matches the BST Iterator's role.

3. Final Answer:

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

4. Quick Check:

   BST Iterator = In-order traversal without recursion [OK]

Hint: BST Iterator helps traverse nodes in sorted order easily [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 C# method signature for the Next() method in a BST Iterator class that returns the next smallest integer?

easy

A. public string Next()

B. public void Next()

C. public int Next()

D. public bool Next()

Solution

1. Step 1: Determine the return type of Next()

   The Next() method should return the next smallest integer value from the BST, so its return type must be int.

2. Step 2: Check method signature correctness

   Only public int Next() matches the expected signature returning an integer value.

3. Final Answer:

   public int Next() -> Option C

4. Quick Check:

   Next() returns int value [OK]

Hint: Next() returns the next smallest value as int [OK]

Common Mistakes:

• Using void return type for Next()
• Returning bool instead of int
• Returning string instead of int

3. Given the BST with nodes inserted in this order: 7, 3, 15, 9, 20. What is the output sequence of calling Next() five times on a correctly implemented BST Iterator?

medium

A. [7, 3, 15, 9, 20]

B. [3, 7, 9, 15, 20]

C. [20, 15, 9, 7, 3]

D. [3, 9, 7, 15, 20]

Solution

1. Step 1: Construct BST and find in-order traversal

   Inserting 7, 3, 15, 9, 20 creates BST:
   7 is root
   3 left of 7
   15 right of 7
   9 left of 15
   20 right of 15
   In-order traversal (left-root-right) is [3, 7, 9, 15, 20].

2. Step 2: Understand Next() output sequence

   Calling Next() five times returns nodes in in-order sequence: 3, 7, 9, 15, 20.

3. Final Answer:

   [3, 7, 9, 15, 20] -> Option B

4. Quick Check:

   In-order traversal = Next() outputs [3,7,9,15,20] [OK]

Hint: Next() outputs nodes in ascending order [OK]

Common Mistakes:

• Confusing insertion order with traversal order
• Reversing the output sequence
• Mixing left and right subtree nodes

4. Identify the bug in this BST Iterator Next() method snippet and choose the correct fix:

public int Next() {
    TreeNode node = stack.Pop();
    if (node.right != null) {
        stack.Push(node.right);
    }
    return node.val;
}

medium

A. Push all left children of node.right onto stack, not just node.right

B. Pop from stack only if it is not empty

C. Return node.val before popping from stack

D. Check node.left instead of node.right

Solution

1. Step 1: Analyze the Next() method logic

   After popping node, if node.right exists, we must push node.right and all its left descendants to maintain in-order traversal.

2. Step 2: Identify missing step

   Current code pushes only node.right, missing its left subtree nodes, causing incorrect traversal order.

3. Final Answer:

   Push all left children of node.right onto stack, not just node.right -> Option A

4. Quick Check:

   Push left subtree nodes after right child [OK]

Hint: Always push left children of right subtree after popping [OK]

Common Mistakes:

• Pushing only right child without left descendants
• Returning value before popping
• Checking left child instead of right child

5. You want to design a BST Iterator that supports HasNext() and Next() methods with O(1) average time per call and O(h) space, where h is tree height. Which approach best achieves this?

hard

A. Use a stack to store left children nodes and push left descendants of right child on Next()

B. Store all nodes in a list during initialization and iterate over the list

C. Use recursion inside Next() to find next node each time

D. Use a queue to store nodes in level order traversal

Solution

1. Step 1: Understand time and space constraints

   O(1) average time per call and O(h) space means we cannot store all nodes upfront or use recursion each call.

2. Step 2: Evaluate approaches

   Using a stack to store left children and pushing left descendants of right child on Next() achieves these constraints efficiently.

3. Final Answer:

   Use a stack to store left children nodes and push left descendants of right child on Next() -> Option A

4. Quick Check:

   Stack with left children = O(1) avg time, O(h) space [OK]

Hint: Stack with left children keeps O(h) space and O(1) average time [OK]

Common Mistakes:

• Storing all nodes wastes O(n) space
• Using recursion causes higher time complexity
• Using queue breaks in-order traversal order