BST Iterator Design in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the stack in the BST iterator constructor.

DSA C#

public BSTIterator(TreeNode root) {
    stack = new Stack<TreeNode>();
    TreeNode current = root;
    while (current != null) {
        stack.[1](current);
        current = current.left;
    }
}

Drag options to blanks, or click blank then click option'

APush

BPop

CClear

DPeek

Attempts:

3 left

💡 Hint

Common Mistakes

Using Pop instead of Push causes runtime errors.

Using Peek does not add elements to the stack.

We use stack.Push(node) to add nodes to the stack while traversing left.

2fill in blank

medium

Complete the code to check if the iterator has more elements.

DSA C#

public bool HasNext() {
    return stack.[1] > 0;
}

Drag options to blanks, or click blank then click option'

ACount

BLength

CSize

DCapacity

Attempts:

3 left

💡 Hint

Common Mistakes

Using Length or Size causes compile errors.

Using Capacity returns the allocated size, not the current count.

Stack.Count returns the number of elements currently in the stack.

3fill in blank

hard

Fix the error in the Next() method to correctly return the next smallest element.

DSA C#

public int Next() {
    TreeNode node = stack.[1]();
    int result = node.val;
    node = node.right;
    while (node != null) {
        stack.Push(node);
        node = node.left;
    }
    return result;
}

Drag options to blanks, or click blank then click option'

APush

BPop

CPeek

DRemove

Attempts:

3 left

💡 Hint

Common Mistakes

Using Peek returns the top element but does not remove it, causing infinite loops.

Using Push or Remove are invalid stack operations here.

Pop removes and returns the top element from the stack, which is the next smallest node.

4fill in blank

hard

Fill both blanks to initialize the BST iterator and push all left children.

DSA C#

public BSTIterator(TreeNode root) {
    stack = new Stack<TreeNode>();
    TreeNode [1] = root;
    while ([2] != null) {
        stack.Push([2]);
        [2] = [2].left;
    }
}

Drag options to blanks, or click blank then click option'

Acurrent

Bnode

Croot

Dtemp

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently causes errors.

Using 'root' inside the loop without updating causes infinite loops.

We use a variable named 'current' to traverse left nodes and push them onto the stack.

5fill in blank

hard

Fill all three blanks to implement the Next() method correctly.

DSA C#

public int Next() {
    TreeNode [1] = stack.Pop();
    int [2] = [1].val;
    [3] = [1].right;
    while (node != null) {
        stack.Push(node);
        node = node.left;
    }
    return [2];
}

Drag options to blanks, or click blank then click option'

Anode

Bresult

CnodeVal

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent variable names causes confusion.

Not updating the stack with right subtree nodes causes incorrect iteration.

We pop the top node as 'node', store its value in 'result', then traverse its right subtree pushing left children.

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