【LeetCode題解】347_前K個高頻元素（Top-K-Frequent-Elements）
目錄java
更多 LeetCode 題解筆記能夠訪問個人 github。python
描述
給定一個非空的整數數組，返回其中出現頻率前 k 高的元素。git
示例 1:github
輸入: 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 中的運行時間也不是特別慢。app
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\) 個高頻元素。ide
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)\)
相關文章
- 1. leetcode 前K個高頻元素 （C++）
- 2. LeetCode 347. 前K個高頻元素
- 3. [LeetCode]347. 前 K 個高頻元素(堆)
- 4. leetcode（前K個高頻元素集）
- 5. LeetCode 前K個高頻元素
- 6. leetcode 347.前K個高頻元素。
- 7. LeetCode 347*. 前 K 個高頻元素（Python）
- 8. leetcode-347-前K個高頻元素
- 9. LeetCode—Python—347. 前K個高頻元素
- 10. leetcode-347前k個高頻元素
- 更多相關文章...
- • Redis悲觀鎖解決高併發搶紅包的問題 - 紅包項目實戰
- • Redis樂觀鎖解決高併發搶紅包的問題 - 紅包項目實戰
- • PHP Ajax 跨域問題最佳解決方案
- • IntelliJ IDEA中SpringBoot properties文件不能自動提示問題解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
