合并排序c/c++算法

合并排序

合并排序思想比较简单，采用分治法，即将原数组分成俩个或多个子数组，分别对每个子数组排序，然后将排好序的子数组合并成一个数组 

合并方法

对于已经排好序的多个子数组（对于二分法，就是两个子数组），每次都取子数组中较小的那个记录下来。

代码实现

代码中增加了计算时间复杂度的过程，统计了20组不同数据量的排序时间，数据量已2指数增长，为了产生数组，这里增加了一个随机数生成的过程，具体说明已在代码注释中，同时输出了第5组数据未排序和已排序的值，验证一下确实已排序。

#include <vector>
#include <sys/time.h>
#include <iterator>
#include <iostream>
using namespace std;

/**
 * @description: 合并相邻的两个子数组，每个子数组的长度为right - left
 * @param {datas}待排序的数组
 * @param {left}第一个待合并的子数组起始位置
 * @param {right}第二个待合并的子数组起始位置
 * @return:
 */
void merges(vector<int> &datas, const size_t &left, const size_t &right)
{
    //计算第二个子数组结束位置，当第二个子数组的长度小于right-left时，结束位置为原数组长度，
    //此情况只会出现在按right-left长度划分原数组时的最后一个子数组，即datas[right...end]
    int end = right + (right - left) > datas.size() ? datas.size()
                                                    : right + (right - left);

    //复制待合并的两个子数组，在原数组中即为datas[left, end],
    //长度为end - left，不一定是2*(right-left),end的计算已经说明原因
    vector<int> tmps(datas.begin() + left, datas.begin() + end);

    // li记录第一个子数组在tmps的起始位置，ri记录第二个子数组在tmps的起始位置，
    // i记录原数组此刻该排序的位置从left开始
    size_t li = 0, ri = right - left, i = left;

    //开始合并两个子数组
    //结束循环条件为至少一个有一个子数组的合并结束，即li或ri超出对应子数组的长度
    //由于第二个子数组的长度可能小于right-left，因此ri的最大值不能超过tmps的长度
    while (li < right - left && ri < tmps.size())
    {
        //记录两个子数组中较小的值
        if (tmps[li] <= tmps[ri]) //第一个子数组li位置比第二个子数组ri位置的数小
        {
            datas[i++] = tmps[li++];
        }
        else //第一个子数组li位置比第二个子数组ri位置的数大
        {
            datas[i++] = tmps[ri++];
        }
    }
    while (li < right - left) //第一个子数组还有未合并的数据，合并到原数组中
    {
        datas[i++] = tmps[li++];
    }
    while (ri < tmps.size()) //第二个子数组还有未合并的数据，合并到原数组中
    {
        datas[i++] = tmps[ri++];
    }
}

/**
 * @description: 合并排序算法
 * @param {datas}待排序的数组
 * @return:
 */
void mergeSort(vector<int> &datas)
{
    for (size_t sz = 1; sz < datas.size(); sz += sz) // sz为合并子数组的长度
    {
        for (size_t i = 0; i < datas.size();
             i += 2 * sz) // i为第一个子数组的在原数组中的位置
        {
            if (i + sz >= datas.size())
                continue; //当合并的第一个子数组长度小于指定长度时不再合并
            merges(datas, i, i + sz);
        }
    }
}

/**
 * @description: 递归方式合并算法
 * @param {datas}待合并的数组
 * @param {left}待合并的子数组的起始位置
 * @param {right}待合并的子数组的终止位置
 * @return:
 */
void mergeSort(vector<int> &datas, const int &left, const int &right)
{
    if ((right - left) == 0) //子数组只有一个元素结束递归
        return;
    int mid = (right + left) / 2; //计算子数组中间位置
    mergeSort(datas, left, mid); //合并排序左半边子数组，即datas[left...mid]
    mergeSort(datas, mid + 1,
              right); //合并排序右半边子数组，即datas[mid+1...right]
    merges(datas, left, mid + 1); //合并左右两个子数组
}

/**
 * @description: 随机生成一个数组
 * @param {datas}生成的随时数组
 * @return:
 */
void gen_and_list(vector<int> &datas)
{
    random_device sd; // random_device一般只用来作为其他伪随机数算法的种子
    minstd_rand linearRan(
        sd()); // linear_congruential_engine(minstd_rand是重命名)线性同余法,这种速度最快、最常用
    uniform_int_distribution<int> dist(1, datas.size()); //整数均匀分布
    for (size_t i = 0; i < datas.size(); i++)
    {
        //使用linear engine做种子，注意这里传入的不是一个值而是一个引擎，
        //使用了uniform_int_distribution重载圆括号方法，看起来更像函数调用
        datas[i] = dist(linearRan);
    }
    return;
}

int main(int argc, char const *argv[])
{
    for (size_t i = 1; i <= 30; i++)
    {
        vector<int> datas((size_t)pow(2, i));

        gen_and_list(datas);
        if (i == 5)
        {
            copy(datas.begin(), datas.end(),
                 ostream_iterator<unsigned int>{cout, " "});
            cout << endl;
        }

        timeval start_tm;
        if (gettimeofday(&start_tm, nullptr) == -1) // 记录合并算法开始时间
            return 0;
        //非递归合并排序
        mergeSort(datas);

        //递归式合并排序
        // mergeSort(datas, 0, datas.size() - 1);

        timeval end_tm;
        if (gettimeofday(&end_tm, nullptr) == -1) //记录合并算法结束时间
            return 0;
        int difftm = (end_tm.tv_sec - start_tm.tv_sec) * 1e6 +
                     (end_tm.tv_usec - start_tm.tv_usec); //计算合并算法所用时间
        cout << "run time:" << difftm << "us" << endl;

        if (i == 5)
        {
            copy(datas.begin(), datas.end(),
                 ostream_iterator<unsigned int>{cout, " "});
            cout << endl;
        }
    }

    return 0;
}

代码给出了基于递归和非递归的算法，可以看出，无论是否递归，合并子数组方法是统一的。

递归是自上而下层层划分进行合并排序的，非递归是自下而上逐步合并的。

 通过上图可以看出，合并排序算法在数据量已2指数增长的情况下，时间确是2的倍数增长，并且数据量达到亿级执行时间不过85秒，这样的执行时间是可观的。

执行时间复杂度计算

假设对N个数据量的数组进行合并排序，执行时间为，则通过划分有如下公式

                                                                                             

为子数组排序所用时间，两个子数组所以乘以2，N为合并所用时间

通过划简上述公式可得到：

                                                                                               

通过上述公式可以计算，当N很大时，N已2的指数增长，时间是以2的倍数增长，如下计算

                                                                       

这就证明了合并排序的优越性。