Top K Frequent Words

问题：

Given a non-empty list of words, return the k most frequent elements.

Your answer should be sorted by frequency from highest to lowest. If two words have the same frequency, then the word with the lower alphabetical order comes first.

Example 1:

Input: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
Output: ["i", "love"]
Explanation: "i" and "love" are the two most frequent words.
    Note that "i" comes before "love" due to a lower alphabetical order.

Example 2:

Input: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
Output: ["the", "is", "sunny", "day"]
Explanation: "the", "is", "sunny" and "day" are the four most frequent words,
    with the number of occurrence being 4, 3, 2 and 1 respectively.

Note:

1. You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
2. Input words contain only lowercase letters.

Follow up:

1. Try to solve it in O(n log k) time and O(n) extra space.

解决：

① 使用PriorityQueue排序

class Solution { //108ms
    public List<String> topKFrequent(String[] words, int k) {
        List<String> res = new ArrayList<>();
        Map<String,Integer> map = new HashMap<>();//单词与出现次数的映射
        for (String word : words){
            map.put(word,map.getOrDefault(word,0) + 1);
        }
        PriorityQueue<Map.Entry<String,Integer>> priorityQueue =
                new PriorityQueue<>((a,b) -> (a.getValue() == b.getValue() ? b.getKey().compareTo(a.getKey()) : a.getValue() - b.getValue()));//构造小顶堆，首先将单词按照出现次数由小到大排序，如果次数相同，则按字典序由大到小排序
        for (Map.Entry<String,Integer> entry : map.entrySet()){
            priorityQueue.offer(entry);
            if (priorityQueue.size() > k){
                priorityQueue.poll();
            }
        }
        while (! priorityQueue.isEmpty()){
            res.add(0,priorityQueue.poll().getKey());
        }
        return res;
    }
}

相反的排序方式：

class Solution {
    public List<String> topKFrequent(String[] words, int k) {
        List<String> res = new ArrayList<>();
        Map<String,Integer> map = new HashMap<>();
        for (String word : words){
            map.put(word,map.getOrDefault(word,0) + 1);
        }
        PriorityQueue<Map.Entry<String,Integer>> priorityQueue =
                new PriorityQueue<>((a,b) ->
                        (a.getValue() == b.getValue() ? a.getKey().compareTo(b.getKey()) : b.getValue() - a.getValue()));
        for (Map.Entry<String,Integer> entry : map.entrySet()){
            priorityQueue.offer(entry);
        }
        int i = 0;
        while(! priorityQueue.isEmpty() && i < k){
            res.add(priorityQueue.poll().getKey());
            i ++;
        }
        return res;
    }
}

② 使用桶排序

class Solution {//24ms
    public List<String> topKFrequent(String[] words, int k) {
        List<String> res = new ArrayList<>();
        Map<String,Integer> map = new HashMap<>();
        for (String word : words) {
            map.put(word, map.getOrDefault(word, 0) + 1);
        }
        List<String>[] bucket = new ArrayList[words.length + 1];
        for (Map.Entry<String,Integer> entry : map.entrySet()){
            int count = entry.getValue();
            if (bucket[count] == null){
                bucket[count] = new ArrayList<>();
            }
            bucket[count].add(entry.getKey());
        }
        for (int j = bucket.length - 1;j >= 0 && res.size() < k;j --){//按照出现次数加入结果集合
            if (bucket[j] != null){//如果出现次数相同，按照字典序排序
                Collections.sort(bucket[j]);
                res.addAll(bucket[j]);
            }
        }
        return res.subList(0,k);//返回前k个值
    }
}