Algorithms and Data Structures

More documents

Recommendations

Info

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).
N.Wirth. Algorithms and Data Structures. Oberon version 161 a) 10 b) 10 5 15 5 15 3 8 13 18 3 8 18 c) 10 d) 10 e) 8 5 18 3 18 3 18 3 8 8 Fig. 4.28. Tree deletion 4.4.5 Analysis of Tree Search and Insertion It is a natural reaction to be suspicious of the algorithm of tree search and insertion. At least one should retain some skepticism until having been given a few more details about its behaviour. What worries many programmers at first is the peculiar fact that generally we do not know how the tree will grow; we have no idea about the shape that it will assume. We can only guess that it will most probably not be the perfectly balanced tree. Since the average number of comparisons needed to locate a key in a perfectly balanced tree with n nodes is approximately log(n), the number of comparisons in a tree generated by this algorithm will be greater. But how much greater? First of all, it is easy to find the worst case. Assume that all keys arrive in already strictly ascending (or descending) order. Then each key is appended immediately to the right (left) of its predecessor, and the resulting tree becomes completely degenerate, i.e., it turns out to be a linear list. The average search effort is then n/2 comparisons. This worst case evidently leads to a very poor performance of the search algorithm, and it seems to fully justify our skepticism. The remaining question is, of course, how likely this case will be. More precisely, we should like to know the length a n of the search path averaged over all n keys and averaged over all n! trees that are generated from the n! permutations of the original n distinct keys. This problem of algorithmic analysis turns out to be fairly straightforward, and it is presented here as a typical example of analyzing an algorithm as well as for the practical importance of its result. Given are n distinct keys with values 1, 2, ... , n. Assume that they arrive in a random order. The probability of the first key — which notably becomes the root node — having the value i is 1/n. Its left subtree will eventually contain i−1 nodes, and its right subtree n−i nodes (see Fig. 4.29). Let the average path length in the left subtree be denoted by a i-1 , and the one in the right subtree is a n-i , again assuming that all possible permutations of the remaining n−1 keys are equally likely. The average path length in a tree with n nodes is the sum of the products of each node's level and its probability of access. If all nodes are assumed to be searched with equal likelihood, then a n = (Si: 1 ≤ i ≤ n: p i ) / n where p i is the path length of node i.
Page 1 and 2:
Algorithms and Data Structures © N
Page 3 and 4:
N.Wirth. Algorithms and Data Struct
Page 5 and 6:
Page 7 and 8:
Page 9 and 10:
Page 11 and 12:
Page 13 and 14:
Page 15 and 16:
Page 17 and 18:
Page 19 and 20:
Page 21 and 22:
Page 23 and 24:
Page 25 and 26:
Page 27 and 28:
Page 29 and 30:
Page 31 and 32:
Page 33 and 34:
Page 35 and 36:
Page 37 and 38:
Page 39 and 40:
Page 41 and 42:
Page 43 and 44:
Page 45 and 46:
Page 47 and 48:
Page 49 and 50:
Page 51 and 52:
Page 53 and 54:
Page 55 and 56:
Page 57 and 58:
Page 59 and 60:
Page 61 and 62:
Page 63 and 64:
Page 65 and 66:
Page 67 and 68:
Page 69 and 70:
Page 71 and 72:
Page 73 and 74:
Page 75 and 76:
Page 77 and 78:
Page 79 and 80:
Page 81 and 82:
Page 83 and 84:
Page 85 and 86:
Page 87 and 88:
Page 89 and 90:
Page 91 and 92:
Page 93 and 94:
Page 95 and 96:
Page 97 and 98:
Page 99 and 100:
Page 101 and 102:
Page 103 and 104:
Page 105 and 106:
Page 107 and 108:
Page 109 and 110: N.Wirth. Algorithms and Data Struct
Page 159: N.Wirth. Algorithms and Data Struct
Page 211:
show all

Algorithms and Data Structures

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?