build

2026-08-30 11:57:13 +00:00 · 2024-04-06 03:02:20 +08:00
parent 0a9daa8b9f
commit 8d37c215c8
148 changed files with 70398 additions and 408 deletions
@@ -0,0 +1,382 @@
+---
+comments: true
+---
+
+# 8.2 &nbsp; 建堆積操作
+
+在某些情況下，我們希望使用一個串列的所有元素來構建一個堆積，這個過程被稱為“建堆積操作”。
+
+## 8.2.1 &nbsp; 藉助入堆積操作實現
+
+我們首先建立一個空堆積，然後走訪串列，依次對每個元素執行“入堆積操作”，即先將元素新增至堆積的尾部，再對該元素執行“從底至頂”堆積化。
+
+每當一個元素入堆積，堆積的長度就加一。由於節點是從頂到底依次被新增進二元樹的，因此堆積是“自上而下”構建的。
+
+設元素數量為 $n$ ，每個元素的入堆積操作使用 $O(\log{n})$ 時間，因此該建堆積方法的時間複雜度為 $O(n \log n)$ 。
+
+## 8.2.2 &nbsp; 透過走訪堆積化實現
+
+實際上，我們可以實現一種更為高效的建堆積方法，共分為兩步。
+
+1. 將串列所有元素原封不動地新增到堆積中，此時堆積的性質尚未得到滿足。
+2. 倒序走訪堆積（層序走訪的倒序），依次對每個非葉節點執行“從頂至底堆積化”。
+
+**每當堆積化一個節點後，以該節點為根節點的子樹就形成一個合法的子堆積**。而由於是倒序走訪，因此堆積是“自下而上”構建的。
+
+之所以選擇倒序走訪，是因為這樣能夠保證當前節點之下的子樹已經是合法的子堆積，這樣堆積化當前節點才是有效的。
+
+值得說明的是，**由於葉節點沒有子節點，因此它們天然就是合法的子堆積，無須堆積化**。如以下程式碼所示，最後一個非葉節點是最後一個節點的父節點，我們從它開始倒序走訪並執行堆積化：
+
+=== "Python"
+
+    ```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++"
+
+    ```cpp title="my_heap.cpp"
+    /* 建構子，根據輸入串列建堆積 */
+    MaxHeap(vector<int> nums) {
+        // 將串列元素原封不動新增進堆積
+        maxHeap = nums;
+        // 堆積化除葉節點以外的其他所有節點
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```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"
+
+    ```go title="my_heap.go"
+    /* 建構子，根據切片建堆積 */
+    func newMaxHeap(nums []any) *maxHeap {
+        // 將串列元素原封不動新增進堆積
+        h := &maxHeap{data: nums}
+        for i := h.parent(len(h.data) - 1); i >= 0; i-- {
+            // 堆積化除葉節點以外的其他所有節點
+            h.siftDown(i)
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="my_heap.swift"
+    /* 建構子，根據輸入串列建堆積 */
+    init(nums: [Int]) {
+        // 將串列元素原封不動新增進堆積
+        maxHeap = nums
+        // 堆積化除葉節點以外的其他所有節點
+        for i in (0 ... parent(i: size() - 1)).reversed() {
+            siftDown(i: i)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="my_heap.js"
+    /* 建構子，建立空堆積或根據輸入串列建堆積 */
+    constructor(nums) {
+        // 將串列元素原封不動新增進堆積
+        this.#maxHeap = nums === undefined ? [] : [...nums];
+        // 堆積化除葉節點以外的其他所有節點
+        for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
+            this.#siftDown(i);
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="my_heap.ts"
+    /* 建構子，建立空堆積或根據輸入串列建堆積 */
+    constructor(nums?: number[]) {
+        // 將串列元素原封不動新增進堆積
+        this.maxHeap = nums === undefined ? [] : [...nums];
+        // 堆積化除葉節點以外的其他所有節點
+        for (let i = this.parent(this.size() - 1); i >= 0; i--) {
+            this.siftDown(i);
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="my_heap.dart"
+    /* 建構子，根據輸入串列建堆積 */
+    MaxHeap(List<int> nums) {
+      // 將串列元素原封不動新增進堆積
+      _maxHeap = nums;
+      // 堆積化除葉節點以外的其他所有節點
+      for (int i = _parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 建構子，根據輸入串列建堆積 */
+    fn new(nums: Vec<i32>) -> Self {
+        // 將串列元素原封不動新增進堆積
+        let mut heap = MaxHeap { max_heap: nums };
+        // 堆積化除葉節點以外的其他所有節點
+        for i in (0..=Self::parent(heap.size() - 1)).rev() {
+            heap.sift_down(i);
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="my_heap.c"
+    /* 建構子，根據切片建堆積 */
+    MaxHeap *newMaxHeap(int nums[], int size) {
+        // 所有元素入堆積
+        MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));
+        maxHeap->size = size;
+        memcpy(maxHeap->data, nums, size * sizeof(int));
+        for (int i = parent(maxHeap, size - 1); i >= 0; i--) {
+            // 堆積化除葉節點以外的其他所有節點
+            siftDown(maxHeap, i);
+        }
+        return maxHeap;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* 大頂堆積 */
+    class MaxHeap(nums: List<Int>?) {
+        // 使用串列而非陣列，這樣無須考慮擴容問題
+        // 將串列元素原封不動新增進堆積
+        private val maxHeap = ArrayList(nums!!)
+
+        /* 建構子，根據輸入串列建堆積 */
+        init {
+            // 堆積化除葉節點以外的其他所有節點
+            for (i in parent(size() - 1) downTo 0) {
+                siftDown(i)
+            }
+        }
+
+        /* 獲取左子節點的索引 */
+        private fun left(i: Int): Int {
+            return 2 * i + 1
+        }
+
+        /* 獲取右子節點的索引 */
+        private fun right(i: Int): Int {
+            return 2 * i + 2
+        }
+
+        /* 獲取父節點的索引 */
+        private fun parent(i: Int): Int {
+            return (i - 1) / 2 // 向下整除
+        }
+
+        /* 交換元素 */
+        private fun swap(i: Int, j: Int) {
+            maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }
+        }
+
+        /* 獲取堆積大小 */
+        fun size(): Int {
+            return maxHeap.size
+        }
+
+        /* 判斷堆積是否為空 */
+        fun isEmpty(): Boolean {
+            /* 判斷堆積是否為空 */
+            return size() == 0
+        }
+
+        /* 訪問堆積頂元素 */
+        fun peek(): Int {
+            return maxHeap[0]
+        }
+
+        /* 元素入堆積 */
+        fun push(value: Int) {
+            // 新增節點
+            maxHeap.add(value)
+            // 從底至頂堆積化
+            siftUp(size() - 1)
+        }
+
+        /* 從節點 i 開始，從底至頂堆積化 */
+        private fun siftUp(it: Int) {
+            // Kotlin的函式參數不可變，因此建立臨時變數
+            var i = it
+            while (true) {
+                // 獲取節點 i 的父節點
+                val p = parent(i)
+                // 當“越過根節點”或“節點無須修復”時，結束堆積化
+                if (p < 0 || maxHeap[i] <= maxHeap[p]) break
+                // 交換兩節點
+                swap(i, p)
+                // 迴圈向上堆積化
+                i = p
+            }
+        }
+
+        /* 元素出堆積 */
+        fun pop(): Int {
+            // 判空處理
+            if (isEmpty()) throw IndexOutOfBoundsException()
+            // 交換根節點與最右葉節點（交換首元素與尾元素）
+            swap(0, size() - 1)
+            // 刪除節點
+            val value = maxHeap.removeAt(size() - 1)
+            // 從頂至底堆積化
+            siftDown(0)
+            // 返回堆積頂元素
+            return value
+        }
+
+        /* 從節點 i 開始，從頂至底堆積化 */
+        private fun siftDown(it: Int) {
+            // Kotlin的函式參數不可變，因此建立臨時變數
+            var i = it
+            while (true) {
+                // 判斷節點 i, l, r 中值最大的節點，記為 ma
+                val l = left(i)
+                val r = right(i)
+                var ma = i
+                if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l
+                if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r
+                // 若節點 i 最大或索引 l, r 越界，則無須繼續堆積化，跳出
+                if (ma == i) break
+                // 交換兩節點
+                swap(i, ma)
+                // 迴圈向下堆積化
+                i = ma
+            }
+        }
+
+        /* 列印堆積（二元樹） */
+        fun print() {
+            val queue = PriorityQueue { a: Int, b: Int -> b - a }
+            queue.addAll(maxHeap)
+            printHeap(queue)
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{__init__}
+    ```
+
+=== "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);
+        }
+    }
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=class%20MaxHeap%3A%0A%20%20%20%20%22%22%22%E5%A4%A7%E9%A1%B6%E5%A0%86%22%22%22%0A%0A%20%20%20%20def%20__init__%28self,%20nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E6%9E%84%E9%80%A0%E6%96%B9%E6%B3%95%EF%BC%8C%E6%A0%B9%E6%8D%AE%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%BB%BA%E5%A0%86%22%22%22%0A%20%20%20%20%20%20%20%20%23%20%E5%B0%86%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%E5%8E%9F%E5%B0%81%E4%B8%8D%E5%8A%A8%E6%B7%BB%E5%8A%A0%E8%BF%9B%E5%A0%86%0A%20%20%20%20%20%20%20%20self.max_heap%20%3D%20nums%0A%20%20%20%20%20%20%20%20%23%20%E5%A0%86%E5%8C%96%E9%99%A4%E5%8F%B6%E8%8A%82%E7%82%B9%E4%BB%A5%E5%A4%96%E7%9A%84%E5%85%B6%E4%BB%96%E6%89%80%E6%9C%89%E8%8A%82%E7%82%B9%0A%20%20%20%20%20%20%20%20for%20i%20in%20range%28self.parent%28self.size%28%29%20-%201%29,%20-1,%20-1%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20self.sift_down%28i%29%0A%0A%20%20%20%20def%20left%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%202%20*%20i%20%2B%201%0A%0A%20%20%20%20def%20right%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%202%20*%20i%20%2B%202%0A%0A%20%20%20%20def%20parent%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E7%88%B6%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%20%28i%20-%201%29%20//%202%20%20%23%20%E5%90%91%E4%B8%8B%E6%95%B4%E9%99%A4%0A%0A%20%20%20%20def%20swap%28self,%20i%3A%20int,%20j%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E4%BA%A4%E6%8D%A2%E5%85%83%E7%B4%A0%22%22%22%0A%20%20%20%20%20%20%20%20self.max_heap%5Bi%5D,%20self.max_heap%5Bj%5D%20%3D%20self.max_heap%5Bj%5D,%20self.max_heap%5Bi%5D%0A%0A%20%20%20%20def%20size%28self%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%22%22%22%0A%20%20%20%20%20%20%20%20return%20len%28self.max_heap%29%0A%0A%20%20%20%20def%20sift_down%28self,%20i%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E4%BB%8E%E8%8A%82%E7%82%B9%20i%20%E5%BC%80%E5%A7%8B%EF%BC%8C%E4%BB%8E%E9%A1%B6%E8%87%B3%E5%BA%95%E5%A0%86%E5%8C%96%22%22%22%0A%20%20%20%20%20%20%20%20while%20True%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E8%8A%82%E7%82%B9%20i,%20l,%20r%20%E4%B8%AD%E5%80%BC%E6%9C%80%E5%A4%A7%E7%9A%84%E8%8A%82%E7%82%B9%EF%BC%8C%E8%AE%B0%E4%B8%BA%20ma%0A%20%20%20%20%20%20%20%20%20%20%20%20l,%20r,%20ma%20%3D%20self.left%28i%29,%20self.right%28i%29,%20i%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20l%20%3C%20self.size%28%29%20and%20self.max_heap%5Bl%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20l%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20r%20%3C%20self.size%28%29%20and%20self.max_heap%5Br%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20r%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E8%8A%82%E7%82%B9%20i%20%E6%9C%80%E5%A4%A7%E6%88%96%E7%B4%A2%E5%BC%95%20l,%20r%20%E8%B6%8A%E7%95%8C%EF%BC%8C%E5%88%99%E6%97%A0%E9%A1%BB%E7%BB%A7%E7%BB%AD%E5%A0%86%E5%8C%96%EF%BC%8C%E8%B7%B3%E5%87%BA%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20ma%20%3D%3D%20i%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E4%BA%A4%E6%8D%A2%E4%B8%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20%20%20%20%20%20%20%20%20self.swap%28i,%20ma%29%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E5%90%91%E4%B8%8B%E5%A0%86%E5%8C%96%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20ma%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap%20%3D%20MaxHeap%28%5B1,%202,%203,%204,%205%5D%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=class%20MaxHeap%3A%0A%20%20%20%20%22%22%22%E5%A4%A7%E9%A1%B6%E5%A0%86%22%22%22%0A%0A%20%20%20%20def%20__init__%28self,%20nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E6%9E%84%E9%80%A0%E6%96%B9%E6%B3%95%EF%BC%8C%E6%A0%B9%E6%8D%AE%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%BB%BA%E5%A0%86%22%22%22%0A%20%20%20%20%20%20%20%20%23%20%E5%B0%86%E5%88%97%E8%A1%A8%E5%85%83%E7%B4%A0%E5%8E%9F%E5%B0%81%E4%B8%8D%E5%8A%A8%E6%B7%BB%E5%8A%A0%E8%BF%9B%E5%A0%86%0A%20%20%20%20%20%20%20%20self.max_heap%20%3D%20nums%0A%20%20%20%20%20%20%20%20%23%20%E5%A0%86%E5%8C%96%E9%99%A4%E5%8F%B6%E8%8A%82%E7%82%B9%E4%BB%A5%E5%A4%96%E7%9A%84%E5%85%B6%E4%BB%96%E6%89%80%E6%9C%89%E8%8A%82%E7%82%B9%0A%20%20%20%20%20%20%20%20for%20i%20in%20range%28self.parent%28self.size%28%29%20-%201%29,%20-1,%20-1%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20self.sift_down%28i%29%0A%0A%20%20%20%20def%20left%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%202%20*%20i%20%2B%201%0A%0A%20%20%20%20def%20right%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%202%20*%20i%20%2B%202%0A%0A%20%20%20%20def%20parent%28self,%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E7%88%B6%E8%8A%82%E7%82%B9%E7%9A%84%E7%B4%A2%E5%BC%95%22%22%22%0A%20%20%20%20%20%20%20%20return%20%28i%20-%201%29%20//%202%20%20%23%20%E5%90%91%E4%B8%8B%E6%95%B4%E9%99%A4%0A%0A%20%20%20%20def%20swap%28self,%20i%3A%20int,%20j%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E4%BA%A4%E6%8D%A2%E5%85%83%E7%B4%A0%22%22%22%0A%20%20%20%20%20%20%20%20self.max_heap%5Bi%5D,%20self.max_heap%5Bj%5D%20%3D%20self.max_heap%5Bj%5D,%20self.max_heap%5Bi%5D%0A%0A%20%20%20%20def%20size%28self%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%22%22%22%0A%20%20%20%20%20%20%20%20return%20len%28self.max_heap%29%0A%0A%20%20%20%20def%20sift_down%28self,%20i%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%22%22%22%E4%BB%8E%E8%8A%82%E7%82%B9%20i%20%E5%BC%80%E5%A7%8B%EF%BC%8C%E4%BB%8E%E9%A1%B6%E8%87%B3%E5%BA%95%E5%A0%86%E5%8C%96%22%22%22%0A%20%20%20%20%20%20%20%20while%20True%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E8%8A%82%E7%82%B9%20i,%20l,%20r%20%E4%B8%AD%E5%80%BC%E6%9C%80%E5%A4%A7%E7%9A%84%E8%8A%82%E7%82%B9%EF%BC%8C%E8%AE%B0%E4%B8%BA%20ma%0A%20%20%20%20%20%20%20%20%20%20%20%20l,%20r,%20ma%20%3D%20self.left%28i%29,%20self.right%28i%29,%20i%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20l%20%3C%20self.size%28%29%20and%20self.max_heap%5Bl%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20l%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20r%20%3C%20self.size%28%29%20and%20self.max_heap%5Br%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20r%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E8%8A%82%E7%82%B9%20i%20%E6%9C%80%E5%A4%A7%E6%88%96%E7%B4%A2%E5%BC%95%20l,%20r%20%E8%B6%8A%E7%95%8C%EF%BC%8C%E5%88%99%E6%97%A0%E9%A1%BB%E7%BB%A7%E7%BB%AD%E5%A0%86%E5%8C%96%EF%BC%8C%E8%B7%B3%E5%87%BA%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20ma%20%3D%3D%20i%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E4%BA%A4%E6%8D%A2%E4%B8%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20%20%20%20%20%20%20%20%20self.swap%28i,%20ma%29%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E5%BE%AA%E7%8E%AF%E5%90%91%E4%B8%8B%E5%A0%86%E5%8C%96%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20ma%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap%20%3D%20MaxHeap%28%5B1,%202,%203,%204,%205%5D%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+## 8.2.3 &nbsp; 複雜度分析
+
+下面，我們來嘗試推算第二種建堆積方法的時間複雜度。
+
+- 假設完全二元樹的節點數量為 $n$ ，則葉節點數量為 $(n + 1) / 2$ ，其中 $/$ 為向下整除。因此需要堆積化的節點數量為 $(n - 1) / 2$ 。
+- 在從頂至底堆積化的過程中，每個節點最多堆積化到葉節點，因此最大迭代次數為二元樹高度 $\log n$ 。
+
+將上述兩者相乘，可得到建堆積過程的時間複雜度為 $O(n \log n)$ 。**但這個估算結果並不準確，因為我們沒有考慮到二元樹底層節點數量遠多於頂層節點的性質**。
+
+接下來我們來進行更為準確的計算。為了降低計算難度，假設給定一個節點數量為 $n$ 、高度為 $h$ 的“完美二元樹”，該假設不會影響計算結果的正確性。
+
+![完美二元樹的各層節點數量](build_heap.assets/heapify_operations_count.png){ class="animation-figure" }
+
+<p align="center"> 圖 8-5 &nbsp; 完美二元樹的各層節點數量 </p>
+
+如圖 8-5 所示，節點“從頂至底堆積化”的最大迭代次數等於該節點到葉節點的距離，而該距離正是“節點高度”。因此，我們可以對各層的“節點數量 $\times$ 節點高度”求和，**得到所有節點的堆積化迭代次數的總和**。
+
+$$
+T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
+$$
+
+化簡上式需要藉助中學的數列知識，先將 $T(h)$ 乘以 $2$ ，得到：
+
+$$
+\begin{aligned}
+T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{h-1}\times1 \newline
+2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \dots + 2^{h}\times1 \newline
+\end{aligned}
+$$
+
+使用錯位相減法，用下式 $2 T(h)$ 減去上式 $T(h)$ ，可得：
+
+$$
+2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \dots + 2^{h-1} + 2^h
+$$
+
+觀察上式，發現 $T(h)$ 是一個等比數列，可直接使用求和公式，得到時間複雜度為：
+
+$$
+\begin{aligned}
+T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
+& = 2^{h+1} - h - 2 \newline
+& = O(2^h)
+\end{aligned}
+$$
+
+進一步，高度為 $h$ 的完美二元樹的節點數量為 $n = 2^{h+1} - 1$ ，易得複雜度為 $O(2^h) = O(n)$ 。以上推算表明，**輸入串列並建堆積的時間複雜度為 $O(n)$ ，非常高效**。
@@ -0,0 +1,21 @@
+---
+comments: true
+icon: material/family-tree
+---
+
+# 第 8 章 &nbsp; 堆積
+
+![堆積](../assets/covers/chapter_heap.jpg){ class="cover-image" }
+
+!!! abstract
+
+    堆積就像是山嶽峰巒，層疊起伏、形態各異。
+    
+    座座山峰高低錯落，而最高的山峰總是最先映入眼簾。
+
+## Chapter Contents
+
+- [8.1 &nbsp; 堆積](https://www.hello-algo.com/en/chapter_heap/heap/)
+- [8.2 &nbsp; 建堆積操作](https://www.hello-algo.com/en/chapter_heap/build_heap/)
+- [8.3 &nbsp; Top-k 問題](https://www.hello-algo.com/en/chapter_heap/top_k/)
+- [8.4 &nbsp; 小結](https://www.hello-algo.com/en/chapter_heap/summary/)
@@ -0,0 +1,21 @@
+---
+comments: true
+---
+
+# 8.4 &nbsp; 小結
+
+### 1. &nbsp; 重點回顧
+
+- 堆積是一棵完全二元樹，根據成立條件可分為大頂堆積和小頂堆積。大（小）頂堆積的堆積頂元素是最大（小）的。
+- 優先佇列的定義是具有出列優先順序的佇列，通常使用堆積來實現。
+- 堆積的常用操作及其對應的時間複雜度包括：元素入堆積 $O(\log n)$、堆積頂元素出堆積 $O(\log n)$ 和訪問堆積頂元素 $O(1)$ 等。
+- 完全二元樹非常適合用陣列表示，因此我們通常使用陣列來儲存堆積。
+- 堆積化操作用於維護堆積的性質，在入堆積和出堆積操作中都會用到。
+- 輸入 $n$ 個元素並建堆積的時間複雜度可以最佳化至 $O(n)$ ，非常高效。
+- Top-k 是一個經典演算法問題，可以使用堆積資料結構高效解決，時間複雜度為 $O(n \log k)$ 。
+
+### 2. &nbsp; Q & A
+
+**Q**：資料結構的“堆積”與記憶體管理的“堆積”是同一個概念嗎？
+
+兩者不是同一個概念，只是碰巧都叫“堆積”。計算機系統記憶體中的堆積是動態記憶體分配的一部分，程式在執行時可以使用它來儲存資料。程式可以請求一定量的堆積記憶體，用於儲存如物件和陣列等複雜結構。當這些資料不再需要時，程式需要釋放這些記憶體，以防止記憶體流失。相較於堆疊記憶體，堆積記憶體的管理和使用需要更謹慎，使用不當可能會導致記憶體流失和野指標等問題。
@@ -0,0 +1,456 @@
+---
+comments: true
+---
+
+# 8.3 &nbsp; Top-k 問題
+
+!!! question
+
+    給定一個長度為 $n$ 的無序陣列 `nums` ，請返回陣列中最大的 $k$ 個元素。
+
+對於該問題，我們先介紹兩種思路比較直接的解法，再介紹效率更高的堆積解法。
+
+## 8.3.1 &nbsp; 方法一：走訪選擇
+
+我們可以進行圖 8-6 所示的 $k$ 輪走訪，分別在每輪中提取第 $1$、$2$、$\dots$、$k$ 大的元素，時間複雜度為 $O(nk)$ 。
+
+此方法只適用於 $k \ll n$ 的情況，因為當 $k$ 與 $n$ 比較接近時，其時間複雜度趨向於 $O(n^2)$ ，非常耗時。
+
+![走訪尋找最大的 k 個元素](top_k.assets/top_k_traversal.png){ class="animation-figure" }
+
+<p align="center"> 圖 8-6 &nbsp; 走訪尋找最大的 k 個元素 </p>
+
+!!! tip
+
+    當 $k = n$ 時，我們可以得到完整的有序序列，此時等價於“選擇排序”演算法。
+
+## 8.3.2 &nbsp; 方法二：排序
+
+如圖 8-7 所示，我們可以先對陣列 `nums` 進行排序，再返回最右邊的 $k$ 個元素，時間複雜度為 $O(n \log n)$ 。
+
+顯然，該方法“超額”完成任務了，因為我們只需找出最大的 $k$ 個元素即可，而不需要排序其他元素。
+
+![排序尋找最大的 k 個元素](top_k.assets/top_k_sorting.png){ class="animation-figure" }
+
+<p align="center"> 圖 8-7 &nbsp; 排序尋找最大的 k 個元素 </p>
+
+## 8.3.3 &nbsp; 方法三：堆積
+
+我們可以基於堆積更加高效地解決 Top-k 問題，流程如圖 8-8 所示。
+
+1. 初始化一個小頂堆積，其堆積頂元素最小。
+2. 先將陣列的前 $k$ 個元素依次入堆積。
+3. 從第 $k + 1$ 個元素開始，若當前元素大於堆積頂元素，則將堆積頂元素出堆積，並將當前元素入堆積。
+4. 走訪完成後，堆積中儲存的就是最大的 $k$ 個元素。
+
+=== "<1>"
+    ![基於堆積尋找最大的 k 個元素](top_k.assets/top_k_heap_step1.png){ class="animation-figure" }
+
+=== "<2>"
+    ![top_k_heap_step2](top_k.assets/top_k_heap_step2.png){ class="animation-figure" }
+
+=== "<3>"
+    ![top_k_heap_step3](top_k.assets/top_k_heap_step3.png){ class="animation-figure" }
+
+=== "<4>"
+    ![top_k_heap_step4](top_k.assets/top_k_heap_step4.png){ class="animation-figure" }
+
+=== "<5>"
+    ![top_k_heap_step5](top_k.assets/top_k_heap_step5.png){ class="animation-figure" }
+
+=== "<6>"
+    ![top_k_heap_step6](top_k.assets/top_k_heap_step6.png){ class="animation-figure" }
+
+=== "<7>"
+    ![top_k_heap_step7](top_k.assets/top_k_heap_step7.png){ class="animation-figure" }
+
+=== "<8>"
+    ![top_k_heap_step8](top_k.assets/top_k_heap_step8.png){ class="animation-figure" }
+
+=== "<9>"
+    ![top_k_heap_step9](top_k.assets/top_k_heap_step9.png){ class="animation-figure" }
+
+<p align="center"> 圖 8-8 &nbsp; 基於堆積尋找最大的 k 個元素 </p>
+
+示例程式碼如下：
+
+=== "Python"
+
+    ```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++"
+
+    ```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++) {
+            heap.push(nums[i]);
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for (int i = k; i < nums.size(); i++) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if (nums[i] > heap.top()) {
+                heap.pop();
+                heap.push(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Java"
+
+    ```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();
+        // 將陣列的前 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"
+
+    ```go title="top_k.go"
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    func topKHeap(nums []int, k int) *minHeap {
+        // 初始化小頂堆積
+        h := &minHeap{}
+        heap.Init(h)
+        // 將陣列的前 k 個元素入堆積
+        for i := 0; i < k; i++ {
+            heap.Push(h, nums[i])
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for i := k; i < len(nums); i++ {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if nums[i] > h.Top().(int) {
+                heap.Pop(h)
+                heap.Push(h, nums[i])
+            }
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="top_k.swift"
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    func topKHeap(nums: [Int], k: Int) -> [Int] {
+        // 初始化一個小頂堆積，並將前 k 個元素建堆積
+        var heap = Heap(nums.prefix(k))
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for i in nums.indices.dropFirst(k) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if nums[i] > heap.min()! {
+                _ = heap.removeMin()
+                heap.insert(nums[i])
+            }
+        }
+        return heap.unordered
+    }
+    ```
+
+=== "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) {
+        // 初始化小頂堆積
+        // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
+        const maxHeap = new MaxHeap([]);
+        // 將陣列的前 k 個元素入堆積
+        for (let i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for (let i = k; i < nums.length; i++) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        // 返回堆積中元素
+        return getMinHeap(maxHeap);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="top_k.ts"
+    /* 元素入堆積 */
+    function pushMinHeap(maxHeap: MaxHeap, val: number): void {
+        // 元素取反
+        maxHeap.push(-val);
+    }
+
+    /* 元素出堆積 */
+    function popMinHeap(maxHeap: MaxHeap): number {
+        // 元素取反
+        return -maxHeap.pop();
+    }
+
+    /* 訪問堆積頂元素 */
+    function peekMinHeap(maxHeap: MaxHeap): number {
+        // 元素取反
+        return -maxHeap.peek();
+    }
+
+    /* 取出堆積中元素 */
+    function getMinHeap(maxHeap: MaxHeap): number[] {
+        // 元素取反
+        return maxHeap.getMaxHeap().map((num: number) => -num);
+    }
+
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    function topKHeap(nums: number[], k: number): number[] {
+        // 初始化小頂堆積
+        // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
+        const maxHeap = new MaxHeap([]);
+        // 將陣列的前 k 個元素入堆積
+        for (let i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for (let i = k; i < nums.length; i++) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        // 返回堆積中元素
+        return getMinHeap(maxHeap);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="top_k.dart"
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    MinHeap topKHeap(List<int> nums, int k) {
+      // 初始化小頂堆積，將陣列的前 k 個元素入堆積
+      MinHeap heap = MinHeap(nums.sublist(0, k));
+      // 從第 k+1 個元素開始，保持堆積的長度為 k
+      for (int i = k; i < nums.length; i++) {
+        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+        if (nums[i] > heap.peek()) {
+          heap.pop();
+          heap.push(nums[i]);
+        }
+      }
+      return heap;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="top_k.rs"
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
+        // BinaryHeap 是大頂堆積，使用 Reverse 將元素取反，從而實現小頂堆積
+        let mut heap = BinaryHeap::<Reverse<i32>>::new();
+        // 將陣列的前 k 個元素入堆積
+        for &num in nums.iter().take(k) {
+            heap.push(Reverse(num));
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for &num in nums.iter().skip(k) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if num > heap.peek().unwrap().0 {
+                heap.pop();
+                heap.push(Reverse(num));
+            }
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="top_k.c"
+    /* 元素入堆積 */
+    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 = (int *)malloc(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);
+        // 釋放記憶體
+        delMaxHeap(maxHeap);
+        return res;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="top_k.kt"
+    /* 基於堆積查詢陣列中最大的 k 個元素 */
+    fun topKHeap(nums: IntArray, k: Int): Queue<Int> {
+        // 初始化小頂堆積
+        val heap = PriorityQueue<Int>()
+        // 將陣列的前 k 個元素入堆積
+        for (i in 0..<k) {
+            heap.offer(nums[i])
+        }
+        // 從第 k+1 個元素開始，保持堆積的長度為 k
+        for (i in k..<nums.size) {
+            // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
+            if (nums[i] > heap.peek()) {
+                heap.poll()
+                heap.offer(nums[i])
+            }
+        }
+        return heap
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="top_k.rb"
+    [class]{}-[func]{top_k_heap}
+    ```
+
+=== "Zig"
+
+    ```zig title="top_k.zig"
+    [class]{}-[func]{topKHeap}
+    ```
+
+??? pythontutor "視覺化執行"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=import%20heapq%0A%0Adef%20top_k_heap%28nums%3A%20list%5Bint%5D,%20k%3A%20int%29%20-%3E%20list%5Bint%5D%3A%0A%20%20%20%20%22%22%22%E5%9F%BA%E4%BA%8E%E5%A0%86%E6%9F%A5%E6%89%BE%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9C%80%E5%A4%A7%E7%9A%84%20k%20%E4%B8%AA%E5%85%83%E7%B4%A0%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20heap%20%3D%20%5B%5D%0A%20%20%20%20%23%20%E5%B0%86%E6%95%B0%E7%BB%84%E7%9A%84%E5%89%8D%20k%20%E4%B8%AA%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20for%20i%20in%20range%28k%29%3A%0A%20%20%20%20%20%20%20%20heapq.heappush%28heap,%20nums%5Bi%5D%29%0A%20%20%20%20%23%20%E4%BB%8E%E7%AC%AC%20k%2B1%20%E4%B8%AA%E5%85%83%E7%B4%A0%E5%BC%80%E5%A7%8B%EF%BC%8C%E4%BF%9D%E6%8C%81%E5%A0%86%E7%9A%84%E9%95%BF%E5%BA%A6%E4%B8%BA%20k%0A%20%20%20%20for%20i%20in%20range%28k,%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%BD%93%E5%89%8D%E5%85%83%E7%B4%A0%E5%A4%A7%E4%BA%8E%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%EF%BC%8C%E5%88%99%E5%B0%86%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%E3%80%81%E5%BD%93%E5%89%8D%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3E%20heap%5B0%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappop%28heap%29%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappush%28heap,%20nums%5Bi%5D%29%0A%20%20%20%20return%20heap%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B1,%207,%206,%203,%202%5D%0A%20%20%20%20k%20%3D%203%0A%0A%20%20%20%20res%20%3D%20top_k_heap%28nums,%20k%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=import%20heapq%0A%0Adef%20top_k_heap%28nums%3A%20list%5Bint%5D,%20k%3A%20int%29%20-%3E%20list%5Bint%5D%3A%0A%20%20%20%20%22%22%22%E5%9F%BA%E4%BA%8E%E5%A0%86%E6%9F%A5%E6%89%BE%E6%95%B0%E7%BB%84%E4%B8%AD%E6%9C%80%E5%A4%A7%E7%9A%84%20k%20%E4%B8%AA%E5%85%83%E7%B4%A0%22%22%22%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20heap%20%3D%20%5B%5D%0A%20%20%20%20%23%20%E5%B0%86%E6%95%B0%E7%BB%84%E7%9A%84%E5%89%8D%20k%20%E4%B8%AA%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20for%20i%20in%20range%28k%29%3A%0A%20%20%20%20%20%20%20%20heapq.heappush%28heap,%20nums%5Bi%5D%29%0A%20%20%20%20%23%20%E4%BB%8E%E7%AC%AC%20k%2B1%20%E4%B8%AA%E5%85%83%E7%B4%A0%E5%BC%80%E5%A7%8B%EF%BC%8C%E4%BF%9D%E6%8C%81%E5%A0%86%E7%9A%84%E9%95%BF%E5%BA%A6%E4%B8%BA%20k%0A%20%20%20%20for%20i%20in%20range%28k,%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20%23%20%E8%8B%A5%E5%BD%93%E5%89%8D%E5%85%83%E7%B4%A0%E5%A4%A7%E4%BA%8E%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%EF%BC%8C%E5%88%99%E5%B0%86%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%E3%80%81%E5%BD%93%E5%89%8D%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3E%20heap%5B0%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappop%28heap%29%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappush%28heap,%20nums%5Bi%5D%29%0A%20%20%20%20return%20heap%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B1,%207,%206,%203,%202%5D%0A%20%20%20%20k%20%3D%203%0A%0A%20%20%20%20res%20%3D%20top_k_heap%28nums,%20k%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">全螢幕觀看 ></a></div>
+
+總共執行了 $n$ 輪入堆積和出堆積，堆積的最大長度為 $k$ ，因此時間複雜度為 $O(n \log k)$ 。該方法的效率很高，當 $k$ 較小時，時間複雜度趨向 $O(n)$ ；當 $k$ 較大時，時間複雜度不會超過 $O(n \log n)$ 。
+
+另外，該方法適用於動態資料流的使用場景。在不斷加入資料時，我們可以持續維護堆積內的元素，從而實現最大的 $k$ 個元素的動態更新。