Smoothsort

Abstract: Quicksort is the preferred in-place sorting algorithm in many contexts, since its average computing time on uniformly distributed inputs is Θ(N log N), and it is in fact faster than most other sorting algorithms on most inputs. Its drawback is that its worst-case time bound is Θ(N2). Previous attempts to protect against the worst case by improving the way quicksort chooses pivot elements for partitioning have increased the average computing time too much – one might as well use heapsort, which has a Θ(N log N) worst-case time bound, but is on the average 2–5 times slower than quicksort. A similar dilemma exists with selection algorithms (for finding the i-th largest element) based on partitioning. This paper describes a simple solution to this dilemma: limit the depth of partitioning, and for subproblems that exceed the limit switch to another algorithm with a better worst-case bound. Using heapsort as the ‘stopper’ yields a sorting algorithm that is just as fast as quicksort in the average case, but also has an Θ(N log N) worst case time bound. For selection, a hybrid of Hoare's FIND algorithm, which is linear on average but quadratic in the worst case, and the Blum–Floyd–Pratt–Rivest–Tarjan algorithm is as fast as Hoare's algorithm in practice, yet has a linear worst-case time bound. Also discussed are issues of implementing the new algorithms as generic algorithms, and accurately measuring their performance in the framework of the C+:+ Standard Template Library. ©1997 by John Wiley & Sons, Ltd.

Abstract: Heapsort is a classical sorting algorithm due to Williams. Given an array to sort, Heapsort first transforms the keys of the array into a heap. The heap is then sorted by repeatedly swapping the root of the heap with the last key in the bottom row, and then sifting this new root down to an appropriate position to restore heap order. In Williams' original Heapsort, the new root is sifted down by repeatedly comparing its two children, and swapping it with its larger child if a comparison shows the child to be larger than the key being sifted. Floyd proposed an important variant of Williams' Heapsort which unconditionally performs the swap with the larger child. This thesis analyzes the asymptotic number of executions of each instruction for both versions of Heapsort in the average, best, and worst cases. In the average case, when sorting a uniformly generated random heap on N distinct keys, Williams' Heapsort performs $\sim$2N lg N key comparisons while Floyd's variant performs ${\sim}N$ lg N key comparisons (lg is the logarithm base two). Another quantity of interest is the number of times keys are swapped with their right children. Both Williams' and Floyd's versions of Heapsort expect to perform ${\sim}{1\over2}N$ lg N such swaps. Sedgewick, and independently Fleischer and Wegener, have presented arguments to demonstrate that the number of key comparisons required by Williams' Heapsort in the best case and Floyd's Heapsort in the worst case are ${\sim}N$ lg N and ${\sim}{3\over2}N$ lg N respectively. These arguments are extended and applied in a different form to demonstrate that in the worst case, Williams' and Floyd's Heapsorts perform ${\sim}{3\over2}N$ lg N swaps of keys with their right children, while in the best case at most ${\sim}{1\over4}N$ lg N such swaps are performed. For both versions of Heapsort, it is shown that these best and worst case numbers can be found in heaps that also require the best and worst case numbers of key comparisons.