《编程之美》——寻找最大的K个数

题目：
N个无序的数（可能数目非常大），选出其中最大的K个数。

分析与解法：

【解法一】
对N个数进行排序，然后选出最大的K个数。可以使用快速排序或堆排序，时间复杂度为O(NlogN)。
因为这里N的数目可能非常大，即N>>K，而前N-K个数可以不进行排序，使用可以部分排序的算法，如选择排序或交换排序，时间复杂度为O(NK)。

【解法二】
当N的数值很大的时候，即N>>K。可以使用快速排序中的partition函数， 将数分为两组。
(1)分为两个组，sa和sb。
(2)若sa组的个数大于K，则继续在sa分组中找取最大的K个数字 。
(3)若sa组中的数字小于K ，其个数为T，则继续在sb中找取 K-T个数字 。
时间复杂度为O(NlogK)。

代码：

#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大的数p，可以先找出N个数中最大的和最小的元素的值，然后使用二分法进行搜索找到p，再根据p找到其他大于它的K-1个数。其时间复杂度是O(N)+O(NlogN)+O(N)，近似后为O(NlogN)。

代码：

 #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  ;  
      }  
      return min ;  
 }  

 int main()  
 {  
   int a[N] = {54, 2 ,5 ,11 ,554 ,65 ,33 ,2};    
   int x = getK(a , 554 , 2);
   cout << x << " ";
   for(int i = 0; i < N; i++)
   {
        if(x < a[i])
            cout << a[i] << " ";
   }  
   return 0 ;      
 }

【解法四】
当N的数值很大的时候，即N>>K。从N个数中任取K个数建立一个有K个节点的小顶堆，每次从剩下N-K个数中取出一个数，与堆顶元素进行比较，若小于等于堆顶元素则舍弃，若大于等于堆顶，则将堆顶元素更新为该元素并重新调整堆。维护堆的时间复杂度是O(logK)。所以总的时间复杂度是O(NlogK)。

代码：

#include <iostream>  

using namespace std;  

void buildMinHeap(int *pArray, int K);
void adjustHeap(int *pArray, int rootIndex, int heapSize);

int main()  
{  
    int a[] = {9, 8, 7, 6, 5, 4, 3, 11, 12, 13, 1, 28};
    int K = 5 ;

    //建一个K个元素大小的最小堆
    buildMinHeap(a, K);

    //从第K个元素开始扫描，看有没有比根节点更大的节点，若有则替换，并更新堆；若没有比根节点大则扫描下一个元素，直到数组结束
    for (int i = K; i < sizeof(a) / sizeof(int); i++)
    {
        if (a[i] > a[0])
        {
            swap(a[i], a[0]);
            adjustHeap(a, 0, K);
        }
    }

    //打印出前K大的数，没有排序。
    for (int i = 0; i < K; i++)
    {
        cout << a[i] << " ";
    }
    system("pause");
}  

//建一个K个元素大小的最小堆
void buildMinHeap(int *pArray, int K)
{
    for (int i = (K - 2) / 2; i >= 0; i--)
    {
        adjustHeap (pArray, i, K);
    }
}

void adjustHeap (int *pArray, int rootIndex, int heapSize)
{
    int minIndex = rootIndex;

    //左孩子节点
    int leftIndex = 2 * rootIndex + 1;

    //右孩子节点
    int rightIndex = 2 * (rootIndex + 1);

    //如果左孩子比根节点和右孩子节点小的话，则左孩子和根节点进行交换
    if ((leftIndex < heapSize) && (rightIndex < heapSize) &&
        (pArray[leftIndex] < pArray[rootIndex]))
    {
        minIndex = leftIndex;
    }
    if ((leftIndex < heapSize) && (rightIndex >= heapSize) && 
        (pArray[leftIndex] < pArray[rootIndex]))
    {
        minIndex = leftIndex;
    }


    if ((rightIndex < heapSize) && (pArray[rightIndex] <
         pArray[leftIndex]) && (pArray[rightIndex] < 
             pArray[rootIndex]))
    {
        minIndex = rightIndex;
    }

    if (minIndex != rootIndex) 
    {
        //如果左孩子或者右孩子比根节点小的话，那么就交换，并且重新调整以
        //minIndex为根节点的子树
        swap(pArray[rootIndex], pArray[minIndex]);
        adjustHeap(pArray, minIndex, heapSize);
    }
}

【解法五】
N个数都是正整数，且取值范围不大的时候。可以使用空间换时间的方法，使用一个数组记录每个元素出现的次数，数组长度为MAXN，为N个数中的最大元素的值，然后找出最大的K个数。时间复杂度为O(N)+O(MAXN)，近似为O(N)。

代码：

#include <iostream>  

using namespace std;  

int findMaxN(int *pArray, int len);

int main()  
{  
    int a[] = {9, 8, 7, 6, 5, 4, 3, 11, 12, 13, 1, 28};
    int K = 5;
    int MAXN = findMaxN(a, sizeof(a) / sizeof(int));
    //申请一个count数组，记录每一个数出现的次数
    int *count = new int[MAXN + 1]();
    for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    {
        count[a[i]]++;
    }
    int index = MAXN;
    int sumCount = 0;
    for (;index >= 0; index--)
    {
        sumCount += count[index];
        if (sumCount == K)
        {
            break;
        }
    }

    //打印出最大的K个数
    for (int i = MAXN; i >= index; i--)
    {
        if (0 != count[i])
        {
            cout << i << " ";
        }
    }
    system("pause");
}  

//找出一个数组中最大的值
int findMaxN(int *pArray, int len)
{
    int MAXN = pArray[0];
    for (int i = 1; i < len; i++)
    {
        if (pArray[i] > MAXN)
        {
            MAXN = pArray[i];
        }
    }
    return MAXN;
}

扩展问题：
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大的数呢？

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

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。

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

分析与解法：
1.除了解法五，其他四种方法都可以。还可以利用解法五的思想使用STL中的map存储每个数出现的次数，之后从大到小扫描出K个最大的数，时间复杂度为O(nlogn)，空间复杂度为O(n)，因为STL中map是由红黑树实现的，每次插入的时间复杂度为O(logn)。

2.维护一个m个节点的小顶堆，然后遍历找出比第m大的元素小的m-k个元素。

3.4.5.解法见参考博文。

文章及代码参考以下博文：
http://www.2cto.com/kf/201504/388795.html
http://blog.csdn.net/rein07/article/details/6742933