1.有10亿个浮点数，从中找出1万个最大的数。写一个高性能的算法 .^_^..比我的算法快200分就都给你了..

[zhiang75]

1.有10亿个浮点数，从中找出1万个最大的数。写一个高性能的算法
凑个热闹...和我PK..谁的算法比我的快200分就给谁..

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace WindowsApplication14
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            for (int a = 0; a < 65536; a++)
            {
                container[a] = new List<float>();
            }
        }

        /// <summary>
        /// 内存容器
        /// </summary>
        List<float>[] container = new List<float>[65536];
        
        /// <summary>
        /// 可以使用的内存容器最小索引
        /// </summary>
        uint containerIndex = 0;

        /// <summary>
        /// 构造数据文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            FileStream data=File.Create("d:\\data.float", 1024 * 1024 * 10);
            DateTime bt1 = DateTime.Now;
            Random random=new Random();
            for (int a = 0; a < 200000000; a++)
            {
                double temp = random.NextDouble();
                int bi1 = random.Next(10000000);
                temp = temp * bi1;
                float rand = (float)temp;
                byte[] array = BitConverter.GetBytes(rand);
                data.Write(array,0,4);
            }
            data.Close();
            DateTime bt2 = DateTime.Now;
            this.Text=(bt2-bt1).ToString();
        }

        int addCount = 0;
        /// <summary>
        /// 将数据加入到容器
        /// </summary>
        /// <param name="value"></param>
        /// <param name="dataFrame"></param>
        void AddContainer(float value, uint dataFrame)
        {
            addCount++;

            uint index = dataFrame & 0x7FFF8000;//01111111 11111111 10000000 00000000
            index >>= 15;
            //以上获得8位指数和8位头尾数组成的索引
            if (index >= containerIndex)
            {
                container[(int)index].Add(value);
            }
            //每当添加的数据大于1000w时进行整理
            if (addCount > 10000000)
            {
                //计数器清零
                addCount = 0;

                //容器中数据量的合计
                int sumContainerCount = 0;

                for (int a = 65535; a >= 0; a--)
                {
                    sumContainerCount += container[a].Count;
                    if (sumContainerCount >= 10000)
                    {
                        //移动可以使用的容器索引,小于此索引的容器不可以使用
                        containerIndex = (uint)a;
                        break;
                    }
                }
                //清理不可以使用的容器,释放内存
                for (int a = 0; a < containerIndex; a++)
                {
                    container[a].Clear();
                }
            }


        }
        /// <summary>
        /// 合并数据整理输出
        /// </summary>
        /// <returns></returns>
        List<float> Retuen()
        {
            List<float> R = new List<float>();
            for (int a = 65535; a >= containerIndex; a--)
            {
                R.AddRange(container[a]);
            }
            //调用.Net内置排序器，其实就是快排
            R.Sort();
            //将顺序反转
            R.Reverse();
            //返回10000个最大的数
            return R.GetRange(0, 10000);
        }


        /// <summary>
        /// 计算获得1W个最大数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            for (int a = 0; a < 65536; a++)
            {
                container[a] = new List<float>();
            }
            containerIndex = 0;
            addCount = 0;
            
            
            FileStream data = File.OpenRead("d:\\data.float");
            DateTime bt1 = DateTime.Now;
            byte[] array = new byte[4];
            while (data.Read(array, 0, 4) > 0)
            {
                //转换为一个整数结构
                uint bi1 = BitConverter.ToUInt32(array,0);
                //还原为浮点数
                float bf1 = BitConverter.ToSingle(array, 0);
                AddContainer(bf1, bi1);
            }

            data.Close();
            Retuen();


            DateTime bt2 = DateTime.Now;
            this.Text = (bt2 - bt1).ToString();
        }
    }
}

[王集鹄]

const int numberCount = 100000000;
//上面的代码是1亿，改成：
const int numberCount = 1000000000;

[rangeon]

学习

[zhiang75]

...顶一下...

[zhiang75]

我非常认可,不过4G的东东不用文件不行啊...

[zhiang75]

[Quote=引用 21 楼 zswang 的回复:]
200000000？明显不是10亿，是2亿。
我建议不要折腾硬盘了（文件上G了）
直接按顺序生成10亿个随机数来处理。
只要随机种子一样，大家的数据也就一样。
运行后输出10个结果（每1000个抽出一个）。
如果结果都错了，再快的效率有何用？
本楼只是提供一个测试样本，看看楼主是否认可。

C# codeprivate void button1_Click(object sender, EventArgs e)
{
//常量固定
const int numberCount = 100000000;…
[/Quote]

我非常认可,不过4G的东东不用文件不行啊...

[王集鹄]

我的算法如下：

private void button1_Click(object sender, EventArgs e)
{                          
    const int numberCount = 1000000000;
    const int resultCount = 10000;
    double[] resultData = new double[resultCount];
    
    Random random = new Random(1000); // 随机数种子固定，这样保证大家测试的数据一致
    long tickCount = Environment.TickCount;

    #region 初始化
    int count = 0; // 所填的数据个数
    #endregion 初始化

    for (int i = 0; i < numberCount; i++)
    {
        double value = random.NextDouble();
        #region 处理数据
        if (count >= resultCount && value <= resultData[resultCount - 1]) continue;
        ///////Begin 对分查找
        int low = 0;
        int high = count - 1;
        while (low <= high)
        {
            int j = (low + high) >> 1; // 除2
            if (value < resultData[j])
                low = j + 1;
            else
            {
                high = j - 1;
                if (value == resultData[j]) low = j;
            }
        }
        if (low < count && low < resultCount - 1)
        {
            int l = count - low;
            if (low  + l > resultCount - 1) l--;
            Array.Copy(resultData, low, resultData, low + 1, l);
        }
        resultData[low] = value;
        if (count < resultCount) count++;
        ///////End 对分查找
        #endregion 处理数据
    }
    Console.WriteLine("运算耗时：{0}", Environment.TickCount - tickCount);

    #region 采用输出结果
    for (int i = 0; i < resultCount; i += resultCount / 10)
    {
        Console.WriteLine("返回结果[{0}]={1}", i, resultData[i]);
    }
    #endregion 采用输出结果
}

我的机器上(CPU：1.6G*2，内存：2G)运行的结果是：
[code=BatchFile]运算耗时：55766
返回结果[0]=0.999999998603016
返回结果[1000]=0.999999055173248
返回结果[2000]=0.999998114071786
返回结果[3000]=0.999997190199791
返回结果[4000]=0.999996206257491
返回结果[5000]=0.99999517155811
返回结果[6000]=0.999994183890519
返回结果[7000]=0.999993186444041
返回结果[8000]=0.999992232769724
返回结果[9000]=0.999991213902827[/code]

[qinglisheng]

mark

[王集鹄]

就是单独空循环10亿次也是很耗时间的（我机器上是30秒左右）

[vwxyzh]

修正一处错误，顺便稍微改一下：

        static float[] GetTop10000()
            const int MaxCount = 10000;
            const int FloatLength = 65536;
            const int ByteLength = FloatLength * 4;
            bool isInit = true;
            byte[] buf = new byte[ByteLength];
            byte[] byteData = new byte[ByteLength];
            float[] maxAfterMerge = new float[MaxCount];
            float[] maxBeforeMerge = new float[MaxCount];
            float[] current = new float[FloatLength];
            int readCount;
            float[] tempFloats;
            byte[] tempBytes;
            using (FileStream data = File.OpenRead("data.float"))
            {

                readCount = data.Read(byteData, 0, ByteLength);
                while (readCount == ByteLength)
                {

                    IAsyncResult ar = data.BeginRead(buf, 0, ByteLength, null, null);

                    Buffer.BlockCopy(byteData, 0, current, 0, ByteLength);

                    Array.Sort(current);
                    Array.Reverse(current);
                    if (isInit)
                    {
                        Buffer.BlockCopy(current, 0, maxBeforeMerge, 0, MaxCount);
                        isInit = false;
                    }
                    else
                    {

                        Merge(maxAfterMerge, maxBeforeMerge, current);

                        tempFloats = maxBeforeMerge;
                        maxBeforeMerge = maxAfterMerge;
                        maxAfterMerge = tempFloats;
                    }

                    readCount = data.EndRead(ar);

                    tempBytes = byteData;
                    byteData = buf;
                    buf = tempBytes;
                }
                // 需要讨论一下正好读完的情况，否则Merge方法会有逻辑错误
                if (readCount == 0)
                    return maxBeforeMerge;
                Buffer.BlockCopy(byteData, 0, current, 0, readCount);
                Array.Sort(current, 0, readCount >> 2);
                Array.Reverse(current, 0, readCount >> 2);

                Merge(maxAfterMerge, maxBeforeMerge, current, readCount >> 2);

                return maxAfterMerge;
            }
        }

顺便说一下，我的机器是T2400@1.83G，内存1G，比较小，硬盘是fujitsu mhv2060bh，都比较烂

对lz代码有少量修改：

        public Form1()
        {
            InitializeComponent();
        }

        // lz的算法需要的东西
        List<float>[] container = null;

在Button3_Click里面补上：

            container = new List<float>[65536];
            for (int a = 0; a < 65536; a++)
            {
                container[a] = new List<float>();
            }
            // ...lz的代码
            container = null;

实测：
程序绑定到CPU0后（强制单核），测试的结果是：
我的代码在运行时，使用约14m内存（包含Winform用掉的），CPU占49%（系统会占用1%），偶尔比较低（估计是磁盘碎片导致的）
lz的代码在运行时，使用约104m内存（包含Winform用掉的），CPU占10%-40%，平均在25%左右（估计我的硬盘实在太烂了，喂不饱lz高效的排序算法）

分析：
我的代码因为IO算法好，排序算法烂，所以CPU占用率高，最快时间受排序算法限制
lz的代码因为排序算法好，IO算法烂，所以CPU占用率低，最快时间受IO算法限制

例外：
如果内存足够大，并且Windows已经缓存这个或部分文件，或者因为机器原因IO性能很好（Raid 0或5，或者什么？Ram盘。。。），lz的代码瓶颈就消失了，所以，某些时候可以更快的完成。

[王集鹄]

.NET自身在IO上做了优化（也是分块读取，可以参考内核代码）。
否则2亿次访问硬盘可想而知。。。

[zhiang75]

to:vwxyzh
你的计算机的内存多大啊?

[qgmzhfj]

关注中...

[ghao0]

上条看错了。
-----------------
我的算法
45.78
lz的52.07
---------------------------
private void button3_Click(object sender, EventArgs e)
{
List<float> a;
a =new List<float>();

FileStream data = File.OpenRead("I:\\data.float");
DateTime bt1 = DateTime.Now;
byte[] array = new byte[4];
const int Num = 16384;//2^14
for (int i = 0; i < Num; i++)
{
data.Read(array, 0, 4);
//转换为一个整数结构
uint bi1 = BitConverter.ToUInt32(array, 0);
//还原为浮点数
float bf1 = BitConverter.ToSingle(array, 0);
a.Add(bf1);
}
a.Sort();
a.Reverse();
while (data.Read(array, 0, 4) > 0)
{
//转换为一个整数结构
uint bi1 = BitConverter.ToUInt32(array, 0);
//还原为浮点数
float bf1 = BitConverter.ToSingle(array, 0);
if (bf1 < a[10000-1]) continue;
int locate;
int step;
if (a[Num/2 - 1] < bf1)
{
step = Num / 4;
locate = Num/2 -step;}
else
{
step = Num / 16;
locate = Num / 2 + step;
}
while (step > 1)
{
step = step / 2;
if (a[locate - 1] > bf1)
locate = locate + step;
else
locate = locate - step;
}
a.Insert(locate - 1, bf1);
}
data.Close();
DateTime bt2 = DateTime.Now;
this.Text = (bt2 - bt1).ToString();
}
}

[ghao0]

运算耗时：83156
返回结果[0]=0.999999998603016
返回结果[1000]=0.999999084044247
返回结果[2000]=0.999998142477124
返回结果[3000]=0.999997217208146
返回结果[4000]=0.999996210914103
返回结果[5000]=0.999995217192916
返回结果[6000]=0.999994203913954
返回结果[7000]=0.999993198085573
返回结果[8000]=0.99999222392216
返回结果[9000]=0.999991221353408
p4 2.93 内存512M
运行前可用物理内存222M
-------------------------------
private void button4_Click(object sender, EventArgs e)
{
//常量固定
const int numberCount = 1000000000;
const int resultCount = 10000;

Random random = new Random(1000); // 随机数种子固定，这样保证大家测试的数据一致
long tickCount = Environment.TickCount;

#region 初始化
//初始化对象的时间也要计算在内
List<double> a;
a = new List<double>();
#endregion 初始化
#region 处理数据
//部分快排
const int Num = 16384;//2^14
for (int i = 0; i < Num; i++)
{
double value = random.NextDouble();
a.Add(value);
}
a.Sort();
a.Reverse();
//余下2分插入
for (int i = 0; i < numberCount - Num; i++)
{
double value = random.NextDouble();
if (value < a[10000 - 1]) continue;
int locate;
int step;
if (a[Num / 2 - 1] < value)
{
step = Num / 4;
locate = Num / 2 - step;
}
else
{
step = Num / 16;
locate = Num / 2 + step;
}
while (step > 1)
{
step = step / 2;
if (a[locate - 1] > value)
locate = locate + step;
else
locate = locate - step;
}
a.Insert(locate - 1, value);
}
#endregion 处理数据
Console.WriteLine("运算耗时：{0}", Environment.TickCount - tickCount);

#region 采用输出结果
for (int i = 0; i < resultCount; i += 1000)
{
Console.WriteLine("返回结果[{0}]={1}", i, a[i]);
}
#endregion 采用输出结果

}

[gushansanren]

#include <stdio.h>
#include <time.h>

typedef struct {
double data;
int flag;
}zryData;

//先分组，再排序，再验证
int PaiXu(double *inbuf,int inlen,double *outbuf,int outlen)
{
int j,i,k,count,flag;
double tmpdou,td2;
double *p,*q,*pout;
zryData *tmpdata,*pd,*qd;

if(inlen%outlen) return -1; //做个检测，如果不能整除的情况，先不考虑

//选取每组最大数
count = inlen/outlen; //每组大小
p = inbuf; //临时指针
for(i=0;i<outlen;i++)
{
tmpdou = *p; //每组最后一个最大
for(j=0;j<count-1;j++)
{
q = p+1;
if(*p > *q)
{
tmpdou = *q;
*q = *p;
*p = tmpdou;
}
p = q;
}
p++; //如果不加这个，可能选出来的是整个数组最大的
}

//虽然快速排序比较快，但是如果对大量数据需要多次递归，对系统资源浪费太大，
//改用冒泡，如果有递归实现可以使用
tmpdata = (zryData *)malloc(outlen *sizeof(zryData));
pd = tmpdata;
for(i=1;i<=outlen;i++)
{
pd->data = inbuf[i*count-1];
pd->flag = i-1;
pd++;
}

for (i=0;i<outlen;i++)
{
pd = tmpdata;
flag = 0;
for(j=0;j<outlen-i;j++)
{
qd = pd+1;
if((*pd).data < (*qd).data)
{
tmpdou = (*qd).data;
(*qd).data = (*pd).data;
(*pd).data = tmpdou;

flag = (*qd).flag;
(*qd).flag = (*pd).flag;
(*pd).flag = flag;

flag =1;
}
pd++;
}
if(flag == 0) //已经排序完成
break;
}

//现在开始验证所选的数，变相冒泡排序
pout = outbuf;
pd = tmpdata;

for(i=0;i<outlen;i++)
{
tmpdou = (*pd).data;

//检验
for(j=0;j<i;j++)
{
qd = tmpdata;
p = &inbuf[((*qd).flag)*count];
for(k=0;k<count;k++)
{
if(*p >tmpdou && *p < td2)
tmpdou = *p;
p++;
}
qd++;
}
//完成
*pout = td2 =tmpdou;
pd++;
pout++;
}
return 0;
}
//直接找
int PaiXu2(double *inbuf,int inlen,double *outbuf,int outlen)
{
int j,i;
double tmpdou;
double *p,*q,*pout;

pout = outbuf;
for (i=0;i<inlen;i++)
{
p = inbuf;
for(j=0;j<inlen-i-1;j++)
{
q = p+1;
if(*p >*q)
{
tmpdou = *q;
*q = *p;
*p = tmpdou;
}
p++;
}
*pout = *q;
pout++;

if(i ==outlen-1)
break;
}
return 0;
}

void main()
{
int i,inlen;
double inbuf[100000],outbuf[100];
unsigned long start,end;

inlen = 100000;
srand(10000000);
for(i=0;i<inlen;i++)
{
inbuf[i] =rand()/100.00;
}
time(&start);
PaiXu(inbuf,inlen,outbuf,100);
time(&end);
printf("time is %d \n",end-start);

time(&start);
PaiXu2(inbuf,inlen,outbuf,100);
time(&end);
printf("time is %d \n",end-start);

getchar();
}

[gushansanren]

兄弟，你就赶快给分吧

[ghao0]

不是讨论过吗？
部分快排，余下2分插入

lz 数不够，folat = byte? 以此优化？？

[longjurujiang]

学习学习再学习

[shanyue198]

学习中····看牛人的精彩···

[小白菜VS]

这个题目要用全排序的话那代价岂不是很大吗