第一章：开篇

第一章的一个问题：

问题描述：
输入：给定一个文件，里面最多含有n个不重复的正整数（也就是说可能含有少于n个不重复正整数），且其中每个数都小于等于n，n=10^7。
输出：得到按从小到大升序排列的包含所有输入的整数的列表。
条件：最多有大约1MB的内存空间可用，但磁盘空间足够。且要求运行时间在5分钟以下，10秒为最佳结果。

先写一下会用到的归并排序：

#include<stdio.h>
#include<stdlib.h>
void merge(int *a, int *b, int lenA, int lenB){
	int i = 0, j = 0;
	int k = 0;
	/*生成临时保存的数组*/
	int *newArray = malloc( (lenA + lenB) * sizeof(int) );
	/*判断k是否越界，判断i是否越界，j是否越界（其实k不用判断）*/
	for (; k < lenA + lenB && i < lenA && j < lenB; k++){
		if (a[i] < b[j]){
			newArray[k] = a[i];
			i++;
		}
		else{
			newArray[k] = b[j];
			j++;
		}
	}
	/*两个数组a，b中有一个已经遍历完毕，找出没有遍历完毕的*/
	if (i < lenA){
		for (; i < lenA; i++){
			newArray[k] = a[i];
			k++;
		}
	}
	else if (j < lenB){
		for (; j < lenB; j++){
			newArray[k] = b[j];
			k++;
		}
	}
	/*对数组进行重新赋值*/
	for (int i1 = 0; i1 < lenA + lenB; i1++){
		a[i1] = newArray[i1];
	}
	/*释放指针*/
	free(newArray);
}
void printArray(int *a,int len){
	for (int i = 0; i < len; i++){
		printf("%d ", a[i]);
	}
	printf("\n");
} 
void mergeSort(int *a, int len){
	/*当数组a只有一个元素时候，不用进行split&&merge过程*/
	if (len > 1){
		/*数组从0开始，左边有middle个，所以右边第一个元素下边为middle*/
		int middle = len / 2;
		int left = middle;
		/*数组b有len - middle个元素*/
		int right = len - middle;
		int *b = &a[middle];
		mergeSort(a, left);
		mergeSort(b, right);
		merge(a, b, left, right);

	}
}
int main(){
	
	int a[10] = { 1, 11, 8, 9, 0, 2, 4, 5, 6, 7 };
	printArray(a, 10);
	mergeSort(a, 10);
	printArray(a, 10);
}

还有外部排序用到的：胜者树和败者树算法：

给出参考博客：http://blog.csdn.net/wypblog/article/details/8074831

对对K个有序的序列，希望把他们归并到一个单独的有序序列中。我们可以每次比较者k个有序序列的第一个元素，找出最小，然后进行插入。

但这样会增加比较次数，所以引入了胜者树与败者树，来减少比较次数。

[1]胜者树与败者树是完全二叉树。就像是参加比赛一样，每个选手有不同的实力，两个选手PK,实力决定胜负，晋级下一轮，经过几轮之后，就能得到冠军。不同的是，胜者树的中间结点记录的是胜者的标号；而败者树的中间结点记录的败者的标号。 胜者树与败者树可以在log(n)的时间内找到最值。任何一个叶子结点的值改变后，利用中间结点的信息，还是能够快速地找到最值。在k路归并排序中经常用到。

                           

                                                            图一                                                                                                                                                      图二

胜者树：按照图一,这里找出最小值。八个数组，在叶子节点中已经放置了每个数组的最小值。节点的父节点保存了起子节点的最的最小值（也保存了是哪一个数组产生了这个节点）。

更新操作：当最小元素被读入文件中时候，例如，图一中最小元素1保存在第一个数组中，所以讲数组1中的元素的下一个进行读取，通过比较其兄弟节点的值，来更新父节点，一直到根节点结束。如图二所示。

败者树：

胜者树每次更新主要还要比较兄弟节点，因为其父节点保存了两个自己点的胜者，但是胜者已经读取过了。

败者树，在父节点中，保存了比较的败者，败者还未读取，所以更新操作时候，只需要将新添加的节点与父节点比较即可。

败者树根节点上又添加了一个节点（一个父节点），以保存每次的最终胜者，以进行更新操作。

如下图：

                                                                    

这个博客写的也挺好的 http://blog.csdn.net/whz_zb/article/details/7425152

用书上的位示图法。（前提是没有重复元素）

假如有10000000个元素，新建一个含有10000000个元素的数组

伪代码如下：

for(int i = 0;i<n;i++){
    bit[i] = 0;
}
读取操作：
    读取稳重中的i;
    bit[i] = 1;
输出：
for (int i = 0;i<n;i++){
    if(bit[i] == 1){
        输出i;
    }
}

generageData.cpp
#include<iostream>
#include<time.h>
#include<assert.h>
using namespace std;
const int size = 10000000;
int *num = new int[size];
int main(){
	FILE * outputFile = fopen("data.txt", "w");
	assert(outputFile);
	for (int i = 1; i < size; i++){
		num[i] = i;
	}
	srand((unsigned)time(NULL));
	int i, j;
	for (int n = 0; n <= size; n++){
		//洗牌算法
		i = (rand() * RAND_MAX + rand()) % 10000000;
		j = (rand() * RAND_MAX + rand()) % 10000000;
		int temp = num[j];
		num[j] = num[i];
		num[i] = temp;
	}
	for (int n = 0; n < size; n++){
		fprintf(outputFile, "%d\n", num[n]);
	}
	fclose(outputFile);
	return 0;
}

排序算法：

sort.cpp

#include<iostream>
#include<bitset>
#include<assert.h>
#include<time.h>
using namespace std;
const int max_number = 5000000;
/*两次读取*/
int main(){
	clock_t begin = clock();//定时开始
	bitset<max_number> bits;
	bits.reset();
	FILE *inputFile = fopen("data.txt", "r");
	assert(inputFile);
	int num;
	while(fscanf(inputFile, "%d", &num) != EOF){
		if(max_number > num && num >=0)
		{
			bits[num] = 1;
		}
	}

	cout << "step1"<< endl;
	FILE *outputFile = fopen("sort.txt", "w");
	assert(outputFile);
	for(int i = 0; i < max_number; i++){
		if (bits[i] == 1){
			fprintf(outputFile, "%d\n", i);
		}
	}
	// the second time scan to sort the data between 5000000 - 9999999  
	rewind(inputFile);//其实本函数相当于fseek(inputFile,0L,SEEK_SET); 
	bits.reset();
	cout << "step2" << endl;
	while (fscanf(inputFile, "%d", &num) != EOF){
		if (num >= max_number && num < 2 * max_number){
			bits[num - max_number] = 1;
		}
	}

	for (int i = 0; i < max_number; i++){
		if (bits[i] == 1){
			fprintf(outputFile, "%d\n", i + max_number);
		}
	}
	clock_t end = clock();
	cout << "位示图耗时：" << endl;
	cout << (end - begin) / CLK_TCK << "s" << endl;
	fclose(inputFile);
	fclose(outputFile);
	return 0;
}

磁盘文件多路归并排序的实现：

multiMerge.cpp
#include<iostream>
#include<time.h>
#include<algorithm>
using namespace std;
/*
第一步：分割，返回分割的临时文件个数；
第二步：读取分割的临时文件，读取数据进行排序。并进行内存排序；
第三步：对已经排序的临时文件进行合并；
*/
const char *inputFile = "inputFile.txt";
const char *outputFile = "outputFile.txt";
const int max_number = 10000000;
const int memCount = 1000000;
//随机产生一个文件
void generateData(const char *inFile, int n){
	if (n <= 0){
		printf("rand %d number is Wrong!",n);
	}
	FILE *infile = fopen(inFile, "w");
	srand(time(NULL));//设置随机发生器
	for (int i = 0; i < n; i++){
		fprintf(infile, "%d\n", rand());
	}
	fclose(infile);
}
char* tempFileName(int count);
int comp(const void *first_num, const void *second_num)
{
	return *(int *)first_num - *(int *)second_num;
}
int splitAndSortData(const char *inFile, int number){
	
	FILE *file = fopen(inFile, "r");
	int fileCount = 0;//统计第几个文件
	int inputNum = 0;//读取的那个数字
	int count = 0;//统计文件中读取的第几个数字；
	char *tempFile = tempFileName(fileCount);
	FILE *tf = fopen(tempFile, "w");
	int *array = (int *)malloc(memCount*sizeof(int));//保存读进来的数字，进行quickSort排序；

	while (fscanf(file, "%d", &inputNum) != EOF){

		array[count] = inputNum;
		count++;
		if (count == memCount){
			printf("%d\n",fileCount);
			tempFile = tempFileName(fileCount);
			tf = fopen(tempFile, "w");
			
			qsort(array, memCount, sizeof(int), comp);
			for (int i = 0; i < count; i++){
				fprintf(tf, "%d\n", array[i]);
			}
			fileCount++;
			count = 0;
			fclose(tf);
		}

	}
	if (count != 0){//当遇到EOF时候，文件达到memCount数量
		qsort(array, count, sizeof(int), comp);
		for (int i = 0; i < count; i++){
			fprintf(tf, "%d\n", array[i]);
		}
		fclose(tf);
	}
	return fileCount;
}
void merge(int fileCount){
	FILE *output = fopen(outputFile, "w");
	FILE **fp = (FILE**)malloc(fileCount * sizeof(FILE*));
	for (int i = 0; i < fileCount; i++){
		fp[i] = fopen(tempFileName(i), "r");
	}
	//用于找出最小的数，和文件中是否还有数
	int *minNum = (int *)malloc(fileCount*sizeof(int));
	bool *bits = (bool*)malloc(fileCount*sizeof(bool));
	for (int i = 0; i < fileCount; i++){
		fscanf(fp[i], "%d", &minNum[i]);
		bits[i] = true;
	}
	bool tag = true;
	//假如全是FALSE，则tag为FALSE；
	while (tag){
		int min = INT_MIN;
		int minCur = INT_MIN;
		for (int i = 0; i < fileCount; i++){
			if (bits[i] == true){
				if (minNum[i] >= min){
					min = minNum[i];
					minCur = i;
				}
			}
		}
		fprintf(output, "%d", min);
		if (fscanf(fp[minCur], "%d", &minNum[minCur]) == EOF){
			cout << "EOF-appear" << endl;
			bits[minCur] = false;
		};
		tag = false;
		for (int i = 0; i < fileCount; i++){
			if (bits[i] == true){
				tag = true;
			}
		}

	}



	cout << "SUCCESS" << endl;
}
char* tempFileName(int count){
	char *c = new char(64);
	//把string读取char数组中
	sprintf(c, "temp%d.txt", count);
	return c;
}
int main(){
	//生成数据；
	generateData(inputFile, max_number);
	//分割数据
 	int fileCount = splitAndSortData(inputFile,memCount);
	//合并数据
	merge(fileCount);
	return 0;
}

败者树版本：

有n个叶节点的完全二叉树，共有n - 1个分支为2的节点。加上败者树的一个存储最后胜者的节点，共有n个节点。