从快速排序到求序列中最大的N个数

给定一个无序的序列，求其中最大的N个数，这是一个经常遇到的实际问题。下面，我们先从快速排序说起。

我们知道，快速排序的平均排序速度是最快的，其原理就是任取序列中的一个数M，把剩下的数分为两组，一组是大于等于M的数，另一组是小于M的数，显然，在最终的结果中，M应该居于中间位置。接着，对这两组数分别递归地调用快速排序即可。

比如，设有无序序列{9， 2， 11，7，5，1，4，6}，第一步，任取一个数，比如说5，再按照上述规则把剩下的数分为两组，得：

{2，1，4} 5 {9，11，7，6}

其中5居于中间位置，左边是小于5的所有数的集合，右边是所有大于等于5的数的集合。显然，最终的结果中，5就应该在当前的位置，即从左往右数的第4个位置。

接着，对左右两个集合分别调用快速排序。比如左右两边分别以2和9为中间数，分组得到：

{1} 2 {4} 5 {7，6} 9 {11}

此时，有3个小组中仅有一个数，不用再递归排序了，所以只需对{7, 6}再调一次快速排序即可，假设选择7为中间数，得到：

1 2 4 5 {6} 7 9 11

最终得到有序序列：

1 2 4 5 6 7 9 11

快速平均平均时间复杂度是

快速排序的这种任选一个数M，然后把剩下的数按照对M的大小分两组的做法十分巧妙，完全可以应用到求最大的N个数问题中。方法是，首先，假设按照中间数M把剩下的数分为left和right两组，前者包含大于等于M的数，后者包含小于M的数。然后，设left中一共有ls个数。如果ls > N，则问题归结为在left序列中找N个最大的数。如果ls=N，这意味着left就是我们要找的集合。如果ls<N，则left中的所有数以及中间数M构成了最大的ls+1个数，我们只需在right中再找N-ls-1个最大的数即可。

下面就是我们按照上述想法构成的算法。值得注意的是，算法中我们没有使用递归，而是使用了循环，这样一方面可以加快速度（因为递归在参数传递、进入被调函数、从被调函数返回等步骤上是要花时间的），另一方面还避免了高级计算机语言例如C、C++、Java和Python都会遇到的最大递归深度溢出问题。比如Python缺省约定最大递归深度是1000，在一个基本有序的且含有1500个数据的序列中找最大的2个数就很有可能遭遇最大递归深度溢出。

def top_n(items, num, compare_func=None):
    """
    Get the top num items from the items.
    :param items: a list/tuple/set/dict of items.
    :param num: number of the maximum items to be returned from the items.
    :param compare_func: the function used to compare two items. It contains
    two parameters: a and b, and returns a negitive number if a < b, zero if
    a == b, or a positive number if a > b.
    :return: a list contains top num items of the iterable.
    """
    assert num >= 0
    items = tuple(items)  # 如果items是个iterable，把它转为tuple
    if len(items) <= num:
        return items
    if compare_func is None:
        compare_func = lambda a, b: 1 if a > b else 0 if a == b else -1

    result = []  # 存放最终结果
    while num > 0:
        left = []  # 存放大于等于中间值的元素
        right = []  # 存放小于中间值的元素
        mid = items[-1]  # 中间值
        for item in items[:-1]:  # 大的值放进left，小的放进right
            if compare_func(item, mid) < 0:
                right.append(item)
            else:
                left.append(item)
        ls = len(left)   # 看看大的值有多少个
        if ls > num:     # 如果大于num，问题归结为在left中找num个最大的
            items = left
        elif ls == num:  # 如果正好相等，把left中所有值添加到result中
            result.extend(left)
            break
        else:            # 否则，ls < num
            result.extend(left)  # left中所有值添加到result中
            result.append(mid)   # mid也加入到result中
            items = right
            num -= 1 + ls
    return result


if __name__ == '__main__':
    a = [3, 9, 7, 12, 5, 6, 10, 11, 1, 4, 5]
    for n in range(1, len(a)+1):
        print(top_n(a, n))

上述算法的平均时间复杂度是，其中n表示要求的最大的n个数，m是原无序序列的长度。