海量数据处理：一亿个浮点数的排序算法

有1亿个浮点数，请找出其中最小的10000个。提示：假设每个浮点数占4个字节，1亿个浮点数就要站到相当大的空间，因此不能一次将全部读入内存进行排序。
问题分析：
1) 1亿个浮点数，其数据大小为 400 M。如此规模的排序，首先想到分批处理。每次读取 1 000 000 个数据并进行快速排序。需要的内存空间为 1 000 000 * 4  = 4M。需要100 次这样的排序。

2）完全没的规律的数据，考虑使用快速排序。快速排序的平均复杂度是 O( Nlog(N) )。我们可以直接使用 stl 提供的全局函数 sort() ， 它使用了快速排序算法（实际是三平均分区法　median-of-three　）。
3) 最后只要最大的 10000 个。则每个批次只需要保留排序结果的前 10000 个数据。这段数据已经是分段有序的。数据量为 10000 * 100。
解法：
1) 数据结构定义：
定义数据规模：

enum
{
    batchCapacity  =   1000000 ,
    batchCount     =   100 ,
    resultCount     =   10000
}

２）生成 数据样本：

void  dataPrepare(  const   char *  filName  )
{
     float *  pbuf;
     if ( ( pbuf =  (   float   * )malloc( batchCapacity   *   sizeof (  float  ) ))  ==  NULL )
    {
         throw (  " failed to malloc "  );
    }
     //   生成 batchCapacity * batchCount 个随机实数，并保存到文件 
    ofstream fout;
    fout.exceptions(std::ios::badbit  |  std::ios::failbit  |  std::ios::eofbit );
    fout.open( filName, ios::binary ) ;
     if  (  ! fout   )
    {
         throw (  " file not exits "  );
    }
     for ( size_t index  =   0 ; index  <  batchCount; index ++  )
    {
         for ( size_t index  =   0 ; index  <  batchCapacity; index ++   )
        {
            pbuf[index]  =  RandomFloat(  0 ,  65537  );
        }
        fout.write( ( char * )pbuf, batchCapacity  *   sizeof (  float  )  );
    }
    fout.close();
    delete pbuf;
    pbuf  =  NULL;
     return  ;
}

以上，用 RandomFloat() 生成随机数。其定义如下：

/* *******************************************
 * Rand::rand 线性同余算法获得随机数
 * 会循环出现相同的数。有待改进
 *
 ******************************************** */

#include  < cstdlib >
#include  < ctime >
class  Rand
{
public :
     static   long   long  r;
     static   int  rand() // 产生随机数
    {
       // 三个参数的取值　关键字：辗转相除 二次同余
        r = ( r * 1010557   + 79390691  ) %  100663363 ;  
         return  r;
    }
};
long   long  Rand::r  =   43215 ;

float  RandomFloat(  float  low,  float  high) {
     float  d  =   float ( Rand::rand())  /  (  float (RAND_MAX)  +   1 );
         return  low  +  d  *  (high  -  low);
}

3 ) 排序

void  dataOrder(  const   char *  filName  )
{
     float *  pbuf   =  (   float   * )malloc( batchCapacity   *   sizeof (  float  ) );
     if  ( pbuf  ==  NULL )
    {
         throw (  " failed to malloc  "  );
    }
    ifstream fin;
    ofstream fout;
    fin.exceptions(std::ios::badbit  |  std::ios::failbit  |  std::ios::eofbit );
    fout.exceptions(std::ios::badbit  |  std::ios::failbit  |  std::ios::eofbit );
    fin.open( filName, ios::binary );
    fout.open(  string (  string (filName).append( " .order " ) ).c_str(), ios::binary ); 
     for ( size_t index  =   0 ;index  <  batchCount;index ++  )
    {
         // 　分批读入，排序
        fin.read( ( char * )pbuf, batchCapacity  *   sizeof (  float  )  );
        std::sort( pbuf, pbuf  +  batchCapacity );
        fout.write( ( char * )pbuf,  resultCount  *   sizeof (  float  ) );
        cout  <<    " writed bytes: "    <<  resultCount  *  index  +   1   <<   endl;
    }
    fin.close();
    fout.close();
    delete pbuf;
     //  将分组的数据综合排序
    pbuf  =   (   float   * )malloc( resultCount  *  batchCount  *   sizeof (  float  ) );
     if  ( pbuf  ==  NULL )
    {
         throw (  " failed to malloc  "  );
    }
    fin.open(  string (  string (filName).append( " .order " ) ).c_str(), ios::binary ); 
    fin.read( ( char * )pbuf, resultCount  *  batchCount  *   sizeof (  float  )  );
    std::sort( pbuf, pbuf  +   resultCount  *  batchCount  );

     // merge_sort<float>(  pbuf,0,( resultCount *  batchCount ) - 1 );
     //  输出
     for (  size_t index  =   0 ; index  <  resultCount; index ++  )
    {
        printf(  " %d\t%f\n " ,  index, pbuf[index ] );
    }
    fin.close();
    delete pbuf;
    pbuf  =  NULL;
}

性能测试结果： p4 的 cpu，每秒大约处理 30万个记录。
整个程序：

const   char *  filName  =   " c:\\float.df " ;
void  dataPrepare(  const   char *  filName  );
void  helpInfo();
void  dataOrder(  const   char *  filName  );
int  main(  int  argc,  char *  argv[] )
{
     try
    {
         if   ( argc  ==   1  )
        {
            helpInfo();
             return   0 ;
        }
         const   char *  filename  =  argv[ 1 ] +   2 ;
         if  ( filename  !=  NULL  &&  strlen( filename )  >   0  )
        {
            filName  =  filename;
        }
         switch  ( argv[ 1 ][ 1 ] )
        {
         case   ' g ' :
            dataPrepare( filName  );
             break ;

         case   ' o ' :
            dataOrder( filName  );
             break ;
         default :
            helpInfo();
             return   0 ;
             break ;
        }
    }
     catch (   const   char *  e)
    {
        cout  <<   e  <<  endl;
    }
     catch (    )
    {
        cout  <<    " unknown error "   <<  endl;
    }
    system(  " pause "  );
     return   0 ;
}

Referance:
快速排序
the c++ programming lanauage, by bjarne stroustrup chapter 18: Algorithms and Function Objects
线性同余法生成随机数
Introduction to Algorithms, Second Edition,by Thomas H. Cormen, Charles E. 11.3 Hash functions 介绍了线性同余法的原理和用法。

三平均分区法：
Introduction to Algorithms, Second Edition,by Thomas H. Cormen, Charles E.　Problems 7-5: Median-of-3 partition