topk问题

1. 求出现频率前 k 高的元素

（1）遍历整个数组，并使用哈希表记录每个数字出现的次数，并形成一个「出现次数数组」。
（2）找出原数组的前 k个高频元素，就相当于找出「出现次数数组」的前 k大的值。

class Solution {
public:
    class myComparison{
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs)
        {
         	//将 > 改为 < 则是频率最小的k个数
            return lhs.second > rhs.second;  
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        //1. 利用map统计元素出现的次数
        unordered_map<int, int> map;
        for(int i = 0; i < nums.size(); i++)
        {
            map[nums[i]]++;
        }
        //2. 对元素出现频率排序，求topK，定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, myComparison> pri_que;
         // 用固定大小为k的小顶堆，扫描所有频率的数值
        for(unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++)
        {
            pri_que.push(*it);
            //如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
            if(pri_que.size() > k)
            {
                pri_que.pop();
            }
        }
        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒叙来输出到数组 
        vector<int> res(k);
        for(int i = k - 1; i >=0; i--)
        {
            //first指向高频率的元素
            res[i] = pri_que.top().first;
            pri_que.pop();
        }
        return res;
    }
};

时间复杂度：O(Nlogk)，其中N 为数组的长度。我们首先遍历原数组，并使用哈希表记录出现次数，每个元素需要 O(1)的时间，共需 O(N) 的时间。随后，我们遍历「出现次数数组」，由于堆的大小至多为 k，因此每次堆操作需要 O(log⁡k) 的时间，共需 O(Nlog⁡k)的时间。二者之和为 O(Nlog⁡k)。

2. 求最大的k个数

class Solution {
public:
    class cmp
    {
    public:
        bool operator()(int a, int b)
        {
            return a > b;
        }
    };
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> res;
        //排除top0的情况
        if(k == 0)  return res;
        //创建大根堆
        priority_queue<int, vector<int>, cmp> minHeap;
        for(int num : arr)
        {
            if(minHeap.size() < k)
            {
                minHeap.push(num);
            }
            else if(minHeap.top() < num)
            {
                minHeap.pop();
                minHeap.push(num);
            }
        }
        for(int i = 0; i < k; i++)
        {
            res.push_back(minHeap.top());
            minHeap.pop();
        }
        return res;
    }
};

3 有序矩阵中第 K 小的元素

二分查找

class Solution {
public:
    bool check(vector<vector<int>>& matrix, int mid, int k, int n) {
        int i = n - 1;
        int j = 0;
        int num = 0;
        while (i >= 0 && j < n) {
            if (matrix[i][j] <= mid) {
                num += i + 1;
                j++;
            } else {
                i--;
            }
        }
        return num >= k;
    }

    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int n = matrix.size();
        int left = matrix[0][0];
        int right = matrix[n - 1][n - 1];
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (check(matrix, mid, k, n)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
};