The
qsort() function is a modified partition-exchange sort, or quicksort. The
heapsort() function is a modified selection sort. The
mergesort() function is a modified merge sort with exponential search intended for sorting data with pre-existing order.
The
qsort() and
heapsort() functions sort an array of
nmemb objects, the initial member of which is pointed to by
base. The size of each object is specified by
size.
mergesort() behaves similarly, but
requires that
size be greater than “sizeof(void *) / 2”.
The contents of the array
base are sorted in ascending order according to a comparison function pointed to by
compar, which requires two arguments pointing to the objects being compared.
The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
The functions
qsort() and
heapsort() are
not stable, that is, if two members compare as equal, their order in the sorted array is undefined. The function
mergesort() is stable.
The
qsort() function is an implementation of C.A.R. Hoare's ``quicksort'' algorithm, a variant of partition-exchange sorting; in particular, see D.E. Knuth's Algorithm Q.
qsort() takes O N lg N average time. This implementation uses median selection to avoid its O N**2 worst-case behavior.
The
heapsort() function is an implementation of J.W.J. William's ``heapsort'' algorithm, a variant of selection sorting; in particular, see D.E. Knuth's Algorithm H.
heapsort() takes O N lg N worst-case time. Its
only advantage over
qsort() is that it uses almost no additional memory; while
qsort() does not allocate memory, it is implemented using recursion.
The function
mergesort() requires additional memory of size
nmemb * size bytes; it should be used only when space is not at a premium.
mergesort() is optimized for data with pre-existing order; its worst case time is O N lg N; its best case is O N.
Normally,
qsort() is faster than
mergesort() is faster than
heapsort(). Memory availability and pre-existing order in the data can make this untrue.