二刷347

Author: diguage

docs/0347-top-k-frequent-elements.adoc

@@ -1,42 +1,61 @@
 [#0347-top-k-frequent-elements]
-= 347. Top K Frequent Elements
+= 347. 前 K 个高频元素
 
-{leetcode}/problems/top-k-frequent-elements/[LeetCode - Top K Frequent Elements^]
+https://leetcode.cn/problems/top-k-frequent-elements/[LeetCode - 347. 前 K 个高频元素 ^]
 
-利用桶排序实在是妙妙妙啊！
+给你一个整数数组 `nums` 和一个整数 `k` ，请你返回其中出现频率前 `k` 高的元素。你可以按 *任意顺序* 返回答案。
 
-Given a non-empty array of integers, return the *_k_* most frequent elements.
+*示例 1:*
 
-*Example 1:*
+....
+输入: nums = [1,1,1,2,2,3], k = 2
+输出: [1,2]
+....
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* nums = [1,1,1,2,2,3], k = 2
-*Output:* [1,2]
-----
+*示例 2:*
 
+....
+输入: nums = [1], k = 1
+输出: [1]
+....
 
-*Example 2:*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* nums = [1], k = 1
-*Output:* [1]
-----
+*提示：*
 
+* `1 \<= nums.length \<= 10^5^`
+* `k` 的取值范围是 `[1, 数组中不相同的元素的个数]`
+* 题目数据保证答案唯一，换句话说，数组中前 `k` 个高频元素的集合是唯一的
 
-*Note: *
+**进阶：**你所设计算法的时间复杂度 *必须* 优于 stem:[O(nlogn)] ，其中 `n` 是数组大小。
 
 
-* You may assume _k_ is always valid, 1 ≤ _k_ ≤ number of unique elements.
-* Your algorithm's time complexity *must be* better than O(_n_ log _n_), where _n_ is the array's size.
+== 思路分析
 
+利用桶排序实在是妙妙妙啊：使用哈希表统计频率，统计完成后，创建一个数组，将频率作为数组下标，对于出现频率不同的数字集合，存入对应的数组下标即可。
 
+Top K 问题！
 
 
 [[src-0347]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0347_TopKFrequentElements.java[tag=answer]
 ----
+--
+
+二刷::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0347_TopKFrequentElements_2.java[tag=answer]
+----
+--
+====
+
 

logbook/202503.adoc

@@ -65,6 +65,11 @@ endif::[]
 |{doc_base_url}/0316-remove-duplicate-letters.adoc[题解]
 |❌ 完全想不到单调栈！
 
+|{counter:codes2503}
+|{leetcode_base_url}/top-k-frequent-elements/[347. Top K Frequent Elements^]
+|{doc_base_url}/0347-top-k-frequent-elements.adoc[题解]
+|✅ Top K 问题，优先队列
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_0347_TopKFrequentElements.java

@@ -41,6 +41,9 @@ public class _0347_TopKFrequentElements {
      * Memory Usage: 41.2 MB, less than 31.89% of Java online submissions for Top K Frequent Elements.
      *
      * Copy from: https://leetcode.com/problems/top-k-frequent-elements/discuss/81602/Java-O(n)-Solution-Bucket-Sort[Java O(n) Solution - Bucket Sort - LeetCode Discuss]
+     *
+     * @author D瓜哥 · https://www.diguage.com
+     * @since 2020-01-11 00:04
      */
     public List<Integer> topKFrequent(int[] nums, int k) {
         Map<Integer, Integer> numToCountMap = new HashMap<>();

src/main/java/com/diguage/algo/leetcode/_0347_TopKFrequentElements_2.java

@@ -0,0 +1,42 @@
+package com.diguage.algo.leetcode;
+
+import java.util.*;
+
+public class _0347_TopKFrequentElements_2 {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-03-25 21:20:04
+   */
+  public int[] topKFrequent(int[] nums, int k) {
+    Map<Integer, Integer> numToCountMap = new HashMap<>();
+    for (int num : nums) {
+      Integer count = numToCountMap.getOrDefault(num, 0);
+      numToCountMap.put(num, ++count);
+    }
+    // 寻找最频繁的 K 个元素，这里就要用最小堆。
+    // 注意：堆里比较的是元素出现的次数，不是元素本身，所以自定义比较器
+    PriorityQueue<Integer> minHeap = new PriorityQueue<>(Comparator.comparingInt(numToCountMap::get));
+    for (Map.Entry<Integer, Integer> entry : numToCountMap.entrySet()) {
+      Integer num = entry.getKey();
+      Integer count = entry.getValue();
+      if (minHeap.size() < k) {
+        minHeap.offer(num);
+      } else {
+        if (numToCountMap.get(minHeap.peek()) < count) {
+          minHeap.poll();
+          minHeap.offer(num);
+        }
+      }
+    }
+    int[] result = new int[k];
+    for (int num : minHeap) {
+      result[--k] = num;
+    }
+    return result;
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0347_TopKFrequentElements_2().topKFrequent(new int[]{4, 1, -1, 2, -1, 2, 3}, 2);
+  }
+}