Deletion in BST in Data Structures Theory - Step-by-Step Execution

Concept Flow - Deletion in BST

Start at root

↓

Find node to delete

↓

Node found?

No→Stop: Node not in tree

Yes↓

Check children count

↓

No children

→Remove node

↓

One child

→Replace node with child

↓

Two children

→Find inorder successor

↓

Copy successor value

↓

Delete successor node

↓

Done

Start from the root and find the node to delete. If found, handle three cases: no children (remove), one child (replace), two children (replace with inorder successor and delete successor).

Execution Sample

Data Structures Theory

DeleteNode(root, key):
  if root is None:
    return None
  if key < root.val:
    root.left = DeleteNode(root.left, key)
  elif key > root.val:
    root.right = DeleteNode(root.right, key)
  else:
    # Node found, handle deletion cases
    ...

This recursive function finds the node with the given key and deletes it following BST deletion rules.

Analysis Table

Step	Operation	Current Node	Action Taken	Tree State (Inorder)
1	Start at root	50	Compare key=30 with 50, go left	[30, 40, 50, 60, 70]
2	Move to left child	30	Compare key=30 with 30, node found	[30, 40, 50, 60, 70]
3	Check children	30	Node has one child (40)	[30, 40, 50, 60, 70]
4	Delete node	30	Replace node 30 with child 40	[40, 50, 60, 70]
5	Return updated tree	50	Deletion complete	[40, 50, 60, 70]
6	Stop	N/A	Node deleted, stop recursion	[40, 50, 60, 70]

💡 Node with key 30 deleted by replacing it with its single child 40.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
root	50	50	30	30	40	40
key	30	30	30	30	30	30
current_node	50	30	30	30	40	40

Key Insights - 3 Insights

Why do we replace the node with its inorder successor when it has two children?

Replacing with the inorder successor maintains the BST property because the successor is the smallest node in the right subtree, ensuring all left nodes remain smaller and right nodes larger. See execution_table step 3 for the case when two children exist.

What happens if the node to delete has no children?

If the node has no children, it can be removed directly without replacement. This is simpler than other cases. This is implied in the concept_flow under 'No children' case.

Why do we recursively call DeleteNode on left or right subtree?

Because BST is a tree, we must search down the correct subtree to find the node. Recursion helps traverse until the node is found or the subtree is empty. See execution_table steps 1 and 2.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what happens to the node with value 30?

A It is replaced by its child node 40

B It is replaced by its inorder successor

C It is removed without replacement

D It remains unchanged

💡 Hint

Check the 'Action Taken' column at step 4 in execution_table.

At which step does the algorithm confirm the node to delete has been found?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'node found' in the 'Action Taken' column in execution_table.

If the node to delete had two children, which additional step would appear in the execution_table?

A Find inorder predecessor

B Replace node with left child

C Find inorder successor and delete it

D Remove node directly

💡 Hint

Refer to concept_flow where two children case leads to finding inorder successor.

Concept Snapshot

Deletion in BST:
- Find node to delete by comparing keys
- If no children: remove node
- If one child: replace node with child
- If two children: replace node with inorder successor (smallest in right subtree) and delete successor
- Recursion helps traverse tree
- Maintains BST property after deletion

Full Transcript

Deletion in a Binary Search Tree (BST) starts by searching for the node with the given key from the root. If the node is not found, the process stops. If found, there are three cases: if the node has no children, it is simply removed; if it has one child, it is replaced by that child; if it has two children, it is replaced by its inorder successor, which is the smallest node in its right subtree, and then the successor node is deleted. This process maintains the BST property. The deletion is typically implemented recursively, traversing left or right subtree depending on the key comparison. The example traced shows deleting node 30 which has one child 40, so 30 is replaced by 40. Variables like root and current_node update as the recursion proceeds. Key confusions include why inorder successor is used for two children case, what happens with no children, and why recursion is needed. The visual quiz tests understanding of these steps and outcomes.