剑指 Offer 40. 最小的k个数

仅供自己学习

 

思路：
一开始自己用的multiset 做容器，全部加进去再取出k个

代码：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        multiset<int> a;
        vector<int> res;
        for(int i=0;i<arr.size();++i){
            a.insert(arr[i]);
        }
        multiset<int>::iterator p=a.begin();
        int count=0;
        while(count<k){
            count++;
            res.push_back(*p++);
        }
        return res;
    }
};

 

然后就是直接调用sort函数，再取出前面k个

 

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

 

还有就是用大顶堆了。我也是考虑全部加进去再取出k次堆顶元素。

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int n=arr.size();
        vector<int> res;
        if(k==0) return res;
        priority_queue<int,vector<int>,greater<int>> pq;
        for(int i=0;i<n;++i){
            pq.push(arr[i]);
        }
        while(k--){
            res.push_back(pq.top());pq.pop();

        }
        return res;
    }
};

 

堆的话还可以只开k个空间，先把arr的前k个元素加入进堆里，然后每次判断如果栈顶元素大于arr[ i ]的元素就pop再加入arr[ i ]。最后再从堆里取出全部元素即可

代码：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int n=arr.size();
        vector<int> res;
        if(k==0) return res;
        priority_queue<int,vector<int>,less<int>> pq;
        for(int i=0;i<k;++i){
            pq.push(arr[i]);
        }
        for(int i=k;i<n;++i){
            if(pq.top()>arr[i]){
                pq.pop();
                pq.push(arr[i]);
            }
        }
        while(!pq.empty()){
            res.push_back(pq.top());
            pq.pop();
        }
        return res;
    }
};

 

还有对快排进行优化

这里有一个称为哨兵的标记，用于作为比较的基准点。我们从两侧开始移动，先移动右侧的指针，从最后一个往前移动判断是否小于基准点的值，如果小于那么就停止移动右指针，开始移动左指针，如果遇到的值大于基准点，那么久交换左右指针指向的的元素。交换后再次循环，知道左右指针指向同一个位置。然后将这个位置的元素和基准点交换位置。然后判断基准点的位置是否小于K或者大于K。因为前面这样做了之后，前面的点都是小于基准点的，后面的都是大于基准点的。所以要这样判断来减少不需要的额外循环。但我们确定了他大于K，那么我们就继续快排 数组第一个元素到基准点位置-1的范围的元素。如果小于K，那么就快排 基准点下一个元素到数组最后一个元素的范围。如果基准点等于K，那么就返回结果即可

 

代码：

class Solution {
public:
    vector<int> quick_sort(vector<int>&arr,int k,int left,int right){
        int l=left,r=right;
        vector<int> res;
        while(l<r){
            while(l<r&&arr[r]>=arr[left]) --r;
            while(l<r&&arr[l]<=arr[left]) ++l;
            swap(arr[l],arr[r]);
        }
        swap(arr[l],arr[left]);
        if(l>k) return quick_sort(arr,k,left,l-1);
        if(l<k) return quick_sort(arr,k,l+1,right);
        res.assign(arr.begin(),arr.begin()+k);
        return res;
    }
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        if(k>=arr.size()) return arr;
        return quick_sort(arr,k,0,arr.size()-1);
    }
};