寻找最大的k个数问题

这是编程之美书第2.5节的一道题目。

各种解法：

解法一，用nlgn复杂度的排序算法对数组进行从大到小排序，取前K个。但这方法做了两件不必要做的事：它对想得到的K个数进行了排序，对不想得到的n-K个数也进行了排序。方法不可取。

解法二，用选择排序或冒泡排序，复杂度O(NK)。但这方法也做了不必要做的一件事：对想得到的K个数进行了排序。方法不可取。

解法三，用顺序统计位（类快排）算法来计算（可参考算法导论）。算法导论上说这种方法从平均性能上来讲是线性的，但编程之美上却说复杂度是O(N*lgK)。对于这点，我对编程之美持怀疑态度。我认为，对于一个无序的数组，用顺序统计位算法，可以在近似O(n)的时间复杂度内得到第K大的元素。当这个过程执行完毕时，数组中位于该元素之前的元素就是前K大的元素。

解法三，先查找出数组中的Vmax和Vmin，组成新的数组[Vmin,Vmax]，二分查找该数组，并在原数组中查找。具体请参见编程之美。复杂度为O(nlgn)，方法不可取。

解法四，维护一个K大小的数组A，遍历原数组中的每个数，与A每个元素进行比较，如果大于A数组中的最小元素，则交换，否则继续。复杂度为O(NK)，方法不可取。

解法五，维护一个最小堆，大小为K。一开始先从原数组中随便取K个元素建最小堆，复杂度为O(K)。然后遍历原数组中剩余的n-K个元素，每个元素先与堆顶比较，如果大于堆顶则交换，并维护最小堆性质。总复杂度为K+(n-K)lgK = nlgK。该方法只需要遍历一次数组，且无须在内存中存储所有数组数据，而只需维护K大小的数据。是一种适用于 大数据，小内存的好方法。如果K还是太大，则分次来求，通过先用K’（K’<K）来求……具体请参见编程之美。[1]

解法六，利用hash保存数组中元素S_i出现的次数，利用计数排序的思想，线性从大到小扫描过程中，前面有k-1个数则为第k大数，平均情况下时间复杂度O(n)。这个方法要求数组中的取值范围跨度不能太大。

解法七，对于原数组A，它的取值范围跨度为[Vmin,Vmax]，直接用hash来统计的方法就是解法六。这里，我们把该范围平均分成M份，每份范围跨度都是N/M。遍历原数组，分别统计各个跨度中每个元素出现的次数。从[Vmax-N/M, Vmax] 遍历到 [Vmin, Vmin+N/M]，累加元素出现的次数。当发现某个跨度累加超过K时，那么我们就知道第K大元素在这个跨度里。这样，我们就可以在该跨度里用Hash的方法寻找该元素（该跨度很小，可以在内存中存放Hash表）。编程之美中的时间复杂度有待研究。

解法八，有文章表明，用“败者树”有可能比堆得到更好的结果。参见[6]。是一个北交大的学生写的。

小结：

解法一、二、四最差，不推荐。
解法三、解法四 只适用于小数据，因为他们要经常读取整个数组的数据。解法四不推荐。
解法三、解法五是线性的解法，分别适用于小数据和大数据。 【因为lgk可能很小，堆方法类线性】 ，推荐。
解法六、解法七都是线性的解法，在面对大数据量时用解法七可以比较高效。
解法八是一个很有意思的解法。

编程之美中的扩展题：

1. 找前K个不同的浮点数。

网上[2]有关该题的简短解答。他认为上面的各种解法都可以应用在本题上。但我认为并不可以这样来做。因为本题是想找“不同”的前K大数。用堆排序，中位数方法无法计算重复的数据。所以，个人认为可以用两种方法：
A. 完全排序。然后顺序找前K个“不同”的元素。
B. 用桶排序的方法。重复的数据被映射到桶中，只算一个。
还要注意的是，浮点数的相同应该用fabsf(a-b)<0.00001等类似的方法来判断。

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

同[2]的中解答。

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

用映射二分堆的方式。用O(4*n)的方法对原数组建最大堆，然后pop出k次即可。时间复杂度为O(4*n + k*logn)。映射二分堆与普通堆不同的地方是：它的节点并不真正保存数据单元本身，而是保存指向数据单元的指针。因此 当需要交换父子节点的数据时，可以避免拷贝大量数据所消耗的时间。同时，映射二分堆还有一个功能可以根据具体的数据单元的索引来删除该单元，即使这个单元 不是堆中的最值。[4].

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

参考[2]. 正如提示中所说，可以让每台机器返回最相关的K’个文档，然后利用归并排序的思想，得到所有文档中最相关的K个。 最好的情况是这K个文档在所有机器中平均分布，这时每台机器只要K’ = K / n （n为所有机器总数）；最坏情况，所有最相关的K个文档只出现在其中的某一台机器上，这时K’需近似等于K了。我觉得比较好的做法可以在每台机器上维护一 个堆，然后对堆顶元素实行归并排序。个人觉得这还是正确的解答。没有回答90%准确时的高效率做法。如果是用维护堆的做法，这是完全精确的。

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

参考[2]. 肯定是有帮助的。在搜索关键字q_j最相关的K个文档时，可以在q_j的“近义词”相关文档中搜索部分，然后在全局的所有文档中在搜索部分。

Reference:

[1]. csdn上的讨论 http://topic.csdn.net/u/20071011/09/de941ca9-8dee-42c6-ae76-31729dd2fae3.html
[2]. 别人的想法: http://www.cnblogs.com/drizzlecrj/archive/2009/08/23/1537910.html
[3]. 另种想法 http://www.cppblog.com/flyinghearts/archive/2010/08/16/123538.html
[4]. http://hi.baidu.com/xiangzifengshi/blog/item/ba12abea790b9b242df53408.html
[5]. 映射二叉堆 http://www.zhongsisi.com/?p=166
[6]. 败者树 http://blog.csdn.net/patriotlml/archive/2006/09/09/1199793.aspx

所谓“第（前）k大数问题”指的是在长度为n(n>=k)的乱序数组中S找出从大到小顺序的第（前）k个数的问题。
解法1： 我们可以对这个乱序数组按照从大到小先行排序，然后取出前k大，总的时间复杂度为O(n*logn + k)。
解法2： 利用选择排序或交互排序，K次选择后即可得到第k大的数。总的时间复杂度为O(n*k)
解法3： 利用快速排序的思想，从数组S中随机找出一个元素X，把数组分为两部分S_a和S_b。S_a中的元素大于等于X，S_b中元素小于X。这时有两种情况：
1. S_a中元素的个数小于k，则S_b中的第k-|S_a|个元素即为第k大数；
2. S_a中元素的个数大于等于k，则返回S_a中的第k大数。时间复杂度近似为O(n)
解法4： 二分[S_min,S_max]查找结果X，统计X在数组中出现，且整个数组中比X大的数目为k-1的数即为第k大数。时间复杂度平均情况为O(n*logn)
解法5：用O(4*n)的方法对原数组建最大堆，然后pop出k次即可。时间复杂度为O(4*n + k*logn)
解法6：维护一个k大小的最小堆，对于数组中的每一个元素判断与堆顶的大小，若堆顶较大，则不管，否则，弹出堆顶，将当前值插入到堆中。时间复杂度O(n * logk)
解法7：利用hash保存数组中元素S_i出现的次数，利用计数排序的思想，线性从大到小扫描过程中，前面有k-1个数则为第k大数，平均情况下时间复杂度O(n)

附注：
1. STL中可以用nth_element求得类似的第n大的数（由谓词决定），使用的是解法3中的思想，还可以用partial_sort对区间进行部分排序，得到类似前k大的数（由谓词决定），它采用的是解法5的思想。
2. 求中位数实际上是第k大数的特例。

《编程之美》2.5节课后习题：
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）。
解答：上面的解法均适用，需要注意的是浮点数比较时和整数不同，另外求hashkey的方法也会略有不同。
2. 如果是找第k到第m（0<k<=m<=n)大的数呢？
解答：如果把问题看做m-k+1个第k大问题，则前面解法均适用。但是对于类似前k大这样的问题，最好使用解法5或者解法7，总体复杂度较低。
3. 在搜索引擎中，网络上的每个网页都有“权威性”权重，如page rank。如果我们需要寻找权重最大的K个网页，而网页的权重会不断地更新，那么算法要如何变动以达到快速更新（incremental update）并及时返回权重最大的K个网页？
提示：堆排序？当每一个网页权重更新的时候，更新堆。还有更好的方法吗？
解答：要达到快速的更新，我们可以解法5，使用映射二分堆，可以使更新的操作达到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，相对于不同的关键字q₁, q₂, …, q_m，分别有相关性权重f（d, q₁），f（d, q₂）, …, f（d, q_m）。如果用户输入关键字q_i之后，我们已经获得了最相关的K个文档，而已知关键字q_j跟关键字q_i相似，文档跟这两个关键字的权重大小比较靠近，那么关键字q_i的最相关的K个文档，对寻找q_j最相关的K个文档有没有帮助呢？

解答：肯定是有帮助的。在搜索关键字q_j最相关的K个文档时，可以在q_j的“近义词”相关文档中搜索部分，然后在全局的所有文档中在搜索部分。

练手题：
第k小的数http://acm.nuaa.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1084

<<编程之美>>当中看到的题目，题目很经典也很有意义，刚看到题目我没有直接去看解答，而是自己想了想。想完之后再看题解感觉受益非常，思路得到了开阔。

题目：寻找一个数组中的最大的k个数字。

方法1：

这是我最直接想到的方法-》冒泡排序，只要走K趟就能把最大的K个数字找出来。

时间复杂度：O(n*k)

代码：

void fun(int *arry,int n,int k)  
{
 for(int i=0;i<k;i++)
 {
  for(int j=0;j<(n-i-1);j++)
  {
   if(arry[j]>arry[j+1])
   {
    int temp=arry[j];
    arry[j]=arry[j+1];
    arry[j+1]=temp;
   }
  }
 }

}

方法2：

数组从头到尾扫一遍，借用K个数组保存当前扫的最大K个数字，每次都要在这k个数字找到最小值与当前扫描的值作比较。

效率上略胜方法1.其实还是有优化空间得，个人太懒了。

时间复杂度：O（n*k）

空间复杂度：O（k) 需要借助K长的数组记录当前最大K个数字。

代码：

void fun(int *arry,int n,int k)
{
 int *temp=new int[k];

for(int i=0;i<n;i++)
 {
  if(i<k)           //前k个数字填充数组
  {
   temp[i]=arry[i];
  }
  else
  {
   int min_num=temp[0];
   int pos=0;
   for(int j=1;j<k;j++)           //找到当前最大K个数字的最小值并记录位置
   {
    if(min_num>temp[j])
    {
     min_num=temp[j];
     pos=j;
    }
   }

if(min_num<arry[i])            //更新K数组
   {
    temp[pos]=arry[i];
   }
  }
 }

delete[] temp;
}

方法3：

hash索引的思想，该个数字出现过，则标记相对应的hash表。为了减少hash表的存储空间，扫了三次数组。

第一遍：

寻找数组最大最小值，确定hash表长度。

第二遍：

标记hash表

第三遍：

在hash表寻找最大K个数字。

时间复杂度：O(3*n)

空间复杂度：依赖于数组中数字范围。

代码：

void fun(int *arry,int n,int k)
{
 int max_num=arry[0];
 int min_num=arry[0];

for(int i=1;i<n;i++)  //寻找最大最小值
 {
  if(arry[i]>max_num)
  {
   max_num=arry[i];
  }

if(arry[i]<min_num)
  {
   min_num=arry[i];
  }
 }

int l=max_num-min_num+1;

int *flag=new int[l]();
 for(int i=0;i<n;i++)           //标记hash表
 {
  flag[arry[i]-min_num]=1;
 }
 for(int i=l;i>=0;i--)        //寻找最大k个值
 {
  if(k>0&&flag[i]==1)
  {
   k--;
   cout<<(i+min_num)<<" ";
  }
  if(k<=0)
  {
   break;
  }
 }
 cout<<endl;

delete[] flag;
}

方法4：

我们知道快排的主要思想是把集合分成两个部分进行递归排序，那么同样的思想，我们可以递归进行寻找最大K个元素。

假设，某趟快排元素找寻的位置为l,那么，

当k==l时，说明最大的k个元素就是以l位置为标准的左边或者右边集合。

当k>l时，说明l个最大元素已经找到，而再需找k-l+1个元素，QuickSort(arry,start,l,k-l+1);

当k<l时，说明还需缩小范围，继续递归,QuickSort(arry,l,end,k);

代码：

void QuickSort(int *arry,const int &start,const int &end,const int &kSize)
{
    if(start<end)
    {
        int l=start;
        int h=end;
        int key=arry[l];

while(l<h)
        {
            
            while(l<h&&key<=arry[h])
            {
                h--;
            }

int temp=arry[h];
            arry[h]=arry[l];
            arry[l]=temp;

while(l<h&&key>=arry[l])
            {
                l++;
            }
            temp=arry[h];
            arry[h]=arry[l];
            arry[l]=temp;

}

if(kSize==end-l+1)
        {
            return ;
        }
        else if(kSize>end-l+1)
        {
             QuickSort(arry,start,l-1,kSize-end+l-1);
        }
        else
        {
            QuickSort(arry,l+1,end,kSize);
        }
    }

}