C++实现归并排序Mergesort（使用递归的方法）

归并排序的最坏运行时间为$O(N\log N)$。它的思想是把两个有序的子序列，通过一次遍历，合并且有序的放在第三个序列中。显然合并两个已排序的表的时间是线性的，最多进行$N-1$次比较，其中N是元素的总个数。对总的运行时间进行推导如下:
假设N是2的幂次，从而每次总能分裂成两个相等的子列。对于$N=1$的子列，归并排序的时间为常数，我们记为1，那么我们可以得到如下的递推关系（参考Weiss的《数据结构与算法分析》第三版C++语言描述）：

$$\begin{split} T(1)&=1\\ T(N)&=2T(N/2)+N \end{split}$$
其中，对于N个数的归并排序用的时间等于两个大小为 $N/2$的归并排序所用的时间加上合并的时间。
把上面的式子两边同时除以N，得到以下的递推关系：
$$\begin{split} \frac{T(N)}{N}&=\frac{2T(N/2)}{N/2}+1 \\ \frac{T(N/2)}{N/2}&=\frac{T(N/4)}{N/4}+1\\ \frac{T(N/4)}{N/4}&=\frac{T(N/8)}{N/8}+1\\ \vdots\\ \frac{T(2)}{2}&=\frac{T(1)}{1}+1\\ \end{split}$$
然后把上面的式子相加，消去等号两边相等的项，该过程称之为叠缩求和，最后得到的结果为
$$\frac{T(N)}{N}=\frac{T(1)}{1}+\log N$$
因为总的方程个数等于执行归并排序中子列长度变化的次数 $k=\log_2^N$
所以得到：
$$T(N)=NT(1)+N\log N$$
得证。

下面给出使用递归方法的程序:

#include<iostream>
#include<vector>
#include<random>
#include<ctime>
#include<iterator>
#include<algorithm>
using namespace std;

/*
 使用递归的归并排序
 该函数为驱动函数
*/
template<typename Comparable>
void mergeSortRecursive(vector<Comparable> &a)
{
    vector<Comparable> tmpArray(a.size());
    mergeSortRecursive(a, tmpArray, 0, a.size() - 1);
}

/*
 实现采用递归的归并排序
 a为原始数据
 tmpArray用于存放归并排序过程中的结果
 left表示迭代中子列的最左端的下标
 right表示迭代中子列的最右端的下标
*/
template<typename Comparable>
void mergeSortRecursive(vector<Comparable> &a,
    vector<Comparable> &tmpArray, int left, int right)
{
    if (left < right)
    {
        int center = (right + left) / 2;
        mergeSortRecursive(a, tmpArray, left, center);
        mergeSortRecursive(a, tmpArray, center + 1, right);
        merge(a, tmpArray, left, center + 1, right);
    }
}


/*
 归并排序中使用的合并函数
 a为原始数据
 tmpArray用于存放归并排序过程中的结果
 leftPos表示前一个子列的最左端的元素的下标
 rightPos表示后一个子列的最左端的元素的下标
 rightEnd表示后一个子列的最右端的元素的下标
*/
template<typename Comparable>
void merge(vector<Comparable> &a,
    vector<Comparable> &tmpArray, int leftPos, int rightPos, int rightEnd)
{
    int leftEnd = rightPos - 1;
    int tmpPos = leftPos; // 用来保存在合并过程中存放结果的临时向量的下标
    int numElements = rightEnd - leftPos + 1;

    //主循环，把数据合并
    while (leftPos <= leftEnd && rightPos <= rightEnd)
    {
        if (a[leftPos] < a[rightPos])
            tmpArray[tmpPos++] = a[leftPos++];
        else
            tmpArray[tmpPos++] = a[rightPos++];
    }

    //如果是因为后边子列的数据全部放在临时向量中导致主循环结束
    //则把前面没放完的数据依次放入临时变量中
    while (leftPos <= leftEnd)
        tmpArray[tmpPos++] = a[leftPos++];

    //同上处理前面子列数据全部先放入向量中的情况
    while (rightPos <= rightEnd)
        tmpArray[tmpPos++] = a[rightPos++];

    //注意！不能直接用a=tmpArray,因为可能只是复制子列
    for (int i = 0; i < numElements; ++i, --rightEnd)
        a[rightEnd] = tmpArray[rightEnd];

}



/*输出向量*/
template<typename T>
void printVector(vector<T> & v)
{
    copy(v.cbegin(), v.cend(), ostream_iterator<T>(cout, " "));
    cout << endl;
}

int main()
{
    vector<int> source;
    uniform_int_distribution<int> u(0, 1000);
    default_random_engine e(static_cast<unsigned int>(time(0)));
    for (int i = 0; i < 31; i++)
    {
        source.push_back(u(e));
    }

    cout << "排序前：" << endl;
    printVector(source);

    mergeSortRecursive(source);

    cout << "排序后：" << endl;
    printVector(source);

    return 0;
}

该程序对merge每次都调用相同的临时向量，因为每次调用merge的时候只有一个临时向量在使用，因此建立和待排向量等长的临时向量，每次使用的地方都是正在执行归并排序操作下标起始处。

执行结果如下：