力扣面试题17.14最小K个数

题目：

设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

示例：

输入： arr = [1,3,5,7,2,4,6,8], k = 4
输出： [1,2,3,4]

提示：

• 0 <= len(arr) <= 100000
• 0 <= k <= min(100000, len(arr))

思路：

先将前k个数创建为最大堆，然后将k+1位置的数拿来做比较，看他该放在哪里，如果大于堆顶元素，直接判断下一个，如果小于的话，将堆顶元素和那个数进行交换，然后重新排列最大堆。

class Solution {
public:
    void Adjust(vector<int> &arr, int start, int end){//优先级队列其实就是这个
        int father = start;
        int child = father * 2 + 1;
        while(child <= end){
            if(child + 1 <= end && arr[child] < arr[child + 1]){
                child++;
            }
            if(arr[father] < arr[child]){
                swap(arr[father], arr[child]);
                father = child;
                child = father * 2 + 1;
            }
            else{
                break;
            }
        }
    }
    
    vector<int> smallestK(vector<int>& arr, int k) {
        vector<int> ans(k);
        if(k == 0){
            return ans;
        }
        for(int u = k / 2 - 1; u >= 0; u--){//先将前k个进行堆排序
            Adjust(arr, u, k - 1);
        }
        for(int i = arr.size() - 1; i >= k; i--){
            if(arr[i] < arr[0]){//与堆顶元素做比较
                swap(arr[0], arr[i]);
                Adjust(arr, 0, k - 1);
            }
        }
        for(int j = 0; j < k; j++){
            ans[j] = arr[j];
        }
        return ans;
    }
};

其实有可以将堆排序的部分直接使用优先队列

priority_queue(优先级队列)

容器声明：

priority_queue容器存放在模板库
//头文件：<queue>
//定义：
priority_queue<Type, Container, Functional>
Type是数据类型；
Container是容器类型（必须是数组实现的容器，比如vector,deque等，但不能用list。STL里默认用的是vector）
Functional是比较方式，当需要自定义数据类型时要传入三个参数，使用基本数据类型时，只需要传入数据类型

大小根堆

//基本数据类型，默认大根堆（从大到小）
#include<queue>
priority_queue<int> q;
priority_queue<string> q;
priority_queue<pair<int,int>> q;
//复杂的
//升序队列 greater 从小到大
priority_queue<int, vector<int>, greater<int>> q;
//降序队列 less 从大到小
priority_queue<int, vector<int>, less<int>> q;

class Solution {
public:
    vector<int> smallestK(vector<int>& arr, int k) {
        vector<int> ans(k);
        if(!k){
            return ans;
        }
        priority_queue<int> que;//优先级队列大根堆（默认从大到小）
        for(int i = 0; i < k; i++){//先向队列中存储k个数
            que.push(arr[i]);
        }
        for(int j = k; j < (int) arr.size(); j++){//若第k+1位置的数大于队列中队顶的数，则判断下一个，反之将队顶元素弹出，把数组中的数字放回
            if(arr[j] < que.top()){
                que.pop();
                que.push(arr[j]);
            }
        }
        for(int s = 0; s < k; s++){
            ans[s] = que.top();
            que.pop();
        }
        return ans;
    }
};