Top K问题是面试时手写代码的常考题，某些场景下的解法与堆排和快排的关系紧密，所以把它放在堆排后面讲。

下面先来还原一下Top K考试常见的套路。

你正紧张地坐在小隔间里，听着越来越近的脚步声，内心忐忑，犹如兔脱。

推门声呷然而起，你扭头一看，身体已不由自主起立，打量着眼前来人，心里一阵窃喜：还好，面善。

面试官点头致意，你配合坐下，满心满眼一片赤诚，恨不得把公司的茶水阿姨都夸一遍来表明你面试的诚意。

面试官拿着你的简历目不斜视，有意无意间想起了经年彼时自己面试的紧张场景，自己走过的弯路不能让他再重复走，于是决定先暖暖场活跃活跃气氛，也多少祭奠一下那夕阳晚钟，那迎风少年，那狗日的青春。

面试官说今天的天气真好，你说蓝天白云不多见，哈哈哈哈。

你说贵公司的办公环境真心不错，面试官看看四周表面克制内心放浪——那是自…不对，不能这么说，年轻人面前还是不要喜形于色。

面试官说还好了，哈哈哈哈。

真的，环境很不错，哈哈哈哈。你说着，手心大汗淋漓，嗓子里干得冒烟。

面试官眯着眼看了看你，说公司大了人就多，人多了数据就多了，现在有一组千万级别的数，你能不能帮我找出最大的5个？尽量少用空间和时间。

你听完风中凌乱一脸懵逼，电光火石之间抖一抖眼皮，一阵狂喜，还好看过丑旦的这篇笔记。

Offer，稳了。
…

嘿嘿，以上扯的这个淡，希望能加深你对Top K问题的印象^_^。

言归正传，笔者见过关于Top K问题最全的分类总结是在这里（包括海量数据的处理），个人将这些题分成了两类：一类是容易写代码实现的；另一类侧重考察思路的。毫无疑问，后一种比较简单，你只要记住它的应用场景、解决思路，并能在面试的过程中将它顺利地表达出来，便能以不变应万变。前一种，需要手写代码，就必须要掌握一定的技巧，常见的解法有两种，就是前面说过的堆排和快排的变形。

本文主要来看看方便用代码解决的问题。

堆排解法

用堆排来解决Top K的思路很直接。

前面已经说过，堆排利用的大（小）顶堆所有子节点元素都比父节点小（大）的性质来实现的，这里故技重施：既然一个大顶堆的顶是最大的元素，那我们要找最小的K个元素，是不是可以先建立一个包含K个元素的堆，然后遍历集合，如果集合的元素比堆顶元素小（说明它目前应该在K个最小之列），那就用该元素来替换堆顶元素，同时维护该堆的性质，那在遍历结束的时候，堆中包含的K个元素是不是就是我们要找的最小的K个元素？

实现：
在堆排的基础上，稍作了修改，buildHeap和heapify函数都是一样的实现，不难理解。

速记口诀：最小的K个用最大堆，最大的K个用最小堆。

public class TopK {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = { 1, 17, 3, 4, 5, 6, 7, 16, 9, 10, 11, 12, 13, 14, 15, 8 };
        int[] b = topK(a, 4);
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + ", ");
        }
    }

    public static void heapify(int[] array, int index, int length) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int largest = index;
        if (left < length && array[left] > array[index]) {
            largest = left;
        }
        if (right < length && array[right] > array[largest]) {
            largest = right;
        }
        if (index != largest) {
            swap(array, largest, index);
            heapify(array, largest, length);
        }
    }

    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }

    public static void buildHeap(int[] array) {
        int length = array.length;
        for (int i = length / 2 - 1; i >= 0; i--) {
            heapify(array, i, length);
        }
    }

    public static void setTop(int[] array, int top) {
        array[0] = top;
        heapify(array, 0, array.length);
    }

    public static int[] topK(int[] array, int k) {
        int[] top = new int[k];
        for (int i = 0; i < k; i++) {
            top[i] = array[i];
        }
        //先建堆，然后依次比较剩余元素与堆顶元素的大小，比堆顶小的， 说明它应该在堆中出现，则用它来替换掉堆顶元素，然后沉降。
        buildHeap(top);
        for (int j = k; j < array.length; j++) {
            int temp = top[0];
            if (array[j] < temp) {
                setTop(top, array[j]);
            }
        }
        return top;
    }
}

时间复杂度
n*logK

速记：堆排的时间复杂度是n*logn，这里相当于只对前Top K个元素建堆排序，想法不一定对，但一定有助于记忆。

适用场景
实现的过程中，我们先用前K个数建立了一个堆，然后遍历数组来维护这个堆。这种做法带来了三个好处：（1）不会改变数据的输入顺序（按顺序读的）；（2）不会占用太多的内存空间（事实上，一次只读入一个数，内存只要求能容纳前K个数即可）；（3）由于（2），决定了它特别适合处理海量数据。

这三点，也决定了它最优的适用场景。

快排解法

用快排的思想来解Top K问题，必然要运用到”分治”。

与快排相比，两者唯一的不同是在对”分治”结果的使用上。我们知道，分治函数会返回一个position，在position左边的数都比第position个数小，在position右边的数都比第position大。我们不妨不断调用分治函数，直到它输出的position = K-1，此时position前面的K个数（0到K-1）就是要找的前K个数。

实现：
“分治”还是原来的那个分治，关键是getTopK的逻辑，务必要结合注释理解透彻，自动动手写写。

public class TopK {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = { 9, 3, 1, 10, 5, 7, 6, 2, 8, 0 };
        getTopK(array, 4);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + ", ");
        }
    }

    // 分治
    public static int partition(int[] array, int low, int high) {
        if (array != null && low < high) {
            int flag = array[low];
            while (low < high) {
                while (low < high && array[high] >= flag) {
                    high--;
                }
                array[low] = array[high];
                while (low < high && array[low] <= flag) {
                    low++;
                }
                array[high] = array[low];
            }
            array[low] = flag;
            return low;
        }
        return 0;
    }

    public static void getTopK(int[] array, int k) {
        if (array != null && array.length > 0) {
            int low = 0;
            int high = array.length - 1;
            int index = partition(array, low, high);
            //不断调整分治的位置，直到position = k-1
            while (index != k - 1) {
                //大了，往前调整
                if (index > k - 1) {
                    high = index - 1;
                    index = partition(array, low, high);
                }
                //小了，往后调整
                if (index < k - 1) {
                    low = index + 1;
                    index = partition(array, low, high);
                }
            }
        }
    }
}

时间复杂度
n

速记：记住就行，基于partition函数的时间复杂度比较难证明，从来没考过。

适用场景
对照着堆排的解法来看，partition函数会不断地交换元素的位置，所以它肯定会改变数据输入的顺序；既然要交换元素的位置，那么所有元素必须要读到内存空间中，所以它会占用比较大的空间，至少能容纳整个数组；数据越多，占用的空间必然越大，海量数据处理起来相对吃力。

但是，它的时间复杂度很低，意味着数据量不大时，效率极高。

好了，两种解法写完了，赶紧实现一下吧。