内部排序->归并排序->2-路归并排序

文字描述

　　假设初始序列有n个记录，则可看成是n个有序的字序列，每个字序列的长度为1，然后两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并，…, 如此重复，直到得到一个长度为n的有序序列为止，这种排序方法称为2-路归并排序。

示意图

算法分析

　　2-路归并排序的时间复杂度为nlogn；

　　2-路归并排序需要至少同待排序序列同等大小的辅助空间；

　　与快速排序和堆排序相比，归并排序最大特点就是，它是一种稳定的排序方法。

　　在一般情况下，2-路归并排序，尤其是递归形式的，很少在内部排序中使用，一般用于外部排序，因为反复的自身函数的调用，容易引起栈溢出。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*
 * double log2(double x);    以2为底的对数
 * double ceil(double x);    取上整
 * double floor(double x);    取下整
 * double fabs(double x);    取绝对值
 */

#define DEBUG

#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) <  (b))
#define LQ(a, b) ((a) <= (b))

//定义顺序表中结点个数的最大值
#define MAXSIZE  100
//定义无穷大INF的值
#define INF         1000000

//定义结点中的关键字类型为int
typedef int KeyType;
//定义结点中除关键字外的附件信息为int
typedef char InfoType;

//待排序的结点的结构体
typedef struct{
    //结点中的关键字
    KeyType key;
    //结点中的除关键字外的附加信息
    InfoType otherinfo;
}RedType;

//顺序表的结构体
typedef struct{
    //顺序表中待排序的结点
    RedType r[MAXSIZE+1];
    //顺序表中待排序的结点个数
    int length;
}SqList;

//依次打印顺序表中结点的信息
void PrintList(SqList L){
    int i = 0;
    printf("下标值：");
    for(i=0; i<=L.length; i++){
        printf("[%d] ", i);
    }
    printf("
关键字：");
    for(i=0; i<=L.length; i++){
        if(EQ(L.r[i].key, INF)){
            printf(" %-3c", '-');
        }else{
            printf(" %-3d", L.r[i].key);
        }
    }
    printf("
其他值：");
    for(i=0; i<=L.length; i++){
        printf(" %-3c", L.r[i].otherinfo);
    }
    printf("

");
    return ;
}

//将有序的SR[i,...,m]和SR[m+1,...,n]归并为有序的TR[i,...,n]
void Merge(RedType SR[], RedType TR[], int i, int m, int n)
{
    int j = 0, k =0;
    //将SR中记录由小到大地归并到TR
    for(j=m+1, k=i; i<=m && j<=n; ++k){
        if(LQ(SR[i].key, SR[j].key)){
            TR[k] = SR[i++];
        }else{
            TR[k] = SR[j++];
        }
    }
    //将剩余的SR[i,...,m]复制到TR
    for(; i<=m; i++){
        TR[k++] = SR[i];
    }
    //将剩余的SR[j,...,n]复制到TR
    for(; j<=n; j++){
        TR[k++] = SR[j];
    }
}

//将SR[s,...,t]归并排序为TR1[s,...,t]
void MSort(RedType SR[], RedType TR1[], int s, int t)
{
    if(s == t){
        TR1[s] = SR[s];
    }else{
        //将SR[s,...,t]平分为SR[s,...,m]和SR[m+1,...,t]
        int m = (s+t)/2;
        RedType TR2[MAXSIZE+1];
        //递归地将SR[s,...,m]归并为有序的TR2[s,...,m]
        MSort(SR, TR2, s, m);
        //递归地将SR[m+1,...,t]归并为有序的TR2[m+1,...,t]
        MSort(SR, TR2, m+1, t);
        //将TR2[s,...,m]和TR2[m+1,...,t]归并到TR1[s,...,t]
        Merge(TR2, TR1, s, m, t);
    }
}

//对顺序表L作2-路归并排序
void MergeSort(SqList *L)
{
    MSort(L->r, L->r, 1, L->length);
#ifdef DEBUG
    printf("对该数据作2-路归并排序后：
");
    PrintList(*L);
#endif
}

int  main(int argc, char *argv[])
{
    if(argc < 2){
        return -1;
    }
    SqList L;
    int i = 0;
    for(i=1; i<argc; i++){
        if(i>MAXSIZE)
            break;
        L.r[i].key = atoi(argv[i]);
        L.r[i].otherinfo = 'a'+i-1;
    }
    L.length = (i-1);
    L.r[0].key = 0;
    L.r[0].otherinfo = '0';
    printf("输入数据:
");
    PrintList(L);
    //对顺序表L最2-路归并排序
    MergeSort(&L);
    return 0;
}

运行