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

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

T(1)T(N)=1=2T(N/2)+N

其中，对于N个数的归并排序用的时间等于两个大小为 N/2 的归并排序所用的时间加上合并的时间。
把上面的式子两边同时除以N，得到以下的递推关系：

T(N)NT(N/2)N/2T(N/4)N/4⋮T(2)2=2T(N/2)N/2+1=T(N/4)N/4+1=T(N/8)N/8+1=T(1)1+1

然后把上面的式子相加，消去等号两边相等的项，该过程称之为叠缩求和，最后得到的结果为

T(N)N=T(1)1+logN

因为总的方程个数等于执行归并排序中子列长度变化的次数 k=logN2
所以得到：

T(N)=NT(1)+NlogN

得证。

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

#include
#include
#include
#include
#include
#include
using namespace std;

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

/*
 实现采用递归的归并排序
 a为原始数据
 tmpArray用于存放归并排序过程中的结果
 left表示迭代中子列的最左端的下标
 right表示迭代中子列的最右端的下标
*/
template<typename Comparable>
void mergeSortRecursive(vector &a,
    vector &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 &a,
    vector &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 & v)
{
    copy(v.cbegin(), v.cend(), ostream_iterator(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的时候只有一个临时向量在使用，因此建立和待排向量等长的临时向量，每次使用的地方都是正在执行归并排序操作下标起始处。

执行结果如下：