Deletion procedure for a Binary Search Tree
Consider the deletion procedure on a BST, when the node to delete has two children. Let's say i always replace it with the node holding the minimum key in its right subtree. The question is: is this procedure commutative? That is, deleting x and then y has the same result than deleting first y and then x? I think the answer is no, but i can't find a counterexample, nor figure out any valid reasoning. EDIT: Maybe i've got to be clearer. Consider the transplant(node x, node y) procedure: it replace x with y (and its subtree). So, if i want to delete a node (say x) which has two children i replace it with the node holding the minimum key in its right subtree: y = minimum(x.right) transplant(y, y.right) // extracts the minimum (it doesn't have left child) y.right = x.right y.left = x.left transplant(x,y) The question was how to prove the procedure above is not commutative.
Solutions/Answers:
Answer 1:
Deletion (in general) is not commutative. Here is a counterexample:
4
/ \
3 7
/
6
What if we delete 4 and then 3?
When we delete 4, we get 6 as the new root:
6
/ \
3 7
Deleting 3 doesn’t change the tree, but gives us this:
6
\
7
What if we delete 3 and then 4?
When we delete 3 the tree doesn’t change:
4
\
7
/
6
However, when we now delete 4, the new root becomes 7:
7
/
6
The two resulting trees are not the same, therefore deletion is not commutative.
UPDATE
I didn’t read the restriction that this is when you always delete a node with 2 children. My solution is for the general case. I’ll update it if/when I can find a counterexample.
ANOTHER UPDATE
I don’t have concrete proof, but I’m going to hazard a guess:
In the general case, you handle deletions differently based on whether you have two children, one child, or no children. In the counterexample I provided, I first delete a node with two children and then a node with one child. After that, I delete a node with no children and then another node with one child.
In the special case of only deleting nodes with two children, you want to consider the case where both nodes are in the same subtree (since it wouldn’t matter if they are in different subtrees; you can be sure that the overall structure won’t change based on the order of deletion). What you really need to prove is whether the order of deletion of nodes in the same subtree, where each node has two children, matters.
Consider two nodes A and B where A is an ancestor of B. Then you can further refine the question to be:
Is deletion commutative when you are considering the deletion of two nodes from a Binary Search Tree which have a ancestordescendant relationship to each other (this would imply that they are in the same subtree)?
When you delete a node (let’s say A), you traverse the right subtree to find the minimum element. This node will be a leaf node and can never be equal to B (because B has two children and cannot be a leaf node). You would then replace the value of A with the value of this leafnode. What this means is that the only structural change to the tree is the replacement of A’s value with the value of the leafnode, and the loss of the leafnode.
The same process is involved for B. That is, you replace the value of the node and replace a leafnode. So in general, when you delete a node with two children, the only structural change is the change in value of the node you are deleting, and the deletion of the leaf node who’s value you are using as replacement.
So the question is further refined:
Can you guarantee that you will always get the same replacement node regardless of the order of deletion (when you are always deleting a node with two children)?
The answer (I think) is yes. Why? Here are a few observations:
 Let’s say you delete the descendant node first and the ancestor node second. The subtree that was modified when you deleted the descendant node is not in the left subtree of the ancestor node’s right child. This means that this subtree remains unaffected. What this also means is regardless of the order of deletion, two different subtrees are modified and therefore the operation is commutative.
 Again, let’s say you delete the descendant node first and the ancestor node second. The subtree that was modified when you deleted the descendant node is in the left subtree of the ancestor node’s right child. But even here, there is no overlap. The reason is when you delete the descendant node first, you look at the left subtree of the descendant node’s right child. When you then delete the ancestor node, you will never go down that subtree since you will always be going towards the left after you enter the ancestor node’s rightchild’s left subtree. So again, regardless of what you delete first you are modifying different subtrees and so it appears order doesn’t matter.
 Another case is if you delete the ancestor node first and you find that the minimum node is a child of the descendant node. This means that the descendant node will end up with one child, and deleting the one child is trivial. Now consider the case where in this scenario, you deleted the descendant node first. Then you would replace the value of the descendant node with its right child and then delete the right child. Then when you delete the ancestor node, you end up finding the same minimum node (the old deleted node’s left child, which is also the replaced node’s left child). Either way, you end up with the same structure.
This is not a rigorous proof; these are just some observations I’ve made. By all means, feel free to poke holes!
Answer 2:
It seems to me that the counterexample shown in Vivin’s answer is the sole case of noncommutativity, and that it is indeed eliminated by the restriction that only nodes with two children can be deleted.
But it can also be eliminated if we discard what appears to be one of Vivin’s premises, which is that we should traverse the right subtree as little as possible to find any acceptable successor. If, instead, we always promote the smallest node in the right subtree as the successor, regardless of how far away it turns out to be located, then even if we relax the restriction on deleting nodes with fewer than two children, Vivin’s result
7 / 6
is never reached if we start at
4 / \ 3 7 / 6
Instead, we would first delete 3 (without successor) and then delete 4 (with 6 as successor), yielding
6 \ 7
which is the same as if the order of deletion were reversed.
Deletion would then be commutative, and I think it is always commutative, given the premise I have named (successor is always smallest node in right subtree of deleted node).
I do not have a formal proof to offer, merely an enumeration of cases:

If the two nodes to be deleted are in different subtrees, then deletion of one does not affect the other. Only when they are in the same path can the order of deletion possibly affect the outcome.
So any effect on commutativity can come only when an ancestor node and one of its descendants are both deleted. Now, how does their vertical relationship affect commutativity?

Descendant in the left subtree of the ancestor. This situation will not affect commutativity because the successor comes from the right subtree and cannot affect the left subtree at all.

Descendant in the right subtree of the ancestor. If the ancestor’s successor is always the smallest node in the right subtree, then order of deletion cannot change the choice of successor, no matter what descendant is deleted before or after the ancestor. Even if the successor to the ancestor turns out to be the descendant node that is also to be deleted, that descendant too is replaced with the the nextlargest node to it, and that descendant cannot have its own left subtree remaining to be dealt with. So deletion of an ancestor and any rightsubtree descendant will always be commutative.
Answer 3:
I think there are two equally viable ways to delete a node, when it has 2 children:
SKIP TO CASE 4…
Case 1: delete 3 (Leaf node)
2 3
/ \ –> / \
1 3 1
Case 2: delete 2 (Left child node)
2 3
/ \ –> / \
1 3 1
Case 3: delete 2 (Right child node)
2 2
/ \ –> / \
1 3 3
______________________________________________________________________
Case 4: delete 2 (Left & Right child nodes)
2 2 3
/ \ –> / \ or / \
1 3 1 3
BOTH WORK and have different resulting trees 🙂
______________________________________________________________________
As algorithm explained here: http://www.mathcs.emory.edu/~cheung/Courses/323/Syllabus/Trees/AVLdelete.html
Deleting a node with 2 children nodes:
1) Replace the (todelete) node with its inorder predecessor or inorder successor
2) Then delete the inorder predecessor or inorder successor
Answer 4:
I respond here to Vivin’s second update.
I think this is a good recast of the question:
Is deletion commutative when you are
considering the deletion of two nodes
from a Binary Search Tree which have a
ancestordescendant relationship to
each other (this would imply that they
are in the same subtree)?
but this bold sentence below is not true:
When you delete a node (let’s say A),
you traverse the right subtree to
find the minimum element. This node
will be a leaf node and can never be equal to B
since the minimum element in A’s right subtree can have a right child. So, it is not a leaf.
Let’s call the minimum element in A’s right subtree successor(A)
.
Now, it is true that B cannot be successor(A)
, but it can be in its right subtree. So, it is a mess.
I try to summarize.
Hypothesis:
 A and B have two children each.
 A and B are in the same subtree.
Other stuff we can deduce from hypothesis:
 B is not
successor(A)
, neither A issuccessor(B)
.
Now, given that, i think there are 4 different cases (as usual, let be A an ancestor of B):
 B is in A’s left subtree
 B is an ancestor of
successor(A)
successor(A)
is an ancestor of B B and successor(A) don’t have any relationship. (they are in different A’s subtrees)
I think (but of course i cannot prove it) that cases 1, 2 and 4 don’t matter.
So, only in the case successor(A)
is an ancestor of B deletion procedure could not be commutative. Or could it?
I pass the ball : )
Regards.
References
 Database Administration Tutorials
 Programming Tutorials & IT News
 Linux & DevOps World
 Entertainment & General News
 Games & eSport