Algorithms and Data Structures

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.