排序算法实现及分析

所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：
　　输入：n个记录R₁，R₂，…，R_n，其相应的关键字分别为K₁，K₂，…，K_n。

　　输出：R_il，R_i2，…，R_in，使得K_i1≤K_i2≤…≤K_in。(或K_i1≥K_i2≥…≥K_in)。

    排序的时间开销可用算法执行中的数据比较次数与数据移动次数来衡量。基本的排序算法有如下几种：交换排序（冒泡排序、快速排序）、选择排序（直接选择排序、堆排序）、插入排序（直接插入排序、希尔排序）、归并排序、分配排序（基数排序、箱排序、计数排序）。下面依次列出各种算法的代码，并进行简要分析。分配排序算法的代码没有列出。

    （1）快速排序：快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。最好、平均复杂度都为O(nlogn)，最坏为O(n^2)。

[cpp] view plaincopyprint?

1. void quick_sort1(int a[],int l,int r)  
2. {  
3.     if(l >= r)  
4.         return;  
5.     int i, j, p;  
6.     i = l-1, j = l,p = a[r];  
7.     while(j < r)  
8.     {  
9.         if(a[j] < p)  
10.             swap(a[++i], a[j]);  
11.         j++;  
12.     }  
13.     swap(a[++i], a[r]);  
14.     quick_sort1(a, l, i-1);  
15.     quick_sort1(a, i+1, r);  
16. }  

    《算法导论》一书中，给出了这个程序的伪代码。当数组元素相等、逆序、顺序排列时，调用这个程序会导致栈溢出。因为每次划分都是最坏坏分。可以改进一下。上述程序每次选的划分基准元素都是固定的，如果是随机产生的，那么可以大大降低出现最坏划分的概率。

[cpp] view plaincopyprint?

1. void quick_sort2(int a[],int l,int r)  
2. {  
3.     if(l >= r)  
4.         return;  
5.     int i,j,p;  
6.     i = l-1,j = l;  
7.   
8.     p=l + rand()%(r-l); //随机产生[l,r)之间的数  
9.     swap(a[p], a[r]);  
10.     p = a[r];  
11.     while(j < r)  
12.     {  
13.         if(a[j] < p)  
14.             swap(a[++i], a[j]);  
15.         j++;  
16.     }  
17.     swap(a[++i], a[r]);  
18.     quick_sort2(a, l, i-1);  
19.     quick_sort2(a, i+1, r);  
20. }  

    但是，当数组元素相等时，还是出现了栈溢出。可以做如下调整。

[cpp] view plaincopyprint?

1. void quick_sort3(int a[],int l,int r)  
2. {  
3.     if(l >= r)  
4.         return;  
5.     int i,j,p;  
6.     i = l-1, j = r, p = a[r];  
7.     while(1)  
8.     {  
9.         do { i++; } while(a[i] < p && i < r);  
10.         do { j--; } while(a[j] > p && j > l);  
11.         if(i >= j)  
12.             break;  
13.         swap(a[i], a[j]);  
14.     }  
15.     swap(a[i],a[r]);  
16.     quick_sort3(a, l, i-1);  
17.     quick_sort3(a, i+1, r);  
18. }  

    但是，当数组元素顺序，逆序时，同样出现了栈溢出。若将两者结合起来，就可以尽量避免栈溢出。

[cpp] view plaincopyprint?

1. void quick_sort4(int a[],int l,int r)  
2. {  
3.     if(l >= r)  
4.         return;  
5.     int i,j,p;  
6.     i = l-1, j = r;  
7.   
8.     p = l + rand()%(r-l);  
9.     swap(a[p],a[r]);  
10.     p = a[r];  
11.     while(1)  
12.     {  
13.         do { i++; } while(a[i] < p && i < r);  
14.         do { j--; } while(a[j] > p && j > l);  
15.         if(i >= j)  
16.             break;  
17.         swap(a[i], a[j]);  
18.     }  
19.     swap(a[i], a[r]);  
20.     quick_sort4(a, l, i-1);  
21.     quick_sort4(a, i+1, r);  
22. }  

    （2）冒泡排序：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。

[cpp] view plaincopyprint?

1. void bubble_sort1(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 0; i < n-1; i++)  
5.     {  
6.         for(j = i+1; j < n; j++)  
7.         {  
8.             if(a[i] > a[j])  
9.                 swap(a[i], a[j]);  
10.         }  
11.     }  
12. }  

    可以稍作改进，当数组数元素顺序时，时间复杂度为O(n)。加入一个变量，如果在一遍扫描中，没有出现交换，那么结束排序，因为数组已排好序了。

[cpp] view plaincopyprint?

1. void bubble_sort2(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 0; i < n-1; i++)  
5.     {  
6.         bool exchange = false;  
7.         for(j = i+1; j < n; j++)  
8.         {  
9.             if(a[i] > a[j])  
10.             {  
11.                 exchange = true;  
12.                 swap(a[i], a[j]);  
13.             }  
14.         }  
15.         if(exchange == false)  
16.             break;  
17.     }  
18. }  

     经网友指出，上面这个冒泡排序有问题，无法得到正确结果。下面引自网友的正确写法：

[cpp] view plaincopyprint?

1. void bubble_sort2(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 0;i < n-1; i++)  
5.     {  
6.         bool exchange = false;  
7.         for(j = n-1;j > i; j--)  
8.         {  
9.             if(a[j-1] > a[j])  
10.             {  
11.                 exchange = true;  
12.                 swap(a[j-1], a[j]);  
13.             }  
14.         }     
15.         if(exchange == false)  
16.             break;  
17.     }  
18. }  

    （3）直接选择排序：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。

[cpp] view plaincopyprint?

1. void select_sort1(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 0; i < n-1; i++)  
5.     {  
6.         int min = i;  
7.         for(j = i+1; j < n; j++)  
8.         {  
9.             if(a[j] < a[min])  
10.                 min = j;  
11.         }  
12.         if(min != i)  
13.             swap(a[i], a[min]);  
14.     }  
15. }  

    （4）堆排序：根据输入数据，利用堆的调整算法形成初始堆，然后交换根元素与尾元素，总的元素个数减1，然后从根往下调整。堆排序的最好、最坏、平均时间复杂度都为O(nlogn)

[cpp] view plaincopyprint?

1. void heap_siftdown(int a[],int n,int p) //调整算法  
2. {  
3.     int i = p,j = i*2+1;  
4.     int tmp = a[i];  
5.     while(j < n)  
6.     {  
7.         if(j+1 < n && a[j] < a[j+1])  
8.             j++;  
9.         if(a[j] <= tmp)  
10.             break;  
11.         else  
12.         {  
13.             a[i] = a[j];  
14.             i = j;j = j*2+1;  
15.         }  
16.     }  
17.     a[i] = tmp;  
18. }  
19. void heap_sort1(int a[],int n)  
20. {  
21.     int i;  
22.     for(i = (n-1)/2; i >= 0;i--)  
23.         heap_siftdown(a, n, i);  
24.     for(i = n-1;i >= 0; i--)  
25.     {  
26.         swap(a[i], a[0]);  
27.         heap_siftdown(a, i, 0);  
28.     }  
29. }  

     （5）直接插入排序：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。当数组已经排好序，直接插入排序的时间复杂度为O(n)

[cpp] view plaincopyprint?

1. void insert_sort1(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 1; i < n; i++)  
5.     {  
6.         for(j = i; j > 0 && a[j]<a[j-1]; j--)  
7.             swap(a[j-1], a[j]);  
8.     }  
9. }  

     如果将交换函数展开，可以加快排序的速度。

[cpp] view plaincopyprint?

1. void insert_sort2(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 1; i < n; i++)  
5.     {  
6.         for(j = i; j > 0 && a[j] < a[j-1]; j--)  
7.         {  
8.             int t = a[j-1];  
9.             a[j-1] = a[j];  
10.             a[j] = t;  
11.         }  
12.     }  
13. }  

     可以进一步改进，insert_sort2的算法不断给t赋值，可以将赋值语句移到循环外面。

[cpp] view plaincopyprint?

1. void insert_sort3(int a[],int n)  
2. {  
3.     int i,j;  
4.     for(i = 1;i < n; i++)  
5.     {  
6.         int t = a[i];  
7.         for(j = i; j > 0 && a[j-1] > t; j--)  
8.             a[j] = a[j-1];  
9.         a[j] = t;  
10.     }  
11. }  

     （6）希尔排序：先取一个小于n的整数d₁作为第一个增量，把文件的全部记录分成d₁个组。所有距离为d_l的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d₂<d₁重复上述的分组和排序，直至所取的增量d_t=1(d_t<d_t-l<…<d₂<d₁)，即所有记录放在同一组中进行直接插入排序为止。

    最后一遍的增量必须是1，其实是就是调用直接插入排序算法。

[cpp] view plaincopyprint?

1. void shell_sort1(int a[],int n)  
2. {  
3.     int i = n;  
4.     do{  
5.         i = i/3 + 1;  
6.         shell_pass1(a, n, i);  
7.     }while(i > 1);  
8. }  
9. void shell_pass1(int a[],int n,int inc)  //inc为1时，其实就是直接插入排序  
10. {  
11.     int i,j;  
12.     for(i = inc; i < n; i++)  
13.     {  
14.         int t=a[i];  
15.         for(j = i;j >= inc && a[j-inc] > t; j-= inc)  
16.             a[j] = a[j-inc];  
17.         a[j] = t;  
18.     }  
19. }  

  （7）归并排序：利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。可以用于外排序。

[cpp] view plaincopyprint?

1. void merge_sort1(int a[],int b[],int l,int r)  
2. {  
3.     if(l >= r)  
4.         return;  
5.     int m = (l+r)/2;  
6.     merge_sort1(a, b, l, m);  
7.     merge_sort1(a, b, m+1, r);  
8.     merge1(a, b, l, m, r);  
9. }  
10. void merge1(int a[],int b[],int l,int m,int r)  
11. {  
12.     int i,j,k;  
13.     for(i = l; i <= r; i++)  
14.         b[i] = a[i];  
15.     i = l; j = m+1; k = l;  
16.     while(i <= m && j <= r)  
17.     {  
18.         if(b[i] <= b[j]) a[k++] = b[i++];  
19.         else a[k++] = b[j++];  
20.     }  
21.     while(i <= m) a[k++] = b[i++];  
22.     while(j <= r) a[k++] = b[j++];  
23. }  

     给出上述算法的程序的测试驱动程序及两个辅助程序。要测试某种排序算法，只需将注释去掉即可。

[cpp] view plaincopyprint?

1. #include <iostream>  
2. #include <ctime>  
3. using namespace std;  
4. const int N = 100;  
5. int a[N];  
6. int b[N];  
7.   
8. int main()   
9. {  
10.     int i;  
11.     srand(time(0));  
12.     //for(i=0;i<N;i++)  
13.     // a[i]= N-i;  
14.     for(i = 0;i < N; i++)  
15.         a[i]=rand()%N;  
16.     long start,end;  
17.     start = clock();  
18.   
19.     //quick_sort1(a,0,N-1);  
20.     //quick_sort2(a,0,N-1);  
21.     //quick_sort3(a,0,N-1);  
22.     //quick_sort4(a,0,N-1);  
23.     //bubble_sort1(a,N);  
24.     //bubble_sort2(a,N);  
25.     //merge_sort1(a,b,0,N-1);  
26.     //heap_sort1(a,N);  
27.     //shell_sort1(a,N);  
28.     //select_sort1(a,N);  
29.     //insert_sort1(a,N);  
30.     //insert_sort2(a,N);  
31.     //insert_sort3(a,N);  
32.   
33.     end = clock();  
34.     print_array(a, N);  
35.     cout<<"total time is : "<<(end-start)/1000.0<<'s'<<endl;  
36.     return 0;  
37. }  
38.   
39. void swap(int a[],int i,int j) //交换元素  
40. {  
41.     int t = a[i];  
42.     a[i] = a[j];  
43.     a[j] = t;  
44. }  
45.   
46. void print_array(int a[],int n) //打印元素值  
47. {  
48.     for(int i = 0; i < n; i++)  
49.     {  
50.         cout<<a[i]<<' ';  
51.         if(i%10==0 && i!=0)  
52.             cout<<endl;  
53.     }  
54.     cout<<endl;  
55. }  

     下面对排序算法做一个简单的比较。直接选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

                     最好          最坏         平均         稳定         辅助空间       

快速排序            O(nlogn)       O(n^2)     O(nlogn)        否            不要          

冒泡排序            O(n)           O(n^2)     O(n^2)          是            不要

直接选择排序        O(n^2)        O(n^2)     O(n^2)          否            不要

堆排序              O(nlogn)      O(nlogn)  O(nlogn)        否            不要

直接插入排序        O(n)           O(n^2)     O(n^2)          是            不要

希尔排序            O(n)           O(n^2)     O(n^2)          否            不要

归并排序            O(nlogn)       O(nlogn)   O(nlogn)        是            要

转载 http://blog.csdn.net/wuzhekai1985