feat: update solutions to lc problem: No.0347

solution/0300-0399/0347.Top K Frequent Elements/README.md

@@ -62,9 +62,13 @@ tags:
 
 ### 方法一：哈希表 + 优先队列（小根堆）
 
-使用哈希表统计每个元素出现的次数，然后使用优先队列（小根堆）维护前 $k$ 个出现次数最多的元素。
+我们可以使用一个哈希表 $\text{cnt}$ 统计每个元素出现的次数，然后使用一个小根堆（优先队列）来保存前 $k$ 个高频元素。
 
-时间复杂度 $O(n\log k)$。
+我们首先遍历一遍数组，统计每个元素出现的次数，然后遍历哈希表，将元素和出现次数存入小根堆中。如果小根堆的大小超过了 $k$，我们就将堆顶元素弹出，保证堆的大小始终为 $k$。
+
+最后，我们将小根堆中的元素依次弹出，放入结果数组中即可。
+
+时间复杂度 $O(n \times \log k)$，空间复杂度 $O(k)$。其中 $n$ 是数组的长度。
 
 <!-- tabs:start -->
 
@@ -74,48 +78,52 @@ tags:
 class Solution:
     def topKFrequent(self, nums: List[int], k: int) -> List[int]:
         cnt = Counter(nums)
-        return [v[0] for v in cnt.most_common(k)]
+        return [x for x, _ in cnt.most_common(k)]
 ```
 
 #### Java
 
 ```java
 class Solution {
     public int[] topKFrequent(int[] nums, int k) {
-        Map<Integer, Long> frequency = Arrays.stream(nums).boxed().collect(
-            Collectors.groupingBy(Function.identity(), Collectors.counting()));
-        Queue<Map.Entry<Integer, Long>> queue = new PriorityQueue<>(Map.Entry.comparingByValue());
-        for (var entry : frequency.entrySet()) {
-            queue.offer(entry);
-            if (queue.size() > k) {
-                queue.poll();
+        Map<Integer, Integer> cnt = new HashMap<>();
+        for (int x : nums) {
+            cnt.merge(x, 1, Integer::sum);
+        }
+        PriorityQueue<Map.Entry<Integer, Integer>> pq
+            = new PriorityQueue<>(Comparator.comparingInt(Map.Entry::getValue));
+        for (var e : cnt.entrySet()) {
+            pq.offer(e);
+            if (pq.size() > k) {
+                pq.poll();
             }
         }
-        return queue.stream().mapToInt(Map.Entry::getKey).toArray();
+        return pq.stream().mapToInt(Map.Entry::getKey).toArray();
     }
 }
 ```
 
 #### C++
 
 ```cpp
-using pii = pair<int, int>;
-
 class Solution {
 public:
     vector<int> topKFrequent(vector<int>& nums, int k) {
         unordered_map<int, int> cnt;
-        for (int v : nums) ++cnt[v];
+        using pii = pair<int, int>;
+        for (int x : nums) {
+            ++cnt[x];
+        }
         priority_queue<pii, vector<pii>, greater<pii>> pq;
-        for (auto& [num, freq] : cnt) {
-            pq.push({freq, num});
+        for (auto& [x, c] : cnt) {
+            pq.push({c, x});
             if (pq.size() > k) {
                 pq.pop();
             }
         }
-        vector<int> ans(k);
-        for (int i = 0; i < k; ++i) {
-            ans[i] = pq.top().second;
+        vector<int> ans;
+        while (!pq.empty()) {
+            ans.push_back(pq.top().second);
             pq.pop();
         }
         return ans;
@@ -128,19 +136,19 @@ public:
 ```go
 func topKFrequent(nums []int, k int) []int {
 	cnt := map[int]int{}
-	for _, v := range nums {
-		cnt[v]++
+	for _, x := range nums {
+		cnt[x]++
 	}
-	h := hp{}
-	for v, freq := range cnt {
-		heap.Push(&h, pair{v, freq})
-		if len(h) > k {
-			heap.Pop(&h)
+	pq := hp{}
+	for x, c := range cnt {
+		heap.Push(&pq, pair{x, c})
+		if pq.Len() > k {
+			heap.Pop(&pq)
 		}
 	}
 	ans := make([]int, k)
-	for i := range ans {
-		ans[i] = heap.Pop(&h).(pair).v
+	for i := 0; i < k; i++ {
+		ans[i] = heap.Pop(&pq).(pair).v
 	}
 	return ans
 }
@@ -159,124 +167,42 @@ func (h *hp) Pop() any          { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1];
 
 ```ts
 function topKFrequent(nums: number[], k: number): number[] {
-    let hashMap = new Map();
-    for (let num of nums) {
-        hashMap.set(num, (hashMap.get(num) || 0) + 1);
+    const cnt = new Map<number, number>();
+    for (const x of nums) {
+        cnt.set(x, (cnt.get(x) ?? 0) + 1);
     }
-    let list = [...hashMap];
-    list.sort((a, b) => b[1] - a[1]);
-    let ans = [];
-    for (let i = 0; i < k; i++) {
-        ans.push(list[i][0]);
+    const pq = new MinPriorityQueue();
+    for (const [x, c] of cnt) {
+        pq.enqueue(x, c);
+        if (pq.size() > k) {
+            pq.dequeue();
+        }
     }
-    return ans;
+    return pq.toArray().map(x => x.element);
 }
 ```
 
 #### Rust
 
 ```rust
-use std::collections::HashMap;
+use std::cmp::Reverse;
+use std::collections::{BinaryHeap, HashMap};
+
 impl Solution {
     pub fn top_k_frequent(nums: Vec<i32>, k: i32) -> Vec<i32> {
-        let mut map = HashMap::new();
-        let mut max_count = 0;
-        for &num in nums.iter() {
-            let val = map.get(&num).unwrap_or(&0) + 1;
-            map.insert(num, val);
-            max_count = max_count.max(val);
+        let mut cnt = HashMap::new();
+        for x in nums {
+            *cnt.entry(x).or_insert(0) += 1;
         }
-        let mut k = k as usize;
-        let mut res = vec![0; k];
-        while k > 0 {
-            let mut next = 0;
-            for key in map.keys() {
-                let val = map[key];
-                if val == max_count {
-                    res[k - 1] = *key;
-                    k -= 1;
-                } else if val < max_count {
-                    next = next.max(val);
-                }
-            }
-            max_count = next;
-        }
-        res
-    }
-}
-```
-
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### 方法二
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
-        cnt = Counter(nums)
-        hp = []
-        for num, freq in cnt.items():
-            heappush(hp, (freq, num))
-            if len(hp) > k:
-                heappop(hp)
-        return [v[1] for v in hp]
-```
-
-#### Java
-
-```java
-class Solution {
-    public int[] topKFrequent(int[] nums, int k) {
-        Map<Integer, Integer> cnt = new HashMap<>();
-        for (int v : nums) {
-            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
-        }
-        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);
-        for (var e : cnt.entrySet()) {
-            pq.offer(new int[] {e.getKey(), e.getValue()});
-            if (pq.size() > k) {
-                pq.poll();
-            }
-        }
-        int[] ans = new int[k];
-        for (int i = 0; i < k; ++i) {
-            ans[i] = pq.poll()[0];
-        }
-        return ans;
-    }
-}
-```
-
-#### TypeScript
-
-```ts
-function topKFrequent(nums: number[], k: number): number[] {
-    const map = new Map<number, number>();
-    let maxCount = 0;
-    for (const num of nums) {
-        map.set(num, (map.get(num) ?? 0) + 1);
-        maxCount = Math.max(maxCount, map.get(num));
-    }
-
-    const res = [];
-    while (k > 0) {
-        for (const key of map.keys()) {
-            if (map.get(key) === maxCount) {
-                res.push(key);
-                k--;
+        let mut pq = BinaryHeap::with_capacity(k as usize);
+        for (&x, &c) in cnt.iter() {
+            pq.push(Reverse((c, x)));
+            if pq.len() > k as usize {
+                pq.pop();
             }
         }
-        maxCount--;
+        pq.into_iter().map(|Reverse((_, x))| x).collect()
     }
-    return res;
 }
 ```