算法---LeetCode 347. 前 K 个高频元素

1. 题目

原题链接

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
Related Topics 堆 哈希表
👍 734 👎 0

2. 题解

2.1 解法1: 纯哈希表

1. 哈希表统计元素出现次数
2. 遍历哈希表, 统计最大出现次数 maxTimes
3. 依次减少 maxTimes, 在哈希表中遍历查找是否存在该出现频率元素, 并加入结果数组

    class Solution {
        public int[] topKFrequent(int[] nums, int k) {
            int[] ans = new int[k];
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            }
            Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
            int maxTimes = 0;
            for (Map.Entry<Integer, Integer> entry : entrySet) {
                maxTimes = Math.max(maxTimes, entry.getValue());
            }
            int count = 0;
            while (count < k && maxTimes > 0) {
                for (Map.Entry<Integer, Integer> entry : entrySet) {
                    if (entry.getValue() == maxTimes) {
                        ans[count++] = entry.getKey();
                    }
                }
                maxTimes--;
            }
            return ans;
        }
    }

2.2 解法2: 哈希表 + 优先队列(小顶堆)

1. 哈希表保存元素出现次数
2. 优先队列中保存 前 k 个元素

    class Solution {
        public int[] topKFrequent(int[] nums, int k) {
            int[] ans = new int[k];
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            }
            PriorityQueue<Integer> pQue = new PriorityQueue<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return map.get(o1) - map.get(o2);
                }
            });
            Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Integer, Integer> entry : entrySet) {
                if (pQue.size() < k) {
                    pQue.offer(entry.getKey());
                } else if (pQue.size() == k) {
                    int min = pQue.peek();
                    if (map.get(min) < entry.getValue()) {
                        pQue.poll();
                        pQue.add(entry.getKey());
                    }
                }
            }
            int i = 0;
            while (!pQue.isEmpty()) {
                ans[i++] = pQue.poll();
            }
            return ans;
        }
    }

2.3 解法3: 哈希表 + 桶排序

1. 以出现次数为下标, 使用一个 list 数组存储元素

    class Solution {
        public List<Integer> topKFrequent(int[] nums, int k) {
            List<Integer> ans = new ArrayList<>();
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            }

            List[] lists = new List[nums.length + 1];
            Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Integer, Integer> entry : entrySet) {
                int index = entry.getValue();
                if (lists[index] == null) {
                    List<Integer> tempList = new ArrayList<>();
                    tempList.add(entry.getKey());
                    lists[index] = tempList;
                } else {
                    lists[index].add(entry.getKey());
                }
            }
            // 从尾向前遍历桶数组
            for (int i = lists.length - 1; k > 0; i--) {
                if (lists[i] != null) {
                    ans.addAll(lists[i]);
                    k -= lists[i].size();
                }
            }
            return ans;

        }
    }

参考:
347. 前 K 个高频元素