多路归并排序

下面的问题描述及相关文字参考于CSDN中JULY的博客，在此对JULY表示感谢。JULY的博客地址如下：

http://blog.csdn.net/v_JULY_v/article/details/6451990

1. 问题描述

输入：一个最多最多含有n个正整数的大文件，并且不含重复元素，每个数都小于等于n，且n=10^7

输出：得到按从小到大升序排列的输出序列

条件：最多含有约1MB的内存空间，但磁盘空间足够

2. 算法描述

由于本题的特殊性，不含重复的正整数，因此可以考虑位图排序

基本思路是：用一个bit的0/1来标志一个数据, 如果数据存在就置为1，最后遍历所有位，检查是否存在该数据，如果存在直接输出，输出的序列已经有序，这里需要标志10^7个数据，需要内存10^7/8=1.25MB，但是题目要求最多1MB内存空间。这里稍作变通，分两次读入数据，第一次遍历读入大小在0-49999990的数据，遍历位图输出，第二次读入大小在5000000-10000000的数据，遍历位图输出，每次使用内粗0.625MB，满足题意。

 这里使用STL的bitset会更简单

#include <stdio.h>
#include <stdlib.h>
#define width 5000000

int bit[(width>>5)+1];          /* 注意:移位操作符优先级比算术操作符低 */

void clear(int i)
{
    bit[i>>5] &= ~(1<<(i%32));
}

void set(int i)
{
    bit[i>>5] |= 1 <<(i & 31);
}
int test(int i)
{
    return bit[i>>5]&(1<<(i & 31));
}
int main()
{
    FILE * fpin, *fpout;
    int d;
    fpin=fopen("in","r");
    if(fpin==NULL)
        exit(1);
    for(int i=0;i<width;i++)
        clear(i);
    /* 由于内存容量限制，将磁盘文件分两批排序，第一匹先排序前半部分 */
    while(fscanf(fpin,"%d", &d)!=EOF)
        if(d < width)
            set(d);

    fpout=fopen("out","w");
    if(fpout==NULL)
        exit(1);

    for(int i=0;i<width;i++)
        if(test(i))
            fprintf(fpout,"%d\n",i);

    int length=fseek(fpin,0,SEEK_SET);
    if(length)                  /* 定位正确返回0 */
        exit(1);

    for(int i=0;i<width;i++)
        clear(i);
    while(fscanf(fpin,"%d", &d)!=EOF)
        if(d >= width && d < 10000000)
            set(d-width);

    for(int i=0;i<width;i++)
        if(test(i))
            fprintf(fpout,"%d\n",i+width);
    return 0;
}

位图排序速度很快，需要kn次遍历和n/k的内存空间，但是要求没有重复元素，当数据中有重复元素的时候位图排序就不好用了， 下面介绍借助败者树实现的外部多路归并排序。

假设文件中整数个数为N(N是亿级的)，整数之间用空格分开。首先分多次从该文件中读取M（十万级）个整数，每次将M个整数在内存中使用内部排序之后存入临时文件，这样就得到多个外部文件，对应于多个外部文件，我们可以利用多路归并将各个临时文件中的数据一边读入内存，一边进行归并输出到输出文件。显然，该排序算法需要对每个整数做2次磁盘读和2次磁盘写

归并多个临时文件的过程中，从每个临时文件中读入一个值，它们是对应临时文件中的最小值，可以采用遍历的方法选出这些数据中的最小值，使用时间为kn，这里可以采用败者树的方法，这样每次选出最小值的时候不用和所有数值进行比较，使用时间为klogn

整体算法流程如下

/**
 * @file   code.c
 * @author  <kong@KONG-PC>
 * @date   Sun Nov 25 21:25:36 2012
 *
 * @brief  多路归并排序，这里是10路归并排序
 *
 *
 */
#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <stdlib.h>

int a[1000000];                 /* 用来产生随机数 */
int b[100000];                  /* 用来暂存数据 */
char file_name[100][20];        /* 临时存储的文件名 */
FILE * file_fp[100];            /* 指向临时存储文件的指针 */

#define K 10                    /* K路归并排序 */
#define MIN -1                  /* 初始化败者树的时候做特殊值 */
#define MAX 100000000           /* 当某个临时文件读完时，叶子节点赋值
                                 * 为MAX，在程序中用来判断数据是否全部
                                 * 读取完毕 */

int loserTree[K];               /* 存储败者树中间节点值，下标0处存储冠军节点 */
int leaves[K+1];                /* 败者树的叶子节点从下标1开始存储叶子节点值，下标0处
                                 * 存储一个最小值节点 */
/**
 * 调整败者树
 *
 * @param i 需要调整的叶子节点的下标
 */
void adjust(int i)
{
    int parent=(i+K-1)/2;       /* 找到父节点 */
    while(parent>0)
    {
        if(leaves[i]>leaves[loserTree[parent]]) /* 和父节点比较，找到
                                                 * 新的优胜者 */
        {
            int temp=loserTree[parent];
            loserTree[parent]=i;
            /* i指向的是优胜者 */
            i= temp;
        }
        parent = parent / 2;
    }
    loserTree[0]=i;
}

void initLoserTree()
{
    leaves[0]=MIN;
    for(int i=0;i<K;i++)
        loserTree[i]=0;
    for(int i=K;i>0;i--)
        adjust(i);
}

void swap(int * a, int * b)
{
    int t= *a;
    *a=*b;
    *b=t;
}

int Rand(int begin, int end)
{
    int t = rand() % (end - begin) + begin;
    return t;
}

/**
 * 生成1000000个不重复的随机数
 *
 */
void rand_int()
{
    FILE * fp;
    fp = fopen("in", "w");
    assert(fp);
    srand(time(NULL));
    for(int i=0;i<1000000;i++)
        a[i]=i;
    for(int i=0;i<1000000;i++)
    {
        int t = Rand(i, 1000000);
        swap(&a[i],&a[t]);
    }
    for(int i=0;i<1000000;i++)
        fprintf(fp, "%d ", a[i]);
    fclose(fp);
}

int cmp(const void * m, const void * n)
{
    return *(int *)m - *(int *)n;
}

/**
 * 分K次读入文件，每次读入一部分数据，在内存中排完序之后，存入临时文件
 *
 */
void split_data()
{
    FILE * fp = fopen("in","r");
    assert(fp);
    for(int i=0;i<10;i++)
    {
        sprintf(file_name[i], "%s%d%s","data",i,".dat");
        file_fp[i] = fopen(file_name[i],"w");
        for(int j=0;j<100000;j++)
            if(fscanf(fp,"%d",&b[j]) == EOF)
                exit(1);

        /* 采用快速排序的方法 */
        qsort(b, 100000, sizeof(int), cmp);
        for(int j=0;j<100000;j++)
            if(fprintf(file_fp[i], "%d ", b[j]) == EOF)
                exit(1);
        fclose(file_fp[i]);
    }
    fclose(fp);
}

/** 
 * 将临时文件归并，结合败者树，每次从一列数中找出最小值的时候只需要
 * logn次比较,在时间要求不太明显的时候也可以遍历数组找出最值，比较次数
 * 为n
 *
 */
void merge_data()
{
    FILE * fp = fopen("out","w");
    int i;

    for(i=0;i<10;i++)
    {
        file_fp[i]=fopen(file_name[i],"r");
        assert(file_fp[i]);
    }

    /* 先从每个临时文件中读入一个数值，初始化叶子节点 */
    for(i=0;i<10;i++)
        if(fscanf(file_fp[i],"%d", &leaves[i+1])==EOF)
            leaves[i+1]=MAX;

    /* 构造败者树 */
    initLoserTree();

    while(1)
    {
        int flag = loserTree[0];
        int temp = leaves[flag]; /* 判断败者树的最小值，用来确定是否已
                                  * 经完全读取完毕 */
        if(temp==MAX)
            break;
        fprintf(fp, "%d ", temp);
        /* 输出最小值以后，再从响应的临时文件中读入一个数据，同时调整
         * 败者树 */
        if(fscanf(file_fp[flag-1], "%d", &leaves[flag]) == EOF)
            leaves[flag]=MAX;
        adjust(flag);
    }
    for(int i=0;i<10;i++)
        fclose(file_fp[i]);
    fclose(fp);
}


int main()
{
    rand_int();                 /* 产生随机数 */
    split_data();               /* 将大文件分成多个分别有序的临时文件 */
    merge_data();               /* 借助败者树将有序的临时文件归并在一起 */
    return 0;
}