求 TOPK 的三种方法及分析

最新推荐文章于 2021-11-18 16:54:24 发布

原创最新推荐文章于 2021-11-18 16:54:24 发布 · 4.7k 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#算法

algorithm 专栏收录该内容

10 篇文章

订阅专栏

本文介绍了使用冒泡排序、堆排序和快速排序求解TopK问题的方法，对比了不同算法的时间复杂度，并提供了堆排序和快速排序的具体实现代码。

从八大排序来说，适合求 topk 的排序有：冒泡、堆排、快排

冒泡（n*k）：对于冒泡来说，求前k个数，只需要遍历k次即可，因此算法上有性能的提升

堆排（nlogk）：构造一个大小为 k 的堆，求前 k 大就构造最小堆（构造完之后，最小值如果小于当前值，则覆盖然后再调整一次堆），最前 k 小就构造最大堆（同理），然后过一遍即可。

快排(n*logn) ：利用快排的思想，如果 partition 过后，指针刚好指向 k（k-1），则左边部分（加上k）则为求解，但是这个解并不是有序的，还需要排序依次，而大于k的话，则抛弃右边，向左边求解，如果小于 k 的话，则抛弃左边向右边求解（也可以继续对左边排序，这样最后就不用再排序了）。最后求出k，再对k前面部分排序依次就可以。
这里的时间复杂度计算要复杂一些，首先平均要logn次递归是不变的，变化的是每次要遍历的数组大小，第一次要遍历 n 个，第二次要遍历 n/2 个，第三次 n/4 个。。。。一共遍历logn次，这是一个等比数列，求前logn项和之后，复杂度是 2n - （2n/2^logn），也就是o（n）级别的了，所以快排应该是最快的了，不过有个缺点就是排序出来的k个数不是有序的，还要再排序一次。

总结：
（1）如果 k 很小，例如10以内的话，则利用冒泡堆排都可以，毕竟 k 和 logk 相差不大，但是冒泡相对简单。
（2）如果 k 比较大，则不适合用冒泡，考虑堆排和快排，一个是nlogk，一个是 2n - （2n/2^logn），一般而言是快排比较快，但是如果数组会动态变化的话，堆排比较好，因为插入复杂度可以控制在logk，而快排是k。对于辅助空间，快排o(1)，堆排o(k)。
（3）采用quickSelect思想有一个很重要的问题，就是大小相等的数要不要过掉，首先肯定要过掉的，不然当左右指针指向的值都等于privot的时候会死循环。然后因为我们要求topk，而最后的topk都存在数组的前k个位置，因此，这里要特别注意的是前半部分要用 >= 即遇到和枢轴相等的元素跳过，而从后往前的指针不能跳过。参考过几个人写的都没有注意这个问题，自己拿下来测一遍就会出问题了。当然如果采用重复的数最后往中间移这种方案也是可以的。

用堆求解的代码：

import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if(input.length==0 || k==0 || input.length < k) return new ArrayList<Integer>();
        int[] arr = new int[k];
        for(int i=0;i<k;i++) arr[i] = input[i];
        maxHeap(arr,k);
        for(int i=k;i<input.length;i++) {
            if(input[i] < arr[0]) {
                arr[0] = input[i];
                heapAdjust(arr,0,k);
            }
        }
        ArrayList<Integer> ans = new ArrayList<>();
        for(int i=0;i<k;i++) {
            ans.add(arr[i]);
        }
        return ans;
    }

    public void maxHeap(int[] arr, int n) {
        for(int i=n/2-1;i>-1;i--) {
            heapAdjust(arr,i,n);
        }
    }

    public void heapAdjust(int[] arr, int st, int n) {
        int i = st;
        int j = 2*i+1;
        int key = arr[st];
        while(j<n) {
            if(j+1<n && arr[j+1] > arr[j]) j++;
            if(arr[j] < key) break;
            arr[i] = arr[j];
            i = j;
            j = 2*i+1;
        }
        arr[i] = key;
    }
}

快排求解代码

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<bitset>
#include<queue>
#include<vector>
#define INF 0x3f3f3f
#define PI 3.141592653
#define max(a,b) ((a > b) ? a : b)
#define min(a,b) ((a < b) ? a : b)
using namespace std;

void quickSelect(int arr[], int left, int right, int k) {
    if(left>=right || k == 0) return;
    int priot = arr[left];
    int i = left, j = right;
    while(i<j) {
        while(i<j && arr[j]>priot) j--;  //这里不能加 = 号
        arr[i] = arr[j];
        while(i<j && arr[i]<=priot) i++; // 这里必须加 = 号
        arr[j] = arr[i];
    }
    arr[i] = priot;
    if(i > k) {
        quickSelect(arr, left, i-1, k);
    } else if(i < k) {
        quickSelect(arr, i+1, right, k);
    }
}

void topn(int arr[], int n) {
    int k = 5;
    quickSelect(arr,0,n-1,k);
    for(int i = 0 ; i < k; i++) {
        printf("%d ",arr[i]);
    }
}

int main()
{
    //freopen("input.txt","r",stdin);
    int arr[] = {5,4,343,43,54,5565,1,-2,3,12,5,6};
    topn(arr,sizeof(arr)/sizeof(arr[0])); 
    return 0;
}