归并排序

归并排序

算法分析

算法思想

归并排序遵循分治法的思想：

1. 分解带排序的n个元素序列成两个各有n/2个元素的子序列。

2. 使用归并排序递归地对两个子序列进行排序。

3. 合并两个已经排序的子序列，最终得到排序结果。

伪代码：

// 合并两个已经排好序的子序列。

Merge(A, p, q, r)

1　　lLen = q - p + 1

2　　rLen = r - q

3　　for k = 1 to lLen

4　　　　L[i] = A[p + k - 1]

5　　for k = 1 to rLen

6　　　　R[i] = A[q + k]

7　　i = j = 1

8　　for k = p to r

9　　　　if L[i] ≤ R[j]

10　　　　　　A[k] = L[i]

11　　　　　　i = i + 1

12　　　　else

13　　　　　　A[k] = R[j]

14　　　　　　j = j + 1

// 利用归并排序递归地排序两个子序列。

MergeSort(A, p, r)

1　　if p < r

2　　　　q = ⌊(p + r) / 2⌋

3　　　　MergeSort(A, p, q)

4　　　　MergeSort(A, q + 1, r)

5　　　　Merge(A, p, q, r)

注意：if p < r这句必不可少，因为递归必须有终止条件，否则将无限递归。归并排序递归地排序两个子序列地过程中，不断对子序列进行划分，必然会划分到一个元素上，此时p=r，递归结束。

下面利用一组图对归并排序的Merge过程进行分析。注：图中绿色标记的为排过序的元素。



带排序序列为某段子序列A=[2, 4, 5, 7, 1, 2, 3, 6]，分解为两个已经排好序的子序列L=[2, 4, 5, 7]和R=[1, 2, 3, 6]，如图(a)所示。i，j，k分别指向序列L、R和A的首端，即i=j=1，k=9;

i＝1，j＝1，k＝9，比较L[i]和R[j]，发现L[i]>R[j]，取二者中最小的赋值给A[k]，令A[k]=R[j]，同时j和k各后移一位，即j=2, k=10，如图(b)所示;

i＝1，j＝2，k＝10，比较L[i]和R[j]，发现L[i]＝R[j]，取二者中最小的赋值给A[k]，令A[k]=L[i]，同时i和k各后移一位，即i=2, k=11，如图(c)所示;

依此类推，经过图(d)(e)(f)(g)(h)(i)演示的推理过程，最终得到有序序列[1, 2, 2, 3, 4, 5, 6, 7]。

C++代码

#include <iostream>
using namespace std;

void Merge(int array[], int p, int q, int r)
{
int lenLeft = q - p + 1;
int lenRight = r - q;

int *arrayLeft = new int[lenLeft];
int *arrayRight = new int[lenRight];

int k = 0;
int i = 0;
int j = 0;

for (k = 0; k < lenLeft; k++)
{
arrayLeft[k] = array[p + k];
}

for (k = 0; k < lenRight; k++)
{
arrayRight[k] = array[q + 1 + k];
}

for (k = p; k < r; k++)
{
if (arrayLeft[i] < arrayRight[j])
{
array[k] = arrayLeft[i];
++i;
}
else
{
array[k] = arrayRight[j];
++j;
}
}

delete []arrayLeft;
delete []arrayRight;
}

void MergeSort(int array[], int p, int r)
{
if (p < r)
{
int q = (p + r) / 2;

MergeSort(array, p, q);
MergeSort(array, q + 1, r);
Merge(array, p, q, r);
}
}

int main()
{
int array[] = {5, 4, 2, 7, 3, 6, 1, 2};
MergeSort(array, 0, 7);
for (int i = 0; i < 8; i++)
{
cout << array[i] << " ";
}
cout << endl;
return 0;
}

Output:
1 2 2 3 4 5 6 7

算法复杂度

时间复杂度

　　O(nlogn)

空间复杂度

　　在合并两个有序子序列的过程中(Merge)，动用了两个数组保存了两个有序子序列，所以归并排序的空间复杂度为O(n)。