归并排序

　　归并排序（这里主要介绍二路归并）的基本思想是：将排序文件看成为 n 个长度为 1 的有序子文件，把这次子文件两两归并（二路归并），使得到 [n/2] 个长度为 2 的 有序子文件； 然后再把这[n/2] 个有序文件的子文件两两归并，如此反复，直到最后得到一个长度为 n的有序文件为止， 这种排序方法称为二路归并排序。

　　通过一个案例来说明其具体流程， 假设序列 为 ： 125 11 22 34 15 44 76 66 100 8 14 20 2 5 1   共 15 个元素

　　　　初始状态：　　[125]  [11]  [22]  [34]  [15]  [44]  [76]  [66]  [100]  [8]  [14]  [20]  [2]  [5]  [1]     初始每个元素看作是一个组，共 15 组

　　　　一轮归并：      [11 125]  [22 34]  [15 44]  [66 76]  [8 100]  [14 20]  [2 5]  [1]　　两两归并，落单的单独作为一组， 共 8 组

　　　　二轮归并：　　[11 22 34 125]  [15 44 66 76]  [8 14 20 100] [1 2 5]　　两两归并，共 4 组

　　　　三轮归并：　　[11 15 22 34 44 66 76 125]   [1 2 5 8 14 20 100]       两两归并，共 2 组

　　　　四轮归并：　　[1 2 5 8 11 14 15 20 22 34 44 66 76 100 125]　　两两归并，共 1 组，归并完成

　　二路归并排序中的核心操作时将数组中前后相邻的两个有序序列归并为一个有序序列。在实现过程中需要引入另外一个数组用于存放归并好的结果。

　　参考代码：

　　

#include <stdio.h>

#define MAX_NUM 80


void Merge(int* a, int * b, int low, int m,int high)
{
    int i = low;
    int j = m+1;
    int k = low;
    
    while(i <= m && j <= high)
    {
        if(a[i] < a[j])        
            b[k++]= a[i++];
        else
            b[k++] = a[j++];
    }
            
    while(i <= m)
        b[k++] = a[i++];
            
    while(j <= high)
        b[k++] = a[j++];            
    
    for( i = low; i <= high;i++)
    {
        printf("%d ",b[i]);
    } 
    printf("  ");    
    
    
}
void MergePass(int* a, int* b, int len, int n)
{
    int i;
    for(i = 0; i+2*len-1 < n; i = i+ 2*len)    
        Merge(a,b,i,i+len-1,i+2*len-1);

    if(i+len -1 < n)  // 如果还有两个子文件，其中最后一个长度小于len 
        Merge(a,b,i,i+len-1,n-1);
    else
    {
        for(int j = i; j <n; j++)
            b[j] = a[j];    
    }
    
    printf("
");    
}


void mergesort(int* a, int* b,int n)
{
    int len = 1;
    
    while(len < n)
    {
        MergePass(a,b,len,n);
        len =  len * 2;
        MergePass(b,a,len,n);
        len = len * 2;
    }
}

int main(int argc, char* argv[])
{
    int a[MAX_NUM];
    int b[MAX_NUM];
    int n;    

    printf("Input total numbers: ");
    scanf("%d",&n);

    if( n > MAX_NUM ) n = MAX_NUM;
    
    for(int i = 0; i < n;i++)
    {
        scanf("%d",&a[i]);
        b[i] = a[i];
    }

    printf("归并步骤：
");
    mergesort(a,b,n);
    
    printf("归并排序后的结果：
");
    for(int i = 0; i < n;i++)
    {
        printf("%d ",a[i]);
    } 
    printf("

");    
    
    return 0;
} 

　　案例运行结果：

　　　　

　　　归并排序算法的效率与稳定性分析

　　　二路归并排序的过程需要进行[log n] 趟， 每一轮归并排序的操作就是讲两个有序子文件惊醒归并，而每一对有序子文件归并时，记录的比较次数均小于或等于记录的移动次数，记录移动次数均等于文件中记录的个数，每一轮归并的时间复杂度为O(n)。因此，二路归并排序的时间复杂度为O(n log n)。

　　

　　　二路归并排序时稳定的，因为在每两个有序子文件归并是，若分别在两个有序子文件中出现有相同关键字的记录Merge 算法能够使前一个子文件中同一个关键字的记录先复制，后一个文件中的同一关键字的记录被后复制，从而确保了它们的相对次序不会改变。

　　注：主要参考彭军、向毅主编的 《数据结构与算法》