BST Find Minimum Element in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA Python

def find_min(root):
    current = root
    while current.[1] is not None:
        current = current.left
    return current.val

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

Aleft

Bparent

Cright

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'right' instead of 'left' to find minimum.

The minimum value in a BST is found by going as far left as possible.

2fill in blank

medium

Complete the code to handle the case when the BST is empty.

DSA Python

def find_min(root):
    if [1] is None:
        return None
    current = root
    while current.left is not None:
        current = current.left
    return current.val

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

Aroot.val

Broot.right

Croot

Droot.left

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root.val instead of root for None.

We check if the root itself is None to handle empty trees.

3fill in blank

hard

Fix the error in the code to correctly find the minimum value in the BST.

DSA Python

def find_min(root):
    current = root
    while current.left is not None:
        current = current.[1]
    return current.val

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

Aright

Bchild

Cparent

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Using right child instead of left child.

To find the minimum, we must move left, not right.

4fill in blank

hard

Fill both blanks to create a dictionary of node values and their depths for nodes with values less than 10.

DSA Python

def collect_nodes(root):
    result = {}
    def helper(node, depth):
        if node is None:
            return
        if node.val [1] 10:
            result[node.[2]] = depth
        helper(node.left, depth + 1)
        helper(node.right, depth + 1)
    helper(root, 0)
    return result

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

A<

B>

Cval

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' for comparison.

Using 'left' instead of 'val' as dictionary key.

We check if node.val is less than 10 and use node.val as the key in the dictionary.

5fill in blank

hard

Fill both blanks to create a dictionary of uppercase node values and their depths for nodes with values greater than 5.

DSA Python

def collect_upper_nodes(root):
    result = {}
    def helper(node, depth):
        if node is None:
            return
        if node.val [1] 5:
            result[node.val.[2]()] = depth
        helper(node.left, depth + 1)
        helper(node.right, depth + 1)
    helper(root, 0)
    return result

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

A<

B>

Cupper

Dlower

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' for comparison.

Not calling the 'upper' method with parentheses.

We check if node.val is greater than 5, use the 'upper' method to convert the value to uppercase, and call it with parentheses.

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