【JZ40 最小的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());
        return vector<int>({input.begin(), input.begin() + k});  
    }
};

运行时间：6ms
超过2.88% 用C++提交的代码
占用内存：524KB
超过68.01%用C++提交的代码
时间复杂度：O(nlongn)
空间复杂度：O(1)

方法二：堆排序

建立一个容量为k的大根堆的优先队列。遍历一遍元素，如果队列大小<k,就直接入队，否则，让当前元素与队顶元素相比，如果队顶元素大，则出队，将当前元素入队

代码：

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> ret;
        if (k==0 || k > input.size()) return ret;
        priority_queue<int, vector<int>> pq;
        for (const int val : input) {
            if (pq.size() < k) {
                pq.push(val);
            }
            else {
                if (val < pq.top()) {
                    pq.pop();
                    pq.push(val);
                }
 
            }
        }
 
        while (!pq.empty()) {
            ret.push_back(pq.top());
            pq.pop();
        }
        return ret;
    }
};

运行时间：4ms
超过10.95% 用C++提交的代码
占用内存：532KB
超过66.60%用C++提交的代码
时间复杂度：O(nlongk), 插入容量为k的大根堆时间复杂度为O(longk), 一共遍历n个元素
空间复杂度：O(k)

方法三：快排思想

对数组[l, r]一次快排partition过程可得到，[l, p), p, [p+1, r)三个区间,[l,p)为小于等于p的值
[p+1,r)为大于等于p的值。
然后再判断p，利用二分法

1. 如果[l,p), p，也就是p+1个元素（因为下标从0开始），如果p+1 == k, 找到答案
2. 如果p+1 < k, 说明答案在[p+1, r)区间内，
3. 如果p+1 > k , 说明答案在[l, p)内

代码：

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

运行时间：4ms
超过10.95% 用C++提交的代码
占用内存：524KB
超过68.01%用C++提交的代码
时间复杂度：平均时间复杂度为O(n),每次partition的大小为n+n/2+n/4+… = 2n,最坏时间复杂度为O(n^2), 因为每次partition都只减少一个元素
空间复杂度：O(1)