BST Find Minimum Element in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start searching for the minimum element from the root node.

DSA Javascript

function findMin(root) {
  let current = [1];
  while (current.left !== null) {
    current = current.left;
  }
  return current.data;
}

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

Aroot.right

Broot.left

Croot

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from root.left skips the root node which might be the minimum.

Starting from root.right goes to the right subtree which has larger values.

We start from the root node to find the minimum element in a BST.

2fill in blank

medium

Complete the code to move to the left child node while searching for the minimum.

DSA Javascript

function findMin(root) {
  let current = root;
  while (current.[1] !== null) {
    current = current.left;
  }
  return current.data;
}

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

Aright

Bleft

Cnode

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'right' instead of 'left' will go to larger values.

Using 'child' or 'node' are not valid properties.

We move left because the smallest value in a BST is always in the leftmost node.

3fill in blank

hard

Fix the error in the return statement to correctly return the minimum value.

DSA Javascript

function findMin(root) {
  let current = root;
  while (current.left !== null) {
    current = current.left;
  }
  return current.[1];
}

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

Adata

Bvalue

Cval

Dmin

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'value' or 'val' which are not defined properties.

Returning 'min' which is not a property of the node.

The node's value is stored in the 'data' property, so we return current.data.

4fill in blank

hard

Fill both blanks to create a function that returns null if the tree is empty and finds the minimum otherwise.

DSA Javascript

function findMin(root) {
  if (root === [1]) {
    return null;
  }
  let current = root;
  while (current.[2] !== null) {
    current = current.left;
  }
  return current.data;
}

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

Anull

Bundefined

Croot

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root against undefined instead of null.

Using 'right' instead of 'left' in the while loop.

We check if root is null to handle empty trees, and traverse left to find the minimum.

5fill in blank

hard

Fill all three blanks to implement a recursive function that finds the minimum element in a BST.

DSA Javascript

function findMinRecursive(node) {
  if (node === [1]) {
    return null;
  }
  if (node.[2] === [3]) {
    return node.data;
  }
  return findMinRecursive(node.left);
}

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

Anull

Bundefined

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined instead of null for checks.

Checking right child instead of left child.

The base case checks if node is null, then if left child is null, return current node's data.

Practice

1. In a Binary Search Tree (BST), where is the minimum element always located?

easy

A. At the rightmost node

B. At the root node

C. At the leftmost node

D. At any leaf node

Solution

1. Step 1: Understand BST property

   In a BST, left child nodes have smaller values than their parents.

2. Step 2: Locate minimum element

   The smallest value is found by going as far left as possible.

3. Final Answer:

   At the leftmost node -> Option C

4. Quick Check:

   Minimum = leftmost node [OK]

Hint: Minimum is always the leftmost node in BST [OK]

Common Mistakes:

• Thinking minimum is at root
• Confusing leftmost with rightmost
• Assuming minimum can be any leaf

2. Which of the following JavaScript code snippets correctly finds the minimum element in a BST node structure where each node has left and value properties?

easy

A. function findMin(node) { while(node.left) { node = node.left; } return node.value; }

B. function findMin(node) { while(node.right) { node = node.right; } return node.value; }

C. function findMin(node) { return node.value; }

D. function findMin(node) { if(node.right) return findMin(node.right); else return node.value; }

Solution

1. Step 1: Check traversal direction

   Minimum is found by moving left, so loop should check node.left.

2. Step 2: Verify code correctness

   function findMin(node) { while(node.left) { node = node.left; } return node.value; } loops while node.left exists, then returns node.value, which is correct.

3. Final Answer:

   function findMin(node) { while(node.left) { node = node.left; } return node.value; } -> Option A

4. Quick Check:

   Traverse left until no left child [OK]

Hint: Loop left child nodes to find minimum [OK]

Common Mistakes:

• Looping right child instead of left
• Returning node.value without traversal
• Recursing on right child for minimum

3. Given the BST below and the function findMin that finds the minimum value, what will be the output?

const root = {
  value: 10,
  left: { value: 5, left: { value: 2, left: null, right: null }, right: null },
  right: { value: 15, left: null, right: null }
};

function findMin(node) {
  while(node.left) {
    node = node.left;
  }
  return node.value;
}

console.log(findMin(root));

medium

A. 15

B. 5

C. 10

D. 2

Solution

1. Step 1: Trace left children from root

   Start at 10, move left to 5, then left to 2, which has no left child.

2. Step 2: Return value of leftmost node

   Leftmost node is 2, so function returns 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Leftmost node value = 2 [OK]

Hint: Minimum is leftmost node value 2 here [OK]

Common Mistakes:

• Returning root value instead of leftmost
• Confusing left and right child traversal
• Misreading tree structure

4. The following code is intended to find the minimum value in a BST but has a bug. What is the bug?

function findMin(node) {
  while(node.right) {
    node = node.right;
  }
  return node.value;
}

medium

A. It incorrectly traverses right child instead of left

B. It does not return the node value

C. It causes infinite loop

D. It throws syntax error

Solution

1. Step 1: Analyze traversal direction

   The code moves to node.right repeatedly, which finds the maximum, not minimum.

2. Step 2: Identify correct traversal for minimum

   Minimum requires moving to node.left, so the bug is wrong direction.

3. Final Answer:

   It incorrectly traverses right child instead of left -> Option A

4. Quick Check:

   Minimum = leftmost, not rightmost [OK]

Hint: Minimum is leftmost, not rightmost traversal [OK]

Common Mistakes:

• Confusing left and right child traversal
• Assuming right child leads to minimum
• Not testing code with example trees

5. You want to find the minimum element in a BST that may be empty (null). Which of the following improved functions correctly handles this edge case and returns null if the tree is empty?

hard

A. function findMin(node) { while(node.left) { node = node.left; } return node.value; }

B. function findMin(node) { if(!node) return null; while(node.left) { node = node.left; } return node.value; }

C. function findMin(node) { if(node.left) return findMin(node.left); else return node.value; }

D. function findMin(node) { if(!node.left) return null; else return findMin(node.left); }

Solution

1. Step 1: Check for empty tree

   function findMin(node) { if(!node) return null; while(node.left) { node = node.left; } return node.value; } returns null immediately if node is null, handling empty tree.

2. Step 2: Traverse left children safely

   Then it loops left until no left child, returning minimum value correctly.

3. Final Answer:

   function findMin(node) { if(!node) return null; while(node.left) { node = node.left; } return node.value; } -> Option B

4. Quick Check:

   Check null first, then traverse left [OK]

Hint: Check for null before traversal to avoid errors [OK]

Common Mistakes:

• Not checking for null input
• Returning null incorrectly when node exists
• Recursing without base case for null