BST Find Minimum Element in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the minimum element in a Binary Search Tree (BST)?

The minimum element in a BST is the leftmost node because all smaller values are stored to the left.

beginner

How do you find the minimum element in a BST?

Start at the root and keep moving to the left child until you reach a node with no left child. That node contains the minimum element.

intermediate

Why does the minimum element in a BST always lie in the left subtree?

Because BST property states left child nodes have smaller values than their parents, so the smallest value is found by going left repeatedly.

intermediate

What is the time complexity to find the minimum element in a BST?

The time complexity is O(h), where h is the height of the BST, because you traverse down the left edge only.

beginner

Show the Java code snippet to find the minimum element in a BST.

public int findMin(Node root) { if (root == null) { throw new IllegalArgumentException("Tree is empty"); } Node current = root; while (current.left != null) { current = current.left; } return current.data; }

Where is the minimum element located in a BST?

A Leftmost node

B Rightmost node

C Root node

D Any leaf node

The minimum element is always the leftmost node in a BST.

What is the first step to find the minimum element in a BST?

A Traverse both left and right child nodes

B Traverse right child nodes

C Check the root node only

D Traverse left child nodes

You start from the root and keep moving to the left child nodes to find the minimum.

What happens if the BST is empty when finding the minimum element?

A Return the root node

B Return 0

C Return null or throw an error

D Return the rightmost node

If the BST is empty, there is no minimum element, so an error or null is appropriate.

What is the time complexity to find the minimum element in a balanced BST?

A O(1)

B O(log n)

C O(n)

D O(n log n)

In a balanced BST, height h is about log n, so finding minimum is O(log n).

Which of these is true about the minimum element in a BST?

A It is the node with no left child on the leftmost path

B It is always the root node

C It can be found by traversing right children

D It is the node with no right child on the rightmost path

The minimum element is the leftmost node with no left child.

Explain step-by-step how to find the minimum element in a BST.

Think about the BST property and left children.

Write a simple Java method to find the minimum element in a BST and explain its logic.

Use a while loop to traverse left children.

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