BST Delete Operation in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the delete operation by checking if the root is None.

DSA Python

def delete_node(root, key):
    if root is [1]:
        return root

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

ATrue

B0

CFalse

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using True or False instead of None

Checking if root equals 0

The base case for deleting a node in a BST is when the root is None, meaning the tree or subtree is empty.

2fill in blank

medium

Complete the code to move left in the BST if the key is smaller than the root's value.

DSA Python

if key < root.val:
    root.left = delete_node(root.[1], key)

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

Aleft

Bright

Cval

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Going to the right child instead of left

Using root.val instead of root.left

If the key to delete is smaller than the root's value, we go to the left subtree to continue searching.

3fill in blank

hard

Fix the error in the code to find the minimum value node in the right subtree.

DSA Python

def min_value_node(node):
    current = node
    while current.[1] is not None:
        current = current.left
    return current

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

Aright

Bleft

Cval

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Checking current.right instead of current.left

Using current.val in the while condition

To find the minimum value node, we keep going left until there is no left child. The loop should check current.left to move left if needed. The error is in the attribute checked in the while condition; it should be current.left.

4fill in blank

hard

Fill both blanks to replace the root's value with the minimum value in the right subtree and delete that minimum node.

DSA Python

if root.left is None:
    temp = root.[1]
    root = None
    return temp
elif root.right is None:
    temp = root.[2]
    root = None
    return temp

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

Aright

Bleft

Cval

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right

Using root.val instead of root.left or root.right

If the left child is None, we replace the root with its right child. If the right child is None, we replace the root with its left child.

5fill in blank

hard

Fill all three blanks to replace the root's value with the minimum value in the right subtree, then delete that minimum node.

DSA Python

temp = min_value_node(root.[1])
root.val = temp.[2]
root.[3] = delete_node(root.[1], temp.val)

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

Aright

Bval

Cleft

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using left instead of right

Replacing root.left instead of root.right

Using temp.left or temp.right instead of temp.val

We find the minimum node in the right subtree, replace the root's value with that minimum value, then delete the minimum node from the right subtree.

Practice

1. What happens when you delete a leaf node (a node with no children) from a Binary Search Tree (BST)?

easy

A. The node's children are moved up to replace it.

B. The entire tree is rebuilt from scratch.

C. The node is simply removed without affecting other nodes.

D. The root node is always changed.

Solution

1. Step 1: Understand leaf node deletion

   A leaf node has no children, so removing it does not affect other nodes.

2. Step 2: Effect on BST structure

   Since no children exist, simply remove the node and update its parent's pointer to null.

3. Final Answer:

   The node is simply removed without affecting other nodes. -> Option C

4. Quick Check:

   Leaf node deletion = simple removal [OK]

Hint: Leaf nodes delete by direct removal only [OK]

Common Mistakes:

• Thinking children need rearrangement
• Assuming root always changes
• Believing tree rebuild is needed

2. Which of the following is the correct Python function signature to delete a node with a given key from a BST?

easy

A. def deleteNode(key):

B. def deleteNode(root, key):

C. def deleteNode(root):

D. def deleteNode(key, root):

Solution

1. Step 1: Identify required parameters

   To delete a node, we need the BST root and the key to delete.

2. Step 2: Check function signature

   Only def deleteNode(root, key): has both parameters in correct order.

3. Final Answer:

   def deleteNode(root, key): -> Option B

4. Quick Check:

   Function needs root and key [OK]

Hint: Delete needs root and key parameters [OK]

Common Mistakes:

• Swapping parameter order
• Missing one parameter
• Using only key or root alone

3. Given the BST below, what is the inorder traversal after deleting node 10?

       15
      /  \
    10    20
   /  \     \
  8   12    25

medium

A. [8, 12, 15, 20]

B. [8, 10, 12, 15, 20, 25]

C. [8, 15, 20, 25]

D. [8, 12, 15, 20, 25]

Solution

1. Step 1: Delete node 10 with two children

   Node 10 has two children (8 and 12). Replace it with its inorder successor (12).

2. Step 2: Adjust tree and perform inorder traversal

   After replacement, node 12 replaces 10, and 12's original position is removed. Inorder traversal is [8, 12, 15, 20, 25].

3. Final Answer:

   [8, 12, 15, 20, 25] -> Option D

4. Quick Check:

   Inorder after delete = [8, 12, 15, 20, 25] [OK]

Hint: Replace deleted node with inorder successor [OK]

Common Mistakes:

• Not replacing node with successor
• Leaving deleted node in traversal
• Incorrect traversal order

4. The following code attempts to delete a node from a BST but causes an error. What is the main issue?

def deleteNode(root, key):
    if not root:
        return root
    if key < root.val:
        deleteNode(root.left, key)
    elif key > root.val:
        deleteNode(root.right, key)
    else:
        if not root.left:
            return root.right
        elif not root.right:
            return root.left
        temp = findMin(root.right)
        root.val = temp.val
        deleteNode(root.right, temp.val)
    return root

medium

A. Recursive calls do not update root's children pointers.

B. The base case is missing.

C. The function does not handle leaf nodes.

D. The function uses an undefined findMin function.

Solution

1. Step 1: Check recursive calls for updating children

   Recursive calls like deleteNode(root.left, key) do not assign the result back to root.left, so changes are lost.

2. Step 2: Correct by assigning returned subtree

   We must write root.left = deleteNode(root.left, key) and root.right = deleteNode(root.right, key) to update pointers properly.

3. Final Answer:

   Recursive calls do not update root's children pointers. -> Option A

4. Quick Check:

   Update children with recursive call results [OK]

Hint: Assign recursive call results to children [OK]

Common Mistakes:

• Ignoring returned subtree after recursion
• Assuming in-place changes without assignment
• Missing base case (not the main issue here)

5. You want to delete a node with two children in a BST. Which approach correctly maintains BST properties after deletion?

hard

A. Replace the node with its inorder predecessor or successor, then delete that node.

B. Replace the node with its left child only.

C. Replace the node with its right child only.

D. Remove the node and leave a gap in the tree.

Solution

1. Step 1: Understand deletion of node with two children

   Direct removal breaks BST rules; we must replace the node with a suitable value.

2. Step 2: Use inorder predecessor or successor

   Replacing with inorder predecessor (max in left subtree) or successor (min in right subtree) keeps BST order intact.

3. Step 3: Delete the replaced node recursively

   After replacement, delete the predecessor/successor node which will have at most one child.

4. Final Answer:

   Replace the node with its inorder predecessor or successor, then delete that node. -> Option A

5. Quick Check:

   Use inorder predecessor/successor for two-child deletion [OK]

Hint: Use inorder predecessor or successor for two-child node [OK]

Common Mistakes:

• Replacing with only left or right child
• Removing node without replacement
• Breaking BST ordering rules