BST Delete Operation in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new BST node with the given key.

DSA Go

func newNode(key int) *Node {
    return &Node{
        key: [1],
        left: nil,
        right: nil,
    }
}

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

Akey

Bnil

CnewNode

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil or zero instead of the key parameter.

Trying to call newNode recursively inside itself.

The new node's key should be set to the given key parameter.

2fill in blank

medium

Complete the code to find the minimum value node in a BST.

DSA Go

func minValueNode(node *Node) *Node {
    current := node
    for current.left != [1] {
        current = current.left
    }
    return current
}

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

Anode

BnewNode

Ccurrent

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for node instead of nil.

Using current instead of nil in the condition.

We loop until current.left is nil, which means we reached the smallest node.

3fill in blank

hard

Fix the error in the delete function to correctly delete a node with two children.

DSA Go

func deleteNode(root *Node, key int) *Node {
    if root == nil {
        return root
    }
    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 := [1](root.right)
        root.key = temp.key
        root.right = deleteNode(root.right, temp.key)
    }
    return root
}

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

AminValueNode

BdeleteNode

CnewNode

DmaxValueNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using maxValueNode instead of minValueNode.

Calling deleteNode instead of minValueNode to find replacement.

To delete a node with two children, replace it with the minimum node in the right subtree.

4fill in blank

hard

Fill both blanks to complete the in-order traversal function that prints BST keys.

DSA Go

func inorder(root *Node) {
    if root != [1] {
        inorder(root.[2])
        fmt.Print(root.key, " -> ")
        inorder(root.right)
    }
}

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

Anil

Bleft

Cright

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root against left or right instead of nil.

Traversing right subtree first instead of left.

Check if root is not nil, then recursively traverse the left subtree first.

5fill in blank

hard

Fill all three blanks to complete the delete function that handles all cases correctly.

DSA Go

func deleteNode(root *Node, key int) *Node {
    if root == [1] {
        return root
    }
    if key < root.key {
        root.left = deleteNode(root.left, [2])
    } 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 := minValueNode(root.right)
        root.key = temp.key
        root.right = deleteNode(root.right, [3])
    }
    return root
}

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

Anil

Bkey

Ctemp.key

Droot.key

Attempts:

3 left

💡 Hint

Common Mistakes

Using root.key instead of key in recursive calls.

Not checking for nil root at the start.

Check if root is nil to stop recursion. Pass the key when going left. Use temp.key when deleting the successor node.

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