对归并排序的优化和思考

算法导论的课后习题中有这样一道题目（Problems 2-1）：

即当n的个数较小时，插入排序的速度是要优于归并排序的。原因是：插入排序的时间复杂度是n的平方，即C1n^2；而归并排序的时间复杂度是nlgn，即C2nlgn；当n较小时，由于C1和C2关系，使得插入排序的速度可以比归并排序的速度快。正是利用了这个性质，可以对归并排序的算法进行一下优化。

方法一就是题中所说的，将大小为n的数组分成n/k个大小为k的子数组，对每个大小为k的子数组进行插入排序；然后再合并这n/k个已经排好序的子数组。一种实现的代码如下：

//merge n sub-arrays of size k void merge_n(int *array, int n, int k) { int n_sub,left; if(n>2){ n_sub = n>>1; left = n%2; merge_n(array,n_sub,k);//merge first n/2 sub-arrays merge_n(&array[k*n_sub],n_sub,k);//merge second n/2 sub-arrays merge(array,0,n_sub*k-1,n_sub*k*2-1);//merge together if(left)//maybe left one sub-array when n is odd merge(array,0,n_sub*k*2-1,n*k-1); } else if(n==2) merge(array,0,k-1,2*k-1); else if(n==1) ; } #define K 12 void merge_insert_sort(int *array, int p, int r)//p:first element index, r:last element index { int i,n,n_sub,left; n = r-p+1; n_sub = n/K; //divide array to sub-array of size K, total n_sub sub-arrays left = n%K; //maybe left some elements; for(i=0;i<n_sub;i++) insert_sort(&array[p+i*K],K); if(left){ insert_sort(&array[p+i*K],left); left = p+i*K; //index of first left element } merge_n(&array[p],n_sub,K); if(left) merge(array,p,left-1,r); } #undef K <br/>

方法二是我在看到题目之后就想到的，也是比较直观的：即还是按照原来的分治法的思路，不断二分；不过最终停止二分时，子数组的大小不再是1，而是大一些的一个常数K。然后对这大小为K的子数组做插入排序。一种实现的代码如下：

#define K 32 void merge_sort_modified(int *array, int p, int r) { int q; if(p>=r) return; if(r-p+1<=K){ insert_sort(&array[p],r-p+1); return; } q = (p+r)>>1; merge_sort_modified(array,p,q); merge_sort_modified(array,q+1,r); merge(array,p,q,r); } #undef K <br/>

这两种方法的性能，比原始的二分法都有较大程度的提高。我在本机上实验的结果为：当数组个数为100000000（即1亿个数据）时，采用原始的二分法需要的时间大约是70秒，而另外两种方法在选取合适的K值的条件下（方法一的k值取12，方法二的k值取32），都能达到30秒左右的时间，速度提高了一倍多！这是出乎我的意料意外的。

可见，每个算法所适用的情景是不同的；并不是说时间复杂度低的算法在任何时候的表现都好，有时候“混搭”着来，反而会有意想不到的效果。

附上原始的归并排序和插入排序的源代码:

void insert_sort(int *array, int size)
{
    int i,j,tmp;

    for(i=1;i<size;i++){
        j = i-1;
        tmp = array[i];
        while((j>=0) && (tmp<array[j])){
            array[j+1] = array[j];
            j--;
        }
        array[++j] = tmp;
    }
}

void merge(int *array, int p, int q, int r)
{
    int n1,n2,i=0,j=0,k=0;
    int *a,*b;

    n1 = q-p+1;
    n2 = r-q;
    a = (int *)malloc(sizeof(int)*n1);
    if(!a){
        printf("EXIT:NOMEM\n");
        return;
    }

    b = (int *)malloc(sizeof(int)*n2);
    if(!b){
        printf("EXIT:NOMEM\n");
        return;
    }

    memcpy(a,&array[p],n1*sizeof(int));
    memcpy(b,&array[q+1],n2*sizeof(int));

    i=p;
    j=k=0;
    while(i<=r && j<n1 && k<n2){
        if(a[j]<=b[k])
            array[i++] = a[j++];
        else
            array[i++] = b[k++];
    }

    if(i<=r){
        if(j<n1)
            memcpy(&array[i],&a[j],(n1-j)*sizeof(int));
        else
            memcpy(&array[i],&b[k],(n2-k)*sizeof(int));
    }

    free(a);
    free(b);
}

void merge_sort(int *array, int p, int r)
{
    int q;

    if(p<r){
        q = (p+r)>>1;
        merge_sort(array,p,q);
        merge_sort(array,q+1,r);
        merge(array,p,q,r);
    }
}