更多 LeetCode 题解笔记可以访问我的 github。

文章目录

描述
解法一：排序算法（不满足时间复杂度要求）
- Java 实现
- Python 实现
- 复杂度分析
解法二：最小堆
- 思路
- Java 实现
- Python 实现
- 复杂度分析
解法三：桶排序（bucket sort）
- 思路
- Java 实现
- Python 实现
- 复杂度分析

描述

给定一个非空的整数数组，返回其中出现频率前 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 k k 个元素。但是这样做的时间复杂度是 O ( n log ⁡ n ) O(n\log{n}) O(nlogn) 的，不满足题目要求。虽然不满足题目要求，但是还是将求解程序写一下。

备注：在 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>>() {@Overridepublic 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 ) O(n\log{n}) O(nlogn)，其中 n n n 表示数组的长度。
空间复杂度： O ( n ) O(n) O(n)，最极端的情况下（每个元素都不同），用于存储元素及其频率的 Map 需要存储 n n n 个键值对

解法二：最小堆

思路

进一步，为了满足时间复杂度要求，需要对解法一的排序过程进行改进。因为最终需要返回前 k k k 个频率最大的元素，可以想到借助堆这种数据结构。通过维护一个元素数目为 k k k 的最小堆，每次都将新的元素与堆顶端的元素（堆中频率最小的元素）进行比较，如果新的元素的频率比堆顶端的元素大，则弹出堆顶端的元素，将新的元素添加进堆中。最终，堆中的 k k 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>() {@Overridepublic 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 ) O(n\log{k}) O(nlogk)，其中 n n n 表示数组的长度。首先，遍历一遍数组统计元素的频率，这一系列操作的时间复杂度是 O ( n ) O(n) O(n) 的；接着，遍历用于存储元素频率的 map，如果元素的频率大于最小堆中顶部的元素，则将顶部的元素删除并将该元素加入堆中，这一系列操作的时间复杂度是 O ( n log ⁡ k ) O(n\log{k}) O(nlogk) 的；最后，弹出堆中的元素所需的时间复杂度是 O ( k log ⁡ k ) O(k\log{k}) O(klogk) 的。因此，总的时间复杂度是 O ( n log ⁡ k ) O(n\log{k}) O(nlogk) 的。
空间复杂度： O ( n ) O(n) O(n)，最坏情况下（每个元素都不同），map 需要存储 n n n 个键值对，优先队列需要存储 k k k 个元素，因此，空间复杂度是 O ( n ) O(n) O(n) 的。

解法三：桶排序（bucket sort）

思路

最后，为了进一步优化时间复杂度，可以采用桶排序（bucket sort），即用空间复杂度换取时间复杂度。

第一步和解法二相同，也是统计出数组中元素的频次。接着，将数组中的元素按照出现频次进行分组，即出现频次为 i i i 的元素存放在第 i i i 个桶。最后，从桶中逆序取出前 k k 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:breakreturn ret[:k]

复杂度分析

时间复杂度： O ( n ) O(n) O(n)，其中 n n n 表示数组的长度。
空间复杂度： O ( n ) O(n) O(n)

【LeetCode题解】347_前K个高频元素（Top-K-Frequent-Elements）相关推荐

前K个高频元素(top k)（TX）
思路这道题目主要涉及到如下三块内容: 1.要统计元素出现频率 2.对频率排序 3.找出前K个高频元素首先统计元素出现的频率,这一类的问题可以使用map来进行统计. 然后是对频率进行排序,这里我们可 ...
Leetcode题347、前K个高频元素（Python题解）Amazon面试题
问题: 题目来源:力扣(LeetCode) leetcode347.前K个高频元素难度:中等分析: 本题解提供四种方法,分别是python的Counter技巧.堆.桶排序.快排. 对于python ...
模拟卷Leetcode【普通】347. 前 K 个高频元素
347. 前 K 个高频元素给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素.你可以按任意顺序返回答案. 示例 1: 输入: nums = [1,1,1,2,2 ...
【LeetCode】【HOT】347. 前 K 个高频元素（哈希表+优先队列）
[LeetCode][HOT]347. 前 K 个高频元素文章目录 [LeetCode][HOT]347. 前 K 个高频元素 package hot;import java.util.Arrays ...
LeetCode——347. 前 K 个高频元素【最小堆实现】
LeetCode--347. 前 K 个高频元素[最小堆实现] 给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素.你可以按任意顺序返回答案. 示例1: 输入: n ...
LeetCode 347. 前 K 个高频元素（C++）*
该题在不考虑时间复杂度的要求下,可以使用哈希表来存储元素的次数,或者使用排序算法:为了提高算法的效率,考虑使用优先队列来实现大根堆. 1.题目如下: 给你一个整数数组 nums 和一个整数 k ,请你 ...
Leetcode 347. 前 K 个高频元素
Leetcode 347. 前 K 个高频元素 1.问题分析 2.问题解决 3.总结 1.问题分析题目链接:https://leetcode-cn.com/problems/top-k-freque ...
leetcode题解347-前 K 个高频元素
问题描述给定一个非空的整数数组,返回其中出现频率前 k 高的元素. 示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2] 示例 2: 输入: nums = ...
leetcode：前 K 个高频元素、删除字符串中的所有相邻重复项、有多少小于当前数字的数字、有效的山脉数组、独一无二的出现次数(JavaScript)
文章目录 347. 前 K 个高频元素思路 1047. 删除字符串中的所有相邻重复项思路 1365. 有多少小于当前数字的数字思路优化继续优化完整代码 941. 有效的山脉数组思路 12 ...

【LeetCode题解】347_前K个高频元素（Top-K-Frequent-Elements）

文章目录

描述

解法一：排序算法（不满足时间复杂度要求）

Java 实现

Python 实现

复杂度分析

解法二：最小堆

思路

Java 实现

Python 实现

复杂度分析

解法三：桶排序（bucket sort）

思路

Java 实现

Python 实现

复杂度分析

【LeetCode题解】347_前K个高频元素（Top-K-Frequent-Elements）相关推荐

最新文章

热门文章