排序算法及其效率分析（二）外排序

一般我们常见的冒泡，插入，选择，堆，快速或者归并都是要求数据在内存，即内部排序；但是当文件很大，不能全部放入内存时候，就需要进行外排序了：

例如：

int main(){
fstream inout;
inout.open("D:/large.dat",ios::out|ios::binary);
for(int i=0;i<2000000;i++)
{int val=rand();
inout.write(reinterpret_cast<char*>(&val),sizeof(val));
}
inout.close();
inout.open("D:/large.dat",ios::in|ios::binary);
int x;
for(int i=0;i<10;i++)
{inout.read(reinterpret_cast<char*>(&x),sizeof(x));
cout<<x<<" ";}
inout.close();
system("pause");
return 0;}

200万个int型数据存在"large.dat"的文件，需要进行外排序。

阶段1：反复从文件读取数据存入一个数组，使用内排序算法对数组排序，然后将数组写回一个临时文件。比如设置该数组规模MAX=100000，则有：

阶段2：将每对有序数据段合并成一个大的有序数据段

实现阶段1代码：

int ini(int segment,char*oldfile,char*f1){
		int num=0;
	fstream in;
	in.open(oldfile,ios::in |ios::binary);
	fstream out;
	out.open(f1,ios::out|ios::binary);
	int *list=new int[segment];
	while(!in.eof()){
		int i;
		for(i=0;i<segment&&!in.eof();i++)
		in.read(reinterpret_cast<char*>(&list[i]),sizeof(list[i]));//从源文件读取到数组里
	if(in.eof())i--;
	if(i<=0) break;
	else num++;
	quicksort(list,i);//使用内部排序函数，比如插入，归并等排序
	for(int j=0;j<i;i++)
	out.write(reinterpret_cast<char*>(&list[j]),sizeof(list[j]));
	}//将排序好数组存在临时文件f1里
	delete []list;
	in.close();
	out.close();}

实现阶段2

首先将f1文件的前一半数据复制到f2，然后将f1与f2数据段对应合并，写入临时文件f3

	//将f1中Num个数据段分半，前一半到f2
	void copyfile(int num,int segmentsize,fstream &f1,fstream&f2){
	int i;
	for(i=0;i<(num/2)*segmentsize;i++)
	  {int x;
	f1.read(reinterpret_cast<char*>(&x),sizeof(x));
	f2.write(reinterpret_cast<char*>(&x),sizeof(x));}
	}

下面是真正合并阶段：

由于每次合并都是两个数据段的合并，所以首先实现两个数据段的合并：

//合并两个数据段
	void mergetwoseg(int segmentsize,fstream&f1,fstream&f2,fstream&f3){
	int fromf1;
	f1.read(reinterpret_cast<char*>(&fromf1),sizeof(fromf1));
	int fromf2;
	f2.read(reinterpret_cast<char*>(&fromf2),sizeof(fromf2));
	int f1count=1;
	int f2count=1;
	while(1){
	if(fromf1<fromf2)
		{f3.write(reinterpret_cast<char*>(&fromf1),sizeof(fromf1));
	if(f1.eof()||f1count++>=segmentsize){if(f1.eof())break;f3.write(reinterpret_cast<char*>(&fromf2),sizeof(fromf2));break;}
	else {f1.read(reinterpret_cast<char*>(&fromf1),sizeof(fromf1));}
	}
	else{
		f3.write(reinterpret_cast<char*>(&fromf2),sizeof(fromf2));
		if(f2.eof()||f2count>=segmentsize){if(f2.eof())break;f3.write(reinterpret_cast<char*>(&fromf1),sizeof(fromf1));break;}
		else {f2.read(reinterpret_cast<char*>(&fromf2),sizeof(fromf2));}}
	}
	while(!f1.eof()&&f1count++<segmentsize){
	int x;
	f1.read(reinterpret_cast<char*>(&x),sizeof(x));
	if(f1.eof())break;
	f3.write(reinterpret_cast<char*>(&x),sizeof(x));}
	while(!f2.eof()&&f2count++<segmentsize){
	int y;
	f2.read(reinterpret_cast<char*>(&y),sizeof(y));
	if(f2.eof())break;
	f3.write(reinterpret_cast<char*>(&y),sizeof(y));}
	}

最后是合并所有的：

void merigefile(int num,int segmentsize,char*f1,char*f2,char*f3){
	for(int i=0;i<num;i++)
   mergetwoseg(segmentsize,f1,f2,f3);
	while(!f1.eof()){
	int x;
	f1.read(reinterpret_cast<char*>(&x),sizeof(x));
	if(f1.eof())break;
	f3.write(reinterpret_cast<char*>(&x),sizeof(x));}}

算法性能：在阶段1从源文件读取n个元素并写入临时文件，开销O(n);在阶段2，有序数组数目n/num，每个合并步骤都将数目减少一半，log(n/num)步骤后，数目为1,每次合并从f1读取一半数据段写入f2,f1剩余数据段与f2中数据段进行合并，每次合并O(n)，故O(n)*log(n/num)=O(nlogn)