build

chapter_heap/build_heap.md

@@ -176,6 +176,21 @@ comments: true
     }
     ```
 
+=== "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
+    }
+    ```
+
 ## 8.2.3. &nbsp; 复杂度分析
 
 为什么第二种建堆方法的时间复杂度是 $O(n)$ ？我们来展开推算一下。

chapter_heap/heap.md

@@ -313,6 +313,12 @@ comments: true
     // Dart 未提供内置 Heap 类
     ```
 
+=== "Rust"
+
+    ```rust title="heap.rs"
+
+    ```
+
 ## 8.1.2.   堆的实现
 
 下文实现的是大顶堆。若要将其转换为小顶堆，只需将所有大小逻辑判断取逆（例如，将 $\geq$ 替换为 $\leq$ ）。感兴趣的读者可以自行实现。
@@ -539,6 +545,25 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 获取左子节点索引 */
+    fn left(i: usize) -> usize {
+        2 * i + 1
+    }
+
+    /* 获取右子节点索引 */
+    fn right(i: usize) -> usize {
+        2 * i + 2
+    }
+
+    /* 获取父节点索引 */
+    fn parent(i: usize) -> usize {
+        (i - 1) / 2 // 向下整除
+    }
+    ```
+
 ### 访问堆顶元素
 
 堆顶元素即为二叉树的根节点，也就是列表的首个元素。
@@ -641,6 +666,15 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 访问堆顶元素 */
+    fn peek(&self) -> Option<i32> {
+        self.max_heap.first().copied()
+    }
+    ```
+
 ### 元素入堆
 
 给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 Heapify」。
@@ -966,6 +1000,38 @@ comments: true
     [class]{MaxHeap}-[func]{siftUp}
     ```
 
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 元素入堆 */
+    fn push(&mut self, val: i32) {
+        // 添加节点
+        self.max_heap.push(val);
+        // 从底至顶堆化
+        self.sift_up(self.size() - 1);
+    }
+
+    /* 从节点 i 开始，从底至顶堆化 */
+    fn sift_up(&mut self, mut i: usize) {
+        loop {
+            // 节点 i 已经是堆顶节点了，结束堆化
+            if i == 0 {
+                break;
+            }
+            // 获取节点 i 的父节点
+            let p = Self::parent(i);
+            // 当“节点无需修复”时，结束堆化
+            if self.max_heap[i] <= self.max_heap[p] {
+                break;
+            }
+            // 交换两节点
+            self.swap(i, p);
+            // 循环向上堆化
+            i = p;
+        }
+    }
+    ```
+
 ### 堆顶元素出堆
 
 堆顶元素是二叉树的根节点，即列表首元素。如果我们直接从列表中删除首元素，那么二叉树中所有节点的索引都会发生变化，这将使得后续使用堆化修复变得困难。为了尽量减少元素索引的变动，我们采取以下操作步骤：
@@ -1422,6 +1488,48 @@ comments: true
     [class]{MaxHeap}-[func]{siftDown}
     ```
 
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* 元素出堆 */
+    fn pop(&mut self) -> i32 {
+        // 判空处理
+        if self.is_empty() {
+            panic!("index out of bounds");
+        }
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        self.swap(0, self.size() - 1);
+        // 删除节点
+        let val = self.max_heap.remove(self.size() - 1);
+        // 从顶至底堆化
+        self.sift_down(0);
+        // 返回堆顶元素
+        val
+    }
+
+    /* 从节点 i 开始，从顶至底堆化 */
+    fn sift_down(&mut self, mut i: usize) {
+        loop {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let (l, r, mut ma) = (Self::left(i), Self::right(i), i);
+            if l < self.size() && self.max_heap[l] > self.max_heap[ma] {
+                ma = l;
+            }
+            if r < self.size() && self.max_heap[r] > self.max_heap[ma] {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            if ma == i {
+                break;
+            }
+            // 交换两节点
+            self.swap(i, ma);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
+    ```
+
 ## 8.1.3. &nbsp; 堆常见应用
 
 - **优先队列**：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$ ，而建队操作为 $O(n)$ ，这些操作都非常高效。

chapter_heap/top_k.md

@@ -213,3 +213,26 @@ comments: true
     ```dart title="top_k.dart"
     [class]{}-[func]{top_k_heap}
     ```
+
+=== "Rust"
+
+    ```rust title="top_k.rs"
+    /* 基于堆查找数组中最大的 k 个元素 */
+    fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
+        // Rust 的 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
+    }
+    ```