What is sorting in C language?
Quicksort in any programming language is an algorithm for
sorting data sequences. It is typically implemented as follows
(example demonstrates a quicksort of an array of type int). Note
that a half-open range, [begin:end), includes the one-past-the-end
of the range and is the conventional means of defining a range of
contiguous array values. When begin==end, the range is deemed
empty.
// forward declarations
void qsort (int* unsigned); // this is the function you will
actually invoke
void qsort_rec (int*, int*); // recursive function
int* partition (int*, int*); // utility functions...
int* select_pivot (int*, int*);
void swap (int*, int*);
int count (int*, int*);
// sort a data sequence of length size
void qsort (int* data, unsigned size) {
qsort_rec (data, data + size);
}
// recursively sort the half-open range [begin:end)
void qsort_rec (int* begin, int* end) {
if (count (begin, end) < 2) return; // end point of
recursion
int* pivot = partition (begin, end);
qsort_rec (begin, pivot);
qsort_rec (++pivot, end);
}
// divide the half-open range [begin:end) into two around a
pivot value
int* partition (int* begin, int* end) {
if (count (begin, end) < 2) return begin;
int* pivot = select_pivot (begin, end);
swap (begin, pivot);
--end;
while (begin != end) {
while (*(begin) <= *pivot && begin != end)
++begin;
while (*pivot < *(end) && begin != end) --end;
if (begin!=end) swap (begin, end);
}
assert (begin==end); // sanity check!
swap (pivot, begin);
return begin;
}
// select the median of three from a half-open range
[begin:end)
int* select_pivot (int* begin, int* end) {
int* mid = begin + (count (begin, end) / 2);
if (*end<*begin) swap (begin, end);
if (*mid<*begin) swap (begin, mid);
if (*end<*mid) swap (mid, end);
return end;
}
// swap the values referred to by p and q
void swap (int* p, int* q) {
if (!p !q) return; // sanity check!
int t = *p;
*p = *q;
*q = t;
}
// count the elements in the half-closed range [begin:end)
int count (int* begin, int* end) {
int cnt = 0;
int add;
if (begin>end) { // swap pointers if the range is
reversed
int* t = begin;
begin = end;
end = t;
add = -1; // count will be negative
} else {
add = 1; // count will be positive
}
while (begin++!=end) cnt+=add;
return cnt;
}