Algorithms and Data Structures

N.Wirth. Algorithms and Data Structures. Oberon version 64
Analysis of Heapsort. At first sight it is not evident that this method of sorting provides good results.
After all, the large items are first sifted to the left before finally being deposited at the far right. Indeed, the
procedure is not recommended for small numbers of items, such as shown in the example. However, for
large n, Heapsort is very efficient, and the larger n is, the better it becomes — even compared to Shellsort.
In the worst case, there are n/2 sift steps necessary, sifting items through log(n/2), log(n/2+1), ... ,
log(n-1) positions, where the logarithm (to the base 2) is truncated to the next lower integer.
Subsequently, the sorting phase takes n-1 sifts, with at most log(n-1), log(n-2), ..., 1 moves. In
addition, there are n-1 moves for stashing the item from the top away at the right. This argument shows
that Heapsort takes of the order of n × log(n) moves even in the worst possible case. This excellent
worst-case performance is one of the strongest qualities of Heapsort.
It is not at all clear in which case the worst (or the best) performance can be expected. But generally
Heapsort seems to like initial sequences in which the items are more or less sorted in the inverse order, and
therefore it displays an unnatural behavior. The heap creation phase requires zero moves if the inverse
order is present. The average number of moves is approximately n/2 × log(n), and the deviations from this
value are relatively small.
2.3.3 Partition Sort
After having discussed two advanced sorting methods based on the principles of insertion and selection,
we introduce a third improved method based on the principle of exchange. In view of the fact that
Bubblesort was on the average the least effective of the three straight sorting algorithms, a relatively
significant improvement factor should be expected. Still, it comes as a surprise that the improvement based
on exchanges to be discussed subsequently yields the best sorting method on arrays known so far. Its
performance is so spectacular that its inventor, C.A.R. Hoare, called it Quicksort [2.5 and 2.6].
Quicksort is based on the recognition that exchanges should preferably be performed over large
distances in order to be most effective. Assume that n items are given in reverse order of their keys. It is
possible to sort them by performing only n/2 exchanges, first taking the leftmost and the rightmost and
gradually progressing inward from both sides. Naturally, this is possible only if we know that their order is
exactly inverse. But something might still be learned from this example.
Let us try the following algorithm: Pick any item at random (and call it x); scan the array from the left
until an item a i > x is found and then scan from the right until an item a j < x is found. Now exchange the
two items and continue this scan and swap process until the two scans meet somewhere in the middle of
the array. The result is that the array is now partitioned into a left part with keys less than (or equal to) x,
and a right part with keys greater than (or equal to) x. This partitioning process is now formulated in the
form of a procedure. Note that the relations > and < have been replaced by ≥ and ≤, whose negations in
the while clause are < and >. With this change x acts as a sentinel for both scans.
PROCEDURE partition;
VAR i, j: INTEGER; w, x: Item;
BEGIN
i := 0; j := n-1;
select an item x at random;
REPEAT
WHILE a[i] < x DO i := i+1 END;
WHILE x < a[j] DO j := j-1 END;
IF i j
END partition