数据结构之排序 --- 插入排序

　　以下代码的实现及验证都在manjaro linux中通过，编译器是gcc7.1, 编辑器是vim 8.0, 如果需要调试程序，使用gdb7.12

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

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

直接插入排序示例：


如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

 0 //filename:InsertSort.c
 1 #include "InsertSort.h"
 2 
 3 void InsertSort(int arr[], int size){
 4     for(int i = 1; i < size; i++){                          //将第0个元素当作是有序的，将后边的元素依次插入
 5         if(arr[i] < arr[i -1]){                             //如果后边的元素比前面排序的元素小，说明需要插入
 6             int last = i - 1;                               //将排好序的最后一个元素的下标记录
 7             int tmp = arr[i];                               //保存将要插入的元素到临时变量
 8             while(last >= 0 && tmp < arr[last]){            //最后一个元素存在并且要插入的元素比最后一个元素小
 9                 arr[last + 1] = arr[last];                  //将比比较元素大的元素依次向后移动
10                 last--;                                     //最后一个元素向排好序的序列前移动
11             }                                               //跳出循环时就是找到了正确的插入位置                    
12             arr[last + 1] = tmp;                            //前面已经复制完成，直接覆盖存储即可
13         }
14     }
15 }

　　对应的头文件为：

 0 //filename：InsertSort.h
 1 #ifndef InsertSort_h                                                                                                
 2 #define InsertSort_h
 3 
 4 void InsertSort(int arr[], int size);                       
 5         
 6 #endif

　　测试文件为：

 0 //filename：testSort.c
 1 #include <stdio.h>
 2 #include "InsertSort.h"
 3 
 4 int main(int argc, char **argv)
 5 {
 6     int arr[] = {49, 38, 65, 97, 76, 13, 27, 49};
 7     int size = sizeof(arr) / sizeof(int);
 8 
 9     printf("Sort before:\n");
10     for(int i = 0; i < size; i++){
11         printf("%d\t", arr[i]);
12     }
13     printf("\n");
14 
15     printf("Sort after:\n");
16     InsertSort(arr, size);
17     for(int i = 0; i < size; i++){                                                                                  
18         printf("%d\t", arr[i]);
19     }
20     printf("\n");
21 
22     return 0;
23 }

 　　保证几个文件在同一个英文文件夹下面，使用如下命令编译：

　　gcc testSort.c InsertSort.c -o testSort

　　运行程序为:

　　testSort

　　也许有人需要使用下面的命令才能运行：

　　./testSort

　　如果还是不行，就只能上gdb调试神器了，不过对这种小程序就有点牛刀杀鸡了。　　

效率：

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

其他的插入排序有二分插入排序，2-路插入排序。

 2. 插入排序—折半插入排序(二分插入)

将有序数列折半，看看插入到哪个序列中去

[cpp] view plain copy
  1. //折半插入  
  2. void BInsertSort(int a[], int n)    
  3. {    
  4.     for(int i= 1; i<n; i++){    
  5.         int low=0,high=i;  
  6.         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入    
  7.             int x = a[i];        //复制为哨兵，即存储待排序元素    
  8.             a[i] = a[i-1];           //先后移一个元素 (因为a[i]就是X，所以不怕丢失)   
  9.             while(low<=high){  //查找在有序表的插入位置  (遍历表)  
  10.                 int m=(low+high)/2;  
  11.                 if(x<a[m])  high=m-1;  
  12.                 else low=m+1;  
  13.             }    
  14.             for(int j=i-1;j>=high+1;j--)  
  15.                 a[j+1]=a[j];  
  16.             a[j+1] = x;      //插入到正确位置    
  17.         }    
  18.     }    
  19.         
  20. }   
  21. int main()  
  22. {  
  23.     int n;  
  24.     cin>>n;  
  25.     int *a=new int[n];  
  26.     for(int j=0;j<n;j++)  
  27.         cin>>a[j];  
  28.     BInsertSort(a,n);  
  29.     for(int i=0;i<n;i++)  
  30.         cout<<a[i];  
  31.     delete []a;  
  32. }  

 3. 插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

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

操作方法：

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

希尔排序的示例：


算法实现：

 

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

 

[cpp] view plain copy
  1. //希尔排序：去增量为d1的分为一组，共分成d1组分别进行插入排序，然后每组对应元素放在一起，然后取d2...知道d=1  
  2. void ShellSort(int a[],int n)  
  3. {  
  4.     int dk;  
  5.     int tmp;  
  6.     for(dk=n/2;dk>0;dk/=2)  
  7.         for(int i=dk;i<n;i++)  
  8.         {  
  9.             tmp=a[i];  
  10.             for(int j=i;j>=dk;j-=dk)  
  11.                 if(tmp<a[j-dk])  
  12.                     a[j]=a[j-dk];  
  13.                 else break;  
  14.             a[j]=tmp;  
  15.         }  
  16. }  
  17. int main()  
  18. {  
  19.     int n;  
  20.     cin>>n;  
  21.     int *a=new int[n];  
  22.     for(int j=0;j<n;j++)  
  23.         cin>>a[j];  
  24.     ShellSort(a,n);  
  25.     for(int i=0;i<n;i++)  
  26.         cout<<a[i];  
  27.     delete []a;  
  28. }  

 

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。


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

基本思想：

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

简单选择排序的示例：

 

操作方法：

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

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

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。


算法实现：

 

[cpp] view plain copy
  1. //简单选择排序：遍历一次找到最小与第一个元素呼唤位置，再从第二个元素开始遍历找到最小与第二个元素呼唤位置...  
  2. void SelectSort(int a[],int n)  
  3. {  
  4.     for(int i=0;i<n-1;i++)  
  5.     {  
  6.         int k=i;//记录最小的那个下标的  
  7.         for(int j=i+1;j<n;j++)  
  8.             if(a[j]<a[k])  
  9.                 k=j;  
  10.         if(k!=i)  
  11.         {  
  12.             int t=a[i];  
  13.             a[i]=a[k];  
  14.             a[k]=t;  
  15.         }  
  16.   
  17.     }  
  18. }  
  19. int main()  
  20. {  
  21.     int n;  
  22.     cin>>n;  
  23.     int *a=new int[n];  
  24.     for(int j=0;j<n;j++)  
  25.         cin>>a[j];  
  26.     SelectSort(a,n);  
  27.     for(int i=0;i<n;i++)  
  28.         cout<<a[i];  
  29.     delete []a;  
  30. }  

 简单选择排序的改进——二元选择排序（有bug）

参考另一篇：http://blog.csdn.net/ye_scofield/article/details/39312717

简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：

  1. voidintint int for   
  2.   
  3. for if continue if   
  4. }  


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

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足


时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）



初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。


首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：



再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）
                              


                              

 

 算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

 

[cpp] view plain copy
  1. //堆排序:树形选择排序，将带排序记录看成完整的二叉树，第一步：建立初堆，第二步：调整堆  
  2. //第二步：调整堆  
  3. void HeapAdjust(int a[],int s,int n)  
  4. {  
  5.     //调整为小根堆，从小到大  
  6.     int rc=a[s];  
  7.     for(int j=2*s;j<=n;j*=2)  
  8.     {  
  9.         if(j<n && a[j]>a[j+1])//判断左右子数大小  
  10.             j++;  
  11.         if(rc<=a[j])  
  12.             break;  
  13.         a[s]=a[j];  
  14.         s=j;  
  15.     }  
  16.     a[s]=rc;  
  17. }  
  18. //第一步：建初堆  
  19. void CreatHeap(int a[],int n)  
  20. {  
  21.     //小根堆  
  22.     for(int i=n/2;i>0;i--)  
  23.         HeapAdjust(a,i,n);  
  24. }  
  25. //整合  
  26. void HeapSort(int a[],int n)  
  27. {  
  28.     CreatHeap(a,n);//第一步，建立初堆  
  29.     for(int i=n;i>1;i--)  
  30.     {  
  31.         int x=a[1];//堆顶与最后一个元素互换  
  32.         a[1]=a[i];  
  33.         a[i]=x;  
  34.         HeapAdjust(a,1,i-1);  
  35.     }  
  36.   
  37. }  
  38. int main()  
  39. {  
  40.     int n;  
  41.     cin>>n;  
  42.     int *a=new int[n+1];  
  43.     for(int j=1;j<n;j++)//注意：这里是从1开始的  
  44.         cin>>a[j];  
  45.     HeapSort(a,n);  
  46.     for(int i=1;i<n;i++)  
  47.         cout<<a[i];  
  48.     delete []a;  
  49. }  

分析:

设树深度为k，。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。所以，在建好堆后，排序过程中的筛选次数不超过下式： 

                                

而建堆时的比较次数不超过4n 次，因此堆排序最坏情况下，时间复杂度也为：O(nlogn )。

 

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

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

算法的实现：

 

[cpp] view plain copy
  1. //传统冒泡排序  
  2. void maopao(int a[],int n)  
  3. {  
  4.     for(int i=0;i<n-1;i++)  
  5.         for(int j=0;j<n-i-1;j++)  
  6.             if(a[j]>a[j+1])  
  7.             {  
  8.                 int t=a[j];  
  9.                 a[j]=a[j+1];  
  10.                 a[j+1]=t;  
  11.             }  
  12. }  
  13. int main()  
  14. {  
  15.     int n;  
  16.     cin>>n;  
  17.     int *a=new int[n];  
  18.     for(int j=0;j<n;j++)  
  19.         cin>>a[j];  
  20.     maopao(a,n);  
  21.     for(int i=0;i<n;i++)  
  22.         cout<<a[i];  
  23.     delete []a;  
  24. }  

冒泡排序算法的改进

对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

 

[cpp] view plain copy
  1. //冒泡排序改进1，添加标志位，如果某一次排序中出现没有交换位置，说明排序完成  
  2. void maopao(int a[],int n)  
  3. {  
  4.     int flag=0;  
  5.     for(int i=0;i<n-1;i++)  
  6.     {  
  7.         flag=0;  
  8.         for(int j=0;j<n-i-1;j++)  
  9.             if(a[j]>a[j+1])  
  10.             {  
  11.                 int t=a[j];  
  12.                 a[j]=a[j+1];  
  13.                 a[j+1]=t;  
  14.                 flag=1;  
  15.             }  
  16.         if(flag==0)  
  17.             break;  
  18.     }  
  19. }  
  20. int main()  
  21. {  
  22.     int n;  
  23.     cin>>n;  
  24.     int *a=new int[n];  
  25.     for(int j=0;j<n;j++)  
  26.         cin>>a[j];  
  27.     maopao(a,n);  
  28.     for(int i=0;i<n;i++)  
  29.         cout<<a[i];  
  30.     delete []a;  
  31. }  

2．改进后的算法实现为:

 

[cpp] view plain copy
  1. //冒泡排序改进2，添加标志位，记录最后一次交换位置的地方，证明最后一次交换位置之后的地方时排好序的，下一次只需要排最后一次之前的地方就好了  
  2. void maopao(int a[],int n)  
  3. {  
  4.     int flag=n-1;//刚开始，最后交换位置的地方设置为数组的最后一位  
  5.     while(flag>0)//flag在逐渐减小，到最后肯定会变为0  
  6.     {  
  7.         int pos=0;//每一轮的最开始，标志位置在数组0  
  8.         for(int i=0;i<flag;i++)  
  9.             if(a[i]>a[i+1])  
  10.             {  
  11.                 int t=a[i];  
  12.                 a[i]=a[i+1];  
  13.                 a[i+1]=t;  
  14.                 pos=i;  
  15.             }  
  16.         flag=pos;     
  17.     }  
  18. }  
  19. int main()  
  20. {  
  21.     int n;  
  22.     cin>>n;  
  23.     int *a=new int[n];  
  24.     for(int j=0;j<n;j++)  
  25.         cin>>a[j];  
  26.     maopao(a,n);  
  27.     for(int i=0;i<n;i++)  
  28.         cout<<a[i];  
  29.     delete []a;  
  30. }  

3．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的算法实现为:

[cpp] view plain copy
  1. //冒泡改进3，传统冒泡每趟排序遍历一次找到一个最大值或者最小值，如果每趟遍历两次就会找打一个最大值和一个最小值，减少了一半的排序趟数  
  2. void maopao ( int r[], int n){    
  3.     int low = 0;     
  4.     int high= n -1; //设置变量的初始值    
  5.     int tmp,j;    
  6.     while (low < high) {    
  7.         for (j= low; j< high; ++j) //正向冒泡,找到最大者    
  8.             if (r[j]> r[j+1]) {    
  9.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;    
  10.             }     
  11.         --high;                 //修改high值, 前移一位    
  12.         for ( j=high; j>low; --j) //反向冒泡,找到最小者    
  13.             if (r[j]<r[j-1]) {    
  14.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;    
  15.             }    
  16.         ++low;                  //修改low值,后移一位    
  17.     }     
  18. }   
  19. int main()  
  20. {  
  21.     int n;  
  22.     cin>>n;  
  23.     int *a=new int[n];  
  24.     for(int j=0;j<n;j++)  
  25.         cin>>a[j];  
  26.     maopao(a,n);  
  27.     for(int i=0;i<n;i++)  
  28.         cout<<a[i];  
  29.     delete []a;  
  30. }  

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

基本思想：

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

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

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

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

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程


算法的实现：

 递归实现：

 

[cpp] view plain copy
  1. //快速排序   
  2. //第一个参数要排的数组，第二个参数第一个数，第三个参数数组成员个数  
  3. void kuaipai(int array[],int low,int hight)  
  4. {  
  5.     int i,j,t,m;  
  6.     if(low<hight)  
  7.     {  
  8.         i=low;  
  9.         j=hight;  
  10.         t=array[low];//第一个数为轴  
  11.         while(i<j)  
  12.         {  
  13.             while(i<j && array[j]>t)//从右边找出小于轴的数  
  14.                 j--;  
  15.             if(i<j)//将小于轴的数array[j]放到左边array[i]的位置  
  16.             {  
  17.                 m=array[i];  
  18.                 array[i]=array[j];  
  19.                 array[j]=m;  
  20.                 i++;  
  21.             }  
  22.             while(i<j && array[i]<=t)//从左边找出大于轴的数  
  23.                 i++;  
  24.             if(i<j)//将大于轴的数array[i]放在右边array[j]的位置  
  25.             {  
  26.                 m=array[j];  
  27.                 array[j]=array[i];  
  28.                 array[i]=m;  
  29.                 j--;  
  30.             }     
  31.         }  
  32.           
  33.         array[i]=t;//轴放在中间,现在就有两个区域了分别是[0 i-1]和[i+1 hight],分别快排  
  34.         kuaipai(array,0,i-1);  
  35.         kuaipai(array,i+1,hight);  
  36.     }  
  37. }  
  38. void PX_kuaipai(int buf[],int size)  
  39. {  
  40.     kuaipai(buf,0,size-1);  
  41. }  
  42. void main()  
  43. {  
  44.     while(1)  
  45.     {  
  46.         int m,i;  
  47.         cin>>m;  
  48.         int *buf=new int[m];  
  49.         for(i=0;i<m;i++)  
  50.             cin>>buf[i];  
  51.         PX_kuaipai(buf,m);  
  52.         for(i=0;i<m;i++)  
  53.             cout<<buf[i];  
  54.         cout<<'\n';  
  55.         delete []buf;  
  56.     }  
  57.       
  58. }  

分析：

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

 
快速排序的改进

在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下：

参考：http://blog.csdn.net/hguisu/article/details/7776068

  1. voidintint forint voidintint int intintintint int  
  2. while  
  3. while  
  4. while return voidintintintint if  
  5. int  
  6. voidintintint   
  7.   
  8. forint int int while int int ;  
  9. ;  
  10. }  


8. 归并排序（Merge Sort）


基本思想：

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

归并排序示例：

 


合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。

  1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
  2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
  3. //选取r[i]和r[j]较小的存入辅助数组rf
    如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
    否则，rf[k]=r[j]； j++； k++； 转⑵
  4. //将尚未处理完的子表中元素存入rf
    如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
  5. 合并结束。

 

[cpp] view plain copy
  1. //归并排序  
  2. void copyArray(int source[], int dest[],int len,int first)    
  3. {    
  4.     int i;    
  5.     int j=first;    
  6.     for(i=0;i<len;i++)    
  7.     {    
  8.         dest[j] = source[i];    
  9.         j++;    
  10.     }    
  11.             
  12. }   
  13. //相邻两个有序子序列的归并函数，将a[low...mid]和a[mid+1...high]归并到T[LOW..high]中   
  14. void merge(int a[],int left,int right)    
  15. {    
  16.     int begin1 = left;    
  17.     int mid = (left+right)/2 ;    
  18.     int begin2 = mid+1;    
  19.     int k=0;    
  20.     int newArrayLen = right-left+1;    
  21.     int *b = (int*)malloc(newArrayLen*sizeof(int));    
  22.     while(begin1<=mid && begin2<=right)    
  23.     {    
  24.         if(a[begin1]<=a[begin2])    
  25.             b[k++] = a[begin1++];    
  26.         else    
  27.             b[k++] = a[begin2++];    
  28.     }    
  29.     while(begin1<=mid)    
  30.         b[k++] = a[begin1++];    
  31.     while(begin2<=right)    
  32.         b[k++] = a[begin2++];    
  33.     copyArray(b,a,newArrayLen,left);    
  34.     free(b);    
  35. }    


两路归并的递归算法

 

[cpp] view plain copy
  1. //归并函数,将a[low...high]归并到T[low...high]中  
  2. void mergeSort(int a[],int left,int right)    
  3. {    
  4.     int i;    
  5.     // 保证至少有两个元素    
  6.     if(left < right)    
  7.     {    
  8.         i = (left+right)/2;    
  9.         mergeSort(a,left,i);    
  10.         mergeSort(a,i+1,right);    
  11.         merge(a,left,right);    
  12.     }    
  13. }   
  14. void MergeSort(int a[],int n)  
  15. {  
  16.     mergeSort(a,0,n-1);  
  17. }  


完整程序

 

[cpp] view plain copy
  1. //归并排序  
  2. void copyArray(int source[], int dest[],int len,int first)    
  3. {    
  4.     int i;    
  5.     int j=first;    
  6.     for(i=0;i<len;i++)    
  7.     {    
  8.         dest[j] = source[i];    
  9.         j++;    
  10.     }    
  11.             
  12. }   
  13. //相邻两个有序子序列的归并函数，将a[low...mid]和a[mid+1...high]归并到T[LOW..high]中   
  14. void merge(int a[],int left,int right)    
  15. {    
  16.     int begin1 = left;    
  17.     int mid = (left+right)/2 ;    
  18.     int begin2 = mid+1;    
  19.     int k=0;    
  20.     int newArrayLen = right-left+1;    
  21.     int *b = (int*)malloc(newArrayLen*sizeof(int));    
  22.     while(begin1<=mid && begin2<=right)    
  23.     {    
  24.         if(a[begin1]<=a[begin2])    
  25.             b[k++] = a[begin1++];    
  26.         else    
  27.             b[k++] = a[begin2++];    
  28.     }    
  29.     while(begin1<=mid)    
  30.         b[k++] = a[begin1++];    
  31.     while(begin2<=right)    
  32.         b[k++] = a[begin2++];    
  33.     copyArray(b,a,newArrayLen,left);    
  34.     free(b);    
  35. }    
  36. //归并函数,将a[low...high]归并到T[low...high]中  
  37. void mergeSort(int a[],int left,int right)    
  38. {    
  39.     int i;    
  40.     // 保证至少有两个元素    
  41.     if(left < right)    
  42.     {    
  43.         i = (left+right)/2;    
  44.         mergeSort(a,left,i);    
  45.         mergeSort(a,i+1,right);    
  46.         merge(a,left,right);    
  47.     }    
  48. }   
  49. void MergeSort(int a[],int n)  
  50. {  
  51.     mergeSort(a,0,n-1);  
  52. }  
  53. int main()  
  54. {  
  55.     int n;  
  56.     cin>>n;  
  57.     int *a=new int[n];  
  58.       
  59.     for(int j=0;j<n;j++)  
  60.         cin>>a[j];  
  61.     MergeSort(a,n);  
  62.     for(int i=0;i<n;i++)  
  63.         cout<<a[i];  
  64.     delete []a;  
  65.       
  66. }  



9. 桶排序/基数排序(Radix Sort)

说基数排序之前，我们先说桶排序：

基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
         简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

 

 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

 首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

  然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

  最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

  假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

  对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

  当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

        前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

        2）其次待排序的元素都要在一定的范围内等等。

       桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。


分配排序的基本思想： 基数排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

实例:

扑克牌中52 张牌，可按花色和面值分成两个字段，其大小关系为：
花色： 梅花< 方块< 红心< 黑心  
面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序，得到如下序列：


即两张牌，若花色不同，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色情况下，大小关系才由面值的大小确定。这就是多关键码排序。

为得到排序结果，我们讨论两种排序方法。
方法1：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序，最后，将4 个组连接起来即可。
方法2：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，然后，将4 个花色组依次连接起来即可。

设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系：

                                                               

其中k1 称为最主位关键码，kd 称为最次位关键码     。

 

两种多关键码排序方法：

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

最高位优先(Most Significant Digit first)法，简称MSD 法：

1）先按k1 排序分组，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。

2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。

最低位优先(Least Significant Digit first)法，简称LSD 法：

1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。

2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。


基于LSD方法的链式基数排序的基本思想

　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

算法实现：

  1. int int   
  2. while  
  3. forint  
  4. if else   
  5.   
  6. }  






 

总结

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

 我们比较时间复杂度函数的情况：



                             时间复杂度函数O(n)的增长情况


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


时间复杂度来说：

(1)平方阶(O(n2))排序
　　各类简单排序:直接插入、直接选择和冒泡排序；
 (2)线性对数阶(O(nlog2n))排序
　　快速排序、堆排序和归并排序；
 (3)O(n1+§))排序,§是介于0和1之间的常数。

       希尔排序
(4)线性阶(O(n))排序
　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。 
     稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则：

每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

1．待排序的记录数目n的大小；

2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

3．关键字的结构及其分布情况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
       堆排序 ：  如果内存空间允许且要求稳定性的，

       归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
　　1、关键字可分解。
　　2、记录的关键字位数较少，如果密集更好
　　3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。

posted @ 2017-07-01 07:24  叕叒双又  阅读(1162)  评论(0)  编辑  收藏  举报