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

一、归并排序

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

1、算法描述

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

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

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

2、算法图解

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

（2）整体过程

3、算法demo

#include 
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 
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