BST Delete Operation in DSA Java - Build from Scratch

BST Delete Operation

📖 Scenario: You are managing a simple phone directory stored as a Binary Search Tree (BST). Each node contains a contact's phone number as an integer. You want to remove a contact's phone number from the directory.

🎯 Goal: Build a Java program that creates a BST with given phone numbers, sets a phone number to delete, performs the delete operation on the BST, and prints the BST in-order after deletion.

📋 What You'll Learn

Create a BST by inserting these phone numbers in order: 50, 30, 70, 20, 40, 60, 80

Create an integer variable called keyToDelete with the value 50

Implement a method deleteNode to delete a node with the given key from the BST

Print the BST in-order after deletion using inorderTraversal method

💡 Why This Matters

🌍 Real World

Managing contact lists, phone directories, or any sorted data where fast insertion, deletion, and search are needed.

💼 Career

Understanding BST operations is essential for software engineers working with databases, search engines, and real-time data processing.

1

Create the BST with given phone numbers

Create a class Node with integer key, and left and right child nodes. Then create a class BST with a root node. Insert these phone numbers in order into the BST: 50, 30, 70, 20, 40, 60, 80. Use an insert method to add nodes.

DSA Java

// Define Node class
// Define BST class with root
// Insert nodes 50, 30, 70, 20, 40, 60, 80
// Your code here

Hint

Start by defining the Node class with key, left, and right. Then create the BST class with a root and an insert method. Insert the numbers in the given order.

2

Set the phone number to delete

Create an integer variable called keyToDelete and set it to 50 inside the main method.

DSA Java

class Node {
    int key;
    Node left, right;

    public Node(int item) {
        key = item;
        left = right = null;
    }
}

class BST {
    Node root;

    BST() {
        root = null;
    }

    void insert(int key) {
        root = insertRec(root, key);
    }

    Node insertRec(Node root, int key) {
        if (root == null) {
            root = new Node(key);
            return root;
        }
        if (key  root.key)
            root.right = insertRec(root.right, key);
        return root;
    }
}

public class Main {
    public static void main(String[] args) {
        BST tree = new BST();
        tree.insert(50);
        tree.insert(30);
        tree.insert(70);
        tree.insert(20);
        tree.insert(40);
        tree.insert(60);
        tree.insert(80);
        // Create keyToDelete variable here
        // Your code here
    }
}

Hint

Inside the main method, create an integer variable named keyToDelete and assign it the value 50.

3

Implement the deleteNode method

Inside the BST class, implement a method Node deleteNode(Node root, int key) that deletes the node with the given key from the BST. Use the standard BST delete logic: if the node has no child, remove it; if one child, replace node with child; if two children, replace node with inorder successor (smallest in right subtree).

DSA Java

class Node {
    int key;
    Node left, right;

    public Node(int item) {
        key = item;
        left = right = null;
    }
}

class BST {
    Node root;

    BST() {
        root = null;
    }

    void insert(int key) {
        root = insertRec(root, key);
    }

    Node insertRec(Node root, int key) {
        if (root == null) {
            root = new Node(key);
            return root;
        }
        if (key  root.key)
            root.right = insertRec(root.right, key);
        return root;
    }

    // Implement deleteNode method here
    // Your code here
}

public class Main {
    public static void main(String[] args) {
        BST tree = new BST();
        tree.insert(50);
        tree.insert(30);
        tree.insert(70);
        tree.insert(20);
        tree.insert(40);
        tree.insert(60);
        tree.insert(80);
        int keyToDelete = 50;
    }
}

Hint

Use recursion to find the node to delete. Handle three cases: no child, one child, two children. For two children, find the smallest value in the right subtree and replace the node's key with it, then delete that smallest node.

4

Delete the node and print the BST in-order

In the main method, call tree.root = tree.deleteNode(tree.root, keyToDelete); to delete the node with keyToDelete. Then implement and call a method inorderTraversal(Node root) in the BST class to print the BST keys in ascending order separated by spaces.

DSA Java

Hint

Call deleteNode on the root with keyToDelete. Then print the BST keys in ascending order using an in-order traversal method.

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