BST Find Minimum Element in DSA Python - Execution Trace

Concept Flow - BST Find Minimum Element

Start at root

↓

Check if left child exists?

No→Current node is minimum

Yes↓

Move to left child

↩Back to check left child

Start from the root node and keep moving left until there is no left child. The last node reached is the minimum.

Execution Sample

DSA Python

def find_min(root):
    current = root
    while current.left is not None:
        current = current.left
    return current.data

This code finds the smallest value in a BST by moving left until no left child exists.

Execution Table

Step	Operation	Current Node	Left Child Exists?	Pointer Changes	Visual State
1	Start at root	15	Yes	current = 15	15 / \ 10 20
2	Check left child	15	Yes	Move current to left child	15 / \ 10 20
3	Move left	10	Yes	current = 10	15 / \ 10 20 / 8
4	Check left child	10	Yes	Move current to left child	15 / \ 10 20 / 8
5	Move left	8	No	current = 8	15 / \ 10 20 / 8
6	Check left child	8	No	Stop, current is minimum	15 / \ 10 20 / 8
7	Return minimum	8	-	-	Minimum element found: 8

💡 Left child does not exist at node 8, so 8 is the minimum element.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
current	15	10	8	8	8

Key Moments - 3 Insights

Why do we keep moving left to find the minimum?

In a BST, smaller values are always on the left. The execution_table rows 2, 4, and 5 show moving left to find smaller nodes until no left child exists.

What if the root has no left child?

If the root has no left child, it is the minimum. The execution_table row 1 shows checking left child; if none, we stop immediately.

Why do we stop when current.left is None, not when current is None?

Stopping at current.left == None means current is the smallest node. If we moved until current == None, we would go past the smallest node. See execution_table rows 5 and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after step 4?

A 15

B 10

C 8

D 20

💡 Hint

Check the 'Pointer Changes' and 'Current Node' columns at step 4.

At which step does the algorithm stop moving left because no left child exists?

A Step 3

B Step 5

C Step 6

D Step 7

💡 Hint

Look for the step where 'Left Child Exists?' is 'No' and the operation says 'Stop'.

If the root node had no left child, what would be the minimum element?

A The root node's value

B The right child's value

C None

D The left child's value

💡 Hint

Refer to key_moments about what happens if root has no left child.

Concept Snapshot

BST Find Minimum Element:
- Start at root node
- Move left while left child exists
- When no left child, current node is minimum
- Return current node's value
- Works because BST left subtree has smaller values

Full Transcript

To find the minimum element in a Binary Search Tree (BST), start at the root node. Check if the current node has a left child. If yes, move to that left child and repeat. Continue moving left until you reach a node with no left child. This node holds the smallest value in the BST. The code uses a loop to move left until current.left is None, then returns current.data. This works because in BSTs, smaller values are always in the left subtree. If the root has no left child, it is the minimum. The execution table shows each step, the current node, pointer changes, and the tree's visual state. Key moments clarify why we move left and when to stop. The visual quiz tests understanding of pointer movement and stopping conditions.

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