最小的K个数

最小的K个数

描述
给定一个长度为 n 的可能有重复值的数组，找出其中不去重的最小的 k 个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4(任意顺序皆可)。
数据范围： 0≤k,n≤10000，数组中每个数的大小0≤val≤1000
要求： 空间复杂度 O(n) ，时间复杂度 O(nlogn)

示例1
输入：
[4,5,1,6,2,7,3,8],4

返回值：
[1,2,3,4]

说明：
返回最小的4个数即可，返回[1,3,2,4]也可以
示例2
输入：
[1],0

返回值：
[]

示例3
输入：
[0,1,2,1,2],3

返回值：
[0,1,1]

方法一：（排序）

最直接的想到的办法一般都是排序，然后取前k个元素即可

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> ret;
        if(k==0 || k>input.size()) return ret;
        sort(input.begin(), input.end());
        for(int i=0;i<k;++i){
            ret.push_back(input[i]);
        }
        return ret;
    }
};

• 时间复杂度： O(nlongn)
• 空间复杂度： O(1)

方法二：（堆）

思路： 维护一个堆，这个堆的容量大小为k，那么只要保证堆顶元素是倒数第k大就可以了，因此需要用到大顶堆，即一个容量为k大顶优先队列来过滤每一个元素，最后再把这个优先队列的元素取出即可；

class Solution {
public:
    priority_queue<int,vector<int>,less<int>> que_max;
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> ret;
        if(k==0 || k>input.size()) return ret;
        for(int i=0;i<input.size();++i){
            if(que_max.size()<k) que_max.push(input[i]);
            else if(input[i]<que_max.top()){
                que_max.pop();
                que_max.push(input[i]);
            }
        }
        while(!que_max.empty()){
            ret.push_back(que_max.top());
            que_max.pop();
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

• 时间复杂度： O(nlongk), 插入容量为k的大根堆时间复杂度为O(longk), 一共遍历n个元素
• 空间复杂度： O(k)

方法三：（快速排序）

快排的重要思想就是，每趟排序都是以被排序元素将整个无序序列二分，即每一趟下来，被排序元素左右两侧一侧比其大，另一侧比其小，那这一点正好可以利用起来；在这一题中，我们利用快排需要关注的就是确定这个k；这一点可以在二分搜索的过程中不断缩小搜索区间，每搜索一次返回被排序元素的下标，直到下标+1等于k即可；

class Solution {
public:
    int quick(vector<int>& input,int l,int r){
        int pivot=r-1;
        int i=l;
        for(int j=l;j<r-1;++j){
            if(input[j]<input[pivot]){
                swap(input[i++], input[j]);
            }
        }
        swap(input[pivot],input[i]);
        return i;
    }
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        int sz=input.size();
        vector<int> ret;
        if(k==0 || k>sz) return ret;
        int l=0;int r=sz;
        while(l<r){
            int p=quick(input, l, r);
            if(p+1==k){
                return vector<int>({input.begin(),input.begin()+k});
            }
            if(p+1>k){
                r=p;
            }
            else{
                l=p+1;
            }
        }
        return ret;
    }
};

• 时间复杂度： 平均时间复杂度为O(n),每次quick的大小为n+n/2+n/4+... = 2n,最坏时间复杂度为O(n^2), 因为每次quick都只减少一个元素
• 空间复杂度： O(1)