BST Delete Operation in DSA Java

Mental Model

Deleting a node in a BST means removing it while keeping the tree ordered. We find the node, then fix the tree by replacing it properly.

Analogy: Imagine removing a book from a sorted shelf. If the book is alone, just take it out. If it has neighbors, you shift or replace it so the order stays neat.

      5
     / \
    3   7
   / \   \
  2   4   8
↑root

Dry Run Walkthrough

Input: BST: 5 -> 3 -> 7 -> 2 -> 4 -> 8, delete node with value 3

Goal: Remove node 3 and keep BST properties intact

Step 1: Find node 3 starting from root 5

      5
     / \
    [3] 7
   / \   \
  2   4   8

Why: We need to locate the node to delete

Step 2: Node 3 has two children, find its inorder successor (smallest in right subtree), which is 4

      5
     / \
    3   7
   / \   \
  2  [4]  8

Why: Replacing node 3 with 4 keeps BST order

Step 3: Replace node 3's value with 4

      5
     / \
    4   7
   / \   \
  2   4   8

Why: We copy successor's value to node to delete

Step 4: Delete original node 4 (successor), which has no left child, replace it with its right child (null)

      5
     / \
    4   7
   /     \
  2       8

Why: Remove duplicate successor node to complete deletion

Result:

      5
     / \
    4   7
   /     \
  2       8

Annotated Code

DSA Java

class Node {
    int val;
    Node left, right;
    Node(int val) { this.val = val; }
}

public class BSTDelete {
    public static Node deleteNode(Node root, int key) {
        if (root == null) return null; // base case: empty tree
        if (key < root.val) {
            root.left = deleteNode(root.left, key); // go left
        } else if (key > root.val) {
            root.right = deleteNode(root.right, key); // go right
        } else {
            // found node to delete
            if (root.left == null) return root.right; // no left child
            else if (root.right == null) return root.left; // no right child
            else {
                // two children: find inorder successor
                Node successor = minValueNode(root.right);
                root.val = successor.val; // copy successor value
                root.right = deleteNode(root.right, successor.val); // delete successor
            }
        }
        return root;
    }

    private static Node minValueNode(Node node) {
        Node current = node;
        while (current.left != null) {
            current = current.left; // go left to find smallest
        }
        return current;
    }

    public static void printInOrder(Node root) {
        if (root == null) return;
        printInOrder(root.left);
        System.out.print(root.val + " -> ");
        printInOrder(root.right);
    }

    public static void main(String[] args) {
        Node root = new Node(5);
        root.left = new Node(3);
        root.right = new Node(7);
        root.left.left = new Node(2);
        root.left.right = new Node(4);
        root.right.right = new Node(8);

        root = deleteNode(root, 3);
        printInOrder(root);
        System.out.print("null\n");
    }
}

if (root == null) return null; // base case: empty tree

stop recursion if tree is empty

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

search left subtree for node to delete

else if (key > root.val) { root.right = deleteNode(root.right, key); }

search right subtree for node to delete

if (root.left == null) return root.right;

if no left child, replace node with right child

else if (root.right == null) return root.left;

if no right child, replace node with left child

Node successor = minValueNode(root.right);

find inorder successor in right subtree

root.val = successor.val;

replace node's value with successor's value

root.right = deleteNode(root.right, successor.val);

delete successor node from right subtree

while (current.left != null) { current = current.left; }

find leftmost node in subtree

Output

2 -> 4 -> 5 -> 7 -> 8 -> null

Complexity Analysis

Time: O(h) where h is tree height because we traverse from root to node and possibly to successor

Space: O(h) due to recursion stack in worst case of skewed tree

vs Alternative: Compared to array deletion which may require shifting O(n), BST deletion is faster for balanced trees with O(log n) height

Edge Cases

Deleting a node not present in the tree

Function returns original tree unchanged

DSA Java

if (root == null) return null;

Deleting a leaf node (no children)

Node is simply removed by returning null to parent

DSA Java

if (root.left == null) return root.right;

Deleting root node with two children

Root value replaced by inorder successor and successor node deleted

DSA Java

Node successor = minValueNode(root.right);

When to Use This Pattern

When you need to remove a value from a BST and keep it ordered, use the BST delete pattern which handles three cases: no child, one child, and two children.

Common Mistakes

Mistake: Not handling the two children case by replacing with inorder successor or predecessor
Fix: Always find and replace with inorder successor (smallest in right subtree) or predecessor (largest in left subtree)

Mistake: Deleting the node without reconnecting its children properly
Fix: Return the correct child or subtree to parent to maintain tree structure

Summary

Deletes a node from a BST while keeping the tree ordered.

Use when you need to remove a value from a BST without breaking its properties.

The key is replacing a node with two children by its inorder successor to maintain order.

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