一、前言
排序算法大家都很熟悉了，解法多种多样。
有一个问题和排序算法很相近，TopK问题：从N个数中选出最大的K个数，N通常远大于K。
总结了一些解法，供大家参考。
二、冒泡
private static float[] pickTopKByBubbleSort(float[] a, int k) {
int n = a.length;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (a[j] > a[j + 1]) {
float t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
float[] r = new float[k];
for (int i = 0; i < k; i++) {
r[i] = a[n - i - 1];
}
return r;
}冒泡排序的要义在于：外循环为排序趟数，内循环为每趟比较的次数，每趟得到一个最大的数，放到这一趟的末端。
如果是全数组排序的话，复杂度为O(n^2), 如果只选TopK的话，复杂度为O(n*k)。
三、堆
private static float[] pickTopKByHeapSort(float a[], int k) {
int n = a.length;
PriorityQueue<Float> queue = new PriorityQueue<>(n);
for (int i = 0; i < k; i++) {
queue.offer(a[i]);
}
for (int i = k; i < n; i++) {
if (a[i] > queue.peek()) {
queue.poll();
queue.offer(a[i]);
}
}
float[] r = new float[k];
for (int i = k - 1; i >= 0; i--) {
r[i] = queue.poll();
}
return r;
}堆的实现，在JDK中对应的是PriorityQueue，默认情况下是最小堆。
元素插入和删除的时间复杂度都是O(logn）。
堆可以用于排序：将所有元素插入堆中，在依次取出，即可得到有序排列的元素，时间复杂度为O(nlogn)。
如果按照上面冒泡排序的做法，将所有元素插入，再取出K个：
插入时间复杂度为O(nlogn), 取出的时间复杂度为O(klogn), 总体时间复杂度还是O(nlogn)。
当然，虽然复杂度都是O(nlogn)，但是比全体元素排序快一点（不用取尽n个元素）。
堆在TopK问题上更优的解法是：
1、只放k个元素到堆中，然后遍历剩下的元素，和堆顶的元素（堆中最小的值）比较，
2、若大于堆顶，则取出堆顶的元素，插入当前元素；若小于等于堆顶，直接跳过；
3、最后依次取出堆中元素。
平均时间复杂度为O(nlogk);
最快的情况下是O(n)，如果数组本身已经有序且是逆序的话。
四、快排
先来看下快排的实现：
private static int partition(float[] a, int left, int right) {
int i = left;
int j = right;
float key = a[left];
while (i < j) {
while (i < j && a[j] <= key) {
j--;
}
a[i] = a[j];
while (i < j && a[i] >= key) {
i++;
}
a[j] = a[i];
}
a[i] = key;
return i;
}
private static void sort(float[] a, int left, int right) {
if (left >= right) {
return;
}
int index = partition(a, left, right);
sort(a, left, index - 1);
sort(a, index + 1, right);
}快排的基本思想是：
1、通过一趟排序将要数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据都要小；
2、然后再按此方法对这两部分数据分别进行第1步的操作（递归），以此达到整个数据变成有序序列。
在TopK问题上，可以借鉴以上第1点，以及第2点的一部分：递归。
不同之处在于，求解TopK不需要对整个数据排序，只需要最大的K个数移动到数组的第K个位置的前面即可。
代码如下：
private static void sort(float[] a, int left, int right, int k) {
if (left >= right) {
return;
}
int index = partition(a, left, right);
int len = index - left + 1;
if (k < len) {
sort(a, left, index - 1, k);
} else if (k > len) {
sort(a, index + 1, right, k - len);
}
}
private static float[] pickTopKByQuickSort(float a[], int k) {
sort(a, 0, a.length - 1, k);
float[] r = new float[k];
for (int i = 0; i < k; i++) {
r[i] = a[i];
}
// 执行以上操作之后，r[]数组确实包含了top k的元素，但是不一定有序
// 如果仅仅是要求TopK而不需要有序，则不需要执行下面的排序函数
sort(r, 0, k - 1);
return r;
}最坏的情况下，时间复杂度和快排一样: O(n^2)。
平均情况下，快排的时间复杂度为O(nlogn)，求解TopK时间复杂度为O(n)。
五、桶排序
冒泡排序，堆排序，快速排序等都是基于比较的排序，时间复杂度下限为O(nlogn)。
而有一些排序的时间复杂度可以是O(n), 比如桶排序和基数排序。
但是这类排序有较为苛刻的限制条件：元素须是数值类型。
同时，如果是桶排序的话，范围不能太大，否则需要的桶太多，空间复杂度无法接受。
桶排序的元素不一定要是整数，有时候浮点数也可以。
比如，如果数据取值范围在[0, 100.0], 并且只有两位小数, 可以这么解：
private static float[] pickTopKByBucketSort(float[] a, int k) {
int[] bucket = new int[10000];
for (int i = 0; i < a.length; i++) {
int index = Math.round(a[i] * 100f);
bucket[index]++;
}
float[] r = new float[k];
int p = 0;
for (int i = bucket.length - 1; i >= 0 && p < k; i--) {
int c = bucket[i];
while (c > 0 && p < k) {
r[p++] = i / 100f;
c--;
}
}
return r;
}取一万个桶，将每个元素乘以100，四舍五入为整数（有一些小数在计算机二进制中无法精确表示，同时直接强转成int的话是向下取整），
放到对应的桶中；
然后从最大的桶开始检索，收集100个元素。
时间复杂度跟数据量和桶数量（取决于数据的大小范围）有关。
在数据量远大于桶数量时，时间复杂度为O(n)。
六、测试
集成测试的代码如下：
public static void main(String[] args) {
int n = 100000;
int k = 100;
boolean success = true;
Random r = new Random();
for (int j = 0; j < 100; j++) {
float[] a = new float[n];
for (int i = 0; i < n; i++) {
float t = r.nextFloat() * 100f;
t = (int) (t * 100) / 100f;
a[i] = t;
}
float[] tmp = Arrays.copyOf(a, n);
float[] top1 = pickTopKByBubbleSort(tmp, k);
tmp = Arrays.copyOf(a, n);
float[] top2 = pickTopKByHeapSort(tmp, k);
tmp = Arrays.copyOf(a, n);
float[] top3 = pickTopKByQuickSort(tmp, k);
tmp = Arrays.copyOf(a, n);
float[] top4 = pickTopKByBucketSort(tmp, k);
if (!Arrays.equals(top1, top2)
|| !Arrays.equals(top1, top3)
|| !Arrays.equals(top1, top4)) {
success = false;
break;
}
}
if (success) {
System.out.println("success");
} else {
System.out.println("failed");
}
}七、总结
这么多种方案，那种方案比较好呢？这个要看情况。
- 冒泡的方法看起来时间复杂度是最高的，但是假如K很小，比如极端情况 , K=1，这时候冒泡的方法反而是最快的；
- 平均情况下，如果可以用的上桶排序（数据取值范围较小），那桶排序是最快的；
- 如果数值取值范围较小，而N很大（比方说100000），K又比较小（比方说100）时，运行发现堆的方法比快排的方法快。
原因猜测：范围小，数据多，应该有很多数值是重复的； 用堆的方法，堆会很快攒到Top的数值（即使还不是TopK），检索到那些小的数值的时候就不需要插入，从而检索后面的元素时，操作就只剩简单的遍历了。
跳脱排序算法和TopK问题本身，最主要的还是思想。
例如，日常项目中，堆（优先队列）就不时会遇到，这前提是脑海中知道有优先队列这个东西，知道它的特性。
有的知识就是这样的，专门去学的时候不知道有什么用，但或许某一天碰到了，就会想起它了。
