Reason of child node assignments after deletion from Binary Search Tree? - c++

Question

I have a point which i haven't understood while learning BST Deletion mechanism. Could you explain me why there is an assignment (p->rchild =, p->lchild =) each time the Delete(Node* p, int key) is called? Actually, I thought that the Delete(Node* p, int key) method just keeps returning without any mutation so the tree doesn't change.
And while i was looking for an explanation, i stumbled into this sentence :
We have to make assignments after deletion else we will end up having
duplicate nodes.
If you agree with this statement, could you please explain it to me?
Node* BST::Delete(Node *p, int key) {
Node* q;
if (p == nullptr){
return nullptr;
}
if (p->lchild == nullptr && p->rchild == nullptr){
if (p == root){
root = nullptr;
}
delete p;
return nullptr;
}
if (key < p->data){
p->lchild = Delete(p->lchild, key);
} else if (key > p->data){
p->rchild = Delete(p->rchild, key);
} else {
if (Height(p->lchild) > Height(p->rchild)){
q = InPre(p->lchild);
p->data = q->data;
p->lchild = Delete(p->lchild, q->data);
} else {
q = InSucc(p->rchild);
p->data = q->data;
p->rchild = Delete(p->rchild, q->data);
}
}
return p;
}

Answer 1

why there is an assignment (p->rchild =, p->lchild =) each time the Delete(Node* p, int key) is called?
If the data is found, then the goal is to have a tree that has one node less. The algorithm will uses a value-swapping mechanism to ensure that the node that will actually be removed, is always a leaf node. The deletion of a leaf node consists of two actions:
The removal from memory;
The update of its parent so that the child pointer that references this deleted node is set to a null pointer.
As the algorithm recurses right to that leaf node, it cannot set the null pointer to its parent, as there is at this stage no reference available to the parent node. For that the caller should do something, since the caller does have a reference to the parent.
So when the recursive traversal arrives at the leaf node, it needs to convey to the caller that this node should be detached. It does so by returning a null pointer, and the agreement is that the caller (whose current node p is the parent) should assign the returned pointer to relevant child pointer. That way the deleted node is really detached from the rest of the tree.
Actually, I thought that the Delete(Node* p, int key) method just keeps returning without any mutation so the tree doesn't change.
Surely the tree must change somehow to have a node deleted from it. The change happens in the assignment to p->lchild or p->rchild
I stumbled into this sentence :
We have to make assignments after deletion else we will end up having duplicate nodes.
This is true. Let's take an example tree:
7
/ \
3 8
/ \ \
1 5 9
/ / \
0 4 6
Now let's see what happens if we call Delete(root, 3). p points to the node with value 7. We go to the left with a recursive call:
p->lchild = Delete(p->lchild, key);
In the recursive execution context, we get a new p which points to the node with value 3. This is the value we're looking for, so we get into the outer else block. As the heights of the subtrees below that node are equal, we get into the inner else block. There we assign:
q = InSucc(p->rchild);
This q will reference the node with value 4. And now a duplication happens. We copy the data from q to p. That comes down to deleting the value 3 from the tree:
p->data = q->data;
But now we have twice the value 4 in the tree.
7
/ \
4* 8
/ \ \
1 5 9
/ / \
0 4* 6
So the algorithm descends to the (right) child, and now seeks to delete the node with value 4 in that subtree:
p->rchild = Delete(p->rchild, q->data);
In this new recursive call we get a new p again, which now refers to the node with value 5. We move left -- this assignment will play an important role later:
p->lchild = Delete(p->lchild, key);
This final recursive call has a new p that refers to the node with value 4 -- the one we were looking for.
This time we end up in the if block that has the delete, because this node is a leaf node. The node is freed and a null pointer is returned to the caller. From here on we start backtracking up the tree.
So one level up, at the node with value 5, we get the return value from the recursive call (which is a null pointer) and assign it:
p->lchild = Delete(p->lchild, key);
This important assignment will detach the duplicate node (with value 4) from the tree. You can see that if this assignment would not have been made, there would still be a reference to that node with a duplicate value -- even though it is pointing to freed memory.
The tree is now in its final shape:
7
/ \
4 8
/ \ \
1 5 9
/ \
0 6
Backtracking will still continue, going back to the root. Also there assignments are made to some child pointers, but these will not change the tree, as in all these cases we had returned return p;, which was the original value of the caller's child pointer.
Bug
As mentioned in the comments, the code has a bug. When deleting a leaf node, it does not verify that this node has actually the value to delete. And so in case you call this method with a value that does not occur in the tree, you'll end up deleting a leaf node with another value. In the example tree above: if you were to call Delete(root, 10), the node with value 9 will be deleted.
To correct this bug, move the following if block:
if (p->lchild == nullptr && p->rchild == nullptr){
... inside the outer else block, as the first statement there.