feat: 增加题解347.前 K 个高频元素

Author: suukii

README.md

@@ -112,6 +112,8 @@
 ### 哈希表
 
 -   [x] [【day-19】1.两数之和](./basic/hashmap/19.two-sum.md)
+-   [x] [【day-20】347.前 K 个高频元素](./basic/hashmap/20.top-k-frequent-elements.md)
+
 -   [x] [【day-20】447.回旋镖的数量](./basic/day-20.md)
 -   [ ] 【day-21】36.有效的数独
 -   [x] [【day-22】645.错误的集合](./basic/day-22.md)

basic/hashmap/20.top-k-frequent-elements.md

@@ -0,0 +1,196 @@
+# 347. 前 K 个高频元素
+
+https://leetcode-cn.com/problems/top-k-frequent-elements/
+
+- [347. 前 K 个高频元素](#347-前-k-个高频元素)
+  - [题目描述](#题目描述)
+  - [方法 1：哈希表](#方法-1哈希表)
+    - [思路](#思路)
+    - [复杂度分析](#复杂度分析)
+    - [代码](#代码)
+  - [方法 2：大顶堆](#方法-2大顶堆)
+    - [思路](#思路-1)
+    - [复杂度分析](#复杂度分析-1)
+    - [代码](#代码-1)
+
+## 题目描述
+
+```
+给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
+
+ 
+
+示例 1:
+
+输入: 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 个高频元素的集合是唯一的。
+你可以按任意顺序返回答案。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/top-k-frequent-elements
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+```
+
+## 方法 1：哈希表
+
+### 思路
+
+-   遍历一遍数组，用哈希表统计每个数字出现的次数。
+-   按次数排序，然后输出前 k 个数字。
+
+### 复杂度分析
+
+-   时间复杂度：$O(mlogm)$，m 是数组中不同数字的数量，最大是 N，数组的长度，这是排序的时间。
+-   空间复杂度：$O(m)$，m 是数组中不同数字的数量，哈希表的空间。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+    // 统计出现次数
+    const map = {};
+    for (const n of nums) {
+        n in map || (map[n] = 0);
+        map[n]++;
+    }
+    // 对次数进行排序然后输出前 k 个
+    return Object.entries(map)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, k)
+        .map(a => a[0]);
+};
+```
+
+## 方法 2：大顶堆
+
+### 思路
+
+看到 `前 k 个` 这种描述就能想到 `堆` 了，还是先把数字出现的次数统计在哈希表中，然后入堆按次数排序，再吐出来 k 个。
+
+### 复杂度分析
+
+-   时间复杂度：$O(klogm)$，m 是数组中不同数字的数量，堆中有 m 个元素，移除堆顶的时间是 $logm$，重复操作了 k 次。
+-   空间复杂度：$O(m)$，m 是数组中不同数字的数量，哈希表和堆的空间。
+
+### 代码
+
+JavaScript Code
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+    // 统计出现次数
+    const map = {};
+    for (const n of nums) {
+        n in map || (map[n] = 0);
+        map[n]++;
+    }
+    // 入堆，格式是：[数字，次数]，按次数排序
+    const maxHeap = new MaxHeap(Object.entries(map), function comparator(
+        target,
+        compared,
+    ) {
+        return target[1] < compared[1];
+    });
+    // 输出前 k 个
+    const res = [];
+    while (k-- > 0) {
+        res.push(maxHeap.pop()[0]);
+    }
+    return res;
+};
+
+// *******************************************
+
+class Heap {
+    constructor(list = [], comparator) {
+        this.list = list;
+
+        if (typeof comparator != 'function') {
+            this.comparator = function comparator(target, compared) {
+                return target < compared;
+            };
+        } else {
+            this.comparator = comparator;
+        }
+
+        this.init();
+    }
+
+    init() {
+        const size = this.size();
+        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
+            this.heapify(this.list, size, i);
+        }
+    }
+
+    insert(n) {
+        this.list.push(n);
+        const size = this.size();
+        for (let i = Math.floor(size / 2) - 1; i >= 0; i--) {
+            this.heapify(this.list, size, i);
+        }
+    }
+
+    peek() {
+        return this.list[0];
+    }
+
+    pop() {
+        const last = this.list.pop();
+        if (this.size() === 0) return last;
+        const returnItem = this.list[0];
+        this.list[0] = last;
+        this.heapify(this.list, this.size(), 0);
+        return returnItem;
+    }
+
+    size() {
+        return this.list.length;
+    }
+}
+
+class MaxHeap extends Heap {
+    constructor(list, comparator) {
+        super(list, comparator);
+    }
+
+    heapify(arr, size, i) {
+        let largest = i;
+        const left = Math.floor(i * 2 + 1);
+        const right = Math.floor(i * 2 + 2);
+
+        if (left < size && this.comparator(arr[largest], arr[left]))
+            largest = left;
+        if (right < size && this.comparator(arr[largest], arr[right]))
+            largest = right;
+
+        if (largest !== i) {
+            [arr[largest], arr[i]] = [arr[i], arr[largest]];
+            this.heapify(arr, size, largest);
+        }
+    }
+}
+```