数据结构--排序算法总结

原创不易，尊重原创，本文转载于Nim的辙迹的博文，博文地址：http://blog.csdn.net/codernim/article/details/54312616

概述

排序的分类：内部排序和外部排序

内部排序：数据记录在内存中进行排序

外部排序：因排序的数据量大，需要内存和外存结合使用进行排序

这里总结的八大排序是属于内部排序：

当n比较大的时候，应采用时间复杂度为（nlog2n）的排序算法：快速排序、堆排序或归并排序。

其中，快速排序是目前基于比较的内部排序中被认为最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

———————————————————————————————————————————————————————————————————————

插入排序——直接插入排序（Straight Insertion Sort）

基本思想：

将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。

即：先将序列的第1个记录看成一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，用于临时存储和判断数组边界

直接插入排序示例：

插入排序是稳定的，因为如果一个带插入的元素和已插入元素相等，那么待插入元素将放在相等元素的后边，所以，相等元素的前后顺序没有改变。

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. void print(int a[], int n ,int i)  
5. {    
6.     cout<<i<<":";    
7.     for(int j= 0; j<8; j++){    
8.         cout<<a[j] <<" ";    
9.     }    
10.     cout<<endl;    
11. }   
12.   
13. void InsertSort(int a[],int n)  
14. {  
15.     int i,j,tmp;  
16.     for(i=1;i<n;++i)  
17.     {  
18.         // 如果第i个元素大于第i-1个元素，直接插入  
19.         // 否则  
20.         // 小于的话，移动有序表后插入   
21.         if(a[i]<a[i-1])  
22.         {  
23.             j=i-1;  
24.             tmp=a[i];   // 复制哨兵，即存储待排序元素  
25.             a[i]=a[i-1];    // 先后移一个元素  
26.             while(tmp<a[j])     
27.             {     
28.                 // 哨兵元素比插入点元素小，后移一个元素  
29.                 a[j+1]=a[j];  
30.                 --j;  
31.             }  
32.             a[j+1]=tmp; // 插入到正确的位置   
33.         }  
34.         print(a,n,i); // 打印每一趟排序的结果   
35.     }  
36. }  
37.   
38. int main()  
39. {  
40.     int a[8]={3,1,5,7,3,4,8,2};  
41.     print(a,8,0);   // 打印原始序列   
42.     InsertSort(a,8);  
43.     return 0;  
44. }   

分析：

时间复杂度：O（n^2）

———————————————————————————————————————————————————————————————————————

插入排序——希尔排序（Shell Sort）

基本思想：

先将整个待排序的记录序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录依次进行直接插入排序。

操作方法：

1. 选择一个增量序列{ t1，t2，t3，...，tk } 
   
2. 按增量序列个数k，对序列进行k趟排序；
3. 每趟排序，根据对应的增量ti，将待排序序列分割成若干长度为m的子序列，分别对各子序列进行直接插入排序。仅增量因为为1时，整个序列作为一个整表来处理，表长度即为整个序列的长度。
   

希尔排序的示例：

算法实现：

**如何选择增量序列？

简单选择：增量序列d = { n/2，n/4，n/8，...，1 } ，其中n为要排序数的个数。

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. void print(int a[], int n)  
5. {     
6.     for(int j= 0; j<8; j++){    
7.         cout<<a[j] <<" ";    
8.     }    
9.     cout<<endl;    
10. }  
11.   
12. void ShellInsertSort(int a[],int n,int dk)  
13. {  
14.     int i,j,tmp;  
15.     for(i=dk;i<n;++i)  
16.     {  
17.         // 如果第i个元素大于第i-dk个元素，直接插入  
18.         // 否则  
19.         // 小于的话，移动有序表后插入   
20.         if(a[i]<a[i-dk])  
21.         {  
22.             j=i-dk;  
23.             tmp=a[i];  
24.             a[i]=a[i-dk]; // 复制哨兵，即存储待排序元素  
25.             while(tmp<a[j])  
26.             {  
27.                 // 哨兵元素比插入点元素小，后移dk个元素  
28.                 a[j+dk]=a[j];  
29.                 j-=dk;  
30.             }  
31.             a[j+dk]=tmp; // 插入到正确的位置   
32.         }  
33.     }  
34. }  
35.   
36. void ShellSort(int a[],int n)  
37. {  
38.     int dk=n/2;  
39.     while(dk>=1)  
40.     {  
41.         ShellInsertSort(a,n,dk);  
42.         dk/=2;  
43.     }  
44. }  
45.   
46. int main()  
47. {  
48.     int a[8]={3,1,5,7,3,4,8,2};  
49.     print(a,8); // 打印原始序列   
50.     ShellSort(a,8);  
51.     print(a,8);     // 打印排序后的序列   
52.     return 0;  
53. }  

分析：

可以发现，希尔排序是对简单插入排序算法的一种改进。

但希尔排序是不稳定的排序方法，因为排序过程中可能会改变相同元素在原始序列中的前后关系。

关于希尔排序的时效分析，取决于增量因子序列d的选取，特定情况下可以估算出关键码的比较次数和记录的移动次数。

目前还没有人给出选取最好的增量因子序列的方法。

———————————————————————————————————————————————————————————————————————

选择排序——简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数进行交换；然后在剩下的数当中再找最小（或者最大）的数与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序示例：

操作方法：

第一趟：从n个记录中找出关键码最小的记录与第一个记录交换；

第二趟：从第2个记录开始的n-1个记录中再选出关键码最小的记录与第2个记录交换；

以此类推...

第 i 趟：从第i个记录开始的n-i+1个记录中选出关键码最小的记录与第i个记录交换，直至整个序列按关键码有序。

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. void print(int a[], int n ,int i)  
5. {    
6.     cout<<"第"<<i+1 <<"趟 : ";    
7.     for(int j= 0; j<8; j++){    
8.         cout<<a[j] <<"  ";    
9.     }    
10.     cout<<endl;    
11. }  
12.   
13. // 返回数组的最小值的键值  
14. int SelectMinKey(int a[],int n,int i)  
15. {  
16.     int k=i;  
17.     for(int j=i+1;j<n;++j)  
18.         if(a[k]>a[j])  
19.             k=j;  
20.     return k;  
21. }  
22.   
23. void SelectSort(int a[],int n)  
24. {  
25.     int key,tmp;  
26.     for(int i=0;i<n;++i)  
27.     {  
28.         key=SelectMinKey(a,n,i);    // 选择最小的元素  
29.         if(key!=i)  
30.         {  
31.             // 最小元素与第i位置元素互换   
32.             tmp=a[i];  
33.             a[i]=a[key];  
34.             a[key]=tmp;  
35.         }  
36.         print(a,n,i);  
37.     }  
38. }  
39.   
40. int main()  
41. {  
42.     int a[8]={3,1,5,7,3,4,8,2};  
43.     cout<<"原始序列：";  
44.     for(int i=0;i<8;++i)  
45.     {  
46.         cout<<a[i];  
47.         if(i==7)  
48.             cout<<endl;  
49.         else  
50.             cout<<"  ";  
51.     }  
52.     SelectSort(a,8);  
53.     return 0;  
54. }   

———————————————————————————————————————————————————————————————————————

选择排序——堆排序（Heap Sort）

基本思想：

1）初始化堆；将数列[ 1 ... n ]构造成最大化堆

2）交换数据：将a[ 1 ]和a[ n ]交换，使a[ n ]是[ 1 ... n ]中的最大值；然后将[ 1 ... n-1 ]重新调整为最大堆。接着，将a[ 1 ]和a[ n-1 ]交换，使a[ n-1 ]是[ 1 ... n-1 ]中的最大值；然后将[ 1 ... n-2 ]重新调整为最大堆。依次类推，直到整个数列有序。

堆排序的示例：

实现中用到了“数组实现的二叉堆的性质”。

在第一个元素的索引为0的情形中：

性质一：索引为i 的左孩子的索引是（2*i+1）；

性质二：索引为i 的右孩子的索引是（2*i+2）；

性质三：索引为i 的父节点的索引是floor( ( i-1 ) / 2 )；

下面演示对a={20,30,90,40,70,110,60,10,100,50,80}, n=11进行堆排序过程

数组a对应的初始结构：

1 初始化堆：

在堆排序算法中，首先要将待排序的数组转换成最大堆。

下面演示将数组{20,30,90,40,70,110,60,10,100,50,80}转换为最大堆{110,100,90,40,80,20,60,10,30,50,70}的步骤。

1.1  i = n/2 - 1，即i = 4

1.2  i = 3

1.3  i = 2

1.4  i = 1

1.5  i = 0

2 交换数据

在将数组转换成最大堆后，接着要进行交换数据，从而使数组成为一个真正的有序数组。

下面是当n = 10时交换数组的示意图：

当n = 10时，首先交换a[0]和a[10]，使得a[10]是a[0 ... 10 ]之间的最大值；然后调整a[0 ... 9 ]使它成为最大堆。交换之后，a[10]是有序的；

当n = 9时，首先交换a[0]和a[9]，使得a[9]是a[0 ... 9 ]之间的最大值；然后调整a[0 ... 8 ]使它成为最大堆。交换之后，a[9]是有序的；

... ...

依次类推，直到a[0 ... 10 ]是有序的。

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. void maxheap_down(int a[],int start,int end)  
5. {  
6.     int current=start;  // 当前结点的位置  
7.     int left=2*current+1;   // 左孩子的位置  
8.     int tmp=a[current]; // 当前节点的大小  
9.     for(;left<=end;current=left,left=2*left+1)  
10.     {  
11.         if(left<end&&a[left]<a[left+1])  
12.             ++left; // 左右孩子中选择较大者  
13.         if(tmp>=a[left])  
14.             break;  //调整结束  
15.         else  
16.         {  
17.             // 交换值  
18.             a[current]=a[left];  
19.             a[left]=tmp;  
20.         }   
21.     }   
22. }  
23.   
24. void HeapSort(int a[],int n)  
25. {  
26.     int i,tmp;  
27.     // 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。  
28.     for(i=n/2-1;i>=0;--i)  
29.         maxheap_down(a,i,n-1);  
30.     // 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素  
31.     for(i=n-1;i>0;--i)  
32.     {  
33.         // 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的  
34.         tmp=a[i];  
35.         a[i]=a[0];  
36.         a[0]=tmp;  
37.         // 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆;  
38.         // 即，保证a[i-1]是a[0...i-1]中的最大值  
39.         maxheap_down(a,0,i-1);  
40.     }  
41. }  
42.   
43. int main()  
44. {  
45.     int i;  
46.     int a[]={20,30,90,3,21,11,60,10,23,50,80};  
47.     int len=(sizeof(a))/(sizeof(a[0]));  
48.     cout<<"原始序列：";  
49.     for(i=0;i<len;++i)  
50.         cout<<a[i]<<" ";  
51.     cout<<endl;  
52.     HeapSort(a,len);  
53.     cout<<"堆排序后的序列：";   
54.     for(i=0;i<len;++i)  
55.         cout<<a[i]<<" ";  
56.     cout<<endl;  
57.     return 0;  
58. }  

分析：

时间复杂度：O（nlog2n）

遍历一趟的时间复杂度是O（n）；

堆排序是采用二叉堆进行排序的，二叉堆就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是log2(n+1)，最多也不会超过log22n。因此，遍历次数介于log2(n+1)和log22n之间；因此得出它的时间复杂度是O（nlog2n）。

堆排序稳定性：不稳定的

它在交换数据的时候，是比较父节点和子节点之间的数据，所以即使是存在两个数值相等的兄弟结点，它们的相对顺序在排序中也可能发生变化。

———————————————————————————————————————————————————————————————————————

交换排序——冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的数往上冒。

即：每当相邻的数比较后发现它们的顺序与排序要求相反时，就将它们互换。

冒泡排序的示例：

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. void print(int a[], int n ,int i)  
5. {    
6.     cout<<"第"<<i+1<<"趟 : ";    
7.     for(int j= 0; j<8; j++){    
8.         cout<<a[j]<<"  ";    
9.     }    
10.     cout<<endl;    
11. }  
12.   
13. void BubbleSort(int r[],int size)  
14. {  
15.     int i,j,temp;  
16.     bool exchange;  //交换标志  
17.     for(i=0;i<size;i++)  
18.     {  
19.         exchange=false; //本趟排序开始前，交换标志设为假  
20.         for(j=size-1;j>=i;--j)  
21.             if(r[j]<r[j-1])  
22.             {  
23.                 temp=r[j];  //暂存单元   
24.                 r[j]=r[j-1];  
25.                 r[j-1]=temp;  
26.                 exchange=true;  //发生了交换，故将交换标志置为真   
27.             }  
28.         if(!exchange)   //本趟没有发生交换，提前终止算法   
29.             return;  
30.         print(r,size,i);  
31.     }  
32. }  
33.   
34. int main()  
35. {  
36.     int r[8]={3,1,5,7,3,4,8,2};  
37.     cout<<"原始序列：";  
38.     for(int i=0;i<8;i++)  
39.     {  
40.         cout<<r[i];  
41.         if(i==7)  
42.             cout<<endl;  
43.         else  
44.             cout<<"  ";  
45.     }  
46.     BubbleSort(r,8);  
47.     return 0;  
48. }  

———————————————————————————————————————————————————————————————————————

交换排序——快速排序（Quick Sort）

基本思想：

1）选择一个基准元素，通常选择第一个元素或者最后一个元素

2）通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小，另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序

快速排序的示例：

a）一趟排序的过程：

b）排序的全过程：

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. int Partition(int r[],int first,int end)  
5. {  
6.     int i=first,j=end,temp; //初始化  
7.     while(i<j)  
8.     {  
9.         //j从后向前扫描，直到r[j]<r[i]，将r[j]移动到r[i]的位置，使关键码小（同轴值相比）的记录移动到前面去；  
10.         while(i<j && r[i]<=r[j]) --j; //右侧扫描  
11.         if(i<j)  
12.         {  
13.             //将较小记录交换到前面  
14.             temp=r[i];  
15.             r[i]=r[j];  
16.             r[j]=temp;  
17.             ++i;  
18.         }  
19.         //i从前向后扫描，直到r[i]>r[j]，将r[i]移动到r[j]的位置，使关键码大（同轴值相比）的记录移动到后面去；  
20.         while(i<j && r[i]<=r[j]) ++i; //左侧扫描  
21.         if(i<j)  
22.         {  
23.             //将较大记录交换到后面  
24.             temp=r[i];  
25.             r[i]=r[j];  
26.             r[j]=temp;  
27.             --j;  
28.         }  
29.         //重复上述过程，直到i=j  
30.     }  
31.     return i;  
32. }  
33.   
34. void QuickSort(int r[],int first,int end)  
35. {  
36.     if(first<end)  
37.     {  
38.         int pivotpos=Partition(r,first,end);    //一次划分  
39.         QuickSort(r,first,pivotpos-1);  //对前一个子序列进行快速排序  
40.         QuickSort(r,pivotpos+1,end);    //对后一个子序列进行快速排序  
41.     }  
42.       
43. }  
44.   
45. int main()  
46. {  
47.     int r[8]={3,1,5,7,3,4,8,2};  
48.     cout<<"原始序列：";  
49.     for(int i=0;i<8;i++)  
50.     {  
51.         cout<<r[i];  
52.         if(i==7)  
53.             cout<<endl;  
54.         else  
55.             cout<<"  ";  
56.     }  
57.     QuickSort(r,0,7);  
58.     cout<<"排序后的序列：";  
59.     for(int i=0;i<8;i++)  
60.     {  
61.         cout<<r[i];  
62.         if(i==7)  
63.             cout<<endl;  
64.         else  
65.             cout<<"  ";  
66.     }  
67.     return 0;  
68. }  

分析：

快速排序通常被认为在同数量级（O（nlog2n）中平均性能最好的。但若初始序列按关键码有序或基本有序时，快速排序反而退化为冒泡排序。

为改进之，通常以“三者取中法“来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中地调整为支点记录。

快速排序是一个不稳定的排序算法。

———————————————————————————————————————————————————————————————————————

归并排序（Merge Sort）

基本思想：

归并排序是将两个（或两个以上）的有序表合并成一个新的有序表，即将待排序序列分为若干个子序列，每个序列是有序的。然后再将有序子序列合并为整体有序序列。

归并排序示例：

合并方法：

1个元素的表总是有序的，所以对n个元素的待排序列，每个元素可看成1个有序子表。对子表两两合并，生成n/2个子表，所得子表除最后一个子表长度可能为1外，其余子表长度均为2。再进行两两合并，直到生成n个元素按关键码有序的表。

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.    
4. void print(int a[], int n)  
5. {    
6.     for(int j=0; j<n; j++){    
7.         cout<<a[j] <<"  ";    
8.     }    
9.     cout<<endl;    
10. }   
11.   
12. void merge(int r[],int left,int mid,int right)  
13. {  
14.     int *rf=new int[right-left+1];  //汇总2个有序区的临时数组   
15.     int i=left;      // 第1个有序区的索引  
16.     int j=mid+1;     // 第2个有序区的索引  
17.     int k=0;        // 临时区域的索引  
18.     while(i<=mid&&j<=right)  
19.     {  
20.         if(r[i]<r[j])  
21.         {  
22.             rf[k++]=r[i++];  
23.         }  
24.         else  
25.         {  
26.             rf[k++]=r[j++];  
27.         }   
28.     }   
29.     while(i<=mid)  
30.         rf[k++]=r[i++];  
31.     while(j<=right)  
32.         rf[k++]=r[j++];  
33.     // 将排序后的元素，全部都整合到数组a中。  
34.     for(i=0;i<k;i++)  
35.         r[left + i] = rf[i];  
36.     delete []rf;  
37. }  
38.   
39. void MergeSort(int r[],int left,int right)  
40. {  
41.     if(r!=NULL&&left<right)  
42.     {  
43.         int mid=(left+right)/2;  
44.         MergeSort(r,left,mid);      // 递归排序a[start...mid]  
45.         MergeSort(r,mid+1,right);   // 递归排序a[mid+1...end]  
46.         // a[start...mid] 和 a[mid...end]是两个有序空间，  
47.         // 将它们排序成一个有序空间a[start...end]  
48.         merge(r,left,mid,right);  
49.     }  
50. }   
51.   
52. int main()  
53. {  
54.     int r[9]={32, 21, 67, 11, 5, 43, 99, 18,12};  
55.     cout<<"原始序列：";  
56.     print(r,9);  
57.     MergeSort(r,0,8);  
58.     cout<<"归并排序后的序列：";  
59.     print(r,9);  
60.     return 0;  
61. }   

分析：

归并排序的时间复杂度是O（nlog2n）

归并排序的形式就是一颗二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的深度可以得出它的时间复杂度是O（nlog2n）。

归并排序是稳定的算法，它满足稳定算法的定义。

———————————————————————————————————————————————————————————————————————

桶排序/基数排序（Radix Sort）

基本思想：

将数组分到有限数量的桶子里；

假设待排序的数组a中共有n个整数，并且已知数组a中的数据大小范围是[ 0 , MAX ) 。在桶排序时，创建容量为MAX的桶数组r，并将桶数组的元素都初始化为0；将容量为MAX的桶数组中的每一个单元都看成一个“桶”。

在排序时，逐个遍历数组a，将数组a的值作为“桶数组r”的下标。当a中的数据被读取时，就将相应的桶的值加1。例如，读取到数组a[3]=5，就将r[5]的值+1。

桶排序的示例：

假设a={8,2,3,4,3,6,6,3,9}, max=10。此时，将数组a的所有数据都放到需要为0-9的桶中。如下图：

在将数据放到桶中之后，再通过一定算法将桶中的数据提出来并转换成有序数组，这就得到我们需要的有序序列。

算法实现：

[cpp] view plain copy

 

1. #include<iostream>  
2. #include<cstring> // memset头文件   
3. using namespace std;  
4.   
5. void BucketSort(int a[],int n,int max)  
6. {  
7.     int i,j;  
8.     int buckets[max];  
9.     // 将buckets中的所有数据都初始化为0  
10.     memset(buckets,0,max*sizeof(int));  
11.     // 计数  
12.     for(i=0;i<n;++i)  
13.         ++buckets[a[i]];   
14.     // 排序  
15.     for(i=0,j=0;i<max;++i)  
16.         while((buckets[i]--)>0)  
17.             a[j++]=i;  
18. }  
19.   
20. int main()  
21. {  
22.     int i;  
23.     int a[] = {8,2,1,4,3,7,6,3,9};  
24.     int len = (sizeof(a))/(sizeof(a[0]));  
25.     cout<<"原始序列：";  
26.     for(i=0;i<len;++i)  
27.         cout<<a[i]<<" ";  
28.     cout<<endl;  
29.     BucketSort(a,len,10);  
30.     cout<<"堆排序后的序列：";   
31.     for(i=0;i<len;++i)  
32.         cout<<a[i]<<" ";  
33.     cout<<endl;  
34.     return 0;  
35. }  

—————————————————————————————————————————————————————————————————————————————

总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

来源：CSDN

作者：莫谈天下

链接：https://blog.csdn.net/zhangyonggang886/article/details/54380280