BST Find Minimum Element in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the minimum value in a BST.

DSA Java

public int findMin(Node root) {
    if (root == null) {
        return -1; // empty tree
    }
    Node current = root;
    while (current.[1] != null) {
        current = current.left;
    }
    return current.data;
}

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

Aleft

Bright

Cparent

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Checking current.right instead of current.left

Returning root.data without traversal

Using recursion without base case

In a BST, the minimum element is found by going as far left as possible. So, we check if current.left is not null.

2fill in blank

medium

Complete the code to recursively find the minimum value in a BST.

DSA Java

public int findMinRecursive(Node root) {
    if (root == null) {
        return -1; // empty tree
    }
    if (root.[1] == null) {
        return root.data;
    }
    return findMinRecursive(root.left);
}

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

Aright

Bleft

Cchild

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Checking right child instead of left

Missing base case for null root

Returning root.data too early

If the left child is null, the current node is the minimum. Otherwise, recurse left.

3fill in blank

hard

Fix the error in the code to correctly find the minimum element iteratively.

DSA Java

public int findMin(Node root) {
    if (root == null) {
        return -1;
    }
    Node current = root;
    while (current.[1] != null) {
        current = current.right;
    }
    return current.data;
}

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

Achild

Bright

Cparent

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Moving right instead of left

Returning root.data without traversal

Not checking for null root

To find the minimum, we must move left, not right. The code incorrectly moves right.

4fill in blank

hard

Fill both blanks to create a method that returns the minimum node in a BST.

DSA Java

public Node findMinNode(Node root) {
    if (root == null) {
        return null;
    }
    Node current = root;
    while (current.[1] != null) {
        current = current.[2];
    }
    return current;
}

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

Aleft

Bright

Cparent

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using different directions for condition and assignment

Using right instead of left

Returning data instead of node

Both blanks must be 'left' to traverse left children until the minimum node is found.

5fill in blank

hard

Fill all three blanks to create a recursive method that returns the minimum node in a BST.

DSA Java

public Node findMinNodeRecursive(Node root) {
    if (root == null) {
        return null;
    }
    if (root.[1] == null) {
        return root;
    }
    return findMinNodeRecursive(root.[2]);
    // The minimum node is in the [3] subtree
}

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

Aright

Bleft

Attempts:

3 left

💡 Hint

Common Mistakes

Checking or recursing right child

Returning root too early

Incorrect comment about subtree

Check if left child is null, recurse left, and minimum is in left subtree.

Practice

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

easy

A. At the leftmost node

B. At the rightmost node

C. At the root 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 moving left until no more left child exists.

3. Final Answer:

   At the leftmost node -> Option A

4. Quick Check:

   Minimum = leftmost node [OK]

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

Common Mistakes:

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

2. Which of the following Java code snippets correctly finds the minimum element in a BST node named root?

easy

A. while(root.right != null) { root = root.right; } return root.data;

B. while(root.left != null) { root = root.left; } return root.data;

C. if(root == null) return Integer.MAX_VALUE; return root.data;

D. return root.data;

Solution

1. Step 1: Check loop condition for minimum

   Minimum is found by moving left while left child exists.

2. Step 2: Verify code correctness

   while(root.left != null) { root = root.left; } return root.data; moves left until left child is null, then returns data.

3. Final Answer:

   while(root.left != null) { root = root.left; } return root.data; -> Option B

4. Quick Check:

   Loop left until null, then return [OK]

Hint: Traverse left children until none left [OK]

Common Mistakes:

• Traversing right child instead of left
• Returning root data without traversal
• Ignoring null root check

3. What will be the output of the following Java code snippet?

class Node {
  int data;
  Node left, right;
  Node(int d) { data = d; left = right = null; }
}

Node root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
root.left.left = new Node(2);
root.left.right = new Node(7);

Node current = root;
while(current.left != null) {
  current = current.left;
}
System.out.println(current.data);

medium

A. 2

B. 7

C. 5

D. 10

Solution

1. Step 1: Trace the tree structure

   Root=10, left=5, right=15, left.left=2, left.right=7.

2. Step 2: Follow while loop to find minimum

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

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Leftmost node data = 2 [OK]

Hint: Output is leftmost node's data after loop [OK]

Common Mistakes:

• Printing root data instead of leftmost
• Confusing left and right traversal
• Stopping loop too early

4. Identify the error in the following Java method to find the minimum element in a BST:

public int findMin(Node root) {
  if(root == null) return -1;
  while(root.right != null) {
    root = root.right;
  }
  return root.data;
}

medium

A. Method should be void, not int

B. Should return -1 only if root is leaf

C. Should check for root.data == null

D. Should traverse left child, not right child

Solution

1. Step 1: Analyze traversal direction

   Minimum element is found by moving left, not right.

2. Step 2: Identify correct traversal

   Loop should check root.left != null and move root = root.left.

3. Final Answer:

   Should traverse left child, not right child -> Option D

4. Quick Check:

   Minimum = leftmost node, so traverse left [OK]

Hint: Minimum is leftmost, so traverse left child [OK]

Common Mistakes:

• Traversing right child instead of left
• Returning -1 incorrectly
• Checking data for null instead of node

5. Given a BST where some nodes have duplicate values, which approach correctly finds the minimum unique element?

public int findMinUnique(Node root) {
  Set<Integer> seen = new HashSet<>();
  int min = Integer.MAX_VALUE;
  while(root != null) {
    if(!seen.contains(root.data)) {
      min = Math.min(min, root.data);
      seen.add(root.data);
    }
    root = root.left;
  }
  return min;
}

What is the main issue with this method?

hard

A. It uses a HashSet unnecessarily for BST

B. It does not handle empty tree correctly

C. It only checks left children, missing other nodes

D. It returns max value instead of min

Solution

1. Step 1: Understand traversal logic

   Method only moves down left children, ignoring right subtree.

2. Step 2: Identify missed nodes

   Duplicates or unique values in right subtree are missed.

3. Step 3: Correct approach

   To find minimum unique, full tree traversal (e.g., inorder) is needed.

4. Final Answer:

   It only checks left children, missing other nodes -> Option C

5. Quick Check:

   Partial traversal misses right subtree [OK]

Hint: Traverse entire tree to find minimum unique value [OK]

Common Mistakes:

• Assuming left path covers all nodes
• Ignoring duplicates in right subtree
• Using HashSet without full traversal