外排序(磁盤排序)之多路歸併排序的簡單實現(轉)

摘要：本文簡要介紹了當數據量大到不適合在內存中排序時，利用磁盤進行排序的多路歸併算法。

關鍵字：外排序，磁盤排序，多路歸併

下面以一個包含很多個整數的大文件爲例，來說明多路歸併的外排序算法基本思想。假設文件中

整數個數爲N(N是億級的)，整數之間用空格分開。首先分多次從該文件中讀取M（十萬級）個整數，

每次將M個文件在內存中使用快排序之後存入臨時文件，然後使用多路歸併將臨時文件中的數據牌號序

存入輸出文件。顯然，該排序算法需要對每個整數做2次磁盤讀和2次磁盤寫。

下面代碼是基於以上思想對包含大量整數文件的從小到大排序的一個簡單實現，這裏沒有使用內存緩

衝區，在歸併時簡單使用一個數組來存儲每個臨時文件的第一個元素。

/*使用多路歸併進行外排序的類*****/

//ExternSort.h

/*
* 大數據量的排序
* 多路歸併排序
* 以千萬級整數從小到大排序爲例
* 一個比較簡單的例子，沒有建立內存緩衝區
*/

#ifndef EXTERN_SORT_H
#define EXTERN_SORT_H

#include <cassert>

class ExternSort
{
public:
        void sort()
        {
                time_t start = time(NULL);

                //將文件內容分塊在內存中排序，並分別寫入臨時文件
                int file_count = memory_sort();

                //歸併臨時文件內容到輸出文件
                merge_sort(file_count);

                time_t end = time(NULL);
                printf("total time:%f\n", (end - start) * 1000.0/ CLOCKS_PER_SEC);
        }

        //input_file:輸入文件名
        //out_file:輸出文件名
        //count: 每次在內存中排序的整數個數
        ExternSort(const char *input_file, const char * out_file, int count)
        {
                m_count = count;
                m_in_file = new char[strlen(input_file) + 1];
                strcpy(m_in_file, input_file);
                m_out_file = new char[strlen(out_file) + 1];
                strcpy(m_out_file, out_file);
        }
        virtual ~ExternSort()
        {
                delete [] m_in_file;
                delete [] m_out_file;
        }

private:
        int m_count; //數組長度
        char *m_in_file;   //輸入文件的路徑
        char *m_out_file; //輸出文件的路徑
protected:
        int read_data(FILE* f, int a[], int n)
        {
                int i = 0;
                while(i < n && (fscanf(f, "%d", &a[i]) != EOF)) i++;
                printf("read:%d integer\n", i);
                return i;
        }
        void write_data(FILE* f, int a[], int n)
        {
                for(int i = 0; i < n; ++i)
                        fprintf(f, "%d ", a[i]);
        }
        char* temp_filename(int index)
        {
                char *tempfile = new char[100];
                sprintf(tempfile, "temp%d.txt", index);
                return tempfile;
        }
        static int cmp_int(const void *a, const void *b)
        {
                return *(int*)a - *(int*)b;
        }

        int memory_sort()
        {
                FILE* fin = fopen(m_in_file, "rt");
                int n = 0, file_count = 0;
                int *array = new int[m_count];
                //每讀入m_count個整數就在內存中做一次排序，並寫入臨時文件
                while(( n = read_data(fin, array, m_count)) > 0)
                {
                        qsort(array, n, sizeof(int), cmp_int);
                        char *fileName = temp_filename(file_count++);
                        FILE *tempFile = fopen(fileName, "w");
                        free(fileName);
                        write_data(tempFile, array, n);
                        fclose(tempFile);
                }
                delete [] array;
                fclose(fin);

                return file_count;
        }

        void merge_sort(int file_count)
        {
                if(file_count <= 0) return;
                //歸併臨時文件
                FILE *fout = fopen(m_out_file, "wt");
                FILE* *farray = new FILE*[file_count];
                int i;
                for(i = 0; i < file_count; ++i)
                {
                        char* fileName = temp_filename(i);
                        farray[i] = fopen(fileName, "rt");
                        free(fileName);
                }

                int *data = new int[file_count];//存儲每個文件當前的一個數字
                bool *hasNext = new bool[file_count];//標記文件是否讀完
                memset(data, 0, sizeof(int) * file_count);
                memset(hasNext, 1, sizeof(bool) * file_count);

                for(i = 0; i < file_count; ++i)
                {
                        if(fscanf(farray[i], "%d", &data[i]) == EOF)//讀每個文件的第一個數到data數組
                                hasNext[i] = false;
                }
                while(true)
                {
                        //求data中可用的最小的數字，並記錄對應文件的索引
                        int max = data[0];
                        int j = 0;
                        for(i = 0; i < file_count; ++i)
                        {
                                if(hasNext[i] && max > data[i])
                                {
                                        max = data[i];
                                        j = i;
                                }
                        }
                        if(j == 0 && !hasNext[0]) break; //沒有可取的數字，終止歸併

                        if(fscanf(farray[j], "%d", &data[j]) == EOF) //讀取文件的下一個元素
                                hasNext[j] = false;
                        fprintf(fout, "%d ", max);

                }

                delete [] hasNext;
                delete [] data;

                for(i = 0; i < file_count; ++i)
                {
                        fclose(farray[i]);
                }
                delete [] farray;
                fclose(fout);
        }
};
#endif

/****測試主函數文件*******************************/

/*
* 大文件排序
* 數據不能一次性全部裝入內存
* 排序文件裏有多個整數，整數之間用空格隔開
*/

#include <iostream>
#include <ctime>
#include <fstream>
#include "ExternSort.h"
using namespace std;

const unsigned int count = 100000000; // 文件裏數據的行數

const unsigned int number_to_sort = 1000000; //在內存中一次排序的數量

const char *unsort_file = "unsort_data.txt"; //原始未排序的文件名

const char *sort_file = "sort_data.txt"; //已排序的文件名

void init_data(unsigned int num); //隨機生成數據文件

int main(int argc, char* *argv)
{
        srand(time(NULL));
        init_data(count);
        ExternSort extSort(unsort_file, sort_file, number_to_sort);
        extSort.sort();
        system("pause");
        return 0;
}

void init_data(unsigned int num)
{
        FILE* f = fopen(unsort_file, "wt");
        for(int i = 0; i < num; ++i)
                fprintf(f, "%d ", rand());
        fclose(f);
}