LeetCode-剑指Offer40-最小的k个数-简单(排序/堆/快速选择)

一 题目

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

二 示例及提示

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

限制：

    0 <= k <= arr.length <= 10000
    0 <= arr[i] <= 10000

三 题解

1.排序

思路没啥好说的，从小到大排序后取前k个数。代码如下：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        sort(arr.begin(),arr.end());
        vector<int> mini;
        for(int i = 0; i < k; i++)
        {
            mini.push_back(arr[i]);
        }
        return mini;
    }
};

批注：1.sort() 前两个参数分别为需要排序数组开始的地址，结束的地址，默认从小到大排序，第三个参数可规定排序方式。

sort(a, a + 10, less<int>());        //升序
sort(a, a + 10, greater<int>());    //降序

2.堆

思路：

题目要求是找出前k个最小值，因此只需要构建一个大根堆来维护这k个值。

首先可以直接选择前10个值来建立一个大根堆，那么堆顶肯定是这10个数里的最大值了，然后再从k+1开始遍历整个数组，并逐一和堆顶元素比较，如果比堆顶大，那就继续向下遍历，如果比堆顶小，就把堆顶弹出，替换掉堆顶元素后，重新调整成一个新的大根堆，再重复以上过程，直到遍历结束。每次弹出的栈顶元素则存入数组中，最后返回数组得到结果。

ps.这里笔者偷懒，直接用了priority_queue，之后会再补充自建堆的写法。

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        priority_queue<int> Q;
        vector<int> mini(k,0);
        if(k == 0)
            return mini;
        for(int i = 0; i < k; i++)
        {
            Q.push(arr[i]);//直接选取前k个数建立大根堆
        }
        for(int i = k; i < arr.size(); i++)
        {
            if(arr[i] < Q.top())
            {
                Q.pop();
                Q.push(arr[i]);
            }
        }
        for(int i = 0; i < k; i++)
        {
            mini[i] = Q.top();
            Q.pop();
        }
        return mini;
    }
};

空间复杂度：O(k) 因为大根堆内最多只有k个数。

时间复杂度：O(nlog⁡k)，其中 n 是数组 arr 的长度。由于大根堆实时维护前 k 小值，所以插入删除都是 O(logk) 的时间复杂度，最坏情况下数组里 n 个数都会插入，所以一共需要 O(nlogk) 的时间复杂度。

同时补充一下关于各种排序方法的比较：

这里再注明一下当时自己写代码犯的很蠢的错【作为自己的提醒】：

1.要注意题目的限制情况，尤其要考虑极限情况。忘写给k判空了，还交了好多遍，我晕了。

2.提交之后报错了这个：reference binding to null pointer of type 'int' (stl_vector.h) 然后发现是vector越界访问。如果没有在定义vector的时候分配空间，那么只允许用.push_back()的形式去赋值，绝对不能以数组下标的形式去访问。一天内犯了好多次，大概是新学c++的缘故（抽烟。

3 快速选择（分治思想）

快排和快速选择都是先分治，划分函数执行完之后会将数组基于key被分成两个区间，并返回key的下标值。而这两者的区别在于快排会根据分界的下标值对分界左右两边都进行递归处理，而快速选择只对一边进行处理。

基于题目所求为前k个最小值，因此我们也无须对所有数都进行排序，而只用对局部排序，采取快速选择的方法。

class Solution {
public:
    int partition(vector<int>& arr, int low, int high)
    {
        int key = arr[low];//其实这个key 也就是快排的pivot最好随机取，这样更优化算法的时间度
        while(low < high)
        {
            while(low < high && arr[high] >= key) --high;
            arr[low] = arr[high];
            while(low < high && arr[low] <= key) ++low;
            arr[high] = arr[low];
        }
        arr[low] = key;
        return low;
    }

    void quickSort(vector<int>& arr, int k, int low, int high)
    {
        if(low >= high) return;//
        int pos = partition(arr,low,high);//
        
        if(k == pos) return;     
        else if(k > pos) quickSort(arr, k, pos+1, arr.size()-1);
        else if(k < pos) quickSort(arr, k, 0, pos-1);
    }

    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> mini;
        quickSort(arr,k,0,arr.size()-1);
        for(int i = 0; i < k; i++)
        {
            mini.push_back(arr[i]);
        }
        return mini;
    }
};

遇到了这个报错：in C++98 'arr' must be initialized by constructor, not by '{...}' 就是这种赋值方式是C++11支持的，而我的编译器是C++98.

写的时候晕了很久……我也不知道我咋想的，这可能就是笨b吧orz 其实和快排基本差不多，另外还是需要注意一些临界条件。