归并排序

归并排序需要一个与表等长的辅助元素数组空间，所以空间复杂度为O （n ）。

对n 个元素的表，将这n 个元素看作叶结点，若将两两归并生成的子表看作它们的父节点，则归并排序过程对应由叶向根生成一颗二叉树的过程。

所以归并趟数约等于二叉树的高度，即n 2log ，每趟归并需要移动记录n 次，故时间复杂度为()n n O 2log 。

归并排序的程序代码如下：
#include<iostream.h>
#include<stdio.h>
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)<(b))
#define LQ(a,b) ((a)<=(b))
#define MAX_SIZE 20
typedef int KeyType;
typedef int InfoType; //定义其他数据类型
struct RedType{
KeyType key;
InfoType otherinfo;
};
struct SqList{
RedType r[MAX_SIZE];
int length;
};
void Merge(RedType SR[],RedType TR[],int i,int m,int n){
//将有序表SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
int j,k,r;
for(j=m+1,k=i;i<=m&&j<=n;k++)
if LQ(SR[i].key,SR[j].key) //将SR 中记录由小到大地并入TR
TR[k]=SR[i++];
else
TR[k]=SR[j++];
if(i<=m)
for(r=0;r<=m-i;r++)
TR[k+r]=SR[i+r]; //将剩余的SR[i..m]复制到TR
if(j<=n)
for(r=0;r<=n-j;r++)
TR[k+r]=SR[j+r]; //将剩余的SR[j..n]复制到TR
}
void MSort(RedType SR[],RedType TR1[],int s,int t){
//将SR[..t]归并排序为TR1[s..t]
RedType TR2[MAX_SIZE+1];
if(s==t)
TR1[s]=SR[s];
else{
m=(s+t)/2; //将SR[s...t]平分为SR[s..m]和SR[m+1..t]
MSort(SR,TR2,s,m); //递归地将SR[s..m]归并为有序的TR2[s..m]
MSort(SR,TR2,m+1,t); //递归地将SR[m+1..t]归并为有序的TR2[m+1..t]
Merge(TR2,TR1,s,m,t); //将TR2[s..m]和TR2[m+1..t]
}
}
void MergeSort(SqList &L){
//对顺序表L作归并排序
MSort(L.r,L.r,1,L.length);
}
void print(SqList L){
int i;
for(i=1;i<=L.length;i++)
cout<<"("<<L.r[i].key<<","<<L.r[i].otherinfo<<")";
cout<<endl;
}
#define N 7
void main(){
RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7}};
SqList l;
int i;
for(i=0;i<N;i++)
l.r[i+1]=d[i];
l.length=N;
cout<<"排序前："<<endl;
print(l);
MergeSort(l);
cout<<"排序后："<<endl;
print(l);
}。