外排序

什么是外排序？

外排序（External sorting）是指能够处理极大量数据的排序算法。通常来说，外排序处理的数据不能一次装入内存。（摘自百度）

再简单点来说。比如我们要对10亿个数进行排序。如果用int[]来存储这10亿个数的话，我们需要3*1000000000/8/1024/1024/1024≈3.7G。对于只有2G内存的电脑来说根本就跑不起来。所以这时候什么内存排序算法都玩不起来了。

外排序的思想是将这10亿条数据分割成N个小项（比如每个分割项放2000条数据，然后对这2000条数据进行排序[2000个int放入内存当中只需要7.8K]，排序后写入一个txt文件中）。这样就能得到N个有序的小项。再把这些小项通过运算聚合起来，得到最终结果。说白了其实就跟归并排序思路相似。

拿实际生活举例，比如我们想知道一个图书馆有多少本书，你会怎样做？自己一个一口气肯定数不完。只能今天数一个区域，得到一个总数。明天数另外一个区域得到一个总数。最后把所有总数聚集起来。又或者将图书馆分成N个区域，然后找N个人来数这N个区域。他们数完后向你汇报，你再把他们汇报的结果聚集起来得到最终结果。这跟google提出的MapReduce思想相似。跟之前一个人数的区别只在于一个是单线程，一个是多线程。

知道了思路之后，我们实现起来也就非常简单了

static void Main(string[] args)
{
int count = 11;//生成数据的数量
int step = 2;//设置分割时每份多少条
var sourcepath = string.Format("{0}{1}.txt", AppDomain.CurrentDomain.BaseDirectory, "source");
Init(sourcepath, count);//初始化数据--把所有数据写入source.txt的文件中
Queue<string> queue = Skip(sourcepath, step);//分割source.txt文件，并将每份都进行排序。所以分割后的每个文件中的内容都是有序的
while (queue.Count > 1)//把有序的队列聚合在一起
{
Sort(queue);
}
System.Diagnostics.Process.Start(queue.First());//显示结果
}

/// <summary>
/// 初始化数据
/// </summary>
/// <param name="sourcepath"></param>
/// <param name="count"></param>
private static void Init(string sourcepath, int count)
{
using (StreamWriter writer = new StreamWriter(sourcepath, false))
{
Random random = new Random();
for (int i = 0; i < count; i++)
{
writer.WriteLine(random.Next(1000));
}
writer.Close();
}
}

/// <summary>
/// 对源数据进行分割
/// </summary>
/// <param name="sourcepath"></param>
/// <param name="step"></param>
/// <returns></returns>
private static Queue<string> Skip(string sourcepath, int step)
{
Queue<string> queue = new Queue<string>();
StreamReader read = new StreamReader(sourcepath);
while (true)
{
List<long> temp = new List<long>();
for (int i = 0; i < step; i++)
{
string value = read.ReadLine();
if (string.IsNullOrEmpty(value))
break;
temp.Add(long.Parse(value));
}
if (temp.Count == 0)
break;
string tempfile = null;
do
{
tempfile = string.Format("{0}{1}.txt", AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("MMddHHmmssfff"));
}
while (File.Exists(tempfile));
StreamWriter writer = new StreamWriter(tempfile);
temp = temp.OrderBy(x => x).ToList();
temp.ForEach(x => writer.WriteLine(x));
queue.Enqueue(tempfile);
writer.Close();
writer.Dispose();
}
read.Close();
read.Dispose();
return queue;
}

private static void Sort(Queue<string> queue)
{
StreamReader read1 = new StreamReader(queue.Dequeue());
StreamReader read2 = new StreamReader(queue.Dequeue());
Func<StreamReader, long?> GetValue = (x) =>
{
string temp = x.ReadLine();
if (temp == null)
return null;
return long.Parse(temp);
};
long? value1 = GetValue(read1);
long? value2 = GetValue(read2);
string resultpath = null;
do
{
resultpath = string.Format("{0}{1}.txt", AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("MMddHHmmssfff"));
}
while (File.Exists(resultpath));
StreamWriter writer = new StreamWriter(resultpath);
while (value1.HasValue && value2.HasValue)
{
if (value1 < value2)
{
writer.WriteLine(value1);
value1 = GetValue(read1);
}
else
{
writer.WriteLine(value2);
value2 = GetValue(read2);
}
}
while (value1.HasValue)
{
writer.WriteLine(value1);
value1 = GetValue(read1);
}
while (value2.HasValue)
{
writer.WriteLine(value2);
value2 = GetValue(read2);
}
queue.Enqueue(resultpath);
read1.Close();
read1.Dispose();
read2.Close();
read2.Dispose();
writer.Close();
writer.Dispose();
}

可以看出思路其实很简单。首先把大量数据细分为N个小块（相当于图书馆划分区域）。然后这N个小块各自进行排序（相当于划分完区域后开始点算书籍数量）。最后再把结果聚集起来。

下回将介绍使用压缩的方式在内存中对大量数据进行排序的思路。