【LeetCode題解】347_前K個高頻元素（Top-K-Frequent-Elements）
摘要：
目錄
解法一：排序演算法（不滿足時間複雜度要求）
解法三：桶排序（bucket sort）
更多 LeetCode 題解筆記可以訪問我的github
。
描述
給定一個非空的整數陣列，返回其中出現頻率前k
高的...
目錄
- 解法一：排序演算法（不滿足時間複雜度要求）
- 解法三：桶排序（bucket sort）
更多 LeetCode 題解筆記可以訪問我的ofollow,noindex" target="_blank">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 logn ) ,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)\)