归并排序

归并排序

算法分析

算法思想

归并排序遵循分治法的思想：
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] $\le$ 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 = $\lfloor$(p + r) / 2$\rfloor$
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)。