BST Delete Operation in DSA Go

Mental Model

Deleting a node in a BST means removing it while keeping the tree's order intact. We find the node, then rearrange its children carefully.

Analogy: Imagine removing a book from a sorted bookshelf. If the book has no neighbors, just take it out. If it has one neighbor, slide that neighbor in. If it has two neighbors, replace it with the next book in order and then remove that next book.

      5
     / \
    3   7
   / \   \
  2   4   8

Dry Run Walkthrough

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

Goal: Remove node 3 and keep BST order correct

Step 1: Find node with value 3 starting from root

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

Why: We must 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 3

Step 4: Delete the original node 4 (now duplicate) which has no children

      5
     / \ 
    4   7
   /     \
  2       8

Why: Remove duplicate node to complete deletion

Result:

      5
     / \ 
    4   7
   /     \
  2       8

Annotated Code

DSA Go

package main

import "fmt"

type Node struct {
    val   int
    left  *Node
    right *Node
}

func insert(root *Node, val int) *Node {
    if root == nil {
        return &Node{val: val}
    }
    if val < root.val {
        root.left = insert(root.left, val)
    } else {
        root.right = insert(root.right, val)
    }
    return root
}

func findMin(node *Node) *Node {
    current := node
    for current.left != nil {
        current = current.left
    }
    return current
}

func deleteNode(root *Node, key int) *Node {
    if root == nil {
        return nil
    }
    if key < root.val {
        root.left = deleteNode(root.left, key) // traverse left subtree
    } else if key > root.val {
        root.right = deleteNode(root.right, key) // traverse right subtree
    } else {
        // found node to delete
        if root.left == nil {
            return root.right // replace node with right child
        } else if root.right == nil {
            return root.left // replace node with left child
        }
        // node with two children
        minRight := findMin(root.right) // find inorder successor
        root.val = minRight.val         // copy successor's value
        root.right = deleteNode(root.right, minRight.val) // delete successor
    }
    return root
}

func printInOrder(root *Node) {
    if root == nil {
        return
    }
    printInOrder(root.left)
    fmt.Printf("%d -> ", root.val)
    printInOrder(root.right)
}

func main() {
    var root *Node
    values := []int{5, 3, 7, 2, 4, 8}
    for _, v := range values {
        root = insert(root, v)
    }
    root = deleteNode(root, 3)
    printInOrder(root)
    fmt.Print("null\n")
}

if key < root.val { root.left = deleteNode(root.left, key) // traverse left subtree } else if key > root.val { root.right = deleteNode(root.right, key) // traverse right subtree } else {

search for node to delete by comparing key with current node value

if root.left == nil { return root.right // replace node with right child } else if root.right == nil { return root.left // replace node with left child }

handle cases where node has zero or one child by replacing it with child or nil

minRight := findMin(root.right) // find inorder successor root.val = minRight.val // copy successor's value root.right = deleteNode(root.right, minRight.val) // delete successor

for two children, replace node value with inorder successor and delete successor

Output

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

Complexity Analysis

Time: O(h) because we traverse from root to the node to delete, where h is tree height

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

vs Alternative: Compared to naive array deletion which requires shifting elements O(n), BST delete 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 Go

if root == nil {
        return nil
    }

Deleting a leaf node (no children)

Node is simply removed by returning nil to parent

DSA Go

if root.left == nil {
            return root.right
        } else if root.right == nil {
            return root.left
        }

Deleting root node with two children

Root value replaced with inorder successor and successor node deleted

DSA Go

minRight := findMin(root.right)

When to Use This Pattern

When you need to remove a value from a BST and keep it sorted, use the BST delete pattern that handles zero, one, or two children cases carefully.

Common Mistakes

Mistake: Not handling the two children case by replacing with inorder successor
Fix: Implement finding the minimum node in right subtree and replace value before deleting successor

Mistake: Deleting node without reconnecting children properly
Fix: Return the correct child node to parent after deletion to maintain tree structure

Summary

Deletes a node from a BST while maintaining its sorted order.

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

The key is to replace a node with two children by its inorder successor to keep 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's children replace it in the tree.

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 Go function signatures correctly represents a BST delete operation for a node with integer keys?

easy

A. func deleteNode(key int, root *Node) *Node

B. func deleteNode(root *Node, key int) *Node

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

D. func deleteNode(root *Node, key string) *Node

Solution

1. Step 1: Check parameter order and types

   The root node pointer should be first, key integer second, returning updated root pointer.

2. Step 2: Validate pointer usage and key type

   Root must be a pointer to allow tree modification; key must be int for integer keys.

3. Final Answer:

   func deleteNode(root *Node, key int) *Node -> Option B

4. Quick Check:

   Correct signature = root pointer first, int key [OK]

Hint: Root pointer first, int key second, returns updated root [OK]

Common Mistakes:

• Swapping parameter order
• Using value instead of pointer for root
• Using wrong key type

3. Given the BST below and the Go code to delete node with key 10, what is the in-order traversal output after deletion? BST structure: 15 / \ 10 20 / \ 8 12 Go code snippet:

root = deleteNode(root, 10)

medium

A. [12, 15, 20]

B. [8, 15, 20]

C. [8, 10, 12, 15, 20]

D. [8, 12, 15, 20]

Solution

1. Step 1: Identify node to delete and its children

   Node 10 has two children: 8 (left) and 12 (right).

2. Step 2: Replace node 10 with its in-order successor

   In-order successor is 12. Replace 10 with 12, then delete original 12 node.

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

   Traversal order: 8, 12, 15, 20.

4. Final Answer:

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

5. Quick Check:

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

Hint: Replace deleted node with in-order successor [OK]

Common Mistakes:

• Deleting successor node incorrectly
• Skipping replacement step
• Confusing in-order predecessor with successor

4. Consider this Go code snippet for deleting a node from a BST. What is the bug?

func deleteNode(root *Node, key int) *Node {
    if root == nil {
        return nil
    }
    if key < root.key {
        root.left = deleteNode(root.left, key)
    } else if key > root.key {
        root.right = deleteNode(root.right, key)
    } else {
        if root.left == nil {
            return root.right
        } else if root.right == nil {
            return root.left
        }
        temp := findMin(root.right)
        root.key = temp.key
        deleteNode(root.right, temp.key)
    }
    return root
}

medium

A. Missing assignment of root.right after deleting successor node.

B. Incorrect base case for empty tree.

C. Wrong comparison operators for key checks.

D. Returning nil instead of root in all cases.

Solution

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

   After replacing root.key with successor's key, the successor node must be deleted from right subtree.

2. Step 2: Check recursive call effect on tree structure

   The call deleteNode(root.right, temp.key) is made but its result is not assigned back to root.right, so the successor node remains.

3. Final Answer:

   Missing assignment of root.right after deleting successor node. -> Option A

4. Quick Check:

   Assign recursive delete result to root.right [OK]

Hint: Always assign recursive delete results to child pointers [OK]

Common Mistakes:

• Ignoring returned subtree after deletion
• Not updating pointers after recursive calls
• Confusing base case with recursive case

5. You have a BST with nodes: 30, 20, 40, 10, 25, 35, 50. You delete node 30 (root). Which node becomes the new root after deletion using the standard BST delete operation?

hard

A. Node 35 (in-order successor)

B. Node 25 (in-order predecessor)

C. Node 40 (right child)

D. Node 20 (left child)

Solution

1. Step 1: Identify node to delete and its children

   Node 30 is root with two children: left subtree (20) and right subtree (40).

2. Step 2: Find in-order successor of node 30

   In-order successor is the smallest node in right subtree, which is 35.

3. Step 3: Replace root with in-order successor

   Replace 30 with 35, then delete original 35 node from right subtree.

4. Final Answer:

   Node 35 (in-order successor) -> Option A

5. Quick Check:

   Root replaced by in-order successor = 35 [OK]

Hint: Root replaced by smallest node in right subtree [OK]

Common Mistakes:

• Using in-order predecessor instead of successor
• Choosing direct child without successor check
• Not deleting successor node after replacement