leetcode347.前k个高频元素（中等）

题目类似于leetcode215.topK
做法相同：都是堆排序和快排，唯一的不同是topK是输出第k大元素，这道题是找出前k大，所以在快排的代码中就不能剪枝了。

做法一：排序 时间：O(nlogn)

class Solution {
public:
    static bool cmp(pair<int, int> p1, pair<int, int>p2) {
        return p1.second > p2.second;
    }
    vector<int> topKFrequent(vector<int>& nums, int k) {

        unordered_map<int, int> ump;
        vector<int> ans;
        for (auto& each : nums) {
            ump[each]++;
        }
        vector<pair<int, int>> v(ump.begin(), ump.end()); 
        //vector<pair<int, int>>(map.begin(),map.end())
        sort(v.begin(), v.end(), cmp);
        for (int i = 0; i < k; ++i) {
            ans.push_back(v[i].first);
        }
        return ans;
    }
};

做法二：优先队列 维护一个小顶堆，堆中最多只保存k个元素 O(nlogk)

class Solution {
public:
    struct cmp{
        bool operator()(pair<int, int> p1, pair<int, int> p2) {
            return p1.second > p2.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
    
        unordered_map<int, int> ump;
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        vector<int> ans;
        for (auto& each : nums) {
            ump[each]++;
        }
        for (auto &each : ump) {
            if(pq.size() < k) pq.push(each);
            else if (each.second > pq.top().second) {
                pq.pop();
                pq.push(each);
            }
        }
        while (!pq.empty()) {
            ans.push_back(pq.top().first);
            pq.pop();
        }
        return ans;
    }
};

做法三：快速排序 时间：O(nlogn) 先不管

class Solution {
public:
    //快速排序，常规写法
    int partition(vector<pair<int, int>> &v, int left, int right);
    void quickSort(vector<pair<int, int>> &v, int left, int right);
    vector<int> topKFrequent(vector<int>& nums, int k) {
        
        unordered_map<int, int> mp;
        int n = nums.size();
        for (int i = 0; i < n; ++i) {
            mp[nums[i]]++;
        }
        vector<pair<int, int>> v;
        vector<int> ans;
        n = mp.size();
        for (auto& m : mp) {
            v.push_back(m);
        }
        quickSort(v, 0, n - 1);
        for (int i = n - 1; i >= n - k; --i) {
            ans.push_back(v[i].first);
        }
        return ans;
    }
};
void Solution::quickSort(vector<pair<int, int>> &v, int left, int right) {
    if (left < right) {
        int index = partition(v, left, right);
        quickSort(v, left, index - 1);
        quickSort(v, index + 1, right);
    }
}
int Solution::partition(vector<pair<int, int>> &v, int left, int right) {
    auto tmp = v[left];
    while (left < right) {
        while (left < right && v[right].second > tmp.second) --right;
        v[left] = v[right];
        while (left < right && v[left].second <= tmp.second) ++left;
        v[right] = v[left];
    }
    v[left] = tmp;
    return left;
}

除了上面得到前k大元素外：冒泡排序和直接插入排序也可一趟到达最终位置，但是复杂度O(n^2)