归并排序算法-C++

转自 http://blog.csdn.net/left_la/article/details/8656953

在看 归并排序，感觉这哥们也写很好，就转载过来，只不过他没有加注释，我这里注释一下

归并排序是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。常见的归并排序有两路归并排序（Merge Sort），多相归并排序（Polyphase Merge Sort），Strand排序（Strand Sort）。下面介绍第一种：

（一）两路归并排序

最差时间复杂度：O(nlogn)
平均时间复杂度：O(nlogn)
最差空间复杂度：O(n)
稳定性：稳定

两路归并排序（Merge Sort），也就是我们常说的归并排序，也叫合并排序。它是建立在归并操作上的一种有效的排序算法，归并操作即将两个已经排序的序列合并成一个序列的操作。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
归并操作的基本步骤如下：
1.申请两个与已经排序序列相同大小的空间，并将两个序列拷贝其中；
2.设定最初位置分别为两个已经拷贝排序序列的起始位置，比较两个序列元素的大小，依次选择相对小的元素放到原始序列；
3.重复2直到某一拷贝序列全部放入原始序列，将另一个序列剩下的所有元素直接复制到原始序列尾。

设归并排序的当前区间是R[low..high]，分治法的三个步骤是：
1.分解：将当前区间一分为二，即求分裂点
2.求解：递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序；
3.组合：将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。
递归的终结条件：子区间长度为1（一个记录自然有序）。

算法示意图：

代码实现：

[cpp]  view plain  copy

1. void Merge(int *a, int p, int q, int r)  //p,q,r依次是 头指针、中间指针、尾指针
2. {  
3.     int n1 = q-p+1;  //n1为要动态分配的左数组的大小
4.     int n2 = r-q;  //n2为要动态分配的右数组的大小
5.     int *L = new int[n1+1];   //在栈中动态分配大小为n+1大小的内存空间 其中n+1最后的L[n]设为无穷大，
6.                               //作为结束标志
7.     int *R = new int[n2+1];  
8.     int i, j, k;  
9.       
10.     for (i=0; i<n1; i++){  
11.         L[i] = a[p+i];  //将原始数组中前半部分的数据 复制到L[]中  
12.     }  
13.     for (j=0; j<n2; j++){  
14.         R[j] = a[q+j+1];  /将原始数组中后半部分的数据 复制到R[]中 
15.     }  
16.     L[n1] = 10000000;  //作为结束标志，注意int的范围
17.     R[n2] = 10000000;  
18.   
19.     for (i=0, j=0, k=p; k<=r; k++)  // i j k分别是 L[], R[],a[]的下标索引
20.     {  
21.         if (L[i]<=R[j])  
22.         {  
23.             a[k] = L[i];  
24.             i++;  
25.         }else{  
26.             a[k] = R[j];  
27.             j++;  
28.         }  
29.     }  
30.   
31.     delete []L;  //为了防止内存泄露，new后 要delete
32.     delete []R;  
33. }  
34.   
35. void MergeSort1(int *a, int p, int r)   //a是要排序的数组，p是头指针，r是尾指针
36. {  
37.     if (p<r)  //递归终止条件
38.     {  
39.         int q = (p+r)/2;    //要排序的数组 的中间 指针 
40.         MergeSort1(a, p, q);  //左序列递归分解
41.         MergeSort1(a, q+1, r);  //右序列递归分解
42.         Merge(a, p, q, r);    //进行组合
43.     }  
44. }  

虽然 插入排序 的时间复杂度为O(n^2)，归并排序的时间复杂度为O(nlogn)，但插入排序中的常数因子使得它在n较小时，运行得要更快一些。因此，在归并排序算法中，当子问题足够小时，采用插入排序算法就比较合适了。

代码实现：

[cpp]  view plain  copy

1. void MergeSort2(int *a, int p, int r)  
2. {  
3.     if ((r-p)>=50) // 小于50个数据的数组进行插入排序  
4.     {  
5.         int q = (p+r)/2;  
6.         MergeSort2(a, p, q);  
7.         MergeSort2(a, q+1, r);  
8.         Merge(a, p, q, r);  
9.     }else  
10.     {  
11.         InsertionSort(a+p, r-p+1);  
12.     }  
13. }  

MergeSort1与MergeSort2算法排序时间实验结果比较：

数据量	1K	10K	100K	1000K	10000K
MergeSort1	0.001s	0.008s	0.065s	0.552s	5.875s
MergeSort2	<0.001s	0.001s	0.021s	0.219s	2.317s