目录
描述
解法一: 排序算法(不满足时间复杂度要求)
Java 实现
Python 实现
复杂度分析
解法二: 最小堆
思路
Java 实现
Python 实现
复杂度分析
解法三: 桶排序(bucket sort)
思路
Java 实现
Python 实现
复杂度分析
更多 LeetCode 题解笔记可以访问我的 https://github.com/Genpeng/play-with-leetcode .
描述
给定一个非空的整数数组, 返回其中出现频率前 k 高的元素.
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
说明:
你可以假设给定的 k 总是合理的, 且 1 ≤ k ≤ 数组中不相同的元素的个数.
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小.
解法一: 排序算法(不满足时间复杂度要求)
拿到题目的时候, 如果没有详细看说明的话, 一般都会首先想到使用排序算法对元素按照频率由高到低进行排序, 然后取前 \(k\) 个元素. 但是这样做的时间复杂度是 \(O(n\log{n})\) 的, 不满足题目要求. 虽然不满足题目要求, 但是还是将求解程序写一下.
备注: 在 LeetCode 中的运行时间也不是特别慢.
Java 实现
- import java.util.Map;
- import java.util.HashMap;
- import java.util.List;
- import java.util.ArrayList;
- class Solution {
- public List<Integer> topKFrequent(int[] nums, int k) {
- // 统计元素的频率
- Map<Integer, Integer> freqMap = new HashMap<>();
- for (int num : nums) {
- freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
- }
- // 对元素按照频率进行降序排序
- List<Map.Entry<Integer, Integer>> list = new ArrayList<>(freqMap.entrySet());
- Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
- @Override
- public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
- return o2.getValue() - o1.getValue();
- }
- });
- // 取出前 k 个元素
- int count = 0;
- List<Integer> ret = new ArrayList<>();
- for (Map.Entry<Integer, Integer> entry : list) {
- ret.add(entry.getKey());
- ++count;
- if (count>= k) {
- break;
- }
- }
- return ret;
- }
- }
- // Runtime: 18 ms
- // Your runtime beats 62.23 % of java submissions.
Python 实现
- class Solution:
- def topKFrequent(self, nums, k):
- """
- :type nums: List[int]
- :type k: int
- :rtype: List[int]
- """
- # 统计元素的频率
- freq_dict = dict()
- for num in nums:
- freq_dict[num] = freq_dict.get(num, 0) + 1
- # 按照频率进行排序
- freq_dict_sorted = sorted(freq_dict.items(), key=lambda x: x[1], reverse=True)
- # 取前 k 个元素返回
- ret = list()
- for i in range(k):
- ret.append(freq_dict_sorted[i][0])
- return ret
- # Runtime: 52 ms
- # Your runtime beats 71.83 % of python3 submissions.
- 复杂度分析
- 时间复杂度:\(O(n\log{n})\), 其中 \(n\) 表示数组的长度.
- 空间复杂度:\(O(n)\), 最极端的情况下(每个元素都不同), 用于存储元素及其频率的 Map 需要存储 \(n\) 个键值对
- 解法二: 最小堆
- 思路
- 进一步, 为了满足时间复杂度要求, 需要对解法一的排序过程进行改进. 因为最终需要返回前 \(k\) 个频率最大的元素, 可以想到借助堆这种数据结构. 通过维护一个元素数目为 \(k\) 的最小堆, 每次都将新的元素与堆顶端的元素 (堆中频率最小的元素) 进行比较, 如果新的元素的频率比堆顶端的元素大, 则弹出堆顶端的元素, 将新的元素添加进堆中. 最终, 堆中的 \(k\) 个元素即为前 \(k\) 个高频元素.
- Java 实现
- class Solution {
- public List<Integer> topKFrequent(int[] nums, int k) {
- // 统计元素的频率
- Map<Integer, Integer> map = new HashMap<>(16);
- for (int num : nums) {
- map.put(num, map.getOrDefault(num, 0) + 1);
- }
- // 遍历 map, 用最小堆保存频率最大的 k 个元素
- PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
- @Override
- public int compare(Integer a, Integer b) {
- return map.get(a) - map.get(b);
- }
- });
- // PriorityQueue<Integer> pq = new PriorityQueue<>(
- // (a, b) -> map.get(a) - map.get(b)
- // );
- for (Integer key : map.keySet()) {
- if (pq.size() <k) {
- pq.add(key);
- } else if (map.get(key)> map.get(pq.peek())) {
- pq.remove();
- pq.add(key);
- }
- }
- // 取出最小堆中的元素
- List<Integer> ret = new ArrayList<>();
- while (!pq.isEmpty()) {
- ret.add(pq.remove());
- }
- return ret;
- }
- }
- Python 实现
- class Solution:
- def topKFrequent(self, nums, k):
- """
- :type nums: List[int]
- :type k: int
- :rtype: List[int]
- """
- # 统计元素的频率
- freq_dict = dict()
- for num in nums:
- freq_dict[num] = freq_dict.get(num, 0) + 1
- # 维护一个大小为 k 的最小堆, 使得堆中的元素即为前 k 个高频元素
- pq = list()
- for key, value in freq_dict.items():
- if len(pq) <k:
- heapq.heappush(pq, (value, key))
- elif value> pq[0][0]:
- heapq.heapreplace(pq, (value, key))
- # 取出堆中的元素
- ret = list()
- while pq:
- ret.append(heapq.heappop(pq)[1])
- return ret
- 复杂度分析
- 时间复杂度:\(O(n\log{k})\), 其中 \(n\) 表示数组的长度. 首先, 遍历一遍数组统计元素的频率, 这一系列操作的时间复杂度是 \(O(n)\) 的; 接着, 遍历用于存储元素频率的 map, 如果元素的频率大于最小堆中顶部的元素, 则将顶部的元素删除并将该元素加入堆中, 这一系列操作的时间复杂度是 \(O(n\log{k})\) 的; 最后, 弹出堆中的元素所需的时间复杂度是 \(O(k\log{k})\) 的. 因此, 总的时间复杂度是 \(O(n\log{k})\) 的.
- 空间复杂度:\(O(n)\), 最坏情况下(每个元素都不同),map 需要存储 \(n\) 个键值对, 优先队列需要存储 \(k\) 个元素, 因此, 空间复杂度是 \(O(n)\) 的.
- 解法三: 桶排序(bucket sort)
- 思路
- 最后, 为了进一步优化时间复杂度, 可以采用桶排序(bucket sort), 即用空间复杂度换取时间复杂度.
- 第一步和解法二相同, 也是统计出数组中元素的频次. 接着, 将数组中的元素按照出现频次进行分组, 即出现频次为 \(i\) 的元素存放在第 \(i\) 个桶. 最后, 从桶中逆序取出前 \(k\) 个元素.
- Java 实现
- class Solution {
- public List<Integer> topKFrequent(int[] nums, int k) {
- // 统计元素的频次
- Map<Integer, Integer> int2FreqMap = new HashMap<>(16);
- for (int num : nums) {
- int2FreqMap.put(num, int2FreqMap.getOrDefault(num, 0) + 1);
- }
- // 桶排序
- List<Integer>[] bucket = new List[nums.length + 1];
- for (Integer key : int2FreqMap.keySet()) {
- int freq = int2FreqMap.get(key);
- if (bucket[freq] == null) {
- bucket[freq] = new ArrayList<>();
- }
- bucket[freq].add(key);
- }
- // 逆序 (频次由高到低) 取出元素
- List<Integer> ret = new ArrayList<>();
- for (int i = nums.length; i>= 0 && ret.size() <k; --i) {
- if (bucket[i] != null) {
- ret.addAll(bucket[i]);
- }
- }
- return ret;
- }
- }
- Python 实现
- class Solution:
- def topKFrequent(self, nums, k):
- """
- :type nums: List[int]
- :type k: int
- :rtype: List[int]
- """
- # 统计元素的频率
- freq_dict = dict()
- for num in nums:
- freq_dict[num] = freq_dict.get(num, 0) + 1
- # 桶排序
- bucket = [[] for _ in range(len(nums) + 1)]
- for key, value in freq_dict.items():
- bucket[value].append(key)
- # 逆序取出前 k 个元素
- ret = list()
- for i in range(len(nums), -1, -1):
- if bucket[i]:
- ret.extend(bucket[i])
- if len(ret)>= k:
- break
- return ret[:k]
复杂度分析
时间复杂度:\(O(n)\), 其中 \(n\) 表示数组的长度.
空间复杂度:\(O(n)\)
来源: https://www.cnblogs.com/xugenpeng/p/9950007.html