void sort_quick(int n, int* a)
{
if (n <= 1) return;
int pivot = a[n-1];
int m = partition(n, a, pivot);
/**
* now a[0,m) <= pivot < a[m, n)
*/
/**
* special case all <= pivot
*/
if (m == n) {
sort_quick(n-1, a);
return;
}
/**
* m can't be 0 now since a[0,m) at least contain pivot, must be 0<m<n
*/
sort_quick(m, a);
sort_quick(n-m, a+m);
}
/*-----------------------------------------------------------------------------------
@array: array[first] ~ array[end]
@first: 第一个元素索引 一般为零
@end : 最后一个元素索引 一般为数组元素个数减1
-----------------------------------------------------------------------------------*/
void sort_quick(int array[],int first,int end)
{
int q;
if(first < end)
{
q = partition(array,first,end);
//array_show(array,10,q);
sort_quick(array,first,q-1);
sort_quick(array,q+1,end);
}
}
int main() {
int arr[] = {6, 5, 3, 1, 8, 7, 2, 4};
int len = sizeof(arr)/sizeof(int);
array_display(arr, len);
sort_quick(arr, len);
printf("sort:\n");
array_display(arr, len);
}
/*******************************************************************************
* Function Name : sort_quick
* Description : Sort table using quick sort algorithm.
* Input : tab: table which will be sorted,
* n: number of elements in table,
* f: pointer to the function with sorting comparison.
* Output : None.
* Return : None.
*******************************************************************************/
void sort_quick(SORTEDTYPE *tab, uint16_t n, BOOL(*f)(SORTEDTYPE, SORTEDTYPE)) {
SORTEDTYPE x = *(tab+n/2), tmp;
uint16_t i = 0, j = n - 1;
if(n == 1)
return;
do {
while(f(*(tab+i), x)) i++;
while(f(x, *(tab+j))) j--;
if(i <= j) {
tmp = *(tab+i);
*(tab+i) = *(tab+j);
*(tab+j) = tmp;
i++;
j--;
}
} while(i < j);
if (0 < j) sort_quick(tab, j + 1, f);
if (n > i) sort_quick(tab+i, n - i, f);
}
bool verify_sort_quick(int n) {
for (int vs_len = 1; vs_len < 6; ++vs_len) {
for (rpermut_begin(n, a, vs_len, vs); rpermut_next(n, a, vs_len, vs); ) {
sort_quick(n, a);
if (!is_sorted(n, a))
return false;
}
}
return true;
}
/*******************************************************************************
* Function Name : sort_hybridquick
* Description : Sort table using hybrid quick sort algorithm with help
* algorithm.
* Input : tab: table which will be sorted,
* n: number of elements in table,
* f: pointer to the function with sorting comparison.
* Output : None.
* Return : None.
*******************************************************************************/
void sort_hybridquick(SORTEDTYPE *tab, uint16_t n, BOOL(*f)(SORTEDTYPE, SORTEDTYPE), void (*sort)(SORTEDTYPE*, uint16_t, BOOL(*f)(SORTEDTYPE, SORTEDTYPE))) {
SORTEDTYPE x = *(tab+n/2), tmp;
int i = 0, j = n - 1;
if (n > 10) {
do {
while(f(*(tab+i), x)) i++;
while(f(x, *(tab+j))) j--;
if(i <= j) {
tmp = *(tab+i);
*(tab+i) = *(tab+j);
*(tab+j) = tmp;
i++;
j--;
}
} while(i < j);
if (0 < j) sort_quick(tab, j + 1, f);
if (n > i) sort_quick(tab+i, n - i, f);
} else {
sort(tab, n, f);
}
}
// best: O(n log n), worst: O(n2), avg: O(n log n)
void sort_quick(int *array, int left, int right) {
int i = left, j = right;
int pivot = array[left + (right - left) / 2];
int tmp;
// partition
while(i <= j) {
while(array[i] < pivot) {
i++;
}
while(array[j] > pivot) {
j--;
}
if(i <= j) {
tmp = array[i];
array[i] = array[j];
array[j] = tmp;
i++;
j--;
}
}
// recursion
if(left < j) sort_quick(array, left, j);
if(i < right) sort_quick(array, i, right);
}
bool exprs_for_24(int a1, int a2, int a3, int a4)
{
int ar[4] = {a1, a2, a3, a4};
sort_quick(4, ar);
int ops[4] = {'+', '-', '*', '/'};
int opr[3];
Rpermut rp(3, opr, sizeof(ops)/sizeof(int), ops);
int a, b, c, d;
int op1, op2, op3;
bool found = false;
for (; std::next_permutation(ar, ar+4); ) {
a = ar[0];
b = ar[1];
c = ar[2];
d = ar[3];
for (rp.begin(); !rp.ended; rp.next()) {
op1 = opr[0];
op2 = opr[1];
op3 = opr[2];
if (form1(a, b, c, d, op1, op2, op3) ||
form2(a, b, c, d, op1, op2, op3) ||
form3(a, b, c, d, op1, op2, op3) ||
form4(a, b, c, d, op1, op2, op3) ||
form5(a, b, c, d, op1, op2, op3))
found = true;
}
}
return found;
}
int test_sort()
{
int i, result = 0, length, min_data_val, max_data_val;
int *temp_data;
int data[10];
test_msg_start("Test Selection Sort - Preset Array");
sort_set_array(data);
sort_selection(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Selection Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_selection(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Insertion Sort - Preset Array");
sort_set_array(data);
sort_insertion(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Insertion Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_insertion(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Quick Sort (Recursive) - Preset Array");
sort_set_array(data);
sort_quick(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Quick Sort (Recursive) - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_quick(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
test_msg_start("Test Quick Sort - Preset Array");
sort_set_array(data);
sort_quick_norecurse(data, 0, 9);
result += test_sort_data(data, 0, 9);
result += test_sort_data_loc(data);
test_msg_end(result);
test_msg_start("Test Quick Sort - Random Data");
for(i = 0; i < SORT_TESTS; i++) {
random_seed();
min_data_val = random_int(INT_MIN+1, (INT_MAX/2)-1);
max_data_val = random_int(min_data_val, (INT_MAX/2)-1);
length = random_int(500, 1000); /* get length of a new array */
temp_data = malloc(sizeof(int) * length);
sort_rnd_data_fill(temp_data, length, min_data_val, max_data_val);
sort_quick_norecurse(temp_data, 0, length);
result += test_sort_data(temp_data, 0, length);
free(temp_data);
temp_data = NULL;
}
test_msg_end(result);
return result;
}
void sort_setup(){
puts("");
puts("");
puts("introduce the sorting(排序) menu of the data structure and algorithms");
puts("");
sort_setup:
puts("insert(插入排序) -------------------- 1");
puts("bubble(冒泡排序) -------------------- 2");
puts("select(选择排序) -------------------- 3");
puts("shell(希尔排序) --------------------- 4");
puts("quick(快速排序) --------------------- 5");
puts("heap(堆排序) ------------------------ 6");
puts("");
puts("please input the index you want to go[1-4]");
int index = 0;
scanf("%d", &index);
switch(index){
case 1:
puts("go to insert sort(插入排序)");
before_sort();
sort_insert();
after_sort("insert sort(插入排序)");
break;
case 2:
puts("go to bubble sort(冒泡排序)");
before_sort();
sort_bubble();
after_sort("bubble sort(冒泡排序)");
break;
case 3:
puts("go to select sort(选择排序)");
before_sort();
sort_select();
after_sort("select sort(选择排序)");
break;
case 4:
// puts("go to select sort(希尔排序)");
// before_sort();
// sort_shell();
// after_sort("select sort(希尔排序)");
puts("shell sort is to be continued ...");
break;
case 5:
puts("go to select sort(快速排序)");
before_sort();
sort_quick();
after_sort("select sort(快速排序)");
break;
case 6:
// puts("go to select sort(堆排序)");
// before_sort();
// sort_heap();
// after_sort("select sort(堆排序)");
puts("heap sort is to be continued ...");
break;
default:
puts("incorrect index you chosen, please chose again");
goto sort_setup;
break;
}
}
