算法学习（七）有内存限制的海量数据排序

磁盘文件排序

问题描述：
输入：给定一个文件，里面最多含有n个不重复的正整数（也就是说可能含有少于n个不重复正整数），且其中每个数都小于等于n，n = 10^7。
输出：得到按从小到大升序排列的包含所有输入的整数的列表。
条件：最多有大约1MB的内存空间可用，但磁盘空间足够。且要求运行时间在五分钟以下，10秒为最佳结果。
分析：
首先注意的是它的内存要求，基本上否决了大多数的排序算法。
文件里面的数据是不重复的，这个很关键，因为下面的方案前提就是数据不重复。

位图方案

以位为最小单位，对应位为1，代表位数值，可以用20位长的字符串来表示一个所有元素都小于20的简单的非负数集合，边框用如下字符串来表示集合{1,2,3,5,8,13}：
01110100100001000000
对应位置则置1，没用对应数的位置则置0，开始扳手指头数数吧。我们可以采用一个具有1000万个位的字符串来表示这个文件，其中，当整数i在文件中时，第i位为1。
第一步，所有位置0,将集合初始化。
第二步，通过读入文件中的每个整数来建立集合，将对应的位都置1.
第三步，检验每一位，如果该位为1，就输出对应的整数。
这里不得不提一下c++库中的一个容器bitset,发现这个在处理位的时候简直牛，先来瞅瞅。

#include <iostream>#include <bitset>using namespace std;int main(){    const int max = 20;    int arr[10] = {2,9,3,5,4,0,18,11,12,15};    bitset<max> bit_map;  //一种类模板，放入长度，定义了一个max位，每位都为0    bit_map.reset();  //所有位置0    int i;    for(i = 0;i< 10;i++)    {        bit_map.set(arr[i]);  //将对应位置1    }    for(i = 0;i< max;i++)    {        if(bit_map.test(i))  //判断第i位，如果为1，返回true            cout << i << " ";    }    cout << endl;    return 0;}

再加上文件操作，就是针对海量数据排序。

#include <iostream>#include <bitset>#include <assert.h>#include <time.h>#include <stdio.h>#include <stdlib.h>using namespace std;const int MAX = 5000000;int main(){    clock_t begin = clock();    bitset<MAX> bit_map;    bit_map.reset();    FILE * fp_unsort_file = fopen("data.txt","r");    assert(fp_unsort_file);    int num;    while(fscanf(fp_unsort_file,"%d ",&num)!= EOF)    {        if(num < MAX)   //先对1-4999999的数进行排序            bit_map.set(num);    }    FILE * fp_sort_file = fopen("sort.txt","w");    assert(fp_sort_file);    int i;    for(i= 0;i < MAX;i++)    {        if(bit_map.test(i))            fprintf(fp_sort_file,"%d ",i);    }    int result = fseek(fp_sort_file,0,SEEK_SET); //指针回到文件开始处    if(result)        cout << "fseek failed" << endl;    else    {        bit_map.reset();        while(fscanf(fp_unsort_file,"%d ",&num) !=EOF)        {            if(num > MAX && num < 10000000)  //再对5000000-10000000的数排序            {                num -=MAX;                bit_map.set(num);            }        }        for(i = 0;i<MAX;i++)        {            if(bit_map.test(i))                fprintf(fp_sort_file,"%d ",i+MAX);        }    }    clock_t end = clock();    cout << "time is:" << endl;    cout << (end-begin)/CLOCKS_PER_SEC << "s" << endl;    fclose(fp_sort_file);    fclose(fp_unsort_file);    return 0;}

第一次只处理1-4999999之间的数据，对这些数进行位图排序，只需要约5000000/8 = 625000byte，就是0.625M,排序后输出。
第二次,扫描输入文件，只处理4999999-10000000的数据项，只需要0.625M,因此只需要0.625M。

多路归并

我们先了解一下，归并排序的过程，归并排序就是2路归并
归并排序的过程：
1，把无序表的每一个元素看做是一个有序表，则有n个有序子表；
2，把n个有序表按相邻位置分成若干对，每对中的两个表进行归并，归并后子表数减少一半。
3，反复进行这一过程，直到归并为一个有序表为止。
是采用分治法的典型应用
首先考虑下如何将二个有序数列合并，比较二个数列第一个数，谁小就放入到临时数组中，然后再进行比较，如果一个数列到达结尾，直接将另一个数列放入就临时数组中。

oid MemeryArray(int a[],int n,int b[],int m,int c[]){    int i,j,k;    i = j= k = 0;    while(i < n && j< m)    {        if(a[i] < b[j])            c[k++] = a[i++];        else            c[k++] = b[j++];    }    while(i < n)        c[k++] = a[i++];    while(j < n)        c[k++] = b[j++];}

下一步考虑如何让两个A,B数组有序，可以将A,B各自再分成二组，依次类推，当分出来的小组只有一个元素时，这个小组内已经达到有序了，然后再合并相邻的二个小组就可以了，先递归分解，再合并数列就完成了归并排序。

//将二个有序数列a[first...mid] 和a[mid+1...last]合并void MemeryArray(int a[],int first,int mid,int last,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] < b[j])            temp[k++] = a[i++];        else            temp[k++] = a[j++];    }    while(i <= m)        temp[k++] = a[i++];    while(j <=n)        temp[k++] = a[j++];    for(i = 0;i<k;i++)        a[first+i] = temp[i];}void mergesort(int a[],int first,int last,int temp[]){    if(first < last)    {        int mid = (first + last)/2;        mergesort(a,first,mid,tmep);        mergesort(a,mid+1,last,temp);        MemeryArray(a,first,mid ,last,temp);    }}

归并排序是一种稳定排序，时间复杂度最好情况下和最坏情况下均是O（nlogn）
多路归并就是从多个有序数列中归并。
比如将10000000的数据，分成40个有序文件，分别在内存中排序，然后对这40个有序文件进行归并排序。
1，读取每个文件中第一个数（每个文件的最小数），存放在一个大小为40的data数组中，
2，选择data数组中最小的数min_data，及其相应的文件索引（来自哪个文件）index
3，将min_data写入到文件result，然后更新数组data(根据index,读取该文件的下一个数代替min_data）
4，判读是否所有数据都读取完毕，否则返回到2步。

#include <iostream>#include <string>#include <assert.h>#include <stdio.h>#include <stdlib.h>#include <time.h>using namespace std;int sort_num = 10000000;int memory_size = 250000;  //每次排序250000个数据int read_data(FILE *fp,int *space){    int index = 0;    while(index < memory && fscanf(fp,"%d ",&space[index])!= EOF)        index++;    return index;}void write_data(FILE * fp,int *space,int num){    int index = 0;    while(index < num)    {        fprintf(fp,"%d ",space[index]);        index++;    }}void check_fp(FILE *fp){    if(fp == NULL)    {        cout << "the file not open" << endl;        exit(1);    }}int compare(const void * a,const void * b){    return *(int *)a-*(int *)b;}string new_filename(int n){    char file_name[20];    sprintf(file_name,"data%d.txt",n);    return file_name;}//将原文件分割成多个小文件，并在内存中排序int memroy_sort(){    FILE * fp_in_file = fopen("data.txt","r");    check_fp(fp_in_file);    int counter = 0;    while(true)    {        int * space = new int(memory_size);        int num = read_data(fp_in_file,space);        if(num == 0)            break;        qsort(space,num,sizeof(int),compare);        string file_name = new_filename(++counter);        FILE *fp_aux_file = fopen(file_name,"w");        check_fp(fp_aux_file);        write_data(fp_aux_file,space,num);        fclose(fp_aux_file);        delete []space;    }    fclose(fp_in_file);    return counter;}//将n个小文件归并为一个文件，多路归并void merge_sort(int file_num){    if(file_num < 0)        return;    FILE *fp_out_file = fopen("result.txt","w");    check_fp(fp_out_file);    FILE ** fp_array = new FILE*[file_num];  //存放每个小文件的指针的数组    int i;    for(i = 0;i<file_num;i++)    {        string file_name = new_file_name(i+1);        fp_array[i] = fopen(file_name,"r");        check_fp(fp_array[i]);    }    int * first_data  = new int [file_num];    bool * finish  = new bool[file_num];  //文件是否读取到结尾    memset(finish,false,sizeof(bool) * file_num);    for(i = 0;i<file_num;i++)        fscanf(fp_array[i],"%d ",&first_data[i]);    while(true)    {        int index = 0;        while(index < file_num && finish(index))            index++;        if(index >=file_name)            break;        int min_data = first_data[index];        for(i = index+1;i<file_name,i++)        {            if(min_data > first_data[i] && !finish[index])            {                min_data = first_data[i];                index = i;            }        }        fprintf(fp_out_file ,"%d ",min_data);  //将最小的输出        if(fscanf(fp_array[index],"%d ",&first_data[index]) == EOF) //根据index，找到该文件的下一个数，放入到first_data中。如果这个文件已经读取到结尾，则将标志置为true。            finish(index) = true;    }    fclose(fp_out_file);    delete []finish;    delete[]first_data;    for(i = 0;i<file_num;i++)        fclose(fp_array[i]);    delete[] fp_array;}int main(){    clock_t start = clock();    int aux_file_num = memory_sort();    clock_t memory_end = clock();    cout << "time need in memory sort" << memory_end-start << endl;    merge_sort(aux_file_num);    clock_t end = clock();    cout << "the time need in merge sort" << end - memory_end << endl;    return 0;}

qsort()用法

int cmp(const void* a,const void * b);
void qsort(char *,int n,int m,cmp);
包含在stdlib.h中，函数四个参数，
参与排序的数组，元素个数，单个元素到小(sizeof),比较函数。
再说比较函数，返回正数，a要放在b后面，返回负数，a要放在b前面，返回0，相等。

解决问题的关键是在于熟悉一个算法，而不是某一问题，
通过这个问题，我们学到了两种方法：
一种：位图法，
针对与不重复数据排序，进行数据的快速查找，判重，删除。
二中：多路归并
海量数据，内存有限的情况下。