[Leetcode] Hash表+排序

347. 前 K 个高频元素

public class Solution {

    public int[] topKFrequent(int[] nums, int k) {

        HashMap<Integer, Integer> cntMap = new HashMap<>();
        for (int num : nums) {
            cntMap.put(num, cntMap.getOrDefault(num, 0) + 1);
        }

        PriorityQueue<int[]> que = new PriorityQueue<>(new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return a[1] - b[1];
            }
        });

        for (Map.Entry<Integer, Integer> entry : cntMap.entrySet()) {
            int num = entry.getKey();
            int count = entry.getValue();
            if (que.size() == k) {
                if (count > que.peek()[1]) {
                    que.poll();
                    que.offer(new int[]{num, count});
                }

            } else {
                que.offer(new int[]{num, count});
            }

        }

        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = que.poll()[0];
        }

        return res;
    }
    

    public int[] topKFrequent1(int[] nums, int k) {

        HashMap<Integer, Integer> cntMap = new HashMap<>();
        for (int num : nums) {
            cntMap.put(num, cntMap.getOrDefault(num, 0) + 1);
        }

        List<Integer> keys = new ArrayList<Integer>(cntMap.keySet());
        Collections.sort(keys, (a, b) -> cntMap.get(b) - cntMap.get(a));

        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = keys.get(i);
        }

        return res;
    }

}

692. 前K个高频单词

class Solution {
    public List<String> topKFrequent(String[] words, int k) {
        Map<String, Integer> cnt = new HashMap<String, Integer>();
        for (String word : words) {
            cnt.put(word, cnt.getOrDefault(word, 0) + 1);
        }
        List<String> rec = new ArrayList<String>();
        for (Map.Entry<String, Integer> entry : cnt.entrySet()) {
            rec.add(entry.getKey());
        }
        Collections.sort(rec, new Comparator<String>() {
            public int compare(String word1, String word2) {
                return cnt.get(word1) == cnt.get(word2) ? word1.compareTo(word2) : cnt.get(word2) - cnt.get(word1);
            }
        });
        return rec.subList(0, k);
    }

}

451. 根据字符出现频率排序

class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            int frequency = map.getOrDefault(c, 0) + 1;
            map.put(c, frequency);
        }
        List<Character> list = new ArrayList<Character>(map.keySet());
        Collections.sort(list, (a, b) -> map.get(b) - map.get(a));
        StringBuffer sb = new StringBuffer();
        int size = list.size();
        for (int i = 0; i < size; i++) {
            char c = list.get(i);
            int frequency = map.get(c);
            for (int j = 0; j < frequency; j++) {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}