static inline void
quick_sort_recursive(void *base, uint32 left, uint32 right,
uint32 csize, sint32 (*compare)(const void *, const void *))
{
void *ptr_l;
void *ptr_r;
void *ptr_m;
uint32 median;
assert_exit(sort_parameters_legal_p(base, csize, csize, compare));
ptr_l = base + left * csize;
ptr_r = base + right * csize;
if (left + 2 < right) {
ptr_m = quick_sort_obtain_median(base, left, right, csize, compare);
sort_cell_swap(ptr_m, ptr_r - csize, csize);
ptr_m = ptr_r - csize;
ptr_r = ptr_m;
while (true) {
do {
ptr_l += csize;
} while (compare(ptr_m, ptr_l) > 0);
do {
ptr_r -= csize;
} while (compare(ptr_m, ptr_r) < 0);
if (ptr_l < ptr_r) {
sort_cell_swap(ptr_l, ptr_r, csize);
} else {
break;
}
}
sort_cell_swap(ptr_l, ptr_m, csize);
median = (ptr_l - base) / csize;
quick_sort_recursive(base, left, median - 1, csize, compare);
quick_sort_recursive(base, median + 1, right, csize, compare);
} else if (left + 2 == right) {
quick_sort_obtain_median(base, left, right, csize, compare);
} else if (left + 1 == right && compare(ptr_l, ptr_r) > 0) {
sort_cell_swap(ptr_l, ptr_r, csize);
}
}
void quick_sort_recursive(int (*digits)[2], int start, int end)
{
if(start >= end)
return ;
//int pos = start + (rand() % (end-start+1));
int tmp[2];
/*
tmp[0] = digits[pos][0];
tmp[1] = digits[pos][1];
digits[pos][0] = digits[end][0];
digits[pos][1] = digits[end][1];
digits[end][0] = tmp[0];
digits[end][1] = tmp[1];
*/
int mid = digits[end][0];
int left = start, right = end-1;
while(left < right)
{
while(digits[left][0] < mid && left < right)
left++;
while(digits[right][0] >= mid && left < right)
right--;
tmp[0] = digits[left][0];
tmp[1] = digits[left][1];
digits[left][0] = digits[right][0];
digits[left][1] = digits[right][1];
digits[right][0] = tmp[0];
digits[right][1] = tmp[1];
}
if(digits[left][0] >= digits[end][0])
{
tmp[0] = digits[left][0];
tmp[1] = digits[left][1];
digits[left][0] = digits[end][0];
digits[left][1] = digits[end][1];
digits[end][0] = tmp[0];
digits[end][1] = tmp[1];
}
else
left++;
quick_sort_recursive(digits, start, left-1);
quick_sort_recursive(digits, left+1, end);
}
void
quick_sort(void *base, uint32 size, uint32 csize,
sint32 (*compare)(const void *, const void *))
{
if (sort_parameters_legal_p(base, size, csize, compare)) {
quick_sort_recursive(base, 0, size - 1, csize, compare);
assert_exit(sort_data_sorted_p(base, size, csize, compare));
}
}
void quick_sort_recursive(int arr[], int start, int end) {
if (start >= end)
return;
int mid = arr[end];
int left = start, right = end - 1;
while (left < right) {
while (arr[left] < mid && left < right)
left++;
while (arr[right] >= mid && left < right)
right--;
swap(&arr[left], &arr[right]);
}
if (arr[left] >= arr[end])
swap(&arr[left], &arr[end]);
else
left++;
quick_sort_recursive(arr, start, left - 1);
quick_sort_recursive(arr, left + 1, end);
}
void quick_sort(int arr[], int len) {
quick_sort_recursive(arr, 0, len - 1);
}
void quick_sort(int (*digits)[2], int len)
{
//srand((unsigned)time(NULL));
quick_sort_recursive(digits, 0, len-1);
}
