C语言之各种排序法及核心思想（冒泡、鸡尾酒、选择、插入、二分法、希尔、堆、归并、快速）

[cpp] view plain copy

1. #include <stdio.h>  
2.   
3. void swap(int num[],int a, int b)  
4. {  
5.     int tmp;  
6.         tmp = num[a];  
7.         num[a] = num[b];  
8.         num[b] = tmp;  
9. }  
10.   
11. void printfA(int *num,int len)  
12. {  
13.     int i;  
14.     for(i = 0;i < len; i++)  
15.     {  
16.         printf("%4d",num[i]);  
17.     }  
18.     printf("\n");  
19. }  
20. 各个排序都要调用的交换函数和打印函数，单独提出来。  

[cpp] view plain copy

1. //冒泡排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int i;  
7.     int j;  
8.     for(i = 0;i < len - 1; i++)  
9.     {  
10.         for(j = 0; j < len-1-i; j++)  
11.         {  
12.             if(num[j] > num[j+1])  
13.                 swap(num,j,j+1);  
14.         }  
15.     }  
16.     printfA(num,len);  
17. }  
18. 冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数），将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。如此下去，直至最终完成排序。  
19. 　　由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。  

[cpp] view plain copy

1. //鸡尾酒排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int i;  
7.     int left = 0;  
8.     int right = len - 1;  
9.     while(left < right)  
10.     {  
11.         for(i = left; i < right; i++)  
12.         {  
13.             if(num[i] > num[i+1])  
14.                 swap(num,i,i+1);  
15.         }  
16.         right--;  
17.         for(i = right;i > left; i--)  
18.         {  
19.             if(num[i] < num[i-1])  
20.                 swap(num,i,i-1);  
21.         }  
22.         left++;  
23.     }  
24.       
25.     printfA(num,len);  
26. }  
27. 冒泡排序只是单向冒泡，而鸡尾酒来回反复双向冒泡。  
28. 原理：自左向右将大数冒到末尾，然后将剩余数列再自右向左将小数冒到开头，如此循环往复。  

[cpp] view plain copy

1. //选择排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int i;  
7.     int j;  
8.     int min;  
9.       
10.     for(i = 0;i < len-1; i++)  
11.     {  
12.         min = i;  
13.         for(j = i+1; j < len;j++)  
14.         {  
15.             if(num[min] > num[j])  
16.             {  
17.                 min = j;  
18.             }  
19.         }  
20.         if(min != i)  
21.             swap(num,i,min);  
22.     }  
23.       
24.     printfA(num,len);  
25. }  
26. 选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。  

[cpp] view plain copy

1. //插入排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int i;  
7.     int j;  
8.     int tmp;  
9.     for(i = 1; i < len; i++)  
10.     {  
11.         j = i-1;  
12.         tmp = num[i];  
13.         while(j > 0 && num[j] > tmp)  
14.         {  
15.             num[j + 1] = num[j];  
16.             j--;  
17.         }  
18.         num[j + 1] = tmp;  
19.     }  
20.       
21.     printfA(num,len);  
22. }  
23. 有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。  
24. 插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。  

[cpp] view plain copy

1. //二分查找排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int left,right,mid,i,j;  
7.     int tmp;  
8.       
9.     for(i = 1; i < len; i++)  
10.     {  
11.         left = 0;  
12.         right = i-1;  
13.         tmp = num[i];  
14.           
15.         while(left <= right)  
16.         {  
17.             mid = (left+right)/2;  
18.             if(num[mid] > tmp)  
19.                 right = mid - 1;  
20.             else  
21.                 left = mid + 1;  
22.         }  
23.           
24.         for(j = i-1; j >= left; j--)  
25.         {  
26.             num[j+1] = num[j];  
27.         }  
28.         num[left] = tmp;  
29.     }  
30.       
31.     printfA(num,len);  
32.       
33.     return 0;  
34. }  
35. 二分法排序算法思想简单描述： 在插入第i个元素时，对前面的0～i-1元素进行折半，先跟他们 中间的那个元素比，如果小，则对前半再进行折半，否则对后半 进行折半，直到left>right，然后再把第i个元素前1位与目标位置之间 的所有元素后移，再把第i个元素放在目标位置上。   

[cpp] view plain copy

1. //希尔排序  
2. int main()  
3. {  
4.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
5.     int len = sizeof(num)/sizeof(num[0]);  
6.     int i,tmp,j;  
7.     int d = len;  
8.       
9.     do  
10.     {  
11.         d = d / 3 + 1;  
12.         for(i = d; i < len; i++)  
13.         {  
14.             tmp = num[i];  
15.             j = i - d;  
16.             while(j > 0 && num[j] > tmp)  
17.             {  
18.                 num[j+d] = num[j];  
19.                 j -= d;  
20.             }  
21.             num[j + d] = tmp;  
22.         }  
23.     }while(d > 1);  
24.       
25.     printfA(num,len);  
26.       
27.     return 0;  
28. }  
29. 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量   =1(   <   …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。  

[cpp] view plain copy

1. //堆排序  
2. void heapify(int num[],int i, int len)  
3. {  
4.     int left = 2 * i + 1;  
5.     int right = 2 * i + 2;  
6.     int max = i;  
7.     if(left < len && num[left] > num[max])  
8.         max = left;  
9.     if(right < len && num[max] < num[right])  
10.         max = right;  
11.       
12.     if(max != i)  
13.     {  
14.         swap(num, i, max);  
15.         heapify(num, max, len);  
16.     }  
17. }  
18.   
19. void heapsort(int num[], int len)  
20. {  
21.     int i;  
22.     for(i = len/2-1;i >= 0; i--)  
23.     {  
24.         heapify(num,i,len);  
25.     }  
26.     for(i = len-1;i > 0; i--)  
27.     {  
28.         swap(num,0,i);  
29.         len--;  
30.         heapify(num,0,len);  
31.     }  
32. }  
33.   
34. int main()  
35. {  
36.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
37.     int len = sizeof(num)/sizeof(num[0]);  
38.     heapsort(num,len);  
39.       
40.     printfA(num,len);  
41.       
42.     return 0;  
43. }  
44. 利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。  
45.     其基本思想为(大顶堆)：  
46.     1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；  
47.     2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];   
48.     3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。  

[cpp] view plain copy

1. //归并排序  
2. void merge(int *num,int left, int mid, int right, int *tmp)  
3. {  
4.     int i = left;  
5.     int j = mid + 1;  
6.     int k = 0;  
7.     while(i <= mid && j <= right)  
8.     {  
9.         if(num[i] > num[j])  
10.             tmp[k++] = num[j++];  
11.         else  
12.             tmp[k++] = num[i++];  
13.     }  
14.       
15.     while(i <= mid)  
16.         tmp[k++] = num[i++];  
17.     while(j <= right)  
18.         tmp[k++] = num[j++];  
19.       
20.     k = 0;  
21.     for(i = left; i <= right; i++)  
22.     {  
23.         num[i] = tmp[k++];  
24.     }  
25. }  
26.   
27. void mergesort(int *num,int left, int right, int *tmp)  
28. {  
29.     if(left >= right)  
30.     {  
31.         return;  
32.     }  
33.     int mid = (left + right)/2;  
34.       
35.     mergesort(num, left, mid, tmp);  
36.     mergesort(num, mid+1, right, tmp);  
37.       
38.     merge(num, left, mid, right, tmp);  
39.       
40. }  
41.   
42. int main()  
43. {  
44.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
45.     int len = sizeof(num)/sizeof(num[0]);  
46.     int tmp[10];  
47.     mergesort(num,0,len-1,tmp);  
48.       
49.     printfA(num,len);  
50.       
51.     return 0;  
52. }  
53. 归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。  
54. 归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。  

[cpp] view plain copy

1. //快速排序法  
2. int partition(int *num,int left, int right)  
3. {  
4.     int pivot = num[right];  
5.     int index = left;  
6.     int i;  
7.     for(i = left; i < right; i++)  
8.     {  
9.         if(num[i] < pivot)  
10.         {  
11.             swap(num,i,index);  
12.             index++;  
13.         }  
14.     }  
15.     swap(num,index,right);  
16.     return index;  
17. }  
18.   
19. void qSort(int *num, int left, int right)  
20. {  
21.     if(left < right)  
22.     {  
23.         int pivot = partition(num, left, right);  
24.           
25.         qSort(num, left, pivot-1);  
26.         qSort(num, pivot+1, right);  
27.     }  
28. }  
29.   
30. int main()  
31. {  
32.     int num[10] = {0,9,8,7,6,5,4,3,2,1};  
33.     int len = sizeof(num)/sizeof(num[0]);  
34.     qSort(num,0,len-1);  
35.       
36.     printfA(num,len);  
37.       
38.     return 0;  
39. }  
40. 快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。  
41.      假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：  
42.     1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；  
43.     2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；  
44.     3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；  
45.     4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；  
46.     5）、重复第3、4步，直到I=J；