Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 160
4.4.4 Tree Deletion
We now turn to the inverse problem of insertion: deletion. Our task is to define an algorithm for deleting,
i.e., removing the node with key x in a tree with ordered keys. Unfortunately, removal of an element is not
generally as simple as insertion. It is straightforward if the element to be deleted is a terminal node or one
with a single descendant. The difficulty lies in removing an element with two descendants, for we cannot
point in two directions with a single pointer. In this situation, the deleted element is to be replaced by either
the rightmost element of its left subtree or by the leftmost node of its right subtree, both of which have at
most one descendant. The details are shown in the recursive procedure delete. This procedure
distinguishes among three cases:
1. There is no component with a key equal to x.
2. The component with key x has at most one descendant.
3. The component with key x has two descendants.
PROCEDURE delete (x: INTEGER; VAR p: Node); (* ADenS444_Deletion *)
PROCEDURE del (VAR r: Node);
BEGIN
IF r.right # NIL THEN del(r.right)
ELSE p.key := r.key; p.count := r.count;
r := r.left
END
END del;
BEGIN (*delete*)
IF p = NIL THEN (*word is not in tree*)
ELSIF x < p.key THEN delete(x, p.left)
ELSIF x > p.key THEN delete(x, p.right)
ELSE (*delete p^:*)
IF p.right = NIL THEN p := p.left
ELSIF p.left = NIL THEN p := p.right
ELSE del(p.left)
END
END
END delete
The auxiliary, recursive procedure del is activated in case 3 only. It descends along the rightmost branch of
the left subtree of the element p^ to be deleted, and then it replaces the relevant information (key and
count) in p^ by the corresponding values of the rightmost component r^ of that left subtree, whereafter r^
may be disposed.
We note that we do not mention a procedure that would be the inverse of NEW, indicating that storage is
no longer needed and therefore disposable and reusable. It is generally assumed that a computer system
recognizes a disposable variable through the circumstance that no other variables are pointing to it, and that
it therefore can no longer be referenced. Such a system is called a garbage collector. It is not a feature of
a programming language, but rather of its implementations.
In order to illustrate the functioning of procedure delete, we refer to Fig. 4.28. Consider the tree (a);
then delete successively the nodes with keys 13, 15, 5, 10. The resulting trees are shown in Fig. 4.28 (be).