TopK的3种解法

题目：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

思路1：如果k比较大，可以直接把数组划分为2个部分，一部分为[0,k-1] ，一部分为【k，n-1】

            遍历第二部分，和第一部分的最大值比较，如果更小则交换，遍历结束第一部分就是topk的结果

    时间复杂度是k(n-k)

思路2：利用大顶堆，时间复杂度是nlogk

思路3:  利用快排的思路,得到partition,然后和k进行比较,再继续partition

思路1：

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
     ArrayList<Integer> list = new ArrayList<Integer>();
        if(input.length < k || k == 0)
            return list;
        for (int i = 0; i < k; i++)
            list.add(input[i]);
        for (int i = k; i < input.length; i++) {
            int j = this.getMax(list);
            int temp = (Integer) list.get(j);
            if (input[i] < temp)
                list.set(j, input[i]);
        }
        return list;
    }
    public int getMax(ArrayList<Integer> list) {
        int max = list.get(0);
        int j = 0;
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) > max) {
                max = list.get(i);
                j = i;
            }
        }
        return j;
    }
}

思路2：

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        //检查输入的特殊情况
        if(input==null || input.length<=0 || input.length<k){
            return list;
        }
        //构建最大堆
        for(int len=k/2-1; len>=0; len--){
            adjustMaxHeapSort(input,len,k-1);
        }
        //从第k个元素开始分别与最大堆的最大值做比较，如果比最大值小，则替换并调整堆。
        //最终堆里的就是最小的K个数。
        int tmp;
        for(int i=k; i<input.length; i++){
            if(input[i]<input[0]){
                tmp=input[0];
                input[0]=input[i];
                input[i]=tmp;
                adjustMaxHeapSort(input,0,k-1);
            }
        }
        for(int j=0; j<k; j++){
            list.add(input[j]);
        }
        return list;
    }
     
    public void adjustMaxHeapSort(int[] input, int pos, int length){
        int temp;
        int child;
        for(temp=input[pos]; 2*pos+1<=length; pos=child){
            child=2*pos+1;
            if(child<length && input[child]<input[child+1]){
                child++;
            }
            if(input[child]>temp){
                input[pos]=input[child];
            }else{
                break;
            }
        }
        input[pos]=temp;
    }
}

思路3

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        if(k==0 || k>input.size()) return {};
        if(k==input.size()) return input;
        int left = 0,right=input.size();
        while(left<right){
            int pivot=partition(input,left,right);
            if(pivot+1==k){ //刚好topk
                return vector<int>({input.begin(),input.begin()+k});
            }else if(pivot+1<k){ //左边界右移为pivot+1
                left=pivot+1;
            }else{
                right=pivot;     //右边界左移到pivot
            }
        }
        return {};
    }
    
    //快排
    int partition(vector<int> &input,int left,int right){
        int pivot=input[right-1];
        int i=left;
        for(int j=left;j<right-1;j++){
            if(input[j]<pivot){
                swap(input[i++],input[j]);
            }
        }
        swap(input[right-1],input[i]);
        return i;
    }
};