void
qsort(
void *base
, size_t nmemb
, size_t size
, int (*compar)(const void *, const void *)
)
int
heapsort(
void *base
, size_t nmemb
, size_t size
, int (*compar)(const void *, const void *)
)
int
mergesort(
void *base
, size_t nmemb
, size_t size
, int (*compar)(const void *, const void *)
)
)
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.
)
function
returns no value.
Upon successful completion,
heapsort()
and
mergesort(
)
return 0.
Otherwise, they return -1 and the global variable
errno
is set to indicate the error.
)
function succeeds unless:
EINVAL
]
size
argument is zero, or,
the
size
argument to
mergesort(
)
is less than
``sizeof(void *) / 2''.
ENOMEM
]
)
or
mergesort(
)
were unable to allocate memory.
)
did not permit the comparison routine itself to call
qsort(
).
This is no longer true.
)
function
conforms to
ANSI X3.159-1989 (``ANSI C89'') .