BST Find Minimum Element in DSA Python

Mental Model

In a binary search tree, the smallest value is always found by going left until no more left child exists.

Analogy: Imagine a family tree where the youngest child is always the leftmost leaf; to find the youngest, you keep moving left until you can't go further.

    5
   / \
  3   7
 / 
1  
↑

Dry Run Walkthrough

Input: BST: 5 -> 3 -> 7 -> 1 (1 is left child of 3), find minimum element

Goal: Find the smallest value in the BST by moving left until no left child

Step 1: Start at root node with value 5

5 -> 3 -> 7 -> 1
↑ at 5

Why: We begin search from the root to find minimum

Step 2: Move left from 5 to 3

5 -> [3] -> 7 -> 1
↑ at 3

Why: Minimum is in left subtree, so go left

Step 3: Move left from 3 to 1

5 -> 3 -> 7 -> [1]
↑ at 1

Why: Keep moving left to find smaller value

Step 4: No left child of 1, stop here

5 -> 3 -> 7 -> 1
↑ at 1 (no left child)

Why: Reached leftmost node, this is minimum

Result:

5 -> 3 -> 7 -> 1
Minimum element found: 1

Annotated Code

DSA Python

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def find_minimum(root):
    if root is None:
        return None
    current = root
    while current.left is not None:
        current = current.left  # move left to find smaller value
    return current.val

# Driver code
root = Node(5)
root.left = Node(3)
root.right = Node(7)
root.left.left = Node(1)

min_val = find_minimum(root)
print(f"Minimum element found: {min_val}")

while current.left is not None:

keep moving left while left child exists

current = current.left # move left to find smaller value

advance current pointer to left child to find smaller value

return current.val

return value of leftmost node as minimum

Output

Minimum element found: 1

Complexity Analysis

Time: O(h) because we traverse down the height of the tree following left children

Space: O(1) because we use only a pointer variable without extra storage

vs Alternative: Compared to traversing all nodes (O(n)), this approach is faster as it only follows left children

Edge Cases

Empty tree (root is None)

Returns None gracefully

DSA Python

if root is None: return None  # handles empty tree before traversal

Tree with single node

Minimum is the root itself

DSA Python

while current.left is not None:  # loop skipped if no left child

When to Use This Pattern

When asked to find the smallest element in a BST, look for the leftmost node by following left children until none remain.

Common Mistakes

Mistake: Trying to check right child or traversing entire tree unnecessarily
Fix: Only follow left children because BST property guarantees minimum is leftmost

Mistake: Not handling empty tree input
Fix: Add a check for root being None before traversal

Summary

Finds the smallest value in a BST by moving left until no left child exists.

Use when you need the minimum element quickly in a BST.

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

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, so the smallest value is always towards the left.

2. Step 2: Locate minimum element

   By moving left from the root repeatedly until no more left child exists, we reach the minimum element.

3. Final Answer:

   At the leftmost node -> Option A

4. Quick Check:

   Minimum element = leftmost node [OK]

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

Common Mistakes:

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

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

easy

A. while root.right is not None:
root = root.right
print(root.val)

B. while root.left is not None:
root = root.left
print(root.val)

C. if root.left is None:
print(root.val)

D. print(min(root.val, root.left.val))

Solution

1. Step 1: Check loop for minimum search

   while root.left is not None: root = root.left print(root.val) correctly moves left while left child exists, which is how to find minimum in BST.

2. Step 2: Verify other options

   while root.right is not None: root = root.right print(root.val) moves right (wrong for minimum), C only checks once, D uses min on values without traversal.

3. Final Answer:

   while root.left is not None: root = root.left print(root.val) -> Option B

4. Quick Check:

   Traverse left until None = while root.left is not None: root = root.left print(root.val) [OK]

Hint: Traverse left child until None to find minimum [OK]

Common Mistakes:

• Traversing right child instead of left
• Not using a loop to reach leftmost node
• Using min() function incorrectly on nodes

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

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def find_min(root):
    while root.left:
        root = root.left
    return root.val

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

print(find_min(root))

medium

A. 5

B. 10

C. 7

D. 2

Solution

1. Step 1: Trace the BST structure

   The tree root is 10, left child 5, left-left child 2, left-right child 7, right child 15.

2. Step 2: Follow find_min function

   The function moves left from 10 to 5, then left again to 2, which has no left child, so returns 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Leftmost node value = 2 [OK]

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

Common Mistakes:

• Returning root value instead of leftmost
• Confusing left-right child as minimum
• Not following loop correctly

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

def find_min(root):
    while root.right:
        root = root.right
    return root.val

medium

A. It traverses right child instead of left child

B. It returns root.val without checking children

C. It causes infinite loop if root.right is None

D. It does not handle empty tree (None root)

Solution

1. Step 1: Analyze traversal direction

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

2. Step 2: Identify correct traversal for minimum

   Minimum element is found by moving left child repeatedly, so the code should use root.left.

3. Final Answer:

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

4. Quick Check:

   Minimum = traverse left, not right [OK]

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

Common Mistakes:

• Using right child traversal for minimum
• Ignoring empty tree case
• Assuming root is minimum without traversal

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

def find_min(root):
    # Your code here

Choose the correct code snippet to handle duplicates on the left side.

hard

A. while root.right:
root = root.right
return root.val

B. while root.left and root.left.val < root.val:
root = root.left
return root.val

C. while root.left:
root = root.left
return root.val

D. if root.left and root.left.val < root.val:
return find_min(root.left)
return root.val

Solution

1. Step 1: Understand duplicates on left subtree

   In BSTs allowing duplicates on left (e.g., left <= parent), the minimum is always the leftmost node.

2. Step 2: Correct approach

   while root.left: root = root.left return root.val unconditionally traverses left to the leftmost node, handling duplicates correctly.

3. Step 3: Why others fail

   A finds maximum. C and D only traverse if strictly <, stopping early on equal values, missing smaller nodes further left.

4. Final Answer:

   while root.left: root = root.left return root.val -> Option C

5. Quick Check:

   Unconditional left traversal finds min even with duplicates [OK]

Hint: Always traverse left until None, even with duplicates [OK]

Common Mistakes:

• Ignoring duplicates and returning first left child
• Moving right instead of left
• Stopping traversal too early