编程之美--寻找最大的K个数

方法一： 使用partition函数，将数组分为两组。partition函数是快速排序中用来把数组分成两部分的函数。
            (1)分为两个组，sa和sb。
            (2)若sa组的个数大于K，则继续在sa分组中找取最大的K个数字 。
            (3)若sa组中的数字小于K ，其个数为T，则继续在sb中找取 K-T个数字 。
   具体代码实现：
        

#include <iostream>
  using namespace std ;
  const int N = 8 ; 
  const int K = 4 ;
  int partition(int  a[] ,int low , int high) 
  {
      int i = low - 1 ;
      int j = low;
      
      while(j < high)
      {
         if(a[j] >=  a[high])
         {
           swap( a[i+1] , a[j]) ;        
           i++   ;     
         }
         j++ ;      
      }
      //最后处理a[high]
      swap(a[i+1] , a[high]) ;  
      return i + 1;     
  }
  
  
  int findk(int  a[] , int low , int high , int k)
  {
      if(low < high)
      {
        int q = partition(a , low , high) ;
        
        int len = q - low + 1 ; //表示第几个位置 
        if(len == k)
         return q ; //返回第k个位置
        else if(len < k) 
         return findk(a , q + 1 , high , k - len) ;   
       else
        return findk(a , low , q - 1, k ) ;
      }
  }
  
  int main()
  {
    int a[N] = {5 ,2 ,66 ,23, 11 ,1 ,4 ,55} ;
    findk(a , 0 , N - 1 , K) ;  
    
    for(int i = 0 ; i < K ; i++)
      cout<<a[i]<<endl ;
    
    system("pause") ;  
    return 0 ;    
  } 

 方法二 ：
   此种方法为常用方法，建立一个大小为K的堆。每次遍历数组时，需要判断是否需要加入堆中。
   堆中存储着的是最大的k个数字，但是若是需要插入堆中，则需要对堆进行调整时间为o(log k)。
   全部的时间复杂度为o(n * log k)。
   
  这种方法当数据量比较大的时候，比较方便。因为对所有的数据只会遍历一次，第一种方法则会多次遍历
  数组。 如果所查找的k的数量比较大。可以考虑先求出k` ，然后再求出看k`+1 到 2 * k`之间的数字，然后
  一次求取。
 
 方法三：
     利用二分的方法求取TOP k问题。
     首先查找 max 和 min，然后计算出 mid = (max + min) / 2
     该算法的实质是寻找最大的K个数中最小的一个。 
   
    代码如下：

#include <iostream>
 using namespace std ; 
 const int N = 8 ;
 const int K = 4 ;
 
 /*
 利用二分的方法求取TOP k问题。
 首先查找 max 和 min，然后计算出 mid = (max + min) / 2
 该算法的实质是寻找最大的K个数中最小的一个。 
 
 
 */
 
 int find(int * a , int x) //查询出大于或者等于x的元素个数 
 {
     int sum = 0 ;
     
     for(int i = 0 ; i < N ; i++ )
     { 
        if(a[i] >= x)
          sum++ ;                
     }
      return sum ;
 }
 
 
 
 
 int getK(int * a , int max , int min) //最终max min之间只会存在一个或者多个相同的数字 
 {
     while(max - min > 1)             //max - min的值应该保证比两个最小的元素之差要小 
      {
        int mid = (max + min) / 2 ;
        int num = find(a , mid) ;    //返回比mid大的数字个数 
        if(num >= K)                 //最大的k个数目都要比min值大 
           min = mid ;               
        else
           max = mid  ;
      }
      cout<<"end"<<endl;
      return min ;
 }
 
 int main()
 {
   int a[N] = {54, 2 ,5 ,11 ,554 ,65 ,33 ,2} ;  
   int x = getK(a , 554 , 2) ; 
   cout<<x<<endl ; 
   getchar() ; 
   return 0 ;    
 }

方法4：

如果N个数都是正数，取值范围不太大，可以考虑用空间换时间。申请一个包括N中最大值的MAXN大小的数组count[MAXN]，count[i]表示整数i在所有整数中的个数。这样只要扫描一遍数组，就可以得到低K大的元素。

for(sumCount = 0, v = MAXN -1; v >=0; v--)
{
       cumCount += count[v];
       if(sumCount >= k)
            break;
}
return v;

扩展：

1. 如果需要找出N个数中最大的K个不同的浮点数呢？比如，含有10个浮点数的数组（1.5，1.5，2.5，3.5，3.5，5，0，- 1.5，3.5）中最大的3个不同的浮点数是（5，3.5，2.5）。
     个人觉得除了最后一种方法不行，其他的都可以。因为最后一种需要是正数。

2. 如果是找第k到第m（0<k<=m<=n)大的数呢？

     个人觉得可以用小根堆来先求出m个最大的，然后从中输出k到m个。

3. 在搜索引擎中，网络上的每个网页都有“权威性”权重，如page rank。如果我们需要寻找权重最大的K个网页，而网页的权重会不断地更新，那么算法要如何变动以达到快速更新（incremental update）并及时返回权重最大的K个网页？
提示：堆排序？当每一个网页权重更新的时候，更新堆。还有更好的方法吗？

     网上答案：可以采用小顶堆来实现，使用映射二分堆，可以使更新的操作达到O(logn)。

4. 在实际应用中，还有一个“精确度”的问题。我们可能并不需要返回严格意义上的最大的K个元素，在边界位置允许出现一些误差。当用户输入一个query的时候，对于每一个文档d来说，它跟这个query之间都有一个相关性衡量权重f (query, d)。搜索引擎需要返回给用户的就是相关性权重最大的K个网页。如果每页10个网页，用户不会关心第1000页开外搜索结果的“精确度”，稍有误差是可以接受的。比如我们可以返回相关性第10 001大的网页，而不是第9999大的。在这种情况下，算法该如何改进才能更快更有效率呢？网页的数目可能大到一台机器无法容纳得下，这时怎么办呢？

   提示：归并排序？如果每台机器都返回最相关的K个文档，那么所有机器上最相关K个文档的并集肯定包含全集中最相关的K个文档。由于边界情况并不需要非常精确，如果每台机器返回最好的K’个文档，那么K’应该如何取值，以达到我们返回最相关的90%*K个文档是完全精确的，或者最终返回的最相关的K个文档精确度超过90%（最相关的K个文档中90%以上在全集中相关性的确排在前K），或者最终返回的最相关的K个文档最差的相关性排序没有超出110%*K。

网上答案：答： 正如提示中所说，可以让每台机器返回最相关的 K' 个文档，然后利用归并排序的思想，得到所有文档中最相关的 K 个。 最好的情况是这 K 个文档在所有机器中平均分布，这时每台机器只要 K' = K / n （ n 为所有机器总数）；最坏情况，所有最相关的 K 个文档只出现在其中的某一台机器上，这时 K' 需近似等于 K 了。我觉得比较好的做法可以在每台机器上维护一个堆，然后对堆顶元素实行归并排序。

5. 如第4点所说，对于每个文档d，相对于不同的关键字q1, q2, …, qm，分别有相关性权重f（d, q1），f（d, q2）, …, f（d, qm）。如果用户输入关键字qi之后，我们已经获得了最相关的K个文档，而已知关键字qj跟关键字qi相似，文档跟这两个关键字的权重大小比较靠近，那么关键字qi的最相关的K个文档，对寻找qj最相关的K个文档有没有帮助呢？

解答：肯定是有帮助的。 qi最相关的K个文档可能就是qj的最相关的K个文档，可以先假设这K个就是，然后根据问题四的解法获得K'，分别和这K个比较，可以用堆进行比较，从而获得qj最相关的K个文档。由于最开始的K个文档极有可能是最终的K个文档，所以K'和K比较的次数可能并不多。

参考：

http://www.cppblog.com/jake1036/archive/2011/07/07/150393.aspx