feat: update solutions to lc/lcof2 problems

* Top K Frequent Elements

Author: yanglbme

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/README.md

@@ -43,7 +43,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-经典 Top K 问题，可以用堆解决
+**方法一：哈希表 + 优先队列（小根堆）**
+
+使用哈希表统计每个元素出现的次数，然后使用优先队列（小根堆）维护前 $k$ 个出现次数最多的元素。
+
+时间复杂度 $O(n\log k)$。
 
 <!-- tabs:start -->
 
@@ -54,15 +58,20 @@
 ```python
 class Solution:
     def topKFrequent(self, nums: List[int], k: int) -> List[int]:
-        counter = Counter(nums)
+        cnt = Counter(nums)
+        return [v[0] for v in cnt.most_common(k)]
+```
+
+```python
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        cnt = Counter(nums)
         hp = []
-        for num, freq in counter.items():
-            if len(hp) == k:
-                heappush(hp, (freq, num))
+        for num, freq in cnt.items():
+            heappush(hp, (freq, num))
+            if len(hp) > k:
                 heappop(hp)
-            else:
-                heappush(hp, (freq, num))
-        return [t[1] for t in hp]
+        return [v[1] for v in hp]
 ```
 
 ### **Java**
@@ -72,22 +81,15 @@ class Solution:
 ```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()));
-
+        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 (Map.Entry<Integer, Long> entry : frequency.entrySet()) {
-            long count = entry.getValue();
-            if (queue.size() == k) {
-                if (count > queue.peek().getValue()) {
-                    queue.poll();
-                    queue.offer(entry);
-                }
-            } else {
-                queue.offer(entry);
+        for (var entry : frequency.entrySet()) {
+            queue.offer(entry);
+            if (queue.size() > k) {
+                queue.poll();
             }
         }
-
         return queue.stream().mapToInt(Map.Entry::getKey).toArray();
     }
 }
@@ -96,53 +98,159 @@ class Solution {
 ```java
 class Solution {
     public int[] topKFrequent(int[] nums, int k) {
-        Map<Integer, Integer> counter = new HashMap<>();
-        for (int num : nums) {
-            counter.put(num, counter.getOrDefault(num, 0) + 1);
+        Map<Integer, Integer> cnt = new HashMap<>();
+        for (int v : nums) {
+            cnt.put(v, cnt.getOrDefault(v, 0) + 1);
         }
-        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
-        counter.forEach((num, freq) -> {
-            if (pq.size() == k) {
-                pq.offer(new int[] {num, freq});
+        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();
-            } else {
-                pq.offer(new int[] {num, freq});
             }
-        });
-        return pq.stream().mapToInt(e -> e[0]).toArray();
+        }
+        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[] {
+    let hashMap = new Map();
+    for (let num of nums) {
+        hashMap.set(num, (hashMap.get(num) || 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]);
+    }
+    return ans;
+}
+```
+
+```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--;
+            }
+        }
+        maxCount--;
+    }
+    return res;
+}
+```
+
 ### **C++**
 
 ```cpp
+using pii = pair<int, int>;
+
 class Solution {
 public:
-    static bool cmp(pair<int, int>& m, pair<int, int>& n) {
-        return m.second > n.second;
-    }
     vector<int> topKFrequent(vector<int>& nums, int k) {
-        unordered_map<int, int> counter;
-        for (auto& e : nums) ++counter[e];
-        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> pq(cmp);
-        for (auto& [num, freq] : counter) {
-            if (pq.size() == k) {
-                pq.emplace(num, freq);
+        unordered_map<int, int> cnt;
+        for (int v : nums) ++cnt[v];
+        priority_queue<pii, vector<pii>, greater<pii>> pq;
+        for (auto& [num, freq] : cnt) {
+            pq.push({freq, num});
+            if (pq.size() > k) {
                 pq.pop();
-            } else
-                pq.emplace(num, freq);
+            }
         }
-        vector<int> ans;
-        while (!pq.empty()) {
-            ans.push_back(pq.top().first);
+        vector<int> ans(k);
+        for (int i = 0; i < k; ++i) {
+            ans[i] = pq.top().second;
             pq.pop();
         }
         return ans;
     }
 };
 ```
 
+### **Go**
+
+```go
+func topKFrequent(nums []int, k int) []int {
+	cnt := map[int]int{}
+	for _, v := range nums {
+		cnt[v]++
+	}
+	h := hp{}
+	for v, freq := range cnt {
+		heap.Push(&h, pair{v, freq})
+		if len(h) > k {
+			heap.Pop(&h)
+		}
+	}
+	ans := make([]int, k)
+	for i := range ans {
+		ans[i] = heap.Pop(&h).(pair).v
+	}
+	return ans
+}
+
+type pair struct{ v, cnt int }
+type hp []pair
+
+func (h hp) Len() int            { return len(h) }
+func (h hp) Less(i, j int) bool  { return h[i].cnt < h[j].cnt }
+func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
+func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
+```
+
+### **Rust**
+
+```rust
+use std::collections::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 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
+    }
+}
+```
+
 ### **...**
 
 ```

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/Solution.cpp

@@ -1,22 +1,20 @@
+using pii = pair<int, int>;
+
 class Solution {
 public:
-    static bool cmp(pair<int, int>& m, pair<int, int>& n) {
-        return m.second > n.second;
-    }
     vector<int> topKFrequent(vector<int>& nums, int k) {
-        unordered_map<int, int> counter;
-        for (auto& e : nums) ++counter[e];
-        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> pq(cmp);
-        for (auto& [num, freq] : counter) {
-            if (pq.size() == k) {
-                pq.emplace(num, freq);
+        unordered_map<int, int> cnt;
+        for (int v : nums) ++cnt[v];
+        priority_queue<pii, vector<pii>, greater<pii>> pq;
+        for (auto& [num, freq] : cnt) {
+            pq.push({freq, num});
+            if (pq.size() > k) {
                 pq.pop();
-            } else
-                pq.emplace(num, freq);
+            }
         }
-        vector<int> ans;
-        while (!pq.empty()) {
-            ans.push_back(pq.top().first);
+        vector<int> ans(k);
+        for (int i = 0; i < k; ++i) {
+            ans[i] = pq.top().second;
             pq.pop();
         }
         return ans;

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/Solution.go

@@ -0,0 +1,27 @@
+func topKFrequent(nums []int, k int) []int {
+	cnt := map[int]int{}
+	for _, v := range nums {
+		cnt[v]++
+	}
+	h := hp{}
+	for v, freq := range cnt {
+		heap.Push(&h, pair{v, freq})
+		if len(h) > k {
+			heap.Pop(&h)
+		}
+	}
+	ans := make([]int, k)
+	for i := range ans {
+		ans[i] = heap.Pop(&h).(pair).v
+	}
+	return ans
+}
+
+type pair struct{ v, cnt int }
+type hp []pair
+
+func (h hp) Len() int            { return len(h) }
+func (h hp) Less(i, j int) bool  { return h[i].cnt < h[j].cnt }
+func (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(v interface{}) { *h = append(*h, v.(pair)) }
+func (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/Solution.java

@@ -2,20 +2,13 @@ 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 (Map.Entry<Integer, Long> entry : frequency.entrySet()) {
-            long count = entry.getValue();
-            if (queue.size() == k) {
-                if (count > queue.peek().getValue()) {
-                    queue.poll();
-                    queue.offer(entry);
-                }
-            } else {
-                queue.offer(entry);
+        for (var entry : frequency.entrySet()) {
+            queue.offer(entry);
+            if (queue.size() > k) {
+                queue.poll();
             }
         }
-
         return queue.stream().mapToInt(Map.Entry::getKey).toArray();
     }
 }

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/Solution.py

@@ -1,11 +1,9 @@
 class Solution:
     def topKFrequent(self, nums: List[int], k: int) -> List[int]:
-        counter = Counter(nums)
+        cnt = Counter(nums)
         hp = []
-        for num, freq in counter.items():
-            if len(hp) == k:
-                heappush(hp, (freq, num))
+        for num, freq in cnt.items():
+            heappush(hp, (freq, num))
+            if len(hp) > k:
                 heappop(hp)
-            else:
-                heappush(hp, (freq, num))
-        return [t[1] for t in hp]
+        return [v[1] for v in hp]

lcof2/剑指 Offer II 060. 出现频率最高的 k 个数字/Solution.rs

@@ -0,0 +1,28 @@
+use std::collections::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 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
+    }
+}