LeetCode-347-前k个高频元素

1、哈希表+堆排序

为了比较每个元素出现的次数，我们可以遍历整个数组，利用哈希表记录每个元素出现的次数。而后我们为了确保时间复杂度采用堆排序，此时的小顶堆中的元素是自定义元素。当堆的大小小于k时，我们向堆中添加元素；当堆的大小等于k时，我们比较堆顶元素和新元素出现的次数并保留出现次数更多的一方。最终时间复杂度为$O(nlogk)$。

class Solution {
public:
    static bool cmp(pair<int, int> &m, pair<int, int> &n) {
        return m.second > n.second;
    }

    vector<int> topKFrequent(vector<int> &nums, int k) {
        unordered_map<int, int> hs;
        vector<int> result;
        for (auto i: nums) {
            hs[i]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);
        for (auto &[num, count]: hs) {
            if (q.size() == k) {
                if (q.top().second < count) {
                    q.pop();
                    q.emplace(num, count);
                }
            } else {
                q.emplace(num, count);
            }
        }
        vector<int> ret;
        while (!q.empty()) {
            ret.emplace_back(q.top().first);
            q.pop();
        }
        return ret;
    }
};

2、快速排序改进

考虑到快速排序在每一次排序时能够确定一个数字在正确排序数组中的位置，我们可以先找出一个元素在正确排序数组中的位置：若该位置大于k则在其左半部分寻找前k位；若该位置小于k则在右半部分寻找k-左半部分长度的数；若等于则直接返回。

class Solution {
public:
    void qsort(vector<pair<int, int>>& v, int start, int end, vector<int>& ret, int k) {
        int picked = rand() % (end - start + 1) + start;
        swap(v[picked], v[start]);

        int pivot = v[start].second;
        int index = start;
        for (int i = start + 1; i <= end; i++) {
            if (v[i].second >= pivot) {
                swap(v[index + 1], v[i]);
                index++;
            }
        }
        swap(v[start], v[index]);

        if (k <= index - start) {
            qsort(v, start, index - 1, ret, k);
        } else {
            for (int i = start; i <= index; i++) {
                ret.push_back(v[i].first);
            }
            if (k > index - start + 1) {
                qsort(v, index + 1, end, ret, k - (index - start + 1));
            }
        }
    }

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> occurrences;
        for (auto& v: nums) {
            occurrences[v]++;
        }
        vector<pair<int, int>> values;
        for (auto& kv: occurrences) {
            values.push_back(kv);
        }
        vector<int> ret;
        qsort(values, 0, values.size() - 1, ret, k);
        return ret;
    }
};