build

docs/chapter_heap/top_k.md

@@ -81,6 +81,7 @@ comments: true
     ```python title="top_k.py"
     def top_k_heap(nums: list[int], k: int) -> list[int]:
         """基于堆查找数组中最大的 k 个元素"""
+        # 初始化小顶堆
         heap = []
         # 将数组的前 k 个元素入堆
         for i in range(k):
@@ -99,6 +100,7 @@ comments: true
     ```cpp title="top_k.cpp"
     /* 基于堆查找数组中最大的 k 个元素 */
     priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+        // 初始化小顶堆
         priority_queue<int, vector<int>, greater<int>> heap;
         // 将数组的前 k 个元素入堆
         for (int i = 0; i < k; i++) {
@@ -121,6 +123,7 @@ comments: true
     ```java title="top_k.java"
     /* 基于堆查找数组中最大的 k 个元素 */
     Queue<Integer> topKHeap(int[] nums, int k) {
+        // 初始化小顶堆
         Queue<Integer> heap = new PriorityQueue<Integer>();
         // 将数组的前 k 个元素入堆
         for (int i = 0; i < k; i++) {
@@ -143,6 +146,7 @@ comments: true
     ```csharp title="top_k.cs"
     /* 基于堆查找数组中最大的 k 个元素 */
     PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
+        // 初始化小顶堆
         PriorityQueue<int, int> heap = new();
         // 将数组的前 k 个元素入堆
         for (int i = 0; i < k; i++) {
@@ -165,6 +169,7 @@ comments: true
     ```go title="top_k.go"
     /* 基于堆查找数组中最大的 k 个元素 */
     func topKHeap(nums []int, k int) *minHeap {
+        // 初始化小顶堆
         h := &minHeap{}
         heap.Init(h)
         // 将数组的前 k 个元素入堆
@@ -205,31 +210,63 @@ comments: true
 === "JS"
 
     ```javascript title="top_k.js"
+    /* 元素入堆 */
+    function pushMinHeap(maxHeap, val) {
+        // 元素取反
+        maxHeap.push(-val);
+    }
+
+    /* 元素出堆 */
+    function popMinHeap(maxHeap) {
+        // 元素取反
+        return -maxHeap.pop();
+    }
+
+    /* 访问堆顶元素 */
+    function peekMinHeap(maxHeap) {
+        // 元素取反
+        return -maxHeap.peek();
+    }
+
+    /* 取出堆中元素 */
+    function getMinHeap(maxHeap) {
+        // 元素取反
+        return maxHeap.getMaxHeap().map((num) => -num);
+    }
+
     /* 基于堆查找数组中最大的 k 个元素 */
     function topKHeap(nums, k) {
-        // 使用大顶堆 MaxHeap ，对数组 nums 取相反数
-        const invertedNums = nums.map((num) => -num);
+        // 初始化小顶堆
+        // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+        const maxHeap = new MaxHeap([]);
         // 将数组的前 k 个元素入堆
-        const heap = new MaxHeap(invertedNums.slice(0, k));
+        for (let i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
         // 从第 k+1 个元素开始，保持堆的长度为 k
-        for (let i = k; i < invertedNums.length; i++) {
-            // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆
-            if (invertedNums[i] < heap.peek()) {
-                heap.pop();
-                heap.push(invertedNums[i]);
+        for (let i = k; i < nums.length; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
             }
         }
-        // 取出堆中元素
-        const maxHeap = heap.getMaxHeap();
-        // 对堆中元素取相反数
-        const invertedMaxHeap = maxHeap.map((num) => -num);
-        return invertedMaxHeap;
+        // 返回堆中元素
+        return getMinHeap(maxHeap);
     }
     ```
 
 === "TS"
 
     ```typescript title="top_k.ts"
+    [class]{}-[func]{pushMinHeap}
+
+    [class]{}-[func]{popMinHeap}
+
+    [class]{}-[func]{peekMinHeap}
+
+    [class]{}-[func]{getMinHeap}
+
     /* 基于堆查找数组中最大的 k 个元素 */
     function topKHeap(nums: number[], k: number): number[] {
         // 将堆中所有元素取反，从而用大顶堆来模拟小顶堆
@@ -257,7 +294,7 @@ comments: true
     ```dart title="top_k.dart"
     /* 基于堆查找数组中最大的 k 个元素 */
     MinHeap topKHeap(List<int> nums, int k) {
-      // 将数组的前 k 个元素入堆
+      // 初始化小顶堆，将数组的前 k 个元素入堆
       MinHeap heap = MinHeap(nums.sublist(0, k));
       // 从第 k+1 个元素开始，保持堆的长度为 k
       for (int i = k; i < nums.length; i++) {
@@ -276,7 +313,7 @@ comments: true
     ```rust title="top_k.rs"
     /* 基于堆查找数组中最大的 k 个元素 */
     fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
-        // Rust 的 BinaryHeap 是大顶堆，使用 Reverse 将元素大小反转
+        // BinaryHeap 是大顶堆，使用 Reverse 将元素取反，从而实现小顶堆
         let mut heap = BinaryHeap::<Reverse<i32>>::new();
         // 将数组的前 k 个元素入堆
         for &num in nums.iter().take(k) {
@@ -297,7 +334,67 @@ comments: true
 === "C"
 
     ```c title="top_k.c"
-    [class]{}-[func]{topKHeap}
+    /* 元素入堆 */
+    void pushMinHeap(MaxHeap *maxHeap, int val) {
+        // 元素取反
+        push(maxHeap, -val);
+    }
+
+    /* 元素出堆 */
+    int popMinHeap(MaxHeap *maxHeap) {
+        // 元素取反
+        return -pop(maxHeap);
+    }
+
+    /* 访问堆顶元素 */
+    int peekMinHeap(MaxHeap *maxHeap) {
+        // 元素取反
+        return -peek(maxHeap);
+    }
+
+    /* 取出堆中元素 */
+    int *getMinHeap(MaxHeap *maxHeap) {
+        // 将堆中所有元素取反并存入 res 数组
+        int *res = (int *)malloc(maxHeap->size * sizeof(int));
+        for (int i = 0; i < maxHeap->size; i++) {
+            res[i] = -maxHeap->data[i];
+        }
+        return res;
+    }
+
+    /* 取出堆中元素 */
+    int *getMinHeap(MaxHeap *maxHeap) {
+        // 将堆中所有元素取反并存入 res 数组
+        int *res = (int *)malloc(maxHeap->size * sizeof(int));
+        for (int i = 0; i < maxHeap->size; i++) {
+            res[i] = -maxHeap->data[i];
+        }
+        return res;
+    }
+
+    // 基于堆查找数组中最大的 k 个元素的函数
+    int *topKHeap(int *nums, int sizeNums, int k) {
+        // 初始化小顶堆
+        // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+        int empty[0];
+        MaxHeap *maxHeap = newMaxHeap(empty, 0);
+        // 将数组的前 k 个元素入堆
+        for (int i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < sizeNums; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        int *res = getMinHeap(maxHeap);
+        // 释放内存
+        freeMaxHeap(maxHeap);
+        return res;
+    }
     ```
 
 === "Zig"