What is sorting in C language?

Answer 1

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;

}

Answer 2

sorting is nothing but arranging the elements(numbers ) in order

Answer 3

you sort in the c file