5亿整数的大文件，怎么排？

题目和背景可以参看这里：http://weibo.com/p/1001603856172376577500 和 http://blog.jobbole.com/87600/

这里不妨明确下题目：给定一个大文件，内含5亿个整数，每个整数都属于1-9999999之间。请设计方案，对这些元素进行排序，并将排序结果写成文件输出。可用内存不超过2G。

注意到元素一共有5亿个，因此，文件中肯定存在重复元素，也就是说有些元素不止出现一次，因此基于朴素的bitmap并不能胜任此题。

由于lau叔提供的数据集下载太麻烦，因此自己手动生成了一个。

这里提供两个方案：

方案I：由于每个元素都不超过9999999，因此，可以考虑使用CountingSort（计数排序），统计每个元素出现的次数。如果文件中1出现三次，2出现三次，5出现两次，那么最后的结果就是11122255。对CountingSort的进一步介绍，可以参考《算法导论》

 

#include<iostream>

using namespace std;

const int MAX = 9999999;

int C[MAX + 1] = { 0 };

void countingSort()

{

    char filename_in[] = "E:\\in.txt";

    FILE *fp_in = fopen(filename_in, "r");

    char content[10];

    while (!feof(fp_in))

    {

        fgets(content,10, fp_in);

        int element = atoi(content);

        ++C[element]; //counting...

    }

    fclose(fp_in);

    //output

    char filename_out[] = "E:\\out.txt";

    FILE *fp_out = fopen(filename_out, "w");

    for (int i = 1; i <= MAX;i++)

    {

        for (int j = 1; j <= C[MAX]; j++)

        {

            fprintf(fp_out, "%d\n", i);

        }

    }

    fclose(fp_out);

}

int main()

{

    countingSort();

    system("pause");

    return 0;

}

 

方案II

我们可以使用k-路归并策略，也就是原文提到的外部排序。我们先按行读入文件，分批排序，输出k个临时的小文件，其中每个小文件都是有序的。这样，我们得到k个有序的小文件，问题转换为对这k个有序小文件的合并。

说明：

1，原文评论列表中，网友iduanyingjie 的评论 “ 外部排序的第2部分【合】的时候，没必要每次去取一个最小值。因为文件1,文件2,文件3每个文件中拿出的最小值，肯定是这三个文件中的最小的3个值了，将这三个值进行排序（1,2,3），直接写入大文件。第二回合中就直接取出的是（4,5,6） ”并不正确。考虑如下的三个有序小文件：

20 50 60

40 45 70

70 85 90

首选取出20、40、70，排序比较后输出最小的元素20，此时正确的做法是从第一个文件（也就是最小元素20所在的那个文件）读出50，然后从50、40、70中选出最小元素，也就是50，输出。接着从50所在的文件也就是第一个文件读出60，从60、40、70选出最小元素也就是40输出。以此类推。此时，并不能按照网友iduanyingjie  所说的简单的排序输出、排序输出。

因此，正确的做法是，读入k个元素，输出最小元素，再从最小元素所在的文件读下一个元素，继续选择最小元素输出；直到k个有序文件中的所有元素都处理完毕为止。

 

2，由于选择最小值是一个很关键的操作，因此可以使用包含k个元素的最小堆来高效的完成。整个过程就转换为：输出最小、替换堆顶、重建堆；输出最小、替换堆顶、重建堆......

 

3，当某个小文件的元素都处理完毕后，此时我们采取的策略是移动堆底部的元素到堆顶，并将堆大小减去1。这样，当堆大小为0的时候，说明所有的文件中的所有元素都处理完毕了。为了知道最小元素所在的文件，我们需要一个变量来记录文件号。

 

 

#include<iostream>

using namespace std;

const int K = 500;

struct Node 

{

    int value;

    int file_id;

};

class Heap

{

public:

    Heap(int capacity)

    {

        this->capacity = capacity;

        this->size = 0;

        p = new Node[this->capacity + 1];

    }

    void buildMinHeap() 

    {

        for (int i = size / 2; i >= 1; i--)

        {

            minHeapify(i);

        }            

    }

    void insertNode(Node t)

    {

        size++;

        p[size].value = t.value;

        p[size].file_id = t.file_id;

    }

    Node getMin()

    {

        return p[1];

    }

    int getHeapSize()

    {

        return size;

    }

    void minHeapify(int i) 

    {

        int left = 2 * i;

        int right = 2 * i + 1;

        int min = i;

        if (left <= size && p[left].value < p[i].value)

        {

            min = left;

        }            

        if (right <= size && p[right].value < p[min].value)

        {

            min = right;

        }            

        if (min != i) 

        {

            Node tmp = p[i];

            p[i] = p[min];

            p[min] = tmp;

            minHeapify(min);

        }

    }

    void replaceRootNodeByLastNode()

    {

        p[1] = p[size];

        size--;

    }

    void replaceRootNodeByNextElement(Node n)

    {

        p[1] =n;

    }

    ~Heap()

    {

        delete[]p;

    }

private:

    Node *p;

    int size;

    int capacity;

};

Node getOneElement(FILE* & fp,int file_id)

{

    char content[10];

    Node ret;

    if(!feof(fp))

    {

        fgets(content, 10, fp);

        int element = atoi(content);

        ret.file_id = file_id;

        ret.value = element;

    }

    else

    {

        ret.value = -1;

    }

    return ret;

}

void writeResult(FILE* & fp, int element)

{

    fprintf(fp, "%d\n", element);

}

void kWayMergeViaHeap(FILE** fp)

{

    Heap *pHeap = new Heap(K);

    for (int i = 0; i <K; i++)

    {

        Node t = getOneElement(fp[i], i);

        pHeap->insertNode(t);

    }

    pHeap->buildMinHeap();

    char filename_output[] = "E:\\outT.txt";

    FILE *fp_out = fopen(filename_output, "w");

    while (pHeap->getHeapSize()>0) 

    {

        Node minNode = pHeap->getMin();

        writeResult(fp_out, minNode.value);

        Node t = getOneElement(fp[minNode.file_id], minNode.file_id);

        if (t.value==-1) //there are no elements in fp[minNode.file_id] 

        {

            pHeap->replaceRootNodeByLastNode();

        }

        else 

        {

            pHeap->replaceRootNodeByNextElement(t);

        }

        pHeap->minHeapify(1);

    }

    //

    for (int i = 0; i <K; i++)

    {

        fclose(fp[i]);

    }

    fclose(fp_out);

    delete pHeap;

}

 

 

 

1，堆的实现大学时候写的，参照《算法导论》完成，尽管进一步的加速和优化是可能的。例如，minHeapify函数的末尾是一个尾递归，可以通过循环来代替。当然啦，开启编译器优化之后编译器可能会自动完成，因此2*i这类语句就真没必要用移位操作了。再例如，getOneElement中的接口设计，返回Node意味着需要构造函数开销，当然设计为只返回int更佳，但是后面就稍微麻烦了点。

2，堆是非常有用的一种数据结构，不仅可以用于k路合并，也可以用于k路求交（求k个有序链表/文件的交集），试试看。

3，对于输出，其实可以通过一个buffer保存一定量的元素之后，再一口气刷到硬盘上。麻烦，不写了。

4，为什么io部分用C，而其他部分用C++？这是因为C++的io实在是太慢了，慢的吓人。