451. Sort Characters By Frequency&&347. Top K Frequent Elements

451.

Given a string, sort it in decreasing order based on the frequency of characters.

Example 1:

Input:
"tree"

Output:
"eert"

Explanation:
'e' appears twice while 'r' and 't' both appear once.
So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.

Example 2:

Input:
"cccaaa"

Output:
"cccaaa"

Explanation:
Both 'c' and 'a' appear three times, so "aaaccc" is also a valid answer.
Note that "cacaca" is incorrect, as the same characters must be together.

Example 3:

Input:
"Aabb"

Output:
"bbAa"

Explanation:
"bbaA" is also a valid answer, but "Aabb" is incorrect.
Note that 'A' and 'a' are treated as two different characters.

347.

Given a non-empty array of integers, return the k most frequent elements.

For example,
Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note:

    You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
    Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

这两道题很类似，都要先统计一个集合里的词频，然后按词频排列，以某种方式进行输出。

统计集合里的词频可以用两种方式，map或者直接用数组记录。具体看情况，像347就只能用map，因为整数太多了。

451 using buckets

class Solution {
public:
    string frequencySort(string s) {
        
        vector<int> freq(256, 0);
        vector<string> bucket(s.size()+1, "");
        
        for(auto c : s){
            freq[c]++;
        }
        
        for(int i=0; i!=freq.size(); ++i){
            for(int j=0; j!=freq[i]; ++j)
                bucket[freq[i]]+=char(i);
        }
        
        string res="";
        
        for(int i=bucket.size()-1; i>=0; --i){
            res+=bucket[i];
        }
        
        return res;
    }
};

347. using buckets

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> m;
        for (int num : nums)
            ++m[num];
        
        vector<vector<int>> buckets(nums.size() + 1); 
        for (auto p : m)
            buckets[p.second].push_back(p.first);
        
        vector<int> ans;
        for (int i = buckets.size() - 1; i >= 0 && ans.size() < k; --i) {
            for (int num : buckets[i]) {
                ans.push_back(num);
                if (ans.size() == k)
                    break;
            }
        }
        return ans;
    }
};

347.using sort

class Solution {
public:

    vector<int> topKFrequent(vector<int>& nums, int k) {
        
        unordered_map<int, int> freq;
        vector<int> res;
        
        for(int i=0; i!=nums.size(); ++i){
            freq[nums[i]]++;
        }
        
        vector<pair<int, int>> hist;
        for(auto &it : freq){
            hist.push_back(make_pair(it.first, it.second));
        }
        
        sort(hist.begin(), hist.end(), [=](pair<int, int> &x, pair<int, int> &y) -> int{return x.second>y.second;});
        
        for(int i=0; i<k; i++){
            res.push_back(hist[i].first);
        }
        
        return res;
        
    }
};