Algorithms and Data Structures

More documents

Recommendations

Info

N.Wirth. Algorithms and Data Structures. Oberon version 70 i.e., it is of order n.This explains the power of the program Find for finding medians and similar quantiles, and it explains its superiority over the straightforward method of sorting the entire set of candidates before selecting the k-th (where the best is of order n*log(n)). In the worst case, however, each partitioning step reduces the size of the set of candidates only by 1, resulting in a required number of comparisons of order n 2 . Again, there is hardly any advantage in using this algorithm, if the number of elements is small, say, fewer than 10. 2.3.5 A Comparison of Array Sorting Methods To conclude this parade of sorting methods, we shall try to compare their effectiveness. If n denotes the number of items to be sorted, C and M shall again stand for the number of required key comparisons and item moves, respectively. Closed analytical formulas can be given for all three straight sorting methods. They are tabulated in Table 2.8. The column headings min, max, avg specify the respective minima, maxima, and values averaged over all n! permutations of n items. min avg max Straight C = n-1 (n 2 + n - 2)/4 (n 2 - n)/2 - 1 insertion M = 2(n-1) (n 2 - 9n -10)/4 (n 2 - 3n - 4)/2 Straight C = (n 2 - n)/2 (n 2 - n)/2 (n 2 - n)/2 selection M = 3(n-1) n*(ln(n) + 0.57) n 2 /4 + 3(n-1) Straight C = (n 2 -n)/2 (n 2 -n)/2 (n 2 -n)/2 exchange M = 0 (n 2 -n)*0.75 (n 2 -n)*1.5 Table 2.8. Comparison of straight sorting methods. No reasonably simple accurate formulas are available on the advanced methods. The essential facts are that the computational effort needed is c*n 1.2 in the case of Shellsort and is c*n*log(n) in the cases of Heapsort and Quicksort, where the c are appropriate coefficients. These formulas merely provide a rough measure of performance as functions of n, and they allow the classification of sorting algorithms into primitive, straight methods (n 2 ) and advanced or "logarithmic" methods (n*log(n)). For practical purposes, however, it is helpful to have some experimental data available that shed light on the coefficients c which further distinguish the various methods. Moreover, the formulas do not take into account the computational effort expended on operations other than key comparisons and item moves, such as loop control, etc. Clearly, these factors depend to some degree on individual systems, but an example of experimentally obtained data is nevertheless informative. Table 2.9 shows the times (in seconds) consumed by the sorting methods previously discussed, as executed by the Modula-2 system on a Lilith personal computer. The three columns contain the times used to sort the already ordered array, a random permutation, and the inversely ordered array. Table 2.9 is for 256 items, Table 2.10 for 2048 items. The data clearly separate the n 2 methods from the n*log(n) methods. The following points are noteworthy: 1. The improvement of binary insertion over straight insertion is marginal indeed, and even negative in the case of an already existing order. 2. Bubblesort is definitely the worst sorting method among all compared. Its improved version Shakersort is still worse than straight insertion and straight selection (except in the pathological case of sorting a sorted array). 3. Quicksort beats Heapsort by a factor of 2 to 3. It sorts the inversely ordered array with speed practically identical to the one that is already sorted.
N.Wirth. Algorithms and Data Structures. Oberon version 71 Ordered Random Inverse StraightInsertion 0.02 0.82 1.64 BinaryInsertion 0.12 0.70 1.30 StraightSelection 0.94 0.96 1.18 BubbleSort 1.26 2.04 2.80 ShakerSort 0.02 1.66 2.92 ShellSort 0.10 0.24 0.28 HeapSort 0.20 0.20 0.20 QuickSort 0.08 0.12 0.08 NonRecQuickSort 0.08 0.12 0.08 StraightMerge 0.18 0.18 0.18 Table 2.9. Execution times of sort programs with 256 elements Ordered Random Inverse StraightInsertion 0.22 50.74 103.80 BinaryInsertion 1.16 37.66 76.06 StraightSelection 58.18 58.34 73.46 BubbleSort 80.18 128.84 178.66 ShakerSort 0.16 104.44 187.36 ShellSort 0.80 7.08 12.34 HeapSort 2.32 2.22 2.12 QuickSort 0.72 1.22 0.76 NonRecQuickSort 0.72 1.32 0.80 StraightMerge 1.98 2.06 1.98 Table 2.10. Execution times of sort programs with 2048 elements
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: N.Wirth. Algorithms and Data Struct
Page 69: N.Wirth. Algorithms and Data Struct
Page 121 and 122:
Page 123 and 124:
Page 125 and 126:
Page 127 and 128:
Page 129 and 130:
Page 131 and 132:
Page 133 and 134:
Page 135 and 136:
Page 137 and 138:
Page 139 and 140:
Page 141 and 142:
Page 143 and 144:
Page 145 and 146:
Page 147 and 148:
Page 149 and 150:
Page 151 and 152:
Page 153 and 154:
Page 155 and 156:
Page 157 and 158:
Page 159 and 160:
Page 161 and 162:
Page 163 and 164:
Page 165 and 166:
Page 167 and 168:
Page 169 and 170:
Page 171 and 172:
Page 173 and 174:
Page 175 and 176:
Page 177 and 178:
Page 179 and 180:
Page 181 and 182:
Page 183 and 184:
Page 185 and 186:
Page 187 and 188:
Page 189 and 190:
Page 191 and 192:
Page 193 and 194:
Page 195 and 196:
Page 197 and 198:
Page 199 and 200:
Page 201 and 202:
Page 203 and 204:
Page 205 and 206:
Page 207 and 208:
Page 209 and 210:
Page 211:
show all

Algorithms and Data Structures

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

Delete template?

Save as template?