内部排序->归并排序->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+];
     //顺序表中待排序的结点个数
     int length;
 }SqList;

 //依次打印顺序表中结点的信息
 void PrintList(SqList L){
     int i = ;
     printf("下标值：");
     for(i=; i<=L.length; i++){
         printf("[%d] ", i);
     }
     printf("\n关键字：");
     for(i=; i<=L.length; i++){
         if(EQ(L.r[i].key, INF)){
             printf(" %-3c", '-');
         }else{
             printf(" %-3d", L.r[i].key);
         }
     }
     printf("\n其他值：");
     for(i=; i<=L.length; i++){
         printf(" %-3c", L.r[i].otherinfo);
     }
     printf("\n\n");
     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 = , k =;
     //将SR中记录由小到大地归并到TR
     for(j=m+, 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)/;
         RedType TR2[MAXSIZE+];
         //递归地将SR[s,...,m]归并为有序的TR2[s,...,m]
         MSort(SR, TR2, s, m);
         //递归地将SR[m+1,...,t]归并为有序的TR2[m+1,...,t]
         MSort(SR, TR2, m+, 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, , L->length);
 #ifdef DEBUG
     printf("对该数据作2-路归并排序后：\n");
     PrintList(*L);
 #endif
 }

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

2-路归并排序

运行