build

chapter_heap/build_heap.md

@@ -26,18 +26,16 @@ comments: true
 - 由于叶节点没有子节点，因此无需对它们执行堆化。最后一个节点的父节点是最后一个非叶节点。
 - 在倒序遍历中，我们能够保证当前节点之下的子树已经完成堆化（已经是合法的堆），而这是堆化当前节点的前置条件。
 
-=== "Java"
+=== "Python"
 
-    ```java title="my_heap.java"
-    /* 构造方法，根据输入列表建堆 */
-    MaxHeap(List<Integer> nums) {
-        // 将列表元素原封不动添加进堆
-        maxHeap = new ArrayList<>(nums);
-        // 堆化除叶节点以外的其他所有节点
-        for (int i = parent(size() - 1); i >= 0; i--) {
-            siftDown(i);
-        }
-    }
+    ```python title="my_heap.py"
+    def __init__(self, nums: list[int]):
+        """构造方法，根据输入列表建堆"""
+        # 将列表元素原封不动添加进堆
+        self.max_heap = nums
+        # 堆化除叶节点以外的其他所有节点
+        for i in range(self.parent(self.size() - 1), -1, -1):
+            self.sift_down(i)
     ```
 
 === "C++"
@@ -54,16 +52,33 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="my_heap.py"
-    def __init__(self, nums: list[int]):
-        """构造方法，根据输入列表建堆"""
-        # 将列表元素原封不动添加进堆
-        self.max_heap = nums
-        # 堆化除叶节点以外的其他所有节点
-        for i in range(self.parent(self.size() - 1), -1, -1):
-            self.sift_down(i)
+    ```java title="my_heap.java"
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(List<Integer> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = new ArrayList<>(nums);
+        // 堆化除叶节点以外的其他所有节点
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="my_heap.cs"
+    /* 构造函数，根据输入列表建堆 */
+    MaxHeap(IEnumerable<int> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = new List<int>(nums);
+        // 堆化除叶节点以外的其他所有节点
+        var size = parent(this.size() - 1);
+        for (int i = size; i >= 0; i--) {
+            siftDown(i);
+        }
+    }
     ```
 
 === "Go"
@@ -81,6 +96,20 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="my_heap.swift"
+    /* 构造方法，根据输入列表建堆 */
+    init(nums: [Int]) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = nums
+        // 堆化除叶节点以外的其他所有节点
+        for i in stride(from: parent(i: size() - 1), through: 0, by: -1) {
+            siftDown(i: i)
+        }
+    }
+    ```
+
 === "JS"
 
     ```javascript title="my_heap.js"
@@ -109,69 +138,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="my_heap.c"
-    /* 构造函数，根据切片建堆 */
-    maxHeap *newMaxHeap(int nums[], int size) {
-        // 所有元素入堆
-        maxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));
-        h->size = size;
-        memcpy(h->data, nums, size * sizeof(int));
-        for (int i = parent(size - 1); i >= 0; i--) {
-            // 堆化除叶节点以外的其他所有节点
-            siftDown(h, i);
-        }
-        return h;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="my_heap.cs"
-    /* 构造函数，根据输入列表建堆 */
-    MaxHeap(IEnumerable<int> nums) {
-        // 将列表元素原封不动添加进堆
-        maxHeap = new List<int>(nums);
-        // 堆化除叶节点以外的其他所有节点
-        var size = parent(this.size() - 1);
-        for (int i = size; i >= 0; i--) {
-            siftDown(i);
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="my_heap.swift"
-    /* 构造方法，根据输入列表建堆 */
-    init(nums: [Int]) {
-        // 将列表元素原封不动添加进堆
-        maxHeap = nums
-        // 堆化除叶节点以外的其他所有节点
-        for i in stride(from: parent(i: size() - 1), through: 0, by: -1) {
-            siftDown(i: i)
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="my_heap.zig"
-    // 构造方法，根据输入列表建堆
-    fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
-        if (self.max_heap != null) return;
-        self.max_heap = std.ArrayList(T).init(allocator);
-        // 将列表元素原封不动添加进堆
-        try self.max_heap.?.appendSlice(nums);
-        // 堆化除叶节点以外的其他所有节点
-        var i: usize = parent(self.size() - 1) + 1;
-        while (i > 0) : (i -= 1) {
-            try self.siftDown(i - 1);
-        }
-    }
-    ```
-
 === "Dart"
 
     ```dart title="my_heap.dart"
@@ -201,6 +167,40 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="my_heap.c"
+    /* 构造函数，根据切片建堆 */
+    maxHeap *newMaxHeap(int nums[], int size) {
+        // 所有元素入堆
+        maxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));
+        h->size = size;
+        memcpy(h->data, nums, size * sizeof(int));
+        for (int i = parent(size - 1); i >= 0; i--) {
+            // 堆化除叶节点以外的其他所有节点
+            siftDown(h, i);
+        }
+        return h;
+    }
+    ```
+
+=== "Zig"
+
+    ```zig title="my_heap.zig"
+    // 构造方法，根据输入列表建堆
+    fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
+        if (self.max_heap != null) return;
+        self.max_heap = std.ArrayList(T).init(allocator);
+        // 将列表元素原封不动添加进堆
+        try self.max_heap.?.appendSlice(nums);
+        // 堆化除叶节点以外的其他所有节点
+        var i: usize = parent(self.size() - 1) + 1;
+        while (i > 0) : (i -= 1) {
+            try self.siftDown(i - 1);
+        }
+    }
+    ```
+
 ## 8.2.3 &nbsp; 复杂度分析
 
 下面，我们来尝试推算第二种建堆方法的时间复杂度。

chapter_heap/top_k.md

@@ -76,26 +76,22 @@ comments: true
 
 另外，该方法适用于动态数据流的使用场景。在不断加入数据时，我们可以持续维护堆内的元素，从而实现最大 $k$ 个元素的动态更新。
 
-=== "Java"
+=== "Python"
 
-    ```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++) {
-            heap.offer(nums[i]);
-        }
-        // 从第 k+1 个元素开始，保持堆的长度为 k
-        for (int i = k; i < nums.length; i++) {
-            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
-            if (nums[i] > heap.peek()) {
-                heap.poll();
-                heap.offer(nums[i]);
-            }
-        }
-        return heap;
-    }
+    ```python title="top_k.py"
+    def top_k_heap(nums: list[int], k: int) -> list[int]:
+        """基于堆查找数组中最大的 k 个元素"""
+        heap = []
+        # 将数组的前 k 个元素入堆
+        for i in range(k):
+            heapq.heappush(heap, nums[i])
+        # 从第 k+1 个元素开始，保持堆的长度为 k
+        for i in range(k, len(nums)):
+            # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if nums[i] > heap[0]:
+                heapq.heappop(heap)
+                heapq.heappush(heap, nums[i])
+        return heap
     ```
 
 === "C++"
@@ -120,22 +116,48 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="top_k.py"
-    def top_k_heap(nums: list[int], k: int) -> list[int]:
-        """基于堆查找数组中最大的 k 个元素"""
-        heap = []
-        # 将数组的前 k 个元素入堆
-        for i in range(k):
-            heapq.heappush(heap, nums[i])
-        # 从第 k+1 个元素开始，保持堆的长度为 k
-        for i in range(k, len(nums)):
-            # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
-            if nums[i] > heap[0]:
-                heapq.heappop(heap)
-                heapq.heappush(heap, nums[i])
-        return heap
+    ```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++) {
+            heap.offer(nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < nums.length; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > heap.peek()) {
+                heap.poll();
+                heap.offer(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="top_k.cs"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    PriorityQueue<int, int> topKHeap(int[] nums, int k) {
+        PriorityQueue<int, int> heap = new PriorityQueue<int, int>();
+        // 将数组的前 k 个元素入堆
+        for (int i = 0; i < k; i++) {
+            heap.Enqueue(nums[i], nums[i]);
+        }
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (int i = k; i < nums.Length; i++) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (nums[i] > heap.Peek()) {
+                heap.Dequeue();
+                heap.Enqueue(nums[i], nums[i]);
+            }
+        }
+        return heap;
+    }
     ```
 
 === "Go"
@@ -161,46 +183,6 @@ comments: true
     }
     ```
 
-=== "JS"
-
-    ```javascript title="top_k.js"
-    [class]{}-[func]{topKHeap}
-    ```
-
-=== "TS"
-
-    ```typescript title="top_k.ts"
-    [class]{}-[func]{topKHeap}
-    ```
-
-=== "C"
-
-    ```c title="top_k.c"
-    [class]{}-[func]{topKHeap}
-    ```
-
-=== "C#"
-
-    ```csharp title="top_k.cs"
-    /* 基于堆查找数组中最大的 k 个元素 */
-    PriorityQueue<int, int> topKHeap(int[] nums, int k) {
-        PriorityQueue<int, int> heap = new PriorityQueue<int, int>();
-        // 将数组的前 k 个元素入堆
-        for (int i = 0; i < k; i++) {
-            heap.Enqueue(nums[i], nums[i]);
-        }
-        // 从第 k+1 个元素开始，保持堆的长度为 k
-        for (int i = k; i < nums.Length; i++) {
-            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
-            if (nums[i] > heap.Peek()) {
-                heap.Dequeue();
-                heap.Enqueue(nums[i], nums[i]);
-            }
-        }
-        return heap;
-    }
-    ```
-
 === "Swift"
 
     ```swift title="top_k.swift"
@@ -220,9 +202,15 @@ comments: true
     }
     ```
 
-=== "Zig"
+=== "JS"
 
-    ```zig title="top_k.zig"
+    ```javascript title="top_k.js"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "TS"
+
+    ```typescript title="top_k.ts"
     [class]{}-[func]{topKHeap}
     ```
 
@@ -267,3 +255,15 @@ comments: true
         heap
     }
     ```
+
+=== "C"
+
+    ```c title="top_k.c"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Zig"
+
+    ```zig title="top_k.zig"
+    [class]{}-[func]{topKHeap}
+    ```