BST Find Minimum Element in DSA Python - Build from Scratch

BST Find Minimum Element

📖 Scenario: You are working with a simple phone book application that stores contacts in a Binary Search Tree (BST). Each contact has a unique phone number. You want to find the contact with the smallest phone number to quickly access the earliest saved contact.

🎯 Goal: Build a BST with given phone numbers and write code to find the minimum phone number stored in the BST.

📋 What You'll Learn

Create a BST node class with value, left, and right attributes

Insert given phone numbers into the BST in the given order

Write a function to find the minimum value in the BST

Print the minimum phone number found

💡 Why This Matters

🌍 Real World

BSTs are used in databases and file systems to quickly find minimum or maximum values, like earliest or latest records.

💼 Career

Understanding BST operations is important for software engineers working on efficient data storage, search algorithms, and system design.

1

Create BST Node Class and Insert Nodes

Create a class called Node with an __init__ method that takes value and sets left and right to None. Then create a function called insert that takes root and value and inserts the value into the BST correctly. Finally, create a BST by inserting these phone numbers in order: 50, 30, 70, 20, 40, 60, 80. Store the root node in a variable called root.

DSA Python

# Define Node class and insert function
# Insert the given phone numbers into the BST
# Your code here

Hint

Remember, in a BST, smaller values go to the left child and larger or equal values go to the right child.

2

Create Function to Find Minimum Value

Create a function called find_minimum that takes root as input and returns the minimum value in the BST by moving to the left child until it is None.

DSA Python

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

def insert(root, value):
    if root is None:
        return Node(value)
    if value < root.value:
        root.left = insert(root.left, value)
    else:
        root.right = insert(root.right, value)
    return root

root = None
for number in [50, 30, 70, 20, 40, 60, 80]:
    root = insert(root, number)

# Create find_minimum function to find smallest value in BST
# Your code here

Hint

Keep moving left from the root until you find a node with no left child. That node has the smallest value.

3

Call Function to Find Minimum Value

Call the function find_minimum with the variable root and store the result in a variable called min_value.

DSA Python

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

def insert(root, value):
    if root is None:
        return Node(value)
    if value < root.value:
        root.left = insert(root.left, value)
    else:
        root.right = insert(root.right, value)
    return root

def find_minimum(root):
    current = root
    while current.left is not None:
        current = current.left
    return current.value

root = None
for number in [50, 30, 70, 20, 40, 60, 80]:
    root = insert(root, number)

# Call find_minimum function and save result
# Your code here

Hint

Just call the function with root and save the result in min_value.

4

Print the Minimum Value

Print the variable min_value to display the smallest phone number in the BST.

DSA Python

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

def insert(root, value):
    if root is None:
        return Node(value)
    if value < root.value:
        root.left = insert(root.left, value)
    else:
        root.right = insert(root.right, value)
    return root

def find_minimum(root):
    current = root
    while current.left is not None:
        current = current.left
    return current.value

root = None
for number in [50, 30, 70, 20, 40, 60, 80]:
    root = insert(root, number)

min_value = find_minimum(root)

# Print the minimum value found
# Your code here

Hint

Use print(min_value) to show the smallest phone number.

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