BST Delete Operation in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the current node is null before deletion.

DSA Java

if (root [1] null) {
    return root;
}

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

A=

B==

C!=

D=>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of '==' causes assignment, not comparison.

We use '==' to check if root is null before proceeding.

2fill in blank

medium

Complete the code to recursively delete a node from the left subtree.

DSA Java

if (key < root.val) {
    root.left = root.left [1] deleteNode(root.left, key);
}

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

A=

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' or other operators instead of assignment causes errors.

We assign the result of deleteNode to root.left to update the subtree.

3fill in blank

hard

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

DSA Java

Node minNode = root.right;
while (minNode.[1] != null) {
    minNode = minNode.left;
}

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

Aval

Bparent

Cright

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Checking minNode.right != null instead of minNode.left != null leads to incorrect minimum node.

We traverse right subtree's left children to find the minimum node, so we check minNode.left != null.

4fill in blank

hard

Fill both blanks to replace the node's value and delete the inorder successor.

DSA Java

root.val = minNode.[1];
root.right = deleteNode(root.right, [2]);

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

Aval

Bkey

CminNode.val

Droot.val

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'key' instead of 'minNode.val' causes wrong deletion.

We replace root's value with minNode.val, then delete minNode.val from right subtree.

5fill in blank

hard

Fill all three blanks to handle node deletion with one or no child.

DSA Java

if (root.left == null) {
    return root.[1];
} else if (root.right == null) {
    return root.[2];
}

// Node with two children handled elsewhere

return root;
// End of deleteNode function
// [3]

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

Aright

Bleft

C// return root

D// end

Attempts:

3 left

💡 Hint

Common Mistakes

Returning wrong child causes incorrect tree structure after deletion.

If left child is null, return right child; if right child is null, return left child. The last blank is a comment marking function end.

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 is simply removed and its parent's pointer is set to null.

B. The entire tree is restructured to maintain balance.

C. The node is replaced by its in-order predecessor.

D. The node is replaced by its in-order successor.

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 parent pointer

   The parent's pointer to this node is set to null, effectively removing the node.

3. Final Answer:

   The node is simply removed and its parent's pointer is set to null. -> Option A

4. Quick Check:

   Leaf node deletion = remove node and set parent's pointer null [OK]

Hint: Leaf node deletion just removes the node, no restructuring needed [OK]

Common Mistakes:

• Thinking the tree needs full restructuring
• Replacing leaf node with predecessor or successor
• Confusing leaf node deletion with internal node deletion

2. Which of the following is the correct Java method signature for deleting a node with a given key from a BST?

easy

A. public boolean deleteNode(int key)

B. public void deleteNode(int key)

C. public int deleteNode(Node root, int key)

D. public Node deleteNode(Node root, int key)

Solution

1. Step 1: Understand BST delete method signature

   The method usually takes the root node and the key to delete, returning the updated root.

2. Step 2: Match method signature

   public Node deleteNode(Node root, int key) matches: it takes Node root and int key, returns Node (updated root).

3. Final Answer:

   public Node deleteNode(Node root, int key) -> Option D

4. Quick Check:

   Delete method returns updated root node [OK]

Hint: Delete method returns updated root node after deletion [OK]

Common Mistakes:

• Using void return type instead of Node
• Not passing root node as parameter
• Returning boolean or int instead of Node

3. Given the BST below, what is the in-order traversal after deleting the node with value 10?

       15
      /  \
    10    20
   /  \     \
  8   12    25

medium

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

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

C. [8, 12, 15, 20]

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

Solution

1. Step 1: Delete node 10 from BST

   Node 10 has two children (8 and 12). Replace it with its in-order successor (12) and delete 12.

2. Step 2: Perform in-order traversal after deletion

   In-order traversal visits nodes in ascending order: 8, 12, 15, 20, 25.

3. Final Answer:

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

4. Quick Check:

   In-order after deleting 10 = [8, 12, 15, 20, 25] [OK]

Hint: Replace deleted node with in-order successor for two children case [OK]

Common Mistakes:

• Not replacing node 10 correctly
• Including deleted node 10 in traversal
• Confusing in-order successor with predecessor

4. Consider this Java method snippet for deleting a node from a BST:

public Node deleteNode(Node root, int key) {
    if (root == null) return root;
    if (key < root.val) root.left = deleteNode(root.left, key);
    else if (key > root.val) root.right = deleteNode(root.right, key);
    else {
        if (root.left == null) return root.right;
        else if (root.right == null) return root.left;
        Node temp = minValueNode(root.right);
        root.val = temp.val;
        root.right = deleteNode(root.right, key);
    }
    return root;
}

private Node minValueNode(Node node) {
    Node current = node;
    while (current.left != null) current = current.left;
    return current;
}

What is the bug in this code?

medium

A. The recursive call to deleteNode uses key instead of temp.val.

B. The method does not handle the case when root is null.

C. The method minValueNode should return the maximum value node instead.

D. The method does not update root.left or root.right correctly.

Solution

1. Step 1: Analyze recursive delete call after replacement

   After replacing root.val with temp.val (in-order successor), the successor must be deleted from the right subtree using temp.val.

2. Step 2: Identify the bug

   The recursive call uses key (original value) instead of temp.val. Since key < values in right subtree, it won't correctly delete the successor.

3. Step 3: Check other options

   A is wrong (minValueNode finds successor correctly). B is wrong (null root handled). D is wrong (updates via recursion).

4. Final Answer:

   The recursive call to deleteNode uses key instead of temp.val. -> Option A

5. Quick Check:

   Recursive call must use temp.val [OK]

Hint: Check recursive calls carefully for correct key usage [OK]

Common Mistakes:

• Thinking minValueNode should find max value
• Confusing key and temp.val in recursive call
• Missing base case for null root

5. You have a BST with nodes: 30, 20, 40, 10, 25, 35, 50. You delete node 20. Which of the following is the correct BST in-order traversal after deletion?

hard

A. [10, 25, 30, 40, 50]

B. [10, 20, 25, 30, 35, 40, 50]

C. [10, 25, 30, 35, 40, 50]

D. [25, 30, 35, 40, 50]

Solution

1. Step 1: Identify node 20's children

   Node 20 has two children: 10 (left) and 25 (right).

2. Step 2: Delete node 20 by replacing with in-order successor

   In-order successor is 25. Replace 20 with 25, then delete node 25.

3. Step 3: Perform in-order traversal

   Traversal order: 10, 25, 30, 35, 40, 50.

4. Final Answer:

   [10, 25, 30, 35, 40, 50] -> Option C

5. Quick Check:

   In-order after deleting 20 = [10, 25, 30, 35, 40, 50] [OK]

Hint: Replace deleted node with in-order successor for two children case [OK]

Common Mistakes:

• Leaving deleted node 20 in traversal
• Removing in-order successor node incorrectly
• Confusing in-order predecessor with successor