前K个高频单词(hashmap，priority使用以及自定义排序)

哈希表

class Solution {
    public List<String> topKFrequent(String[] words, int k) {
    HashMap<String,Integer> map=new  HashMap<>();
    for(String ch:words){
        map.put(ch,map.getOrDefault(ch,0)+1);
    }
    List<String> res=new ArrayList<>();
        for(Map.Entry<String,Integer> en:map.entrySet()){
            res.add(en.getKey());
        }
        Collections.sort(res,new Comparator<String>(){
           public int  compare(String a,String b){
               return map.get(a)==map.get(b)?a.compareTo(b):map.get(b)-map.get(a);
           }
        });
           
        
        return res.subList(0, k);
    }
}

class Solution {

public:
    vector<string> topKFrequent(vector<string>& words, int k) {
       vector<string>res;
     unordered_map<string,int> map;
     for(auto ch:words){
         map[ch]++;
         
     }
   for(auto &[key,value]:map){
       res.emplace_back(key);
   }
    sort(res.begin(),res.end(),[&](const string& a,const string& b)->bool{
        return map[a]==map[b]?a<b:map[a]>map[b];
    });
    res.erase(res.begin()+k,res.end());
    return res;
   
    }
};

优先队列(小根堆)

public class Solution {

     public List<String> topKFrequent(String[] words, int k) {
        // 1.先用哈希表统计单词出现的频率
        Map<String, Integer> count = new HashMap();
        for (String word : words) {
            count.put(word, count.getOrDefault(word, 0) + 1);
        }
        // 2.构建小根堆 这里需要自己构建比较规则 此处为 lambda 写法 Java 的优先队列默认实现就是小根堆
        PriorityQueue<String> minHeap = new PriorityQueue<>((s1, s2) -> {
            if (count.get(s1).equals(count.get(s2))) {
                return s2.compareTo(s1);
            } else {
                return count.get(s1) - count.get(s2);
            }
        });
        // 3.依次向堆加入元素。
        for (String s : count.keySet()) {
            minHeap.offer(s);
            // 当堆中元素个数大于 k 个的时候，需要弹出堆顶最小的元素。
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }
        // 4.依次弹出堆中的 K 个元素，放入结果集合中。
        List<String> res = new ArrayList<String>(k);
        while (minHeap.size() > 0) {
            res.add(minHeap.poll());
        }
        // 5.注意最后需要反转元素的顺序。
        Collections.reverse(res);
        return res;
    }        
}

优先队列大根堆)

class Solution {
    public List<String> topKFrequent(String[] words, int k) {
    HashMap<String,Integer> map=new  HashMap<>();
    for(String ch:words){
        map.put(ch,map.getOrDefault(ch,0)+1);
    }
    PriorityQueue<String> q=new PriorityQueue<String>(new Comparator<String>(){
        public int compare(String a,String b){
            return map.get(a)==map.get(b)?a.compareTo(b):map.get(b)-map.get(a);
        }
    });
    for(String st:map.keySet()){
        q.offer(st);
    }
    List<String> res=new ArrayList<>();
    for(int i=0;i<k;i++){
        res.add(q.poll());
    }
        return res.subList(0, k);
    }
}