BST Delete Operation in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What are the three main cases to consider when deleting a node in a Binary Search Tree (BST)?

1. Node to delete is a leaf (no children).
2. Node to delete has one child.
3. Node to delete has two children.

intermediate

In BST deletion, how do you handle deleting a node with two children?

Replace the node's value with its inorder successor (smallest value in right subtree) or inorder predecessor (largest value in left subtree), then delete that successor/predecessor node.

intermediate

Why do we use the inorder successor or predecessor when deleting a node with two children in a BST?

Because replacing with inorder successor or predecessor maintains the BST property by ensuring all left subtree values remain smaller and right subtree values remain larger.

beginner

What happens if you delete a leaf node in a BST?

The leaf node is simply removed by setting its parent's pointer to null, as it has no children.

beginner

In Go, what is the base case for the recursive BST delete function?

When the current node is nil (empty), return nil to stop recursion.

Which node do you replace a deleted node with when it has two children in a BST?

A Random node in the tree

B Inorder successor or inorder predecessor

C Root node

D Any leaf node

Replacing with inorder successor or predecessor keeps the BST properties intact.

What is the first step when deleting a node in a BST?

A Find the node to delete

B Replace the node with root

C Delete all children first

D Balance the tree

You must first find the node to delete by traversing the BST.

If a node to delete has only one child, what do you do?

A Replace with inorder successor

B Replace the node with root

C Delete the entire subtree

D Replace the node with its child

You replace the node with its single child to maintain BST structure.

What is the inorder successor of a node in a BST?

A Smallest node in the right subtree

B Largest node in the left subtree

C Root node

D Any leaf node

Inorder successor is the smallest node in the right subtree.

What does the BST delete function return when the node to delete is not found?

A Nil (no change)

B Error

C Root node

D New node

If node is not found, the function returns the root unchanged.

Explain the steps to delete a node with two children in a BST.

Think about maintaining BST order after deletion.

Describe how BST deletion handles nodes with zero, one, and two children.

Consider each case separately.

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