归并排序算法

归并排序：是通过“归并”两个或两个以上的记录有序子序列，逐步增加记录有序序列的长度;归并排序的基本思想是：将两个或两个以上的有序子序列“归并”为一个有序序列。

  在内部排序中，通常采用的是2-路归并排序。即：将两个位置相邻的有序子序列 归并为一个有序序列。

“归并”算法描述如下：

template

void Merge (Elem SR[], Elem TR[], int i, int m, int n) {

// 将有序的SR[i..m]和SR[m+1..n]归并为

// 有序的TR[i..n]

for (j=m+1, k=i;  i<=m && j<=n;  ++k)  

{        // 将SR中记录由小到大地并入TR

   if (SR.key<=SR[j].key)  TR[k] = SR[i++];

   else TR[k] = SR[j++];

}

if (i<=m) TR[k..n] = SR[i..m];

              // 将剩余的SR[i..m]复制到TR

if (j<=n) TR[k..n] = SR[j..n];

               // 将剩余的SR[j..n]复制到TR

} // Merge

归并排序的算法可以有两种形式：递归的和递推的，它是由两种不同的程序设计思想得出的。在此，只讨论递归形式的算法。

这是一种自顶向下的分析方法：

如果记录无序序列R[s..t]的两部分]û(s+t)/2ëR[s..和û(s+t)/2+1..tëR[分别按关键字有序，则利用上述归并算法很容易将它们归并成整个记录序列是一个有序序列，由此，应该先分别对这两部分进行2-路归并排序。

template

void Msort ( Elem SR[], Elem TR1[], int s, int t ) {

// 将SR[s..t]进行2-路归并排序为TR1[s..t]。

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]归并到TR1[s..t]

}

} // MSort

template

void MergeSort (Elem R[]) {

// 对记录序列R[1..n]作2-路归并排序。

  MSort(R, R, 1, n);

} // MergeSort

容易看出，对n个记录进行归并排序的时间复杂度为Ο(nlogn)。即：每一趟归并的时间复杂度为O(n)，总共需进行logn趟。

下面我们比较一下上面谈到的各种内部排序方法

首先，从时间性能上说：

1. 按平均的时间性能来分，有三类排序方法：

时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好；

时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此；

时间复杂度为O(n)的排序方法只有，基数排序。

2. 当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。

3. 简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。

其次，从空间性能上说：

指的是排序过程中所需的辅助空间大小。

1. 所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)；

2. 快速排序为O(logn)，为栈所需的辅助空间;

3. 归并排序所需辅助空间最多，其空间复杂度为O(n);

4. 链式基数排序需附设队列首尾指针，则空间复杂度为O(rd)。

再次，从排序方法的稳定性能上说：

稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。对于不稳定的排序方法，只要能举出一个实例说明即可。我们需要指出的是：快速排序和堆排序是不稳定的排序方法。