基本排序算法之六 ——归并排序

本文链接：https://blog.csdn.net/stdio1916/article/details/89866207

基本排序算法总结与对比之六 ——归并排序

1、归并排序递归版本

template<typename T>
void mergeSort(T arr[], int lo, int hi)
{
    if(hi - lo < 2) return;
    int mi = (lo + hi) >> 1;
    mergeSort(arr, lo, mi);  mergeSort(arr, mi, hi);  merge(arr, lo, mi, hi);
}

template<typename T>
void merge(T arr[], int lo, int mi, int hi)
{
    T* C = arr + lo;    //C 为待排序数列的起点

    T* A = new T[mi - lo];    
    for(int i = 0; i < mi - lo; A[i] = C[i++]);    //拷贝arr[]中区间[lo,mi)的元素到A

    T* B = arr + mi;    //arr[]中区间[mi,hi)的元素不用单独拷贝出来，排序过程中后半段元素是安全的

    for(int a = 0, b = 0, c = 0; a < mi - lo || b < hi - mi; )    //按升序排列
    {
        if(a < mi - lo && (!(b < hi - mi) || A[a] <= B[b])) C[c++] = A[a++];
        if(b < hi - mi && (!(a < mi - lo) || A[a] >  B[b])) C[c++] = B[b++];
    }
    delete [] A;
}

不难得出，上述代码中归并排序的时间复杂度最好，最坏，平均均为O(nlogn)。（证明过程参考有关书籍）

实际上略微修改上段代码，即可提高算法效率：

① 频繁的new和delete时间成本极高，可以在函数运行初分配好空间。

② merge(arr, lo, mi, hi)仅仅需要在arr[mid - 1] > arr[mid]才有必要执行，若arr[mid - 1] ≤ arr[mid]则其本身就是有序的。

③ 归并函数中引入了较为复杂的控制逻辑，目的是为了统一对不同情况的处理。尽管如此可使代码在形式上更为简洁，但同时也会在一定程度上造成运行效率的下降。

基于以上几点，对上算法略做改进。

2、归并排序递归版本的改进A

template<typename T>
void mergeSort(T arr[], int lo, int hi, bool init = true, T* A = nullptr, int len = 0)
{
    if (hi - lo < 2) { return; }
    if (init) { A = new T[hi - lo]; len = hi - lo; }  //先准备好存储[lo,mi)数据的空间A
                                                      //并且记录下数组长度len
    int mi = (lo + hi) >> 1;
    mergeSort(arr, lo, mi, false, A, len);    mergeSort(arr, mi, hi, false, A, len);
    if (arr[mi - 1] > arr[mi]) merge(arr, lo, mi, hi, A, len); //仅在arr[mid - 1] >         
                                                               //arr[mid]时才执行归并
}

template<typename T>
void merge(T arr[], int lo, int mi, int hi, T* A, int len)
{
    T* C = arr + lo;
    for (int i = 0; i < mi - lo; A[i] = C[i++]);
    T* B = arr + mi;

    //归并过程中可能会出现4种情况
    //1、A，B中数的均没有放完（放进C，我们先这么认为 因为B与C的后半段是重叠的）
    //2、A没有放完，B放完了
    //3、A放完了，B没有放完
    //4、A，B均放完了
    //情况1：a < mi - lo && b < hi - mi，需要对A,B中的数比较
    //情况2：a < mi - lo && b >= hi - mi，只需要把A中剩余的数拷贝到C后边即可
    //情况3：a > mi - lo && b < hi - mi，只需要把B中剩余的数放到C后边即可,
           //但是B与C的后半段是重叠的，即B中剩余的元素就是C的后边部分,所以不用任何操作！
    //情况4：均放完了，也不用任何操作
    //--综上：需要操作的情形只有情况1和2，也就是a < mi - lo
    //--然后只需要 b < hi - mi时比较元素 和 b >= hi - mi时拷贝元素
    //--因此，归并的逻辑控制可以简化如下：

    for (int a = 0, b = 0, c = 0; a < mi - lo; )  //只有a < mi - lo时才需要操作
    {
        if (b < hi - mi){                         //b < hi - mi时比较元素
            if(A[a] <= B[b])  C[c++] = A[a++];
            else C[c++] = B[b++];
        }
        else                                      //b >= hi - mi时拷贝元素
            C[c++] = A[a++];
    }
    if (len == hi - lo) delete[] A; 
}

上述函数的参数列表可能显得有些冗余，但为了统一函数入口，使其简单易用，而不得不做出一些牺牲。实际测试表明，改进的归并排序A 在对大量数据排序时所耗时间为未改进的排序方法的一半左右。

但是，以上改进仍然有不足之处：

① 递归方法不是尾递归形式，最高栈高为log2n，虽然不至于栈满，但空间利用还可以压榨。

3、归并排序迭代版本

若递归函数的尾递归形式难以直接按逻辑列出，则先考虑迭代形式。或者仍然按照普通的递归逻辑，建立一个栈来储存参数以实现尾递归。本文将不讨论尾递归形式的实现方法，网络上已经有一个尾递归实现的版本可以参考。

下面列出归并排序的迭代形式。

迭代版本的实质上是省略了递归版本的递归分解部分，从而直接进行归并。

先对【 n-n 2n元素归并】做个解释：第一路n个有序元素与第二路n个有序元素归并成共2n个有序元素的归并操作。

从1-1 2元素归并 → 2-2 4元素归并 → 4-4 8元素归并 →。。。 → n-n 2n元素归并。（代码中为：step-_step step+_step元素归并，_step为 step 或者 hi - _lo - step 。）

但是，在上述迭代过程中存在2种特殊情况：

① 在 k-k 2k元素归并时，可能第二路元素不足k个（因为在末尾部分），即实际应该为k-k1 k+k1元素归并（step-_step step+_step元素归并）。

② 在 k-k 2k元素归并时，可能剩余元素连第一路都不足，即末尾剩余的不足k个（或者刚好k个）元素不能进行归并。

对于情况①：仅需要把第二路元素的长度设置为排除第一路元素后的剩余的元素个数即可。

对于情况②：对于出现剩余元素连第一路都不足，那么剩余元素肯定是有序的（证明略）。因此不用考虑对剩余元素的归并，因为归并长度是2倍递增的，这些剩余元素最终会称为情况①中的第二路元素。

基于以上分析，实现代码如下：

template<typename T>
void mergeSort(T arr[], int lo, int hi)
{
    T *A = new T[hi-lo], *B, *C;
    int _step = 1;  //储存第二路元素的长度用， 提前分配空间 避免循环中反复分配， 要是开心，后边的变量都可以提前分配好空间
    for(int step = 1; step < hi - lo; step <<= 1)  //step为第一路元素长度
    {
        for(int _lo = lo; _lo < hi - step; _lo += (step << 1))  //_lo < hi - step 为考虑情况 2
        {
            _step = _lo + step << 1 > hi ? hi - _lo - step : step;  //考虑情况 1，设置第二路元素长度
            C = arr + _lo;   B = C + step; 
            for(int i = 0; i < step; A[i] = C[i++]);  //拷贝第一路元素到A
            
            //第一路元素[_lo,_lo + step)与第二路元素[_lo + step,_lo + step +_step) 进行step-_step step+_step元素归并
            for(int a = 0,b = 0, c = 0; a < step; )
            {
                if(b < _step)
                {
                    if(A[a] <= B[b]) C[a++] = A[a++];
                    else C[c++] = B[b++];
                }
                else
                    C[a++] = A[a++];
            }
        }
    }
    delete [] A;
}

上述代码没有考虑只有当 arr[mid - 1] > arr[mid] （即C[step - 1] > B[0]）时才需要进行归并这一条件，逻辑上似乎设置arr[mid - 1] > arr[mid] 的条件判断能够避免不需要的归并操作。但是实际的随机数排序测试中加入了这一条件判断反而耗时略多。（笔者的猜测是：可能出现arr[mid - 1] <= arr[mid] 从而不需要进行归并操作的概率太低了，节省的时间反而不能补偿循环中进行arr[mid - 1] > arr[mid] 条件判断的时间！）所以，代码中没有加入这一考虑。当然，这样在最好的情况下就会更耗时！