BST Iterator Design in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Javascript

class BSTIterator {
  constructor(root) {
    this.stack = [];
    this._leftmostInorder(root);
  }

  _leftmostInorder(node) {
    while (node !== null) {
      this.stack.[1](node);
      node = node.left;
    }
  }
}

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

Aunshift

Bpop

Cshift

Dpush

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' instead of 'push' which removes elements instead of adding.

Using 'shift' or 'unshift' which operate on the start of the array, not the end.

We use 'push' to add nodes to the stack as we traverse left.

2fill in blank

medium

Complete the code to check if there is a next smallest number in the BST Iterator.

DSA Javascript

hasNext() {
  return this.stack.[1] > 0;
}

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

Alength()

Blength

Ccount

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'size' which is for Sets or Maps, not arrays.

Using 'length()' as a function which causes an error.

'length' is the property to get the number of elements in an array in JavaScript.

3fill in blank

hard

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

DSA Javascript

next() {
  let topNode = this.stack.[1]();
  if (topNode.right !== null) {
    this._leftmostInorder(topNode.right);
  }
  return topNode.val;
}

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

Apop

Bpush

Cshift

Dunshift

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'push' which adds instead of removing.

Using 'shift' or 'unshift' which operate on the start of the array.

'pop' removes and returns the last element from the stack, which is the next smallest node.

4fill in blank

hard

Fill both blanks to complete the _leftmostInorder helper method that pushes nodes onto the stack while traversing left.

DSA Javascript

_leftmostInorder(node) {
  while (node !== null) {
    this.stack.[1](node);
    node = node.[2];
  }
}

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

Apush

Bpop

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' instead of 'push' to add nodes.

Moving to 'right' child instead of 'left' in this helper.

We push the current node and move to its left child to traverse the leftmost path.

5fill in blank

hard

Fill all three blanks to complete the BST Iterator class with constructor, hasNext, and next methods.

DSA Javascript

class BSTIterator {
  constructor(root) {
    this.stack = [];
    this._leftmostInorder([1]);
  }

  _leftmostInorder(node) {
    while (node !== null) {
      this.stack.[2](node);
      node = node.left;
    }
  }

  hasNext() {
    return this.stack.[3] > 0;
  }

  next() {
    let topNode = this.stack.pop();
    if (topNode.right !== null) {
      this._leftmostInorder(topNode.right);
    }
    return topNode.val;
  }
}

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

Aroot

Bpush

Clength

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Calling _leftmostInorder with wrong argument.

Using 'pop' instead of 'push' in _leftmostInorder.

Using 'size' or 'length()' instead of 'length' in hasNext.

The constructor calls _leftmostInorder with 'root', _leftmostInorder pushes nodes, and hasNext checks stack length.

Practice

1. What is the main purpose of a BST Iterator in 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.

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 without recursion [OK]

Hint: BST Iterator returns next smallest element step-by-step [OK]

Common Mistakes:

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

2. Which of the following is the correct way to initialize a BST Iterator class in JavaScript?

easy

A. function BSTIterator(root) { this.stack = []; this.pushRight(root); }

B. class BSTIterator { constructor(root) { this.stack = []; this.pushLeft(root); } }

C. class BSTIterator { constructor(root) { this.queue = []; this.pushLeft(root); } }

D. function BSTIterator(root) { this.queue = []; this.pushRight(root); }

Solution

1. Step 1: Identify correct class syntax and initialization

   The BST Iterator is usually implemented as a class with a stack to store nodes and a helper method to push left children.

2. Step 2: Check each option

   class BSTIterator { constructor(root) { this.stack = []; this.pushLeft(root); } } correctly uses a class, initializes a stack, and calls pushLeft on root. Others use queue or pushRight which are incorrect for BST Iterator.

3. Final Answer:

   class BSTIterator { constructor(root) { this.stack = []; this.pushLeft(root); } } -> Option B

4. Quick Check:

   Use stack and pushLeft in constructor [OK]

Hint: BST Iterator uses stack and pushLeft method [OK]

Common Mistakes:

• Using queue instead of stack
• Calling pushRight instead of pushLeft
• Using function instead of class syntax

3. Given the BST below and the following code snippet, what will be the output? BST structure: ``` 7 / \ 3 15 / \ 9 20 ``` Code:

const iterator = new BSTIterator(root);
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.hasNext());

medium

A. [3, 7, false]

B. [7, 9, true]

C. [3, 7, true]

D. [9, 15, true]

Solution

1. Step 1: Trace the first next() call

   First next() returns the smallest element, which is 3.

2. Step 2: Trace the second next() call

   Second next() returns the next smallest, which is 7.

3. Step 3: Check hasNext()

   After two next() calls, there are still nodes (9, 15, 20), so hasNext() returns true.

4. Final Answer:

   [3, 7, true] -> Option C

5. Quick Check:

   next() returns ascending nodes, hasNext() true if more nodes [OK]

Hint: next() returns next smallest; hasNext() true if stack not empty [OK]

Common Mistakes:

• Assuming next() returns root first
• Confusing hasNext() return value
• Ignoring left subtree nodes

4. Consider this buggy BST Iterator method. What is the main error?

next() {
  const node = this.stack.pop();
  if (node.right) {
    this.pushRight(node.right);
  }
  return node.val;
}

pushRight(node) {
  while (node) {
    this.stack.push(node);
    node = node.right;
  }
}

medium

A. next() should not pop from stack

B. next() should return node.key instead of node.val

C. pushRight should use a queue instead of stack

D. pushRight should push left children, not right

Solution

1. Step 1: Analyze pushRight method

   pushRight pushes right children, but BST Iterator needs to push left children to get next smallest.

2. Step 2: Understand correct pushLeft usage

   Correct method pushes left children of right subtree to stack to maintain ascending order.

3. Final Answer:

   pushRight should push left children, not right -> Option D

4. Quick Check:

   Push left children to stack for correct order [OK]

Hint: Push left children of right subtree, not right children [OK]

Common Mistakes:

• Pushing right children instead of left
• Using queue instead of stack
• Returning wrong node property

5. You want to design a BST Iterator that supports next() and hasNext() in O(1) average time and uses O(h) space, where h is tree height. Which approach best achieves this?

hard

A. Use a stack to store left children and push left nodes of right subtree on next()

B. Store all nodes in an array by inorder traversal at initialization

C. Use recursion to traverse nodes on each next() call

D. Use a queue to store nodes level by level

Solution

1. Step 1: Understand time and space constraints

   O(1) average time per next() and O(h) space means no full traversal storage and no recursion per call.

2. Step 2: Evaluate each approach

   Use a stack to store left children and push left nodes of right subtree on next() uses a stack to store left children and pushes left nodes of right subtree on next(), achieving O(1) average time and O(h) space. Store all nodes in an array by inorder traversal at initialization uses O(n) space. Use recursion to traverse nodes on each next() call uses recursion, not O(1) time. Use a queue to store nodes level by level uses queue level order, not inorder.

3. Final Answer:

   Use a stack to store left children and push left nodes of right subtree on next() -> Option A

4. Quick Check:

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

Hint: Use stack with left children for efficient BST Iterator [OK]

Common Mistakes:

• Storing all nodes wastes space
• Using recursion causes slow next()
• Using queue gives wrong traversal order