（1.5.2.5）寻找最大的K个数

在面试中，有下面的问答：

问：有很多个无序的数，我们姑且假定它们各不相等，怎么选出其中最大的若干个数呢？

答：可以这样写：int array[100] ……

问：好，如果有更多的元素呢？

答：那可以改为：int array[1000] ……

问：如果我们有很多元素，例如1亿个浮点数，怎么办？

答：个，十，百，千，万……那可以写：float array [100 000 000] ……

问：这样的程序能编译运行么？

答：嗯……我从来没写过这么多的0 ……

分析与解法

【解法一】

当学生们信笔写下float array [10000000]，他们往往没有想到这个数据结构要如何在电脑上实现，是从当前程序的栈（Stack）中分配，还是堆（Heap），还是电脑的内存也许放不下这么大的东西？

我们先假设元素的数量不大，例如在几千个左右，在这种情况下，那我们就排序一下吧。在这里，快速排序或堆排序都是不错的选择，他们的平均时间复杂度都是O（N * log2N）。然后取出前K个，O（K）。总时间复杂度O（N * log2N）+ O（K） = O（N * log2N）。

你一定注意到了，当K=1时，上面的算法也是O（N * log2N）的复杂度，而显然我们可以通过N-1次的比较和交换得到结果。上面的算法把整个数组都进行了排序，而原题目只要求最大的K个数，并不需要前K个数有序，也不需要后N-K个数有序。

怎么能够避免做后N-K个数的排序呢？我们需要部分排序的算法，选择排序和交换排序都是不错的选择。把N个数中的前K大个数排序出来，复杂度是O（N * K）。

那一个更好呢？O（N * log2N）还是O（N * K）？这取决于K的大小，这是你需要在面试者那里弄清楚的问题。在K（K < = log2N）较小的情况下，可以选择部分排序。

在下一个解法中，我们会通过避免对前K个数排序来得到更好的性能。

【解法二】

回忆一下快速排序，快排中的每一步，都是将待排数据分做两组，其中一组的数据的任何一个数都比另一组中的任何一个大，然后再对两组分别做类似的操作，然后继续下去……

在本问题中，假设N个数存储在数组S中，我们从数组S中随机找出一个元素X，把数组分为两部分Sa和Sb。Sa中的元素大于等于X，Sb中元素小于X。

这时，有两种可能性：

1. Sa中元素的个数小于K，Sa中所有的数和Sb中最大的K-|Sa|个元素（|Sa|指Sa中元素的个数）就是数组S中最大的K个数。

2. Sa中元素的个数大于或等于K，则需要返回Sa中最大的K个元素。

这样递归下去，不断把问题分解成更小的问题，平均时间复杂度O（N * log2K）。伪代码如下：

代码清单2-11

 
 
Kbig(S, k):  
    if(k <= 0):  
        return []       // 返回空数组  
    if(length S <= k):  
        return S  
    (Sa, Sb) = Partition(S)  
    return Kbig(Sa, k).Append(Kbig(Sb, k - length Sa)  
 
Partition(S):  
    Sa = [] // 初始化为空数组  
    Sb = [] // 初始化为空数组  
        // 随机选择一个数作为分组标准，  
        以避免特殊数据下的算法退化  
        // 也可以通过对整个数据进行洗牌预处理实现这个目的  
        // Swap(S[1], S[Random() % length S])  
p = S[1]  
    for i in [2: length S]:  
        S[i] > p ? Sa.Append(S[i]) : Sb.Append(S[i])  
// 将p加入较小的组，可以避免分组失败，也使分组更均匀，提高效率  
length Sa < length Sb ? Sa.Append(p) : Sb.Append(p)  
return (Sa, Sb) 

【解法三】

寻找N个数中最大的K个数，本质上就是寻找最大的K个数中最小的那个，也就是第K大的数。可以使用二分搜索的策略来寻找N个数中的第K大的数。对于一个给定的数p，可以在O（N）的时间复杂度内找出所有不小于p的数。假如N个数中最大的数为Vmax，最小的数为Vmin，那么这N个数中的第K大数一定在区间[Vmin, Vmax]之间。那么，可以在这个区间内二分搜索N个数中的第K大数p。伪代码如下：

代码清单2-12

 
 
while(Vmax - Vmin > delta)  
{  
    Vmid = Vmin + (Vmax - Vmin) * 0.5;  
    if(f(arr, N, Vmid) >= K)  
        Vmin = Vmid;  
    else 
        Vmax = Vmid;  
    } 

伪代码中f（arr, N, Vmid）返回数组arr[0, …, N-1]中大于等于Vmid的数的个数。

上述伪代码中，delta的取值要比所有N个数中的任意两个不相等的元素差值之最小值小。如果所有元素都是整数，delta可以取值0.5。循环运行之后，得到一个区间（Vmin, Vmax），这个区间仅包含一个元素（或者多个相等的元素）。这个元素就是第K大的元素。整个算法的时间复杂度为O（N * log2（|Vmax - Vmin| /delta））。由于delta的取值要比所有N个数中的任意两个不相等的元素差值之最小值小，因此时间复杂度跟数据分布相关。在数据分布平均的情况下，时间复杂度为O（N * log2（N））。

在整数的情况下，可以从另一个角度来看这个算法。假设所有整数的大小都在[0, 2m-1]之间，也就是说所有整数在二进制中都可以用m bit来表示（从低位到高位,分别用0, 1, …, m-1标记）。我们可以先考察在二进制位的第（m-1）位，将N个整数按该位为1或者0分成两个部分。也就是将整数分成取值为[0, 2m-1-1]和[2m-1, 2m-1]两个区间。前一个区间中的整数第（m-1）位为0，后一个区间中的整数第（m-1）位为1。如果该位为1的整数个数A大于等于K，那么，在所有该位为1的整数中继续寻找最大的K个。否则，在该位为0的整数中寻找最大的K-A个。接着考虑二进制位第（m-2）位，以此类推。思路跟上面的浮点数的情况本质上一样。

对于上面两个方法，我们都需要遍历一遍整个集合，统计在该集合中大于等于某一个数的整数有多少个。不需要做随机访问操作，如果全部数据不能载入内存，可以每次都遍历一遍文件。经过统计，更新解所在的区间之后，再遍历一次文件，把在新的区间中的元素存入新的文件。下一次操作的时候，不再需要遍历全部的元素。每次需要两次文件遍历，最坏情况下，总共需要遍历文件的次数为2 * log2（|Vmax - Vmin|/delta）。由于每次更新解所在区间之后，元素数目会减少。当所有元素能够全部载入内存之后，就可以不再通过读写文件的方式来操作了。

此外，寻找N个数中的第K大数，是一个经典问题。理论上，这个问题存在线性算法。不过这个线性算法的常数项比较大，在实际应用中效果有时并不好。

【解法四】

我们已经得到了三个解法，不过这三个解法有个共同的地方，就是需要对数据访问多次，那么就有下一个问题，如果N很大呢，100亿？（更多的情况下，是面试者问你这个问题）。这个时候数据不能全部装入内存（不过也很难说，说知道以后会不会1T内存比1斤白菜还便宜），所以要求尽可能少的遍历所有数据。

不妨设N > K，前K个数中的最大K个数是一个退化的情况，所有K个数就是最大的K个数。如果考虑第K+1个数X呢？如果X比最大的K个数中的最小的数Y小，那么最大的K个数还是保持不变。如果X比Y大，那么最大的K个数应该去掉Y，而包含X。如果用一个数组来存储最大的K个数，每新加入一个数X，就扫描一遍数组，得到数组中最小的数Y。用X替代Y，或者保持原数组不变。这样的方法，所耗费的时间为O（N * K）。

进一步，可以用容量为K的最小堆来存储最大的K个数。最小堆的堆顶元素就是最大K个数中最小的一个。每次新考虑一个数X，如果X比堆顶的元素Y小，则不需要改变原来的堆，因为这个元素比最大的K个数小。如果X比堆顶元素大，那么用X替换堆顶的元素Y。在X替换堆顶元素Y之后，X可能破坏最小堆的结构（每个结点都比它的父亲结点大），需要更新堆来维持堆的性质。更新过程花费的时间复杂度为O（log2K）。

图2-1是一个堆，用一个数组h[]表示。每个元素h[i]，它的父亲结点是h[i/2]，儿子结点是h[2 * i + 1]和h[2 * i + 2]。每新考虑一个数X，需要进行的更新操作伪代码如下:

代码清单2-13

 
 
if(X > h[0])  
{  
    h[0] = X;  
    p = 0;  
    while(p < K)  
    {  
        q = 2 * p + 1;  
        if(q >= K)   
            break;  
        if((q < K - 1) && (h[q + 1] < h[q]))  
            q = q + 1;  
        if(h[q] < h[p])  
        {  
            t = h[p];   
            h[p] = h[q];  
            h[q] = t;  
            p = q;  
        }  
        else 
            break;  
    }  
}