本文探讨的是2-路归并排序的算法，在空间复杂度上，需要与待排记录等数量的辅助空间；时间复杂度上，为O(nlogn)。相比较于快速排序与堆排序而言，归并排序的最大特点就是，它是一种稳定的排序算法。书上给出了其递归算法的实现，本人就自己写的非递归版本，在效率与优化上做一点比较。
递归版本
首先先给出递归版本的实现，编译环境：VS2012
统一定义的头文件：
/* c10-1.h 待排记录的数据类型 */
#define MAXSIZE 20 /* 一个用作示例的小顺序表的最大长度 */
typedef int KeyType; /* 定义关键字类型为整型 */
typedef struct
{
KeyType key; /* 关键字项 */
InfoType otherinfo; /* 其它数据项，具体类型在主程中定义 */
}RedType; /* 记录类型 */
typedef struct
{
RedType r[MAXSIZE+1]; /* r[0]闲置或用作哨兵单元 */
int length; /* 顺序表长度 */
}SqList; /* 顺序表类型 */
然后再给出具体的实现，附上测试：将10个关键字的记录重复测试排序一千万次，计算所需时间
/* alg10-10.c 归并排序 */ #pragma warning(disable: 4996) #include<stdio.h> #include <conio.h> typedef int InfoType; /* 定义其它数据项的类型 */ #include "C10-1.h" #include "time.h" /* c9.h 对两个数值型关键字的比较约定为如下的宏定义 */ #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)<=(b)) void Merge(RedType SR[],RedType TR[],int i,int m,int n) { /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12 */ int j,k,l; for(j=m+1,k=i;i<=m&&j<=n;++k) /* 将SR中记录由小到大地并入TR */ if LQ(SR[i].key,SR[j].key) TR[k]=SR[i++]; else TR[k]=SR[j++]; if(i<=m) for(l=0;l<=m-i;l++) TR[k+l]=SR[i+l]; /* 将剩余的SR[i..m]复制到TR */ if(j<=n) for(l=0;l<=n-j;l++) TR[k+l]=SR[j+l]; /* 将剩余的SR[j..n]复制到TR */ } void MSort(RedType SR[],RedType TR1[],int s, int t) { /* 将SR[s..t]归并排序为TR1[s..t]。算法10.13 */ int m; RedType TR2[MAXSIZE+1]; if(s==t) TR1[s]=SR[s]; else { m=(s+t)/2; /* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */ MSort(SR,TR2,s,m); /* 递归地将SR[s..m]归并为有序的TR2[s..m] */ MSort(SR,TR2,m+1,t); /* 递归地将SR[m+1..t]归并为有序的TR2[m+1..t] */ Merge(TR2,TR1,s,m,t); /* 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] */ } } void MergeSort(SqList *L) { /* 对顺序表L作归并排序。算法10.14 */ MSort((*L).r,(*L).r,1,(*L).length); } void print(SqList L) { int i; for(i=1;i<=L.length;i++) printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo); printf("\n"); } #define N 10 void main() { RedType d[N]={{49,1},{38,2},{97,3},{32,4},{76,5},{13,6},{12,7},{2,8},{3,9},{45,10}}; SqList l; int i,t; clock_t a,b; double c; loop: for(i=0;i<N;i++) l.r[i+1]=d[i]; l.length=N; printf("排序前:\n"); print(l); a=clock(); /*测试用时*/ for(i=0;i<10000000;i++) { for(t=0;t<N;t++) l.r[t+1]=d[t]; MergeSort(&l); } b=clock(); c=(double)(b-a)/1000; printf("用时为%f秒,%d,%d\n",c,a,b); printf("排序后:\n"); print(l); while(1) { printf("是否继续(y/n)："); if((t=getche(),printf("\n\n"),t)=='y') goto loop; if(t=='n') break; } }
在debug版本上，所需时间大约为15.0s，但在release版优化后，就只需2.74s
非递归版本
下面就晒出自己的非递归版本，由于代码写的实在垃圾，无论是debug，还是release都毫无优势，就不做具体分析了，读者自行查看
/* alg10-10.c 归并排序（非递归版） */ #pragma warning(disable: 4996) #include <stdio.h> #include <conio.h> #include <malloc.h> typedef int InfoType; /* 定义其它数据项的类型 */ #include "C10-1.h" #include "time.h" #define N 10 /* c9.h 对两个数值型关键字的比较约定为如下的宏定义 */ #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)<=(b)) void Merge(RedType SR[],RedType TR[],int i,int m,int n) { /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12 */ int j,k,l; for(j=m+1,k=i;i<=m&&j<=n;++k) /* 将SR中记录由小到大地并入TR */ if LQ(SR[i].key,SR[j].key) TR[k]=SR[i++]; else TR[k]=SR[j++]; if(i<=m) for(l=0;l<=m-i;l++) TR[k+l]=SR[i+l]; /* 将剩余的SR[i..m]复制到TR */ if(j<=n) for(l=0;l<=n-j;l++) TR[k+l]=SR[j+l]; /* 将剩余的SR[j..n]复制到TR */ } int twopow(int i) //此处算2的幂 { int j=1; for(;i>0;i--) j*=2; return j; } void MergeSort(SqList *L) { /* 对顺序表L作归并排序。算法10.14 */ // MSort((*L).r,(*L).r,1,(*L).length); int i,j,k; SqList *L1=(SqList *)malloc(sizeof(SqList)); L1->length=N; for(i=1;i<=N;i++) L1->r[i]=L->r[i]; for(j=1;k=twopow(j-1),(L->length)/k>=1;j++) //确定归并的次数 { for(i=1;(i+k)<=L->length;i+=k*2) { if((i+k)==L->length||i+2*k-1>=L->length) { Merge(L->r,L1->r,i,i+k-1,L->length); continue; } Merge(L->r,L1->r,i,i+k-1,i+2*k-1); } for(i=1;i<=N;i++) L->r[i]=L1->r[i]; } free(L1); } void print(SqList L) { int i; for(i=1;i<=L.length;i++) printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo); printf("\n"); } void main() { RedType d[N]={{49,1},{38,2},{97,3},{32,4},{76,5},{13,6},{12,7},{2,8},{3,9},{45,10}}; SqList l; int i,t; clock_t a,b; double c; loop: for(i=0;i<N;i++) l.r[i+1]=d[i]; l.length=N; printf("排序前:\n"); print(l); a=clock(); /*测试用时*/ //for(i=0;i<10000000;i++) for(i=0;i<10000000;i++) { for(t=0;t<N;t++) l.r[t+1]=d[t]; MergeSort(&l); } b=clock(); c=(double)(b-a)/1000; printf("用时为%f秒,%d,%d\n",c,a,b); printf("排序后:\n"); print(l); while(1) { printf("是否继续(y/n)："); if((t=getche(),printf("\n\n"),t)=='y') goto loop; if(t=='n') break; } }
下面就上面的代码，做一下彻底优化，把一些没必要的冗余计算，比如要算出具体的归并趟数，重复的赋值操作给去掉，得到相对高效的代码
/* alg10-10.c 归并排序（非递归版2） */ #pragma warning(disable: 4996) #include <stdio.h> #include <conio.h> #include <malloc.h> typedef int InfoType; /* 定义其它数据项的类型 */ #include "C10-1.h" #include "time.h" #define N 10 /* c9.h 对两个数值型关键字的比较约定为如下的宏定义 */ #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)<=(b)) void Merge(RedType SR[],RedType TR[],int i,int m,int n) { /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12 */ int j,k,l; /*int i0=i;*/ for(j=m+1,k=i;i<=m&&j<=n;++k) /* 将SR中记录由小到大地并入TR */ if LQ(SR[i].key,SR[j].key) TR[k]=SR[i++]; else TR[k]=SR[j++]; if(i<=m) for(l=0;l<=m-i;l++) TR[k+l]=SR[i+l]; /* 将剩余的SR[i..m]复制到TR */ //if(j<=n) // for(l=0;l<=n-j;l++) // TR[k+l]=SR[j+l]; /* 将剩余的SR[j..n]复制到TR */ /*for(l=i0;l<=j;l++) SR[l]=TR[l];*/ } void MergeSort(SqList *L) { int step = 1,i,right; int j; SqList *L1=(SqList *)malloc(sizeof(SqList)); L1->length=N; for(i=1;i<=N;i++) L1->r[i]=L->r[i]; while(step < N) { for(i = 1; i +step<= N; i += 2*step) { if(i+step-1 == N||i+2*step-1>=N) right = N; else right = i+step*2-1; Merge(L->r,L1->r , i, i+step-1, right); for(j=i;j<=right;j++) L->r[j]=L1->r[j]; } step *= 2; } free(L1); } void print(SqList L) { int i; for(i=1;i<=L.length;i++) printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo); printf("\n"); } void main() { RedType d[N]={{49,1},{38,2},{97,3},{32,4},{76,5},{13,6},{12,7},{2,8},{3,9},{45,10}}; SqList l; int i,t; clock_t a,b; double c; loop: for(i=0;i<N;i++) l.r[i+1]=d[i]; l.length=N; printf("排序前:\n"); print(l); a=clock(); /*测试用时*/ for(i=0;i<10000000;i++) { for(t=0;t<N;t++) l.r[t+1]=d[t]; MergeSort(&l); } b=clock(); c=(double)(b-a)/1000; printf("用时为%f秒,%d,%d\n",c,a,b); printf("排序后:\n"); print(l); while(1) { printf("是否继续(y/n)："); if((t=getche(),printf("\n\n"),t)=='y') goto loop; if(t=='n') break; } }
测试结果如下：
显然，Debug版本的效率要比递归版本的要快，但Release版本优化后的效率还是没有递归版的优化效果好。显然在某些时候，递归形式的写法，虽然理解上费劲，（其实数学归纳法学的好，写正确的递归代码并非难事），实用性较差，很多人为了代码的可读性，都不建议写递归形式，虽然形式上简洁。甚至在一般情况下，递归的写法，会因为频繁的入栈出栈而损耗效率。可是事实也许并非如此，编译器对递归函数的优化，有时候明显要比一般的非递归算法要强。