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

时间:2022-06-07 07:41:49

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

描述

给定一个非空的整数数组,返回其中出现频率前 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)\)

【LeetCode题解】347_前K个高频元素(Top-K-Frequent-Elements)的更多相关文章

  1. &lbrack;Swift&rsqb;LeetCode347&period; 前K个高频元素 &vert; Top K Frequent Elements

    Given a non-empty array of integers, return the k most frequent elements. Example 1: Input: nums = [ ...

  2. &lbrack;Swift&rsqb;LeetCode692&period; 前K个高频单词 &vert; Top K Frequent Words

    Given a non-empty list of words, return the k most frequent elements. Your answer should be sorted b ...

  3. LeetCode:前K个高频元素【347】

    LeetCode:前K个高频元素[347] 题目描述 给定一个非空的整数数组,返回其中出现频率前 k 高的元素. 示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [ ...

  4. Java实现 LeetCode 347 前 K 个高频元素

    347. 前 K 个高频元素 给定一个非空的整数数组,返回其中出现频率前 k 高的元素. 示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2] 示例 2: 输 ...

  5. leetcode 347&period; 前 K 个高频元素

    问题描述 给定一个非空的整数数组,返回其中出现频率前 k 高的元素.   示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2] 示例 2: 输入: nums ...

  6. Top K Frequent Elements 前K个高频元素

    Top K Frequent Elements 347. Top K Frequent Elements [LeetCode] Top K Frequent Elements 前K个高频元素

  7. 代码题(3)— 最小的k个数、数组中的第K个最大元素、前K个高频元素

    1.题目:输入n个整数,找出其中最小的K个数. 例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4. 快排思路(掌握): class Solution { public ...

  8. leetcode347&period; 前 K 个高频元素

    题目最终需要返回的是前 kk 个频率最大的元素,可以想到借助堆这种数据结构,对于 kk 频率之后的元素不用再去处理,进一步优化时间复杂度. 具体操作为: 借助 哈希表 来建立数字和其出现次数的映射,遍 ...

  9. 力扣 - 347&period; 前 K 个高频元素

    目录 题目 思路1(哈希表与排序) 代码 复杂度分析 思路2(建堆) 代码 复杂度分析 题目 347. 前 K 个高频元素 思路1(哈希表与排序) 先用哈希表记录所有的值出现的次数 然后将按照出现的次 ...

随机推荐

  1. Smart3D系列教程6之 《案例实战演练3——倾斜数据正射影像及DSM的生产》

    一.前言 Wish3D出品的系列教程中,前面两讲分别讲述说明了小物件的照片三维重建.大区域地形的三维重建,从照片的直接导入至软件到通过Excel表格将区块导入处理,从不同的模型类别.不同的导入方式演示 ...

  2. hive单机安装(实战)

    hive使用与注意事项:http://blog.csdn.net/stark_summer/article/details/44222089 连接命令:beeline -n root -u jdbc: ...

  3. WPF开发时光之痕日记本(一)——富文本编辑器

    本篇给大家推荐一个 WPF 版的富文本编辑器,SmithHtmlEditor,具体网址大家可以找一找,我在这个编辑器的基础上修改了界面,增加了一些功能,模仿了kindeditor 的界面,鉴于自己现在 ...

  4. POJ 2421 Constructing Roads &lpar;最小生成树&rpar;

    Constructing Roads Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u ...

  5. 【Objective-C】2&period;自定义构造方法和description方法

    1.Student.h 1 #import <Foundation/Foundation.h> 2 3 @interface Student : NSObject { 4 int _age ...

  6. java集合判断

    java开发中经常需要做集合判断,在这里mark一下,加强记忆 为空判断: null == applyList || applyList.size() ==0 非空判断: applyList != n ...

  7. LeetCode &amp&semi; Q169-Majority Element-Easy

    Array Divide and Conquer Bit Manipulation Description: Given an array of size n, find the majority e ...

  8. Spring Boot中使用Swagger2构建RESTful APIs

    关于 Swagger Swagger能成为最受欢迎的REST APIs文档生成工具之一,有以下几个原因: Swagger 可以生成一个具有互动性的API控制台,开发者可以用来快速学习和尝试API. S ...

  9. creator NDK&lowbar;PROJECT&lowbar;PATH&equals;null

    NDK_PROJECT_PATH=null 其实不是一个错误= =,少年,不要纠结于此了. 主要问题在于这一句: process_begin: CreateProcess(NULL, E:/Andro ...

  10. 计算机爱好者协会技术贴markdown第四期

    首先先让爱酱用CSDN自带的数学公式方法来闪瞎大家的钛合金狗眼: 有没有感觉到Markdown的强大!!!!! ## KaTeX数学公式 您可以使用渲染LaTeX数学表达式 [KaTeX](https ...