排序算法之归并排序和外部排序

一、归并排序

  归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案”修补”在一起，即分而治之)。

1、算法描述

1. 把长度为n的输入序列分成两个长度为n/2的子序列；

2. 对这两个子序列分别采用归并排序；

3. 将两个排序好的子序列合并成一个最终的排序序列。

2、算法图解

（1）合并相邻有序子序列

（2）整体过程

3、算法demo

#include <bits/stdc++.h>
using namespace std;

//将有二个有序数列a[first...mid]和a[mid...last]合并。  
void mergearray(vector<int> &a, int first, int mid, int last, vector<int> &temp)
{
    int i = first;
    int j = mid + 1;
    int m = mid;
    int n = last;
    int k = 0;
    //比较二个数列的第一个数，谁小就先取谁,放入新数组中
    while (i <= m && j <= n)
    {
        if (a[i] < a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }
    //如果有数列为空，那直接将另一个数列的数据依次取出即可
    while (i <= m)
        temp[k++] = a[i++];
    while (j <= n)
        temp[k++] = a[j++];
    //最后将temp中的内容全部拷贝到原数组中
    for (i = 0; i < k; ++i)
        a[first + i] = temp[i];
}

void mergesort(vector<int> &a, int first, int last, vector<int> &temp)  
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        mergesort(a, first, mid, temp);    //排序左边，使得左子序列有序
        mergesort(a, mid + 1, last, temp); //排序右边，使得右子序列有序
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并
    }
}

int main(int argc, char const *argv[])
{
    vector<int> vec1 = {7, 2, 4, 5, 3, 6, 1};
    vector<int> vec2;
    vec2.resize(vec1.size());
    mergesort(vec1, 0, vec1.size()-1, vec2);
    for (const auto v : vec1)
        cout << v << " ";
    system("pause");
}

4、算法总结

  归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。归并排序的最大好处是在数据呈现最坏情况时，是所有排序算法中表现最好的。

二、外部排序

  当所要排序的的数据量太多或者文件太大，无法直接在内存里排序，而需要依赖外部设备时，就会使用到外部排序。

1、算法描述

  假设文件需要分成k块读入，需要从小到大进行排序。

1. 依次读入每个文件块，在内存中对当前文件块进行排序（应用恰当的内排序算法），此时，每块文件相当于一个由小到大排列的有序队列；

2. 在内存中建立一个最小堆，读入每块文件的队列头；

3. 弹出堆顶元素，如果元素来自第i块，则从第i块文件中补充一个元素到最小值堆。弹出的元素暂存至临时数组；

4. 当临时数组存满时，将数组写至磁盘，并清空数组内容；

5. 重复过程3、4，直至所有文件块读取完毕。

2、算法图解

3、算法demo

#include <bits/stdc++.h>
using namespace std;

vector<int> fun1(string str)
{
    ifstream inFile(str);
    vector<int> vec;
    int temp;
    for (int j = 1; j <= 2000; ++j)
    {
        inFile >> temp;
        vec.push_back(temp);
    }
    return vec;
}

int main(int argc, char const *argv[])
{
    clock_t start_time = clock();
    static default_random_engine e;
    static uniform_int_distribution<unsigned> u(0, 1000);
    const int k = 5;
    int temp;
    ofstream outFile("input.txt");
    ifstream inFile("input.txt");
    ofstream outFile1("input1.txt");
    ofstream outFile2("input2.txt");
    ofstream outFile3("input3.txt");
    ofstream outFile4("input4.txt");
    ofstream outFile5("input5.txt");
    //随机产生一万个小于1000的数据
    for (size_t  i = 0; i < 10000; ++i)
        outFile << u(e) << " ";
    //把一个文件中的数据分割到k个小文件中
    for (int i = 0; i < 10000; ++i)
    {
        inFile >> temp;
        switch (i/2000)
        {
            case 0 : outFile1 << temp << " "; break;
            case 1 : outFile2 << temp << " "; break;
            case 2 : outFile3 << temp << " "; break;
            case 3 : outFile4 << temp << " "; break;
            case 4 : outFile5 << temp << " "; break;
        }
    }   
    //分别读取k个文件中的数据放在vector中
    vector<vector<int>> vec;
    vec.push_back(fun1(string("input1.txt")));
    vec.push_back(fun1(string("input2.txt")));
    vec.push_back(fun1(string("input3.txt")));
    vec.push_back(fun1(string("input4.txt")));
    vec.push_back(fun1(string("input5.txt")));
    //定义排序输出文件
    ofstream outFile_result("output.txt");
    for (int m = 0; m < 10000; ++m)
    {
        int j, min = 1001;
        //分别每个文件中的数据建立最小堆
        for (int i = 0; i < k; ++i)
            make_heap(vec[i].begin(), vec[i].end(), greater<int>());
        for (int i = 0; i < k; ++i)
        {
            if (vec[i][0] < min)
            {
                min = vec[i][0];
                j = i;
            }
        }   
        //取所有文件最小堆中的最小值输出
        outFile_result << min << " ";
        //删除该最小值，重新建堆
        pop_heap(vec[j].begin(), vec[j].end());
        vec[j].pop_back();
    }
    clock_t end_time = clock();
    cout << "Running time is: " << static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000 <<
         "ms" << endl;//输出运行时间。
    system("pause");
    return 0;
}

参考：https://www.cnblogs.com/chengxiao/p/6194356.html
https://blog.csdn.net/jfkidear/article/details/52947264