【推荐】C# 实现 100G数据文件查找100个最大值 【2010支付宝西安最新笔试题】

[happyer_longlong]

问题： 有一个100G大小的文件里存的全是数字，并且每个数字见用逗号隔开。现在在这一大堆数字中找出100个最大的数出来。
见原帖 http://topic.csdn.net/u/20091013/10/d5d371dc-6dec-4034-bf31-432a47ffce96.html
假设：1 文件中整数所占的字节数为固定
假设：2 文件中没有换行
假设：3 文件中 每两个数据之间都有个 逗号 分割
废话少说 代码如下
using System;
using System.Collections.Generic;
using System.Threading;
using System.Linq;
using System.Text;
using System.IO;
namespace BigFile
{
class Find
{
public byte[] Block; //文件缓冲区
public string filePath; //文件路径
public FileStream ft; //文件流
public int MaxSize; //每次处理的最大数字个数
public char s; //分割符号
public Int16 dot; //分隔符号
public int[] Result; //存放的数组
public int NumberSize = 4; //整数所占的字节
public int DotSize = 2; // ，号所占的字节
public long fileLength; //要处理的文件总大小
public long current; //当前处理的位置 字节数
public long start; //开始读取的字节 用于多线程
public long end; //最后读取的字节 用于多线程
public LinkedList<int> list; //用于存放100个数的队列
/// <summary>
/// 构造函数
/// </summary>
/// <param name="file">要打开的文件的路径</param>
public Find(string file)
{
this.MaxSize =10000000;
this.Block = new byte[MaxSize * (NumberSize + DotSize)];
this.filePath = file;
this.s = ',';
this.dot = (Int16)this.s;
this.Result = new int[100];
this.ft = File.Open(this.filePath, FileMode.Open, FileAccess.Read, FileShare.Read); //可以不共享模式打开
this.fileLength = ft.Length;
this.start = 0;
this.end = this.fileLength;
}
/// <summary>
/// 用于多线程的构造函数
/// </summary>
/// <param name="file">文件路径+路径</param>
/// <param name="start">开始处理的字节</param>
/// <param name="end">结束处理的字节</param>
public Find(string file, long start, long end)
{
this.MaxSize = 10000000;
this.Block = new byte[MaxSize * (NumberSize + DotSize)];
this.filePath = file;
this.s = ',';
this.dot = (Int16)this.s;
this.Result = new int[100];
this.start = start;
this.end = end;
this.ft = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read); //共享模式打开
this.fileLength = ft.Length;
}
/// <summary>
/// 析构函数
/// </summary>
~Find()
{
this.ft.Close();
}
/// <summary>
/// 读取100个
/// </summary>
/// <param name="array"></param>
public void Initial(ref int[] array)
{
for (int i = 0; i < array.Length; i++)
{
array[i] = BitConverter.ToInt32(Block, i * (NumberSize + DotSize));
}
}
/// <summary>
///测试专用 创造一个数据文件
/// </summary>
/// <param name="filepath">文件名</param>
public static void WriteFile(string filepath,int MaxCount)
{
char s = ',';
Int16 dot = (Int16)s;
FileStream ft = File.Open(filepath, FileMode.OpenOrCreate);
BinaryWriter w = new BinaryWriter(ft);
// Random ra = new Random(1000); //随机产生数据 随机数据不好用于测试
for (int i = 0; i < MaxCount; i++)
{
w.Write(i); //w.Write(ra);
w.Write(dot);
}
w.Close();
ft.Close();
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="file">数据缓冲区</param>
/// <param name="start">开始读取的位置</param>
/// <param name="count">读取结束的位置</param>
public void ReadFile( ref byte[] file, long start, int count)
{
this.ft.Position = start;
ft.Read(file, 0, count);
this.current += count;
}
/// <summary>
/// 获得排序后的数组
/// </summary>
public void GetArray()
{
Array w = this.Result.ToArray();
Array.Sort(w);
this.Result =(int[]) w; //强制转换为 int[]
}
/// <summary>
/// 将数组转化成为 LinkedList 有好的发现也可以转换为其他结构
/// </summary>
public void GetLinkedList()
{
//以下代码可以将this.Result初始化为最坏的情况
int m = 99999900;
for (int i = 0; i < 99; i++)
this.Result[i] = m + i;
this.Result[0] = 0;
this.list = new LinkedList <int>(this.Result);
}
/// <summary>算法核心
/// 大于队列最小值 则插入队列 同时Remove 掉最小值
/// 需要改进下插入算法 能改成 二分查找 插入 效率最好
/// </summary>
/// <param name="mid"></param>
public void Insert(int mid)
{
//小于最小的值
if(mid<=this.list.First.Value)
return;
//创建个新节点
LinkedListNode<int> linkNode=this.list.Last ;
//当前节点如果不小于 mid 就往前一个节点移动
while (linkNode.Value >= mid)
{
linkNode = linkNode.Previous;
}
//加入新LinkNode
this.list.AddAfter(linkNode, mid);
//去掉最小的 LinkNode
this.list.RemoveFirst();
}
/// <summary>处理核心
/// 分块载入数据 处理数据
/// </summary>
public void Research()
{
this.ReadFile(ref this.Block,this.start, 100*(this.NumberSize+this.DotSize)); //读入指定文件位置this.start的100个数
this.Initial(ref this.Result);
this.GetArray(); //将 this.Result 排序
this.GetLinkedList(); //获得 LinkedList
int temp=0;
while ((this.end - this.current) > this.Block.Length)
{
this.ReadFile( ref this.Block, this.current, (int)this.Block.Length); //循环读入分块数据
for (int i = 0; i < this.MaxSize; i++)
{
this.Insert (BitConverter.ToInt32(Block, i * (NumberSize + DotSize)));//处理每个转化过来的数字
}
Console.WriteLine("完成");
}
temp=(int)this.current; //记录最后一次载入时候的字节流位置
this.ReadFile( ref this.Block, this.current, (int)(this.end -this.current));
//比较剩余的数据
for (int i = 0; i < (this.end - temp)/(this.NumberSize+this.DotSize); i++)
{
this.Insert(BitConverter.ToInt32(Block, i * (NumberSize + DotSize)));
}
}
//// 以下都是多线程处理
/// <summary>
/// 多线程处理方法
/// </summary>
/// <param name="count">指定一共运行几个线程</param>
public void ThreadResearch(int count)
{
if (this.fileLength % count != 0) //不能均等分数据块情况
count++;
long[] Start = new long[count]; //用于保存起始位置的数组
long[] End = new long[count]; //用于保存结束位置的数组
Thread[] Threadarray=new Thread[count];
Find[] Findarray=new Find[count];
int s = (int)this.fileLength / count;
for (int i = 0; i < count; i++)
{
Start[i]=i*s;
End[i] = (i+1) * s-1;
Findarray[i] = new Find(this.filePath,Start[i],End[i]);
Threadarray[i] = new Thread(Findarray[i].Research);
}
///以下三行代码 是 最后一个线程的设置
End[End.Length - 1] = this.fileLength; //不管能否除尽 都设置最后一个结束位置
Findarray[Findarray.Length-1] = new Find(this.filePath, Start[Start.Length-1], End[End.Length -1]);
Threadarray[Threadarray.Length-1] = new Thread(Findarray[Findarray.Length -1].Research);
//启动各个线程
foreach (Thread td in Threadarray)
{
td.Start();
}
//等待线程全部结束
foreach (Thread td in Threadarray)
{
while (td.IsAlive == true)
Thread.Sleep(100);
}
//获取所有处理过后的this.List
int[] FinalResult=new int[100*count];
int index=0;
foreach(Find fd in Findarray)
{
fd.list.CopyTo(FinalResult,index*100);
index++;
}
//sort()排序
Array w = FinalResult.ToArray();
Array.Sort(w); //排序
for (int i = 0; i < 100; i++)
{
this.Result[i] = FinalResult[FinalResult.Length - 100 + i];
}
}
}
class Program
{
static void Main(string[] args)
{
string path = @"D:\1.txt";
// test.WriteFile(test.filePath ); //创建测试文件
int threadcount = 3;
Find test = new Find(path);
Console.WriteLine(DateTime.Now );
// test.ThreadResearch(threadcount); //多线程处理 结果放在 test.Result 中
test.Research(); //单线程处理 结果放在 test.List 中
Console.WriteLine(DateTime.Now);
foreach (int i in test.Result)
{
Console.WriteLine(i);
}
Console.ReadKey();
}
}
}
测试数据为 1.1G左右的数据文件
留待解决的问题：
1 单线程 的效率比 多线程的效率 感觉还要高 【难道是 IO 效率引起的问题】
2 不知道100G 的文件能否顺利处理
3 核心 插入 函数需要改进改进 【改造成个 能够实现二分查找 插入的队列】
来 高手给改进改进 100G 处理时间要论小时计算了 哎........效率问题
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/happyer_longlong/archive/2009/10/25/4726686.aspx

[happyer_longlong]

终于忙完了 回来了

[pyyyf_java]

学习了。

[芽疼]

[Quote=引用 97 楼 billhoward 的回复:]
牛人啊，我什么时候学会啊！
[/Quote]
恩 真牛 。。。。

[wxd024]

帮顶，关注

[groupc]

这么多的数字,最后结果很可能是100个9999999.

[rightthgir]

[Quote=引用 77 楼 heguodong 的回复:]
我觉得100G的文件对于哪个平台下处理都是海量数据,对于海量数据算法的一点点差别会造成巨大的差异
我看了部分回贴,感觉大家的意见基本上分两种
1,保留100个长度的数组,扫描文件的时候更新这个数组
2,排序
对于第一种方法,时间是100*100G的量级上,过大,难以接受
对于第二中方法,时间是100G*ln100G(可能有错误),反正量级更大,显然直接否定
在这里,我们需要一些更加明确的前提:
1,操作系统是64位还是32位?
如果是32位的明显用C的库无法操作,因为32位下,C库里的文件指针偏移最大只能到2的32次方,64位的应该可以(本人暂时还没有使用64位平台,所以也只能假定),本人只做win32开发,只知道32位下可以通过文件印射访问超大文件
2,这个文件里的数据是有没有个范围?
  比如里面是电话号码?还是身份证号?
  如果能明确这一点,那么我们能确定里面的数字在一个范围(0---N)
这几点如果明确了,我说下我的想法
1,建立一个N长度的数组A,即使需要几G的空间,我认为也可以接受
2,扫描文件,每扫描到一个数字X,就把A[X]设置为1,这个操作只需要访问一次内存,效率很高
3,扫描结束后,根据数组A里的标志位,从大到小抽100个状态为1的数字
请批评指正
[/Quote]


用位数组 更好些

[logan2009]

文件不是进行过管理的嘛！

[yunvi]

[Quote=引用 77 楼 heguodong 的回复:]
我觉得100G的文件对于哪个平台下处理都是海量数据,对于海量数据算法的一点点差别会造成巨大的差异
我看了部分回贴,感觉大家的意见基本上分两种
1,保留100个长度的数组,扫描文件的时候更新这个数组
2,排序
对于第一种方法,时间是100*100G的量级上,过大,难以接受
对于第二中方法,时间是100G*ln100G(可能有错误),反正量级更大,显然直接否定
在这里,我们需要一些更加明确的前提:
1,操作系统是64位还是32位?
如果是32位的明显用C的库无法操作,因为32位下,C库里的文件指针偏移最大只能到2的32次方,64位的应该可以(本人暂时还没有使用64位平台,所以也只能假定),本人只做win32开发,只知道32位下可以通过文件印射访问超大文件
2,这个文件里的数据是有没有个范围?
  比如里面是电话号码?还是身份证号?
  如果能明确这一点,那么我们能确定里面的数字在一个范围(0---N)
这几点如果明确了,我说下我的想法
1,建立一个N长度的数组A,即使需要几G的空间,我认为也可以接受
2,扫描文件,每扫描到一个数字X,就把A[X]设置为1,这个操作只需要访问一次内存,效率很高
3,扫描结束后,根据数组A里的标志位,从大到小抽100个状态为1的数字
请批评指正
[/Quote]
你的思想非常好啊。而且简单

[坎离枫]

以前看到一个类似的：
有一个非常大的文件中存电话号码。现有一台内在存1M（排除运行排序程序占用的空间）的电脑，用最短的时间把文件中的电话号码排序。用的是把1M的空间全用来存一个长度为1M的数据A。把电话号码当成数字按位排序。如"00000000001"就把A的第一位换成1，"0000,0000010(十进制数字10)"就把A的第10位换成1，以此类推。最后把A按最高位（或最低位）开始输出，输出后就排好序了。

[nankaiwx]

可否不读取所有的数据呢？

[shewoqishuilxl]

学习。。。。。。。。

[CarefulCroton]

学习 看贴不回是可耻的

[weblai]

建议用单线程内存文件映射。

[maycxd]

饿,还真难看懂 - -

[sesdf]

问题感觉很高深。

[AlenLiu]

为什么非要存在一个文件里呢？

[小晏]

这种问题只与硬盘相关，硬盘本身的速度限制是不可能从算法上面突破的。
不要想当然的去开多线程读取硬盘，那样只会增加硬盘的寻道时间和旋转时间。

[cryakult]

来学习学习~~~~

[g15215761432]

很好狠强大

[intotheland]

2个线程，一个线程不停的读取字节数组到缓存，另外一个线程先把最先的100个存起来降序排列，监视缓存里面是否有新的数据，有新的字节数组拿来比较就OK了。
一般来说只要你的排序插入的算法写的不是太烂，读取数据读完最大的100个数也出来了。