归并排序

对《大话数据结构》P406~P416—归并排序，进行了自己的理解并完善了代码。

一、递归实现归并排序

代码和解释如下（VS2012测试通过）：

#include <iostream>
using namespace std;
#define MAXSIZE 9//用于要排序数组个数最大值，可根据需要修改

//排序用的顺序表结构
typedef struct
{
    int r[MAXSIZE+1];//定义一个数组，用于存储要排序的数，r[0]作为临时变量
    int length;//用于记录顺序表的长度
}SqList;

//排序表的初始化
SqList *InitSqList(SqList *L)
{
    L=new SqList;
    L->length=MAXSIZE;//本例中长度是9
    cout<<"input list"<<endl;
    for(int i=1;i<=L->length;i++)
        cin>>L->r[i];
    return L;
}

//数组遍历输出
void PrintSqList(SqList *L)
{
    for(int i=1;i<=L->length;i++)
        cout<<L->r[i]<<" ";
    cout<<endl;
}

//交换r[i]和r[j]
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//数组遍历输出
void Print(int *R)
{
    for(int num=1;num<=MAXSIZE;num++)
        cout<<R[num]<<" ";
    cout<<endl;
}

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

//递归法，将SR[s..t]归并排序为TR[s..t]
void MSort(int SR[],int TR[],int s, int t)
{
    int m;
    int temp[MAXSIZE+1];//用来存储归并前的二路，分为temp[s..m]和temp[m+1..t]，m=(s+t)/2
    if(s==t)
        TR[s]=SR[s];//最极端的情况，也是递归的终止情况，子序列长度为1
    else
    {
        m=(s+t)/2;//将元素的序列SR[s..t]平分为两部分，SR[s..m]和SR[m+1..t]
        MSort(SR,temp,s,m);//递归，将前半部分SR[s..m]归并为有序的temp[s..m]，递归至子序列长度为1
        cout<<"temp1:";Print(temp);
        MSort(SR,temp,m+1,t);//递归，将后半部分SR[m+1..t]归并为有序的temp[m+1..t]，递归至子序列长度为1
        cout<<"temp2:";Print(temp);
        Merge(temp,TR,s,m,t);//将有序的temp[s..m]和有序的temp[m+1..t]，归并到TR[s..t]
        cout<<"temp3:";Print(temp);
        cout<<"TR:";Print(TR);
    }
}

//对顺序表L作归并排序 
void MergeSort(SqList *L)
{ 
     MSort(L->r,L->r,1,L->length);
}

int main()
{
    SqList *p=NULL;
    p=InitSqList(p);//初始化
    MergeSort(p);//排序
    cout<<"after sort"<<endl;
    PrintSqList(p);//输出
 }

运行结果：

举个4个数的例子便于理解递归过程，只需要把#define MAXSIZE 9修改成#define MAXSIZE 4。

归并排序，原理是假设初始序列有n个值，则可以看成是n子序列，既然每个子序列长度是1，那每个子序列都是有序的。然后不断进行两两归并成新的有序子序列，作为下一次归并的其中一路。

需要两部分：

1、把原始序列一分为二，每路都成为一个有序序列。用递归的方法，把每一路都分至只有一个数，即递归终止开始返回。

//递归法，将SR[s..t]归并排序为TR[s..t]

void MSort(int SR[],int TR[],int s, int t)

2、把有序的两路子序列归并成一路。比如3,1,归并成1,3；4,5,1,6归并成1,4,5,6。

//将有序的temp[s..m]和temp[m+1..t]归并为有序的TR[s..t]

void Merge(int temp[],int TR[],int s,int m,int n)

这个函数作用就是把两路分别有序的temp归并到TR。temp的每一路本身已经有序排列。

比如这个例子，序列短，帮助理解，5,1,4,3:

这部分是递归的结果。两路有序序列5和1。

两路有序序列5和1归并成1,5，作为新的有序子序列。

这部分是递归的结果。两路有序序列4和3。

两路有序序列4和3归并成3,4，作为新的有序子序列。并且将剩余的temp[s..m]复制到TR。

两路有序序列1,5和3,4归并成1,3,4,5，作为新的有序子序列。终止，因为所有递归都已返回。

再看个序列长一点的，原理是一样的。

时间复杂度：

 

二、非递归实现归并排序

代码和解释如下（VS2012测试通过）：

#include <iostream>
using namespace std;
#define MAXSIZE 9//用于要排序数组个数最大值，可根据需要修改

//排序用的顺序表结构
typedef struct
{
    int r[MAXSIZE+1];//定义一个数组，用于存储要排序的数，r[0]作为临时变量
    int length;//用于记录顺序表的长度
}SqList;

//排序表的初始化
SqList *InitSqList(SqList *L)
{
    L=new SqList;
    L->length=MAXSIZE;
    cout<<"input list"<<endl;
    for(int i=1;i<=L->length;i++)
        cin>>L->r[i];
    return L;
}

//数组遍历输出
void PrintSqList(SqList *L)
{
    for(int i=1;i<=L->length;i++)
        cout<<L->r[i]<<" ";
    cout<<endl;
}

//交换r[i]和r[j]
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//数组遍历输出
void Print(int *R)
{
    for(int num=1;num<=MAXSIZE;num++)
        cout<<R[num]<<" ";
    cout<<endl;
}

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

//非递归法，将SR[]中相邻长度为s的子序列两两归并到TR[]
void MergePass(int SR[],int TR[],int s,int n)
{
    int i=1;
    int j;
    while(i <= n-2*s+1)//两两归并
    {
        Merge(SR,TR,i,i+s-1,i+2*s-1);
        i=i+2*s;        
    }
    if(i<n-s+1)//归并最后两个子序列
        Merge(SR,TR,i,i+s-1,n);
    else//如果最后只剩下单个子序列
        for(j =i;j <= n;j++)
            TR[j] = SR[j];
}

//对顺序表L作非递归的归并排序
void MergeSort2(SqList *L)
{
    int* TR=(int*)malloc(L->length * sizeof(int));//申请额外的数组内存空间，用来存放归并结果
    //用递归方法，递归时深度为log2n（2是下标），非递归方法，空间只用到临时用的TR数组，因此空间复杂度是O(n)
    int k=1;
    while(k<L->length)
    {
        MergePass(L->r,TR,k,L->length);//将无序数组r[]两两归并入TR
        k=2*k;//子序列长度加倍
        cout<<"TR:";Print(TR);
        MergePass(TR,L->r,k,L->length);//将TR中已经两两归并的有序序列再次归并回数组r[]
        k=2*k;//子序列长度加倍    
        cout<<"r:";Print(L->r);
    }
}

int main()
{
    SqList *p=NULL;
    p=InitSqList(p);//初始化
    MergeSort2(p);//排序
    cout<<"after sort"<<endl;
    PrintSqList(p);//输出
 }

运行结果：

时间复杂度：