build

zh/chapter_array_and_linkedlist/linked_list.md

@@ -416,73 +416,133 @@ comments: true
 === "Python"
 
     ```python title="linked_list.py"
-    [class]{}-[func]{insert}
+    def insert(n0: ListNode, P: ListNode):
+        """在链表的节点 n0 之后插入节点 P"""
+        n1 = n0.next
+        P.next = n1
+        n0.next = P
     ```
 
 === "C++"
 
     ```cpp title="linked_list.cpp"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    void insert(ListNode *n0, ListNode *P) {
+        ListNode *n1 = n0->next;
+        P->next = n1;
+        n0->next = P;
+    }
     ```
 
 === "Java"
 
     ```java title="linked_list.java"
-    [class]{linked_list}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    void insert(ListNode n0, ListNode P) {
+        ListNode n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
     ```
 
 === "C#"
 
     ```csharp title="linked_list.cs"
-    [class]{linked_list}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    void insert(ListNode n0, ListNode P) {
+        ListNode? n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
     ```
 
 === "Go"
 
     ```go title="linked_list.go"
-    [class]{}-[func]{insertNode}
+    /* 在链表的节点 n0 之后插入节点 P */
+    func insertNode(n0 *ListNode, P *ListNode) {
+        n1 := n0.Next
+        P.Next = n1
+        n0.Next = P
+    }
     ```
 
 === "Swift"
 
     ```swift title="linked_list.swift"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    func insert(n0: ListNode, P: ListNode) {
+        let n1 = n0.next
+        P.next = n1
+        n0.next = P
+    }
     ```
 
 === "JS"
 
     ```javascript title="linked_list.js"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    function insert(n0, P) {
+        const n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
     ```
 
 === "TS"
 
     ```typescript title="linked_list.ts"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    function insert(n0: ListNode, P: ListNode): void {
+        const n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
     ```
 
 === "Dart"
 
     ```dart title="linked_list.dart"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    void insert(ListNode n0, ListNode P) {
+      ListNode? n1 = n0.next;
+      P.next = n1;
+      n0.next = P;
+    }
     ```
 
 === "Rust"
 
     ```rust title="linked_list.rs"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    #[allow(non_snake_case)]
+    pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
+        let n1 =  n0.borrow_mut().next.take();
+        P.borrow_mut().next = n1;
+        n0.borrow_mut().next = Some(P);
+    }
     ```
 
 === "C"
 
     ```c title="linked_list.c"
-    [class]{}-[func]{insert}
+    /* 在链表的节点 n0 之后插入节点 P */
+    void insert(ListNode *n0, ListNode *P) {
+        ListNode *n1 = n0->next;
+        P->next = n1;
+        n0->next = P;
+    }
     ```
 
 === "Zig"
 
     ```zig title="linked_list.zig"
-    [class]{}-[func]{insert}
+    // 在链表的节点 n0 之后插入节点 P
+    fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
+        var n1 = n0.?.next;
+        P.?.next = n1;
+        n0.?.next = P;
+    }
     ```
 
 ### 3. &nbsp; 删除节点
@@ -498,73 +558,176 @@ comments: true
 === "Python"
 
     ```python title="linked_list.py"
-    [class]{}-[func]{remove}
+    def remove(n0: ListNode):
+        """删除链表的节点 n0 之后的首个节点"""
+        if not n0.next:
+            return
+        # n0 -> P -> n1
+        P = n0.next
+        n1 = P.next
+        n0.next = n1
     ```
 
 === "C++"
 
     ```cpp title="linked_list.cpp"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    void remove(ListNode *n0) {
+        if (n0->next == nullptr)
+            return;
+        // n0 -> P -> n1
+        ListNode *P = n0->next;
+        ListNode *n1 = P->next;
+        n0->next = n1;
+        // 释放内存
+        delete P;
+    }
     ```
 
 === "Java"
 
     ```java title="linked_list.java"
-    [class]{linked_list}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    void remove(ListNode n0) {
+        if (n0.next == null)
+            return;
+        // n0 -> P -> n1
+        ListNode P = n0.next;
+        ListNode n1 = P.next;
+        n0.next = n1;
+    }
     ```
 
 === "C#"
 
     ```csharp title="linked_list.cs"
-    [class]{linked_list}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    void remove(ListNode n0) {
+        if (n0.next == null)
+            return;
+        // n0 -> P -> n1
+        ListNode P = n0.next;
+        ListNode? n1 = P.next;
+        n0.next = n1;
+    }
     ```
 
 === "Go"
 
     ```go title="linked_list.go"
-    [class]{}-[func]{removeNode}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    func removeNode(n0 *ListNode) {
+        if n0.Next == nil {
+            return
+        }
+        // n0 -> P -> n1
+        P := n0.Next
+        n1 := P.Next
+        n0.Next = n1
+    }
     ```
 
 === "Swift"
 
     ```swift title="linked_list.swift"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    func remove(n0: ListNode) {
+        if n0.next == nil {
+            return
+        }
+        // n0 -> P -> n1
+        let P = n0.next
+        let n1 = P?.next
+        n0.next = n1
+        P?.next = nil
+    }
     ```
 
 === "JS"
 
     ```javascript title="linked_list.js"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    function remove(n0) {
+        if (!n0.next) return;
+        // n0 -> P -> n1
+        const P = n0.next;
+        const n1 = P.next;
+        n0.next = n1;
+    }
     ```
 
 === "TS"
 
     ```typescript title="linked_list.ts"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    function remove(n0: ListNode): void {
+        if (!n0.next) {
+            return;
+        }
+        // n0 -> P -> n1
+        const P = n0.next;
+        const n1 = P.next;
+        n0.next = n1;
+    }
     ```
 
 === "Dart"
 
     ```dart title="linked_list.dart"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    void remove(ListNode n0) {
+      if (n0.next == null) return;
+      // n0 -> P -> n1
+      ListNode P = n0.next!;
+      ListNode? n1 = P.next;
+      n0.next = n1;
+    }
     ```
 
 === "Rust"
 
     ```rust title="linked_list.rs"
-    [class]{}-[func]{remove}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    #[allow(non_snake_case)]
+    pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
+        if n0.borrow().next.is_none() {return};
+        // n0 -> P -> n1
+        let P = n0.borrow_mut().next.take();
+        if let Some(node) = P {
+            let n1 = node.borrow_mut().next.take();
+            n0.borrow_mut().next = n1;
+        }
+    }
     ```
 
 === "C"
 
     ```c title="linked_list.c"
-    [class]{}-[func]{removeNode}
+    /* 删除链表的节点 n0 之后的首个节点 */
+    // 注意：stdio.h 占用了 remove 关键词
+    void removeNode(ListNode *n0) {
+        if (!n0->next)
+            return;
+        // n0 -> P -> n1
+        ListNode *P = n0->next;
+        ListNode *n1 = P->next;
+        n0->next = n1;
+        // 释放内存
+        free(P);
+    }
     ```
 
 === "Zig"
 
     ```zig title="linked_list.zig"
-    [class]{}-[func]{remove}
+    // 删除链表的节点 n0 之后的首个节点
+    fn remove(n0: ?*inc.ListNode(i32)) void {
+        if (n0.?.next == null) return;
+        // n0 -> P -> n1
+        var P = n0.?.next;
+        var n1 = P.?.next;
+        n0.?.next = n1;
+    }
     ```
 
 ### 4. &nbsp; 访问节点
@@ -574,73 +737,170 @@ comments: true
 === "Python"
 
     ```python title="linked_list.py"
-    [class]{}-[func]{access}
+    def access(head: ListNode, index: int) -> ListNode | None:
+        """访问链表中索引为 index 的节点"""
+        for _ in range(index):
+            if not head:
+                return None
+            head = head.next
+        return head
     ```
 
 === "C++"
 
     ```cpp title="linked_list.cpp"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    ListNode *access(ListNode *head, int index) {
+        for (int i = 0; i < index; i++) {
+            if (head == nullptr)
+                return nullptr;
+            head = head->next;
+        }
+        return head;
+    }
     ```
 
 === "Java"
 
     ```java title="linked_list.java"
-    [class]{linked_list}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    ListNode access(ListNode head, int index) {
+        for (int i = 0; i < index; i++) {
+            if (head == null)
+                return null;
+            head = head.next;
+        }
+        return head;
+    }
     ```
 
 === "C#"
 
     ```csharp title="linked_list.cs"
-    [class]{linked_list}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    ListNode? access(ListNode head, int index) {
+        for (int i = 0; i < index; i++) {
+            if (head == null)
+                return null;
+            head = head.next;
+        }
+        return head;
+    }
     ```
 
 === "Go"
 
     ```go title="linked_list.go"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    func access(head *ListNode, index int) *ListNode {
+        for i := 0; i < index; i++ {
+            if head == nil {
+                return nil
+            }
+            head = head.Next
+        }
+        return head
+    }
     ```
 
 === "Swift"
 
     ```swift title="linked_list.swift"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    func access(head: ListNode, index: Int) -> ListNode? {
+        var head: ListNode? = head
+        for _ in 0 ..< index {
+            if head == nil {
+                return nil
+            }
+            head = head?.next
+        }
+        return head
+    }
     ```
 
 === "JS"
 
     ```javascript title="linked_list.js"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    function access(head, index) {
+        for (let i = 0; i < index; i++) {
+            if (!head) {
+                return null;
+            }
+            head = head.next;
+        }
+        return head;
+    }
     ```
 
 === "TS"
 
     ```typescript title="linked_list.ts"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    function access(head: ListNode | null, index: number): ListNode | null {
+        for (let i = 0; i < index; i++) {
+            if (!head) {
+                return null;
+            }
+            head = head.next;
+        }
+        return head;
+    }
     ```
 
 === "Dart"
 
     ```dart title="linked_list.dart"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    ListNode? access(ListNode? head, int index) {
+      for (var i = 0; i < index; i++) {
+        if (head == null) return null;
+        head = head.next;
+      }
+      return head;
+    }
     ```
 
 === "Rust"
 
     ```rust title="linked_list.rs"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
+        if index <= 0 {return head};
+        if let Some(node) = &head.borrow_mut().next {
+            return access(node.clone(), index - 1);
+        }
+        return head;
+    }
     ```
 
 === "C"
 
     ```c title="linked_list.c"
-    [class]{}-[func]{access}
+    /* 访问链表中索引为 index 的节点 */
+    ListNode *access(ListNode *head, int index) {
+        while (head && head->next && index) {
+            head = head->next;
+            index--;
+        }
+        return head;
+    }
     ```
 
 === "Zig"
 
     ```zig title="linked_list.zig"
-    [class]{}-[func]{access}
+    // 访问链表中索引为 index 的节点
+    fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
+        var head = node;
+        var i: i32 = 0;
+        while (i < index) : (i += 1) {
+            head = head.?.next;
+            if (head == null) return null;
+        }
+        return head;
+    }
     ```
 
 ### 5. &nbsp; 查找节点
@@ -650,73 +910,194 @@ comments: true
 === "Python"
 
     ```python title="linked_list.py"
-    [class]{}-[func]{find}
+    def find(head: ListNode, target: int) -> int:
+        """在链表中查找值为 target 的首个节点"""
+        index = 0
+        while head:
+            if head.val == target:
+                return index
+            head = head.next
+            index += 1
+        return -1
     ```
 
 === "C++"
 
     ```cpp title="linked_list.cpp"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    int find(ListNode *head, int target) {
+        int index = 0;
+        while (head != nullptr) {
+            if (head->val == target)
+                return index;
+            head = head->next;
+            index++;
+        }
+        return -1;
+    }
     ```
 
 === "Java"
 
     ```java title="linked_list.java"
-    [class]{linked_list}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    int find(ListNode head, int target) {
+        int index = 0;
+        while (head != null) {
+            if (head.val == target)
+                return index;
+            head = head.next;
+            index++;
+        }
+        return -1;
+    }
     ```
 
 === "C#"
 
     ```csharp title="linked_list.cs"
-    [class]{linked_list}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    int find(ListNode head, int target) {
+        int index = 0;
+        while (head != null) {
+            if (head.val == target)
+                return index;
+            head = head.next;
+            index++;
+        }
+        return -1;
+    }
     ```
 
 === "Go"
 
     ```go title="linked_list.go"
-    [class]{}-[func]{findNode}
+    /* 在链表中查找值为 target 的首个节点 */
+    func findNode(head *ListNode, target int) int {
+        index := 0
+        for head != nil {
+            if head.Val == target {
+                return index
+            }
+            head = head.Next
+            index++
+        }
+        return -1
+    }
     ```
 
 === "Swift"
 
     ```swift title="linked_list.swift"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    func find(head: ListNode, target: Int) -> Int {
+        var head: ListNode? = head
+        var index = 0
+        while head != nil {
+            if head?.val == target {
+                return index
+            }
+            head = head?.next
+            index += 1
+        }
+        return -1
+    }
     ```
 
 === "JS"
 
     ```javascript title="linked_list.js"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    function find(head, target) {
+        let index = 0;
+        while (head !== null) {
+            if (head.val === target) {
+                return index;
+            }
+            head = head.next;
+            index += 1;
+        }
+        return -1;
+    }
     ```
 
 === "TS"
 
     ```typescript title="linked_list.ts"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    function find(head: ListNode | null, target: number): number {
+        let index = 0;
+        while (head !== null) {
+            if (head.val === target) {
+                return index;
+            }
+            head = head.next;
+            index += 1;
+        }
+        return -1;
+    }
     ```
 
 === "Dart"
 
     ```dart title="linked_list.dart"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    int find(ListNode? head, int target) {
+      int index = 0;
+      while (head != null) {
+        if (head.val == target) {
+          return index;
+        }
+        head = head.next;
+        index++;
+      }
+      return -1;
+    }
     ```
 
 === "Rust"
 
     ```rust title="linked_list.rs"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
+        if head.borrow().val == target {return index};
+        if let Some(node) = &head.borrow_mut().next {
+            return find(node.clone(), target, index + 1);
+        }
+        return -1;
+    }
     ```
 
 === "C"
 
     ```c title="linked_list.c"
-    [class]{}-[func]{find}
+    /* 在链表中查找值为 target 的首个节点 */
+    int find(ListNode *head, int target) {
+        int index = 0;
+        while (head) {
+            if (head->val == target)
+                return index;
+            head = head->next;
+            index++;
+        }
+        return -1;
+    }
     ```
 
 === "Zig"
 
     ```zig title="linked_list.zig"
-    [class]{}-[func]{find}
+    // 在链表中查找值为 target 的首个节点
+    fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
+        var head = node;
+        var index: i32 = 0;
+        while (head != null) {
+            if (head.?.val == target) return index;
+            head = head.?.next;
+            index += 1;
+        }
+        return -1;
+    }
     ```
 
 ## 4.2.2 &nbsp; 数组 VS 链表

zh/chapter_backtracking/n_queens_problem.md

@@ -55,81 +55,547 @@ comments: true
 === "Python"
 
     ```python title="n_queens.py"
-    [class]{}-[func]{backtrack}
+    def backtrack(
+        row: int,
+        n: int,
+        state: list[list[str]],
+        res: list[list[list[str]]],
+        cols: list[bool],
+        diags1: list[bool],
+        diags2: list[bool],
+    ):
+        """回溯算法：N 皇后"""
+        # 当放置完所有行时，记录解
+        if row == n:
+            res.append([list(row) for row in state])
+            return
+        # 遍历所有列
+        for col in range(n):
+            # 计算该格子对应的主对角线和副对角线
+            diag1 = row - col + n - 1
+            diag2 = row + col
+            # 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if not cols[col] and not diags1[diag1] and not diags2[diag2]:
+                # 尝试：将皇后放置在该格子
+                state[row][col] = "Q"
+                cols[col] = diags1[diag1] = diags2[diag2] = True
+                # 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2)
+                # 回退：将该格子恢复为空位
+                state[row][col] = "#"
+                cols[col] = diags1[diag1] = diags2[diag2] = False
 
-    [class]{}-[func]{n_queens}
+    def n_queens(n: int) -> list[list[list[str]]]:
+        """求解 N 皇后"""
+        # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        state = [["#" for _ in range(n)] for _ in range(n)]
+        cols = [False] * n  # 记录列是否有皇后
+        diags1 = [False] * (2 * n - 1)  # 记录主对角线是否有皇后
+        diags2 = [False] * (2 * n - 1)  # 记录副对角线是否有皇后
+        res = []
+        backtrack(0, n, state, res, cols, diags1, diags2)
+
+        return res
     ```
 
 === "C++"
 
     ```cpp title="n_queens.cpp"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
+                   vector<bool> &diags1, vector<bool> &diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q";
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#";
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
 
-    [class]{}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    vector<vector<vector<string>>> nQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        vector<vector<string>> state(n, vector<string>(n, "#"));
+        vector<bool> cols(n, false);           // 记录列是否有皇后
+        vector<bool> diags1(2 * n - 1, false); // 记录主对角线是否有皇后
+        vector<bool> diags2(2 * n - 1, false); // 记录副对角线是否有皇后
+        vector<vector<vector<string>>> res;
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="n_queens.java"
-    [class]{n_queens}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
+            boolean[] cols, boolean[] diags1, boolean[] diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            List<List<String>> copyState = new ArrayList<>();
+            for (List<String> sRow : state) {
+                copyState.add(new ArrayList<>(sRow));
+            }
+            res.add(copyState);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state.get(row).set(col, "Q");
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state.get(row).set(col, "#");
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
 
-    [class]{n_queens}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    List<List<List<String>>> nQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        List<List<String>> state = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<String> row = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                row.add("#");
+            }
+            state.add(row);
+        }
+        boolean[] cols = new boolean[n]; // 记录列是否有皇后
+        boolean[] diags1 = new boolean[2 * n - 1]; // 记录主对角线是否有皇后
+        boolean[] diags2 = new boolean[2 * n - 1]; // 记录副对角线是否有皇后
+        List<List<List<String>>> res = new ArrayList<>();
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="n_queens.cs"
-    [class]{n_queens}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    void backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
+            bool[] cols, bool[] diags1, bool[] diags2) {
+        // 当放置完所有行时，记录解
+        if (row == n) {
+            List<List<string>> copyState = new List<List<string>>();
+            foreach (List<string> sRow in state) {
+                copyState.Add(new List<string>(sRow));
+            }
+            res.Add(copyState);
+            return;
+        }
+        // 遍历所有列
+        for (int col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q";
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#";
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
 
-    [class]{n_queens}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    List<List<List<string>>> nQueens(int n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        List<List<string>> state = new List<List<string>>();
+        for (int i = 0; i < n; i++) {
+            List<string> row = new List<string>();
+            for (int j = 0; j < n; j++) {
+                row.Add("#");
+            }
+            state.Add(row);
+        }
+        bool[] cols = new bool[n]; // 记录列是否有皇后
+        bool[] diags1 = new bool[2 * n - 1]; // 记录主对角线是否有皇后
+        bool[] diags2 = new bool[2 * n - 1]; // 记录副对角线是否有皇后
+        List<List<List<string>>> res = new List<List<List<string>>>();
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="n_queens.go"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            newState := make([][]string, len(*state))
+            for i, _ := range newState {
+                newState[i] = make([]string, len((*state)[0]))
+                copy(newState[i], (*state)[i])
 
-    [class]{}-[func]{nQueens}
+            }
+            *res = append(*res, newState)
+        }
+        // 遍历所有列
+        for col := 0; col < n; col++ {
+            // 计算该格子对应的主对角线和副对角线
+            diag1 := row - col + n - 1
+            diag2 := row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+                // 尝试：将皇后放置在该格子
+                (*state)[row][col] = "Q"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+                // 放置下一行
+                backtrack(row+1, n, state, res, cols, diags1, diags2)
+                // 回退：将该格子恢复为空位
+                (*state)[row][col] = "#"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+            }
+        }
+    }
+
+    /* 回溯算法：N 皇后 */
+    func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            newState := make([][]string, len(*state))
+            for i, _ := range newState {
+                newState[i] = make([]string, len((*state)[0]))
+                copy(newState[i], (*state)[i])
+
+            }
+            *res = append(*res, newState)
+        }
+        // 遍历所有列
+        for col := 0; col < n; col++ {
+            // 计算该格子对应的主对角线和副对角线
+            diag1 := row - col + n - 1
+            diag2 := row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+                // 尝试：将皇后放置在该格子
+                (*state)[row][col] = "Q"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+                // 放置下一行
+                backtrack(row+1, n, state, res, cols, diags1, diags2)
+                // 回退：将该格子恢复为空位
+                (*state)[row][col] = "#"
+                (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+            }
+        }
+    }
+
+    func nQueens(n int) [][][]string {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        state := make([][]string, n)
+        for i := 0; i < n; i++ {
+            row := make([]string, n)
+            for i := 0; i < n; i++ {
+                row[i] = "#"
+            }
+            state[i] = row
+        }
+        // 记录列是否有皇后
+        cols := make([]bool, n)
+        diags1 := make([]bool, 2*n-1)
+        diags2 := make([]bool, 2*n-1)
+        res := make([][][]string, 0)
+        backtrack(0, n, &state, &res, &cols, &diags1, &diags2)
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="n_queens.swift"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            res.append(state)
+            return
+        }
+        // 遍历所有列
+        for col in 0 ..< n {
+            // 计算该格子对应的主对角线和副对角线
+            let diag1 = row - col + n - 1
+            let diag2 = row + col
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = "Q"
+                cols[col] = true
+                diags1[diag1] = true
+                diags2[diag2] = true
+                // 放置下一行
+                backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+                // 回退：将该格子恢复为空位
+                state[row][col] = "#"
+                cols[col] = false
+                diags1[diag1] = false
+                diags2[diag2] = false
+            }
+        }
+    }
 
-    [class]{}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    func nQueens(n: Int) -> [[[String]]] {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        var state = Array(repeating: Array(repeating: "#", count: n), count: n)
+        var cols = Array(repeating: false, count: n) // 记录列是否有皇后
+        var diags1 = Array(repeating: false, count: 2 * n - 1) // 记录主对角线是否有皇后
+        var diags2 = Array(repeating: false, count: 2 * n - 1) // 记录副对角线是否有皇后
+        var res: [[[String]]] = []
+
+        backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="n_queens.js"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    function backtrack(row, n, state, res, cols, diags1, diags2) {
+        // 当放置完所有行时，记录解
+        if (row === n) {
+            res.push(state.map((row) => row.slice()));
+            return;
+        }
+        // 遍历所有列
+        for (let col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            const diag1 = row - col + n - 1;
+            const diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = 'Q';
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = '#';
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
 
-    [class]{}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    function nQueens(n) {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        const state = Array.from({ length: n }, () => Array(n).fill('#'));
+        const cols = Array(n).fill(false); // 记录列是否有皇后
+        const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线是否有皇后
+        const diags2 = Array(2 * n - 1).fill(false); // 记录副对角线是否有皇后
+        const res = [];
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="n_queens.ts"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    function backtrack(
+        row: number,
+        n: number,
+        state: string[][],
+        res: string[][][],
+        cols: boolean[],
+        diags1: boolean[],
+        diags2: boolean[]
+    ): void {
+        // 当放置完所有行时，记录解
+        if (row === n) {
+            res.push(state.map((row) => row.slice()));
+            return;
+        }
+        // 遍历所有列
+        for (let col = 0; col < n; col++) {
+            // 计算该格子对应的主对角线和副对角线
+            const diag1 = row - col + n - 1;
+            const diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // 尝试：将皇后放置在该格子
+                state[row][col] = 'Q';
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state[row][col] = '#';
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
 
-    [class]{}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    function nQueens(n: number): string[][][] {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        const state = Array.from({ length: n }, () => Array(n).fill('#'));
+        const cols = Array(n).fill(false); // 记录列是否有皇后
+        const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线是否有皇后
+        const diags2 = Array(2 * n - 1).fill(false); // 记录副对角线是否有皇后
+        const res: string[][][] = [];
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="n_queens.dart"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    void backtrack(
+      int row,
+      int n,
+      List<List<String>> state,
+      List<List<List<String>>> res,
+      List<bool> cols,
+      List<bool> diags1,
+      List<bool> diags2,
+    ) {
+      // 当放置完所有行时，记录解
+      if (row == n) {
+        List<List<String>> copyState = [];
+        for (List<String> sRow in state) {
+          copyState.add(List.from(sRow));
+        }
+        res.add(copyState);
+        return;
+      }
+      // 遍历所有列
+      for (int col = 0; col < n; col++) {
+        // 计算该格子对应的主对角线和副对角线
+        int diag1 = row - col + n - 1;
+        int diag2 = row + col;
+        // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+        if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+          // 尝试：将皇后放置在该格子
+          state[row][col] = "Q";
+          cols[col] = true;
+          diags1[diag1] = true;
+          diags2[diag2] = true;
+          // 放置下一行
+          backtrack(row + 1, n, state, res, cols, diags1, diags2);
+          // 回退：将该格子恢复为空位
+          state[row][col] = "#";
+          cols[col] = false;
+          diags1[diag1] = false;
+          diags2[diag2] = false;
+        }
+      }
+    }
 
-    [class]{}-[func]{nQueens}
+    /* 求解 N 皇后 */
+    List<List<List<String>>> nQueens(int n) {
+      // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+      List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
+      List<bool> cols = List.filled(n, false); // 记录列是否有皇后
+      List<bool> diags1 = List.filled(2 * n - 1, false); // 记录主对角线是否有皇后
+      List<bool> diags2 = List.filled(2 * n - 1, false); // 记录副对角线是否有皇后
+      List<List<List<String>>> res = [];
+
+      backtrack(0, n, state, res, cols, diags1, diags2);
+
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="n_queens.rs"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：N 皇后 */
+    fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<Vec<Vec<String>>>,
+        cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool]) {
+        // 当放置完所有行时，记录解
+        if row == n {
+            let mut copy_state: Vec<Vec<String>> = Vec::new();
+            for s_row in state.clone() {
+                copy_state.push(s_row);
+            }
+            res.push(copy_state);
+            return;
+        }
+        // 遍历所有列
+        for col in 0..n {
+            // 计算该格子对应的主对角线和副对角线
+            let diag1 = row + n - 1 - col;
+            let diag2 = row + col;
+            // 剪枝：不允许该格子所在列、主对角线、副对角线存在皇后
+            if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+                // 尝试：将皇后放置在该格子
+                state.get_mut(row).unwrap()[col] = "Q".into();
+                (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);
+                // 放置下一行
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // 回退：将该格子恢复为空位
+                state.get_mut(row).unwrap()[col] = "#".into();
+                (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);
+            }
+        }
+    }
 
-    [class]{}-[func]{n_queens}
+    /* 求解 N 皇后 */
+    fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
+        // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+        let mut state: Vec<Vec<String>> = Vec::new();
+        for _ in 0..n {
+            let mut row: Vec<String> = Vec::new();
+            for _ in 0..n {
+                row.push("#".into());
+            }
+            state.push(row);
+        }
+        let mut cols = vec![false; n]; // 记录列是否有皇后
+        let mut diags1 = vec![false; 2 * n - 1]; // 记录主对角线是否有皇后
+        let mut diags2 = vec![false; 2 * n - 1]; // 记录副对角线是否有皇后
+        let mut res: Vec<Vec<Vec<String>>> = Vec::new();
+
+        backtrack(0, n, &mut state, &mut res, &mut cols, &mut diags1, &mut diags2);
+
+        res
+    }
     ```
 
 === "C"

zh/chapter_backtracking/permutations_problem.md

@@ -58,89 +58,411 @@ comments: true
 === "Python"
 
     ```python title="permutations_i.py"
-    [class]{}-[func]{backtrack}
+    def backtrack(
+        state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+    ):
+        """回溯算法：全排列 I"""
+        # 当状态长度等于元素数量时，记录解
+        if len(state) == len(choices):
+            res.append(list(state))
+            return
+        # 遍历所有选择
+        for i, choice in enumerate(choices):
+            # 剪枝：不允许重复选择元素
+            if not selected[i]:
+                # 尝试：做出选择，更新状态
+                selected[i] = True
+                state.append(choice)
+                # 进行下一轮选择
+                backtrack(state, choices, selected, res)
+                # 回退：撤销选择，恢复到之前的状态
+                selected[i] = False
+                state.pop()
 
-    [class]{}-[func]{permutations_i}
+    def permutations_i(nums: list[int]) -> list[list[int]]:
+        """全排列 I"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
     ```
 
 === "C++"
 
     ```cpp title="permutations_i.cpp"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.size()) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.size(); i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push_back(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop_back();
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    vector<vector<int>> permutationsI(vector<int> nums) {
+        vector<int> state;
+        vector<bool> selected(nums.size(), false);
+        vector<vector<int>> res;
+        backtrack(state, nums, selected, res);
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="permutations_i.java"
-    [class]{permutations_i}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
 
-    [class]{permutations_i}-[func]{permutationsI}
+    /* 全排列 I */
+    List<List<Integer>> permutationsI(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="permutations_i.cs"
-    [class]{permutations_i}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    void backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.Add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
 
-    [class]{permutations_i}-[func]{permutationsI}
+    /* 全排列 I */
+    List<List<int>> permutationsI(int[] nums) {
+        List<List<int>> res = new List<List<int>>();
+        backtrack(new List<int>(), nums, new bool[nums.Length], res);
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="permutations_i.go"
-    [class]{}-[func]{backtrackI}
+    /* 回溯算法：全排列 I */
+    func backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+        // 当状态长度等于元素数量时，记录解
+        if len(*state) == len(*choices) {
+            newState := append([]int{}, *state...)
+            *res = append(*res, newState)
+        }
+        // 遍历所有选择
+        for i := 0; i < len(*choices); i++ {
+            choice := (*choices)[i]
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !(*selected)[i] {
+                // 尝试：做出选择，更新状态
+                (*selected)[i] = true
+                *state = append(*state, choice)
+                // 进行下一轮选择
+                backtrackI(state, choices, selected, res)
+                // 回退：撤销选择，恢复到之前的状态
+                (*selected)[i] = false
+                *state = (*state)[:len(*state)-1]
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    func permutationsI(nums []int) [][]int {
+        res := make([][]int, 0)
+        state := make([]int, 0)
+        selected := make([]bool, len(nums))
+        backtrackI(&state, &nums, &selected, &res)
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="permutations_i.swift"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+        // 当状态长度等于元素数量时，记录解
+        if state.count == choices.count {
+            res.append(state)
+            return
+        }
+        // 遍历所有选择
+        for (i, choice) in choices.enumerated() {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] {
+                // 尝试：做出选择，更新状态
+                selected[i] = true
+                state.append(choice)
+                // 进行下一轮选择
+                backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false
+                state.removeLast()
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    func permutationsI(nums: [Int]) -> [[Int]] {
+        var state: [Int] = []
+        var selected = Array(repeating: false, count: nums.count)
+        var res: [[Int]] = []
+        backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="permutations_i.js"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    function backtrack(state, choices, selected, res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    function permutationsI(nums) {
+        const res = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="permutations_i.ts"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    function backtrack(
+        state: number[],
+        choices: number[],
+        selected: boolean[],
+        res: number[][]
+    ): void {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i]) {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    function permutationsI(nums: number[]): number[][] {
+        const res: number[][] = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="permutations_i.dart"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    void backtrack(
+      List<int> state,
+      List<int> choices,
+      List<bool> selected,
+      List<List<int>> res,
+    ) {
+      // 当状态长度等于元素数量时，记录解
+      if (state.length == choices.length) {
+        res.add(List.from(state));
+        return;
+      }
+      // 遍历所有选择
+      for (int i = 0; i < choices.length; i++) {
+        int choice = choices[i];
+        // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+        if (!selected[i]) {
+          // 尝试：做出选择，更新状态
+          selected[i] = true;
+          state.add(choice);
+          // 进行下一轮选择
+          backtrack(state, choices, selected, res);
+          // 回退：撤销选择，恢复到之前的状态
+          selected[i] = false;
+          state.removeLast();
+        }
+      }
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    List<List<int>> permutationsI(List<int> nums) {
+      List<List<int>> res = [];
+      backtrack([], nums, List.filled(nums.length, false), res);
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="permutations_i.rs"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    fn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {
+        // 当状态长度等于元素数量时，记录解
+        if state.len() == choices.len() {
+            res.push(state);
+            return;
+        }
+        // 遍历所有选择
+        for i in 0..choices.len() {
+            let choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] {
+                // 尝试：做出选择，更新状态
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state.clone(), choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.len() - 1);
+            }
+        }
+    }
 
-    [class]{}-[func]{permutations_i}
+    /* 全排列 I */
+    fn permutations_i(nums: &mut [i32]) -> Vec<Vec<i32>> {
+        let mut res = Vec::new(); // 状态（子集）
+        backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+        res
+    }
     ```
 
 === "C"
 
     ```c title="permutations_i.c"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 I */
+    void backtrack(vector *state, vector *choices, vector *selected, vector *res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state->size == choices->size) {
+            vector *newState = newVector();
+            for (int i = 0; i < state->size; i++) {
+                vectorPushback(newState, state->data[i], sizeof(int));
+            }
+            vectorPushback(res, newState, sizeof(vector));
+            return;
+        }
+        // 遍历所有选择
+        for (int i = 0; i < choices->size; i++) {
+            int *choice = malloc(sizeof(int));
+            *choice = *((int *)(choices->data[i]));
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            bool select = *((bool *)(selected->data[i]));
+            if (!select) {
+                // 尝试：做出选择，更新状态
+                *((bool *)selected->data[i]) = true;
+                vectorPushback(state, choice, sizeof(int));
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                *((bool *)selected->data[i]) = false;
+                vectorPopback(state);
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsI}
+    /* 全排列 I */
+    vector *permutationsI(vector *nums) {
+        vector *iState = newVector();
+
+        int select[3] = {false, false, false};
+        vector *bSelected = newVector();
+        for (int i = 0; i < nums->size; i++) {
+            vectorPushback(bSelected, &select[i], sizeof(int));
+        }
+
+        vector *res = newVector();
+
+        // 前序遍历
+        backtrack(iState, nums, bSelected, res);
+        return res;
+    }
     ```
 
 === "Zig"
@@ -186,81 +508,381 @@ comments: true
 === "Python"
 
     ```python title="permutations_ii.py"
-    [class]{}-[func]{backtrack}
+    def backtrack(
+        state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+    ):
+        """回溯算法：全排列 II"""
+        # 当状态长度等于元素数量时，记录解
+        if len(state) == len(choices):
+            res.append(list(state))
+            return
+        # 遍历所有选择
+        duplicated = set[int]()
+        for i, choice in enumerate(choices):
+            # 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if not selected[i] and choice not in duplicated:
+                # 尝试：做出选择，更新状态
+                duplicated.add(choice)  # 记录选择过的元素值
+                selected[i] = True
+                state.append(choice)
+                # 进行下一轮选择
+                backtrack(state, choices, selected, res)
+                # 回退：撤销选择，恢复到之前的状态
+                selected[i] = False
+                state.pop()
 
-    [class]{}-[func]{permutations_ii}
+    def permutations_ii(nums: list[int]) -> list[list[int]]:
+        """全排列 II"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
     ```
 
 === "C++"
 
     ```cpp title="permutations_ii.cpp"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.size()) {
+            res.push_back(state);
+            return;
+        }
+        // 遍历所有选择
+        unordered_set<int> duplicated;
+        for (int i = 0; i < choices.size(); i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
+                // 尝试：做出选择，更新状态
+                duplicated.emplace(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push_back(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop_back();
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    vector<vector<int>> permutationsII(vector<int> nums) {
+        vector<int> state;
+        vector<bool> selected(nums.size(), false);
+        vector<vector<int>> res;
+        backtrack(state, nums, selected, res);
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="permutations_ii.java"
-    [class]{permutations_ii}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // 遍历所有选择
+        Set<Integer> duplicated = new HashSet<Integer>();
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.contains(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
 
-    [class]{permutations_ii}-[func]{permutationsII}
+    /* 全排列 II */
+    List<List<Integer>> permutationsII(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="permutations_ii.cs"
-    [class]{permutations_ii}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    void backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // 遍历所有选择
+        ISet<int> duplicated = new HashSet<int>();
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.Contains(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.Add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.Add(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
 
-    [class]{permutations_ii}-[func]{permutationsII}
+    /* 全排列 II */
+    List<List<int>> permutationsII(int[] nums) {
+        List<List<int>> res = new List<List<int>>();
+        backtrack(new List<int>(), nums, new bool[nums.Length], res);
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="permutations_ii.go"
-    [class]{}-[func]{backtrackII}
+    /* 回溯算法：全排列 II */
+    func backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+        // 当状态长度等于元素数量时，记录解
+        if len(*state) == len(*choices) {
+            newState := append([]int{}, *state...)
+            *res = append(*res, newState)
+        }
+        // 遍历所有选择
+        duplicated := make(map[int]struct{}, 0)
+        for i := 0; i < len(*choices); i++ {
+            choice := (*choices)[i]
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if _, ok := duplicated[choice]; !ok && !(*selected)[i] {
+                // 尝试：做出选择，更新状态
+                // 记录选择过的元素值
+                duplicated[choice] = struct{}{}
+                (*selected)[i] = true
+                *state = append(*state, choice)
+                // 进行下一轮选择
+                backtrackI(state, choices, selected, res)
+                // 回退：撤销选择，恢复到之前的状态
+                (*selected)[i] = false
+                *state = (*state)[:len(*state)-1]
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    func permutationsII(nums []int) [][]int {
+        res := make([][]int, 0)
+        state := make([]int, 0)
+        selected := make([]bool, len(nums))
+        backtrackII(&state, &nums, &selected, &res)
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="permutations_ii.swift"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+        // 当状态长度等于元素数量时，记录解
+        if state.count == choices.count {
+            res.append(state)
+            return
+        }
+        // 遍历所有选择
+        var duplicated: Set<Int> = []
+        for (i, choice) in choices.enumerated() {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i], !duplicated.contains(choice) {
+                // 尝试：做出选择，更新状态
+                duplicated.insert(choice) // 记录选择过的元素值
+                selected[i] = true
+                state.append(choice)
+                // 进行下一轮选择
+                backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false
+                state.removeLast()
+            }
+        }
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    func permutationsII(nums: [Int]) -> [[Int]] {
+        var state: [Int] = []
+        var selected = Array(repeating: false, count: nums.count)
+        var res: [[Int]] = []
+        backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="permutations_ii.js"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    function backtrack(state, choices, selected, res) {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        const duplicated = new Set();
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.has(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    function permutationsII(nums) {
+        const res = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="permutations_ii.ts"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    function backtrack(
+        state: number[],
+        choices: number[],
+        selected: boolean[],
+        res: number[][]
+    ): void {
+        // 当状态长度等于元素数量时，记录解
+        if (state.length === choices.length) {
+            res.push([...state]);
+            return;
+        }
+        // 遍历所有选择
+        const duplicated = new Set();
+        choices.forEach((choice, i) => {
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if (!selected[i] && !duplicated.has(choice)) {
+                // 尝试：做出选择，更新状态
+                duplicated.add(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state, choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.pop();
+            }
+        });
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    function permutationsII(nums: number[]): number[][] {
+        const res: number[][] = [];
+        backtrack([], nums, Array(nums.length).fill(false), res);
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="permutations_ii.dart"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    void backtrack(
+      List<int> state,
+      List<int> choices,
+      List<bool> selected,
+      List<List<int>> res,
+    ) {
+      // 当状态长度等于元素数量时，记录解
+      if (state.length == choices.length) {
+        res.add(List.from(state));
+        return;
+      }
+      // 遍历所有选择
+      Set<int> duplicated = {};
+      for (int i = 0; i < choices.length; i++) {
+        int choice = choices[i];
+        // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+        if (!selected[i] && !duplicated.contains(choice)) {
+          // 尝试：做出选择，更新状态
+          duplicated.add(choice); // 记录选择过的元素值
+          selected[i] = true;
+          state.add(choice);
+          // 进行下一轮选择
+          backtrack(state, choices, selected, res);
+          // 回退：撤销选择，恢复到之前的状态
+          selected[i] = false;
+          state.removeLast();
+        }
+      }
+    }
 
-    [class]{}-[func]{permutationsII}
+    /* 全排列 II */
+    List<List<int>> permutationsII(List<int> nums) {
+      List<List<int>> res = [];
+      backtrack([], nums, List.filled(nums.length, false), res);
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="permutations_ii.rs"
-    [class]{}-[func]{backtrack}
+    /* 回溯算法：全排列 II */
+    fn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {
+        // 当状态长度等于元素数量时，记录解
+        if state.len() == choices.len() {
+            res.push(state);
+            return;
+        }
+        // 遍历所有选择
+        let mut duplicated = HashSet::<i32>::new();
+        for i in 0..choices.len() {
+            let choice = choices[i];
+            // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+            if !selected[i] && !duplicated.contains(&choice) {
+                // 尝试：做出选择，更新状态
+                duplicated.insert(choice); // 记录选择过的元素值
+                selected[i] = true;
+                state.push(choice);
+                // 进行下一轮选择
+                backtrack(state.clone(), choices, selected, res);
+                // 回退：撤销选择，恢复到之前的状态
+                selected[i] = false;
+                state.remove(state.len() - 1);
+            }
+        }
+    }
 
-    [class]{}-[func]{permutations_ii}
+    /* 全排列 II */
+    fn permutations_ii(nums: &mut [i32]) -> Vec<Vec<i32>> {
+        let mut res = Vec::new();
+        backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+        res
+    }
     ```
 
 === "C"

zh/chapter_divide_and_conquer/binary_search_recur.md

@@ -49,81 +49,306 @@ comments: true
 === "Python"
 
     ```python title="binary_search_recur.py"
-    [class]{}-[func]{dfs}
+    def dfs(nums: list[int], target: int, i: int, j: int) -> int:
+        """二分查找：问题 f(i, j)"""
+        # 若区间为空，代表无目标元素，则返回 -1
+        if i > j:
+            return -1
+        # 计算中点索引 m
+        m = (i + j) // 2
+        if nums[m] < target:
+            # 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j)
+        elif nums[m] > target:
+            # 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1)
+        else:
+            # 找到目标元素，返回其索引
+            return m
 
-    [class]{}-[func]{binary_search}
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找"""
+        n = len(nums)
+        # 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1)
     ```
 
 === "C++"
 
     ```cpp title="binary_search_recur.cpp"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    int dfs(vector<int> &nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    int binarySearch(vector<int> &nums, int target) {
+        int n = nums.size();
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search_recur.java"
-    [class]{binary_search_recur}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    int dfs(int[] nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{binary_search_recur}-[func]{binarySearch}
+    /* 二分查找 */
+    int binarySearch(int[] nums, int target) {
+        int n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search_recur.cs"
-    [class]{binary_search_recur}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    int dfs(int[] nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{binary_search_recur}-[func]{binarySearch}
+    /* 二分查找 */
+    int binarySearch(int[] nums, int target) {
+        int n = nums.Length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search_recur.go"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    func dfs(nums []int, target, i, j int) int {
+        // 如果区间为空，代表没有目标元素，则返回 -1
+        if i > j {
+            return -1
+        }
+        //    计算索引中点
+        m := i + ((j - i) >> 1)
+        //判断中点与目标元素大小
+        if nums[m] < target {
+            // 小于则递归右半数组
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m+1, j)
+        } else if nums[m] > target {
+            // 小于则递归左半数组
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m-1)
+        } else {
+            // 找到目标元素，返回其索引
+            return m
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    func binarySearch(nums []int, target int) int {
+        n := len(nums)
+        return dfs(nums, target, 0, n-1)
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search_recur.swift"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    func dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if i > j {
+            return -1
+        }
+        // 计算中点索引 m
+        let m = (i + j) / 2
+        if nums[m] < target {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums: nums, target: target, i: m + 1, j: j)
+        } else if nums[m] > target {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums: nums, target: target, i: i, j: m - 1)
+        } else {
+            // 找到目标元素，返回其索引
+            return m
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    func binarySearch(nums: [Int], target: Int) -> Int {
+        let n = nums.count
+        // 求解问题 f(0, n-1)
+        return dfs(nums: nums, target: target, i: 0, j: n - 1)
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search_recur.js"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    function dfs(nums, target, i, j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        const m = i + ((j - i) >> 1);
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    function binarySearch(nums, target) {
+        const n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search_recur.ts"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    function dfs(nums: number[], target: number, i: number, j: number): number {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        const m = i + ((j - i) >> 1);
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    function binarySearch(nums: number[], target: number): number {
+        const n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search_recur.dart"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    int dfs(List<int> nums, int target, int i, int j) {
+      // 若区间为空，代表无目标元素，则返回 -1
+      if (i > j) {
+        return -1;
+      }
+      // 计算中点索引 m
+      int m = (i + j) ~/ 2;
+      if (nums[m] < target) {
+        // 递归子问题 f(m+1, j)
+        return dfs(nums, target, m + 1, j);
+      } else if (nums[m] > target) {
+        // 递归子问题 f(i, m-1)
+        return dfs(nums, target, i, m - 1);
+      } else {
+        // 找到目标元素，返回其索引
+        return m;
+      }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    int binarySearch(List<int> nums, int target) {
+      int n = nums.length;
+      // 求解问题 f(0, n-1)
+      return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search_recur.rs"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    fn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if i > j { return -1; }
+        let m: i32 = (i + j) / 2;
+        if nums[m as usize] < target {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if nums[m as usize] > target {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
 
-    [class]{}-[func]{binary_search}
+    /* 二分查找 */
+    fn binary_search(nums: &[i32], target: i32) -> i32 {
+        let n = nums.len() as i32;
+        // 求解问题 f(0, n-1)
+        dfs(nums, target, 0, n - 1)
+    }
     ```
 
 === "C"

zh/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -74,81 +74,331 @@ comments: true
 === "Python"
 
     ```python title="build_tree.py"
-    [class]{}-[func]{dfs}
+    def dfs(
+        preorder: list[int],
+        inorder_map: dict[int, int],
+        i: int,
+        l: int,
+        r: int,
+    ) -> TreeNode | None:
+        """构建二叉树：分治"""
+        # 子树区间为空时终止
+        if r - l < 0:
+            return None
+        # 初始化根节点
+        root = TreeNode(preorder[i])
+        # 查询 m ，从而划分左右子树
+        m = inorder_map[preorder[i]]
+        # 子问题：构建左子树
+        root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
+        # 子问题：构建右子树
+        root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
+        # 返回根节点
+        return root
 
-    [class]{}-[func]{build_tree}
+    def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:
+        """构建二叉树"""
+        # 初始化哈希表，存储 inorder 元素到索引的映射
+        inorder_map = {val: i for i, val in enumerate(inorder)}
+        root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)
+        return root
     ```
 
 === "C++"
 
     ```cpp title="build_tree.cpp"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return NULL;
+        // 初始化根节点
+        TreeNode *root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap[preorder[i]];
+        // 子问题：构建左子树
+        root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        unordered_map<int, int> inorderMap;
+        for (int i = 0; i < inorder.size(); i++) {
+            inorderMap[inorder[i]] = i;
+        }
+        TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
+        return root;
+    }
     ```
 
 === "Java"
 
     ```java title="build_tree.java"
-    [class]{build_tree}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
 
-    [class]{build_tree}-[func]{buildTree}
+    /* 构建二叉树 */
+    TreeNode buildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Map<Integer, Integer> inorderMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderMap.put(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
     ```
 
 === "C#"
 
     ```csharp title="build_tree.cs"
-    [class]{build_tree}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    TreeNode dfs(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = inorderMap[preorder[i]];
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
 
-    [class]{build_tree}-[func]{buildTree}
+    /* 构建二叉树 */
+    TreeNode buildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Dictionary<int, int> inorderMap = new Dictionary<int, int>();
+        for (int i = 0; i < inorder.Length; i++) {
+            inorderMap.TryAdd(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.Length - 1);
+        return root;
+    }
     ```
 
 === "Go"
 
     ```go title="build_tree.go"
-    [class]{}-[func]{dfsBuildTree}
+    /* 构建二叉树：分治 */
+    func dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {
+        // 子树区间为空时终止
+        if r-l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        root := NewTreeNode(preorder[i])
+        // 查询 m ，从而划分左右子树
+        m := inorderMap[preorder[i]]
+        // 子问题：构建左子树
+        root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)
+        // 子问题：构建右子树
+        root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)
+        // 返回根节点
+        return root
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    func buildTree(preorder, inorder []int) *TreeNode {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        inorderMap := make(map[int]int, len(inorder))
+        for i := 0; i < len(inorder); i++ {
+            inorderMap[inorder[i]] = i
+        }
+
+        root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)
+        return root
+    }
     ```
 
 === "Swift"
 
     ```swift title="build_tree.swift"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    func dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
+        // 子树区间为空时终止
+        if r - l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        let root = TreeNode(x: preorder[i])
+        // 查询 m ，从而划分左右子树
+        let m = inorderMap[preorder[i]]!
+        // 子问题：构建左子树
+        root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)
+        // 子问题：构建右子树
+        root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)
+        // 返回根节点
+        return root
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
+        return dfs(preorder: preorder, inorderMap: inorderMap, i: 0, l: 0, r: inorder.count - 1)
+    }
     ```
 
 === "JS"
 
     ```javascript title="build_tree.js"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    function dfs(preorder, inorderMap, i, l, r) {
+        // 子树区间为空时终止
+        if (r - l < 0) return null;
+        // 初始化根节点
+        const root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        const m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    function buildTree(preorder, inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = new Map();
+        for (let i = 0; i < inorder.length; i++) {
+            inorderMap.set(inorder[i], i);
+        }
+        const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
     ```
 
 === "TS"
 
     ```typescript title="build_tree.ts"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    function dfs(
+        preorder: number[],
+        inorderMap: Map<number, number>,
+        i: number,
+        l: number,
+        r: number
+    ): TreeNode | null {
+        // 子树区间为空时终止
+        if (r - l < 0) return null;
+        // 初始化根节点
+        const root: TreeNode = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        const m = inorderMap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let inorderMap = new Map<number, number>();
+        for (let i = 0; i < inorder.length; i++) {
+            inorderMap.set(inorder[i], i);
+        }
+        const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
     ```
 
 === "Dart"
 
     ```dart title="build_tree.dart"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    TreeNode? dfs(
+      List<int> preorder,
+      Map<int, int> inorderMap,
+      int i,
+      int l,
+      int r,
+    ) {
+      // 子树区间为空时终止
+      if (r - l < 0) {
+        return null;
+      }
+      // 初始化根节点
+      TreeNode? root = TreeNode(preorder[i]);
+      // 查询 m ，从而划分左右子树
+      int m = inorderMap[preorder[i]]!;
+      // 子问题：构建左子树
+      root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+      // 子问题：构建右子树
+      root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+      // 返回根节点
+      return root;
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    TreeNode? buildTree(List<int> preorder, List<int> inorder) {
+      // 初始化哈希表，存储 inorder 元素到索引的映射
+      Map<int, int> inorderMap = {};
+      for (int i = 0; i < inorder.length; i++) {
+        inorderMap[inorder[i]] = i;
+      }
+      TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+      return root;
+    }
     ```
 
 === "Rust"
 
     ```rust title="build_tree.rs"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    fn dfs(preorder: &[i32], inorder_map: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
+        // 子树区间为空时终止
+        if r - l < 0 { return None; }
+        // 初始化根节点
+        let root = TreeNode::new(preorder[i as usize]);
+        // 查询 m ，从而划分左右子树
+        let m = inorder_map.get(&preorder[i as usize]).unwrap();
+        // 子问题：构建左子树
+        root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        Some(root)
+    }
 
-    [class]{}-[func]{build_tree}
+    /* 构建二叉树 */
+    fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let mut inorder_map: HashMap<i32, i32> = HashMap::new();
+        for i in 0..inorder.len() {
+            inorder_map.insert(inorder[i], i as i32);
+        }
+        let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
+        root
+    }
     ```
 
 === "C"

zh/chapter_divide_and_conquer/hanota_problem.md

@@ -99,101 +99,342 @@ comments: true
 === "Python"
 
     ```python title="hanota.py"
-    [class]{}-[func]{move}
+    def move(src: list[int], tar: list[int]):
+        """移动一个圆盘"""
+        # 从 src 顶部拿出一个圆盘
+        pan = src.pop()
+        # 将圆盘放入 tar 顶部
+        tar.append(pan)
 
-    [class]{}-[func]{dfs}
+    def dfs(i: int, src: list[int], buf: list[int], tar: list[int]):
+        """求解汉诺塔：问题 f(i)"""
+        # 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1:
+            move(src, tar)
+            return
+        # 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf)
+        # 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar)
+        # 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar)
 
-    [class]{}-[func]{solve_hanota}
+    def solve_hanota(A: list[int], B: list[int], C: list[int]):
+        """求解汉诺塔"""
+        n = len(A)
+        # 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C)
     ```
 
 === "C++"
 
     ```cpp title="hanota.cpp"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(vector<int> &src, vector<int> &tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src.back();
+        src.pop_back();
+        // 将圆盘放入 tar 顶部
+        tar.push_back(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "Java"
 
     ```java title="hanota.java"
-    [class]{hanota}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(List<Integer> src, List<Integer> tar) {
+        // 从 src 顶部拿出一个圆盘
+        Integer pan = src.remove(src.size() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.add(pan);
+    }
 
-    [class]{hanota}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{hanota}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "C#"
 
     ```csharp title="hanota.cs"
-    [class]{hanota}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(List<int> src, List<int> tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src[^1];
+        src.RemoveAt(src.Count - 1);
+        // 将圆盘放入 tar 顶部
+        tar.Add(pan);
+    }
 
-    [class]{hanota}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{hanota}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    void solveHanota(List<int> A, List<int> B, List<int> C) {
+        int n = A.Count;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "Go"
 
     ```go title="hanota.go"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    func move(src, tar *list.List) {
+        // 从 src 顶部拿出一个圆盘
+        pan := src.Back()
+        // 将圆盘放入 tar 顶部
+        tar.PushBack(pan.Value)
+        // 移除 src 顶部圆盘
+        src.Remove(pan)
+    }
 
-    [class]{}-[func]{dfsHanota}
+    /* 求解汉诺塔：问题 f(i) */
+    func dfsHanota(i int, src, buf, tar *list.List) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src, tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfsHanota(i-1, src, tar, buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfsHanota(i-1, buf, src, tar)
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    func solveHanota(A, B, C *list.List) {
+        n := A.Len()
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfsHanota(n, A, B, C)
+    }
     ```
 
 === "Swift"
 
     ```swift title="hanota.swift"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    func move(src: inout [Int], tar: inout [Int]) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.popLast()!
+        // 将圆盘放入 tar 顶部
+        tar.append(pan)
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    func dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src: &src, tar: &tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src: &src, tar: &tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    func solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {
+        let n = A.count
+        // 列表尾部是柱子顶部
+        // 将 src 顶部 n 个圆盘借助 B 移到 C
+        dfs(i: n, src: &A, buf: &B, tar: &C)
+    }
     ```
 
 === "JS"
 
     ```javascript title="hanota.js"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    function move(src, tar) {
+        // 从 src 顶部拿出一个圆盘
+        const pan = src.pop();
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    function dfs(i, src, buf, tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i === 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    function solveHanota(A, B, C) {
+        const n = A.length;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "TS"
 
     ```typescript title="hanota.ts"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    function move(src: number[], tar: number[]): void {
+        // 从 src 顶部拿出一个圆盘
+        const pan = src.pop();
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    function dfs(i: number, src: number[], buf: number[], tar: number[]): void {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i === 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    function solveHanota(A: number[], B: number[], C: number[]): void {
+        const n = A.length;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "Dart"
 
     ```dart title="hanota.dart"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(List<int> src, List<int> tar) {
+      // 从 src 顶部拿出一个圆盘
+      int pan = src.removeLast();
+      // 将圆盘放入 tar 顶部
+      tar.add(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
+      // 若 src 只剩下一个圆盘，则直接将其移到 tar
+      if (i == 1) {
+        move(src, tar);
+        return;
+      }
+      // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+      dfs(i - 1, src, tar, buf);
+      // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+      move(src, tar);
+      // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+      dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{solveHanota}
+    /* 求解汉诺塔 */
+    void solveHanota(List<int> A, List<int> B, List<int> C) {
+      int n = A.length;
+      // 将 A 顶部 n 个圆盘借助 B 移到 C
+      dfs(n, A, B, C);
+    }
     ```
 
 === "Rust"
 
     ```rust title="hanota.rs"
-    [class]{}-[func]{move_pan}
+    /* 移动一个圆盘 */
+    fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.remove(src.len() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.push(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    fn dfs(i: i32, src: &mut Vec<i32>, buf: &mut Vec<i32>, tar: &mut Vec<i32>) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move_pan(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move_pan(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{solve_hanota}
+    /* 求解汉诺塔 */
+    fn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {
+        let n = A.len() as i32;
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "C"

zh/chapter_dynamic_programming/dp_problem_features.md

@@ -43,61 +43,210 @@ $$
 === "Python"
 
     ```python title="min_cost_climbing_stairs_dp.py"
-    [class]{}-[func]{min_cost_climbing_stairs_dp}
+    def min_cost_climbing_stairs_dp(cost: list[int]) -> int:
+        """爬楼梯最小代价：动态规划"""
+        n = len(cost) - 1
+        if n == 1 or n == 2:
+            return cost[n]
+        # 初始化 dp 表，用于存储子问题的解
+        dp = [0] * (n + 1)
+        # 初始状态：预设最小子问题的解
+        dp[1], dp[2] = cost[1], cost[2]
+        # 状态转移：从较小子问题逐步求解较大子问题
+        for i in range(3, n + 1):
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+        return dp[n]
     ```
 
 === "C++"
 
     ```cpp title="min_cost_climbing_stairs_dp.cpp"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(vector<int> &cost) {
+        int n = cost.size() - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        vector<int> dp(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 === "Java"
 
     ```java title="min_cost_climbing_stairs_dp.java"
-    [class]{min_cost_climbing_stairs_dp}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        int[] dp = new int[n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 === "C#"
 
     ```csharp title="min_cost_climbing_stairs_dp.cs"
-    [class]{min_cost_climbing_stairs_dp}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // 初始化 dp 表，用于存储子问题的解
+        int[] dp = new int[n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 === "Go"
 
     ```go title="min_cost_climbing_stairs_dp.go"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    func minCostClimbingStairsDP(cost []int) int {
+        n := len(cost) - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        dp := make([]int, n+1)
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1]
+        dp[2] = cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            dp[i] = int(math.Min(float64(dp[i-1]), float64(dp[i-2]+cost[i])))
+        }
+        return dp[n]
+    }
     ```
 
 === "Swift"
 
     ```swift title="min_cost_climbing_stairs_dp.swift"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    func minCostClimbingStairsDP(cost: [Int]) -> Int {
+        let n = cost.count - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = Array(repeating: 0, count: n + 1)
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1]
+        dp[2] = cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in stride(from: 3, through: n, by: 1) {
+            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+        }
+        return dp[n]
+    }
     ```
 
 === "JS"
 
     ```javascript title="min_cost_climbing_stairs_dp.js"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    function minCostClimbingStairsDP(cost) {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = new Array(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 === "TS"
 
     ```typescript title="min_cost_climbing_stairs_dp.ts"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    function minCostClimbingStairsDP(cost: Array<number>): number {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = new Array(n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 === "Dart"
 
     ```dart title="min_cost_climbing_stairs_dp.dart"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    /* 爬楼梯最小代价：动态规划 */
+    int minCostClimbingStairsDP(List<int> cost) {
+      int n = cost.length - 1;
+      if (n == 1 || n == 2) return cost[n];
+      // 初始化 dp 表，用于存储子问题的解
+      List<int> dp = List.filled(n + 1, 0);
+      // 初始状态：预设最小子问题的解
+      dp[1] = cost[1];
+      dp[2] = cost[2];
+      // 状态转移：从较小子问题逐步求解较大子问题
+      for (int i = 3; i <= n; i++) {
+        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+      }
+      return dp[n];
+    }
     ```
 
 === "Rust"
 
     ```rust title="min_cost_climbing_stairs_dp.rs"
-    [class]{}-[func]{min_cost_climbing_stairs_dp}
+    /* 爬楼梯最小代价：动态规划 */
+    fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
+        let n = cost.len() - 1;
+        if n == 1 || n == 2 { return cost[n]; }
+        // 初始化 dp 表，用于存储子问题的解
+        let mut dp = vec![-1; n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in 3..=n {
+            dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        dp[n]
+    }
     ```
 
 === "C"
@@ -109,7 +258,23 @@ $$
 === "Zig"
 
     ```zig title="min_cost_climbing_stairs_dp.zig"
-    [class]{}-[func]{minCostClimbingStairsDP}
+    // 爬楼梯最小代价：动态规划
+    fn minCostClimbingStairsDP(comptime cost: []i32) i32 {
+        comptime var n = cost.len - 1;
+        if (n == 1 or n == 2) {
+            return cost[n];
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = [_]i32{-1} ** (n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            dp[i] = @min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
     ```
 
 图 14-7 展示了以上代码的动态规划过程。
@@ -123,61 +288,181 @@ $$
 === "Python"
 
     ```python title="min_cost_climbing_stairs_dp.py"
-    [class]{}-[func]{min_cost_climbing_stairs_dp_comp}
+    def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
+        """爬楼梯最小代价：空间优化后的动态规划"""
+        n = len(cost) - 1
+        if n == 1 or n == 2:
+            return cost[n]
+        a, b = cost[1], cost[2]
+        for i in range(3, n + 1):
+            a, b = b, min(a, b) + cost[i]
+        return b
     ```
 
 === "C++"
 
     ```cpp title="min_cost_climbing_stairs_dp.cpp"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(vector<int> &cost) {
+        int n = cost.size() - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 === "Java"
 
     ```java title="min_cost_climbing_stairs_dp.java"
-    [class]{min_cost_climbing_stairs_dp}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 === "C#"
 
     ```csharp title="min_cost_climbing_stairs_dp.cs"
-    [class]{min_cost_climbing_stairs_dp}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.Min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 === "Go"
 
     ```go title="min_cost_climbing_stairs_dp.go"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    func minCostClimbingStairsDPComp(cost []int) int {
+        n := len(cost) - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        // 初始状态：预设最小子问题的解
+        a, b := cost[1], cost[2]
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            tmp := b
+            b = int(math.Min(float64(a), float64(tmp+cost[i])))
+            a = tmp
+        }
+        return b
+    }
     ```
 
 === "Swift"
 
     ```swift title="min_cost_climbing_stairs_dp.swift"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    func minCostClimbingStairsDPComp(cost: [Int]) -> Int {
+        let n = cost.count - 1
+        if n == 1 || n == 2 {
+            return cost[n]
+        }
+        var (a, b) = (cost[1], cost[2])
+        for i in stride(from: 3, through: n, by: 1) {
+            (a, b) = (b, min(a, b) + cost[i])
+        }
+        return b
+    }
     ```
 
 === "JS"
 
     ```javascript title="min_cost_climbing_stairs_dp.js"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    function minCostClimbingStairsDPComp(cost) {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        let a = cost[1],
+            b = cost[2];
+        for (let i = 3; i <= n; i++) {
+            const tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 === "TS"
 
     ```typescript title="min_cost_climbing_stairs_dp.ts"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：状态压缩后的动态规划 */
+    function minCostClimbingStairsDPComp(cost: Array<number>): number {
+        const n = cost.length - 1;
+        if (n === 1 || n === 2) {
+            return cost[n];
+        }
+        let a = cost[1],
+            b = cost[2];
+        for (let i = 3; i <= n; i++) {
+            const tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 === "Dart"
 
     ```dart title="min_cost_climbing_stairs_dp.dart"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    int minCostClimbingStairsDPComp(List<int> cost) {
+      int n = cost.length - 1;
+      if (n == 1 || n == 2) return cost[n];
+      int a = cost[1], b = cost[2];
+      for (int i = 3; i <= n; i++) {
+        int tmp = b;
+        b = min(a, tmp) + cost[i];
+        a = tmp;
+      }
+      return b;
+    }
     ```
 
 === "Rust"
 
     ```rust title="min_cost_climbing_stairs_dp.rs"
-    [class]{}-[func]{min_cost_climbing_stairs_dp_comp}
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
+        let n = cost.len() - 1;
+        if n == 1 || n == 2 { return cost[n] };
+        let (mut a, mut b) = (cost[1], cost[2]);
+        for i in 3..=n {
+            let tmp = b;
+            b = cmp::min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        b
+    }
     ```
 
 === "C"
@@ -189,7 +474,22 @@ $$
 === "Zig"
 
     ```zig title="min_cost_climbing_stairs_dp.zig"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
+    // 爬楼梯最小代价：空间优化后的动态规划
+    fn minCostClimbingStairsDPComp(cost: []i32) i32 {
+        var n = cost.len - 1;
+        if (n == 1 or n == 2) {
+            return cost[n];
+        }
+        var a = cost[1];
+        var b = cost[2];
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            var tmp = b;
+            b = @min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
     ```
 
 ## 14.2.2 &nbsp; 无后效性
@@ -237,61 +537,234 @@ $$
 === "Python"
 
     ```python title="climbing_stairs_constraint_dp.py"
-    [class]{}-[func]{climbing_stairs_constraint_dp}
+    def climbing_stairs_constraint_dp(n: int) -> int:
+        """带约束爬楼梯：动态规划"""
+        if n == 1 or n == 2:
+            return 1
+        # 初始化 dp 表，用于存储子问题的解
+        dp = [[0] * 3 for _ in range(n + 1)]
+        # 初始状态：预设最小子问题的解
+        dp[1][1], dp[1][2] = 1, 0
+        dp[2][1], dp[2][2] = 0, 1
+        # 状态转移：从较小子问题逐步求解较大子问题
+        for i in range(3, n + 1):
+            dp[i][1] = dp[i - 1][2]
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2]
+        return dp[n][1] + dp[n][2]
     ```
 
 === "C++"
 
     ```cpp title="climbing_stairs_constraint_dp.cpp"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        vector<vector<int>> dp(n + 1, vector<int>(3, 0));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
     ```
 
 === "Java"
 
     ```java title="climbing_stairs_constraint_dp.java"
-    [class]{climbing_stairs_constraint_dp}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        int[][] dp = new int[n + 1][3];
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
     ```
 
 === "C#"
 
     ```csharp title="climbing_stairs_constraint_dp.cs"
-    [class]{climbing_stairs_constraint_dp}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        int[,] dp = new int[n + 1, 3];
+        // 初始状态：预设最小子问题的解
+        dp[1, 1] = 1;
+        dp[1, 2] = 0;
+        dp[2, 1] = 0;
+        dp[2, 2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (int i = 3; i <= n; i++) {
+            dp[i, 1] = dp[i - 1, 2];
+            dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];
+        }
+        return dp[n, 1] + dp[n, 2];
+    }
     ```
 
 === "Go"
 
     ```go title="climbing_stairs_constraint_dp.go"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    func climbingStairsConstraintDP(n int) int {
+        if n == 1 || n == 2 {
+            return 1
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        dp := make([][3]int, n+1)
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1
+        dp[1][2] = 0
+        dp[2][1] = 0
+        dp[2][2] = 1
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i := 3; i <= n; i++ {
+            dp[i][1] = dp[i-1][2]
+            dp[i][2] = dp[i-2][1] + dp[i-2][2]
+        }
+        return dp[n][1] + dp[n][2]
+    }
     ```
 
 === "Swift"
 
     ```swift title="climbing_stairs_constraint_dp.swift"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    func climbingStairsConstraintDP(n: Int) -> Int {
+        if n == 1 || n == 2 {
+            return 1
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1
+        dp[1][2] = 0
+        dp[2][1] = 0
+        dp[2][2] = 1
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in stride(from: 3, through: n, by: 1) {
+            dp[i][1] = dp[i - 1][2]
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2]
+        }
+        return dp[n][1] + dp[n][2]
+    }
     ```
 
 === "JS"
 
     ```javascript title="climbing_stairs_constraint_dp.js"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    function climbingStairsConstraintDP(n) {
+        if (n === 1 || n === 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = Array.from(new Array(n + 1), () => new Array(3));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
     ```
 
 === "TS"
 
     ```typescript title="climbing_stairs_constraint_dp.ts"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    function climbingStairsConstraintDP(n: number): number {
+        if (n === 1 || n === 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        const dp = Array.from({ length: n + 1 }, () => new Array(3));
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (let i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
     ```
 
 === "Dart"
 
     ```dart title="climbing_stairs_constraint_dp.dart"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    /* 带约束爬楼梯：动态规划 */
+    int climbingStairsConstraintDP(int n) {
+      if (n == 1 || n == 2) {
+        return 1;
+      }
+      // 初始化 dp 表，用于存储子问题的解
+      List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));
+      // 初始状态：预设最小子问题的解
+      dp[1][1] = 1;
+      dp[1][2] = 0;
+      dp[2][1] = 0;
+      dp[2][2] = 1;
+      // 状态转移：从较小子问题逐步求解较大子问题
+      for (int i = 3; i <= n; i++) {
+        dp[i][1] = dp[i - 1][2];
+        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+      }
+      return dp[n][1] + dp[n][2];
+    }
     ```
 
 === "Rust"
 
     ```rust title="climbing_stairs_constraint_dp.rs"
-    [class]{}-[func]{climbing_stairs_constraint_dp}
+    /* 带约束爬楼梯：动态规划 */
+    fn climbing_stairs_constraint_dp(n: usize) -> i32 {
+        if n == 1 || n == 2 { return 1 };
+        // 初始化 dp 表，用于存储子问题的解
+        let mut dp = vec![vec![-1; 3]; n + 1];
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for i in 3..=n {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        dp[n][1] + dp[n][2]
+    }
     ```
 
 === "C"
@@ -303,7 +776,25 @@ $$
 === "Zig"
 
     ```zig title="climbing_stairs_constraint_dp.zig"
-    [class]{}-[func]{climbingStairsConstraintDP}
+    // 带约束爬楼梯：动态规划
+    fn climbingStairsConstraintDP(comptime n: usize) i32 {
+        if (n == 1 or n == 2) {
+            return 1;
+        }
+        // 初始化 dp 表，用于存储子问题的解
+        var dp = [_][3]i32{ [_]i32{ -1, -1, -1 } } ** (n + 1);
+        // 初始状态：预设最小子问题的解
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // 状态转移：从较小子问题逐步求解较大子问题
+        for (3..n + 1) |i| {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
     ```
 
 在上面的案例中，由于仅需多考虑前面一个状态，我们仍然可以通过扩展状态定义，使得问题重新满足无后效性。然而，某些问题具有非常严重的“有后效性”。

zh/chapter_dynamic_programming/edit_distance_problem.md

@@ -80,61 +80,312 @@ $$
 === "Python"
 
     ```python title="edit_distance.py"
-    [class]{}-[func]{edit_distance_dp}
+    def edit_distance_dp(s: str, t: str) -> int:
+        """编辑距离：动态规划"""
+        n, m = len(s), len(t)
+        dp = [[0] * (m + 1) for _ in range(n + 1)]
+        # 状态转移：首行首列
+        for i in range(1, n + 1):
+            dp[i][0] = i
+        for j in range(1, m + 1):
+            dp[0][j] = j
+        # 状态转移：其余行列
+        for i in range(1, n + 1):
+            for j in range(1, m + 1):
+                if s[i - 1] == t[j - 1]:
+                    # 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    # 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
+        return dp[n][m]
     ```
 
 === "C++"
 
     ```cpp title="edit_distance.cpp"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(string s, string t) {
+        int n = s.length(), m = t.length();
+        vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
     ```
 
 === "Java"
 
     ```java title="edit_distance.java"
-    [class]{edit_distance}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[][] dp = new int[n + 1][m + 1];
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
     ```
 
 === "C#"
 
     ```csharp title="edit_distance.cs"
-    [class]{edit_distance}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[,] dp = new int[n + 1, m + 1];
+        // 状态转移：首行首列
+        for (int i = 1; i <= n; i++) {
+            dp[i, 0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0, j] = j;
+        }
+        // 状态转移：其余行列
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i, j] = dp[i - 1, j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n, m];
+    }
     ```
 
 === "Go"
 
     ```go title="edit_distance.go"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    func editDistanceDP(s string, t string) int {
+        n := len(s)
+        m := len(t)
+        dp := make([][]int, n+1)
+        for i := 0; i <= n; i++ {
+            dp[i] = make([]int, m+1)
+        }
+        // 状态转移：首行首列
+        for i := 1; i <= n; i++ {
+            dp[i][0] = i
+        }
+        for j := 1; j <= m; j++ {
+            dp[0][j] = j
+        }
+        // 状态转移：其余行列
+        for i := 1; i <= n; i++ {
+            for j := 1; j <= m; j++ {
+                if s[i-1] == t[j-1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i-1][j-1]
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1
+                }
+            }
+        }
+        return dp[n][m]
+    }
     ```
 
 === "Swift"
 
     ```swift title="edit_distance.swift"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    func editDistanceDP(s: String, t: String) -> Int {
+        let n = s.utf8CString.count
+        let m = t.utf8CString.count
+        var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)
+        // 状态转移：首行首列
+        for i in stride(from: 1, through: n, by: 1) {
+            dp[i][0] = i
+        }
+        for j in stride(from: 1, through: m, by: 1) {
+            dp[0][j] = j
+        }
+        // 状态转移：其余行列
+        for i in stride(from: 1, through: n, by: 1) {
+            for j in stride(from: 1, through: m, by: 1) {
+                if s.utf8CString[i - 1] == t.utf8CString[j - 1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1]
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1
+                }
+            }
+        }
+        return dp[n][m]
+    }
     ```
 
 === "JS"
 
     ```javascript title="edit_distance.js"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    function editDistanceDP(s, t) {
+        const n = s.length,
+            m = t.length;
+        const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+        // 状态转移：首行首列
+        for (let i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (let j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (let i = 1; i <= n; i++) {
+            for (let j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] =
+                        Math.min(
+                            Math.min(dp[i][j - 1], dp[i - 1][j]),
+                            dp[i - 1][j - 1]
+                        ) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
     ```
 
 === "TS"
 
     ```typescript title="edit_distance.ts"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    function editDistanceDP(s: string, t: string): number {
+        const n = s.length,
+            m = t.length;
+        const dp = Array.from({ length: n + 1 }, () =>
+            Array.from({ length: m + 1 }, () => 0)
+        );
+        // 状态转移：首行首列
+        for (let i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (let j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // 状态转移：其余行列
+        for (let i = 1; i <= n; i++) {
+            for (let j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] =
+                        Math.min(
+                            Math.min(dp[i][j - 1], dp[i - 1][j]),
+                            dp[i - 1][j - 1]
+                        ) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
     ```
 
 === "Dart"
 
     ```dart title="edit_distance.dart"
-    [class]{}-[func]{editDistanceDP}
+    /* 编辑距离：动态规划 */
+    int editDistanceDP(String s, String t) {
+      int n = s.length, m = t.length;
+      List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));
+      // 状态转移：首行首列
+      for (int i = 1; i <= n; i++) {
+        dp[i][0] = i;
+      }
+      for (int j = 1; j <= m; j++) {
+        dp[0][j] = j;
+      }
+      // 状态转移：其余行列
+      for (int i = 1; i <= n; i++) {
+        for (int j = 1; j <= m; j++) {
+          if (s[i - 1] == t[j - 1]) {
+            // 若两字符相等，则直接跳过此两字符
+            dp[i][j] = dp[i - 1][j - 1];
+          } else {
+            // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+            dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+          }
+        }
+      }
+      return dp[n][m];
+    }
     ```
 
 === "Rust"
 
     ```rust title="edit_distance.rs"
-    [class]{}-[func]{edit_distance_dp}
+    /* 编辑距离：动态规划 */
+    fn edit_distance_dp(s: &str, t: &str) -> i32 {
+        let (n, m) = (s.len(), t.len());
+        let mut dp = vec![vec![0; m + 1]; n + 1];
+        // 状态转移：首行首列
+        for i in 1..= n {
+            dp[i][0] = i as i32;
+        }
+        for j in 1..m {
+            dp[0][j] = j as i32;
+        }
+        // 状态转移：其余行列
+        for i in 1..=n {
+            for j in 1..=m {
+                if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        dp[n][m]
+    }
     ```
 
 === "C"
@@ -146,7 +397,32 @@ $$
 === "Zig"
 
     ```zig title="edit_distance.zig"
-    [class]{}-[func]{editDistanceDP}
+    // 编辑距离：动态规划
+    fn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 {
+        comptime var n = s.len;
+        comptime var m = t.len;
+        var dp = [_][m + 1]i32{[_]i32{0} ** (m + 1)} ** (n + 1);
+        // 状态转移：首行首列
+        for (1..n + 1) |i| {
+            dp[i][0] = @intCast(i);
+        }
+        for (1..m + 1) |j| {
+            dp[0][j] = @intCast(j);
+        }
+        // 状态转移：其余行列
+        for (1..n + 1) |i| {
+            for (1..m + 1) |j| {
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[i][j] = @min(@min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
     ```
 
 如图 14-30 所示，编辑距离问题的状态转移过程与背包问题非常类似，都可以看作是填写一个二维网格的过程。
@@ -207,61 +483,330 @@ $$
 === "Python"
 
     ```python title="edit_distance.py"
-    [class]{}-[func]{edit_distance_dp_comp}
+    def edit_distance_dp_comp(s: str, t: str) -> int:
+        """编辑距离：空间优化后的动态规划"""
+        n, m = len(s), len(t)
+        dp = [0] * (m + 1)
+        # 状态转移：首行
+        for j in range(1, m + 1):
+            dp[j] = j
+        # 状态转移：其余行
+        for i in range(1, n + 1):
+            # 状态转移：首列
+            leftup = dp[0]  # 暂存 dp[i-1, j-1]
+            dp[0] += 1
+            # 状态转移：其余列
+            for j in range(1, m + 1):
+                temp = dp[j]
+                if s[i - 1] == t[j - 1]:
+                    # 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup
+                else:
+                    # 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(dp[j - 1], dp[j], leftup) + 1
+                leftup = temp  # 更新为下一轮的 dp[i-1, j-1]
+        return dp[m]
     ```
 
 === "C++"
 
     ```cpp title="edit_distance.cpp"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(string s, string t) {
+        int n = s.length(), m = t.length();
+        vector<int> dp(m + 1, 0);
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```
 
 === "Java"
 
     ```java title="edit_distance.java"
-    [class]{edit_distance}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[] dp = new int[m + 1];
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```
 
 === "C#"
 
     ```csharp title="edit_distance.cs"
-    [class]{edit_distance}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[] dp = new int[m + 1];
+        // 状态转移：首行
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (int i = 1; i <= n; i++) {
+            // 状态转移：首列
+            int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```
 
 === "Go"
 
     ```go title="edit_distance.go"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    func editDistanceDPComp(s string, t string) int {
+        n := len(s)
+        m := len(t)
+        dp := make([]int, m+1)
+        // 状态转移：首行
+        for j := 1; j <= m; j++ {
+            dp[j] = j
+        }
+        // 状态转移：其余行
+        for i := 1; i <= n; i++ {
+            // 状态转移：首列
+            leftUp := dp[0] // 暂存 dp[i-1, j-1]
+            dp[0] = i
+            // 状态转移：其余列
+            for j := 1; j <= m; j++ {
+                temp := dp[j]
+                if s[i-1] == t[j-1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftUp
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1
+                }
+                leftUp = temp // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m]
+    }
     ```
 
 === "Swift"
 
     ```swift title="edit_distance.swift"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    func editDistanceDPComp(s: String, t: String) -> Int {
+        let n = s.utf8CString.count
+        let m = t.utf8CString.count
+        var dp = Array(repeating: 0, count: m + 1)
+        // 状态转移：首行
+        for j in stride(from: 1, through: m, by: 1) {
+            dp[j] = j
+        }
+        // 状态转移：其余行
+        for i in stride(from: 1, through: n, by: 1) {
+            // 状态转移：首列
+            var leftup = dp[0] // 暂存 dp[i-1, j-1]
+            dp[0] = i
+            // 状态转移：其余列
+            for j in stride(from: 1, through: m, by: 1) {
+                let temp = dp[j]
+                if s.utf8CString[i - 1] == t.utf8CString[j - 1] {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1
+                }
+                leftup = temp // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m]
+    }
     ```
 
 === "JS"
 
     ```javascript title="edit_distance.js"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：状态压缩后的动态规划 */
+    function editDistanceDPComp(s, t) {
+        const n = s.length,
+            m = t.length;
+        const dp = new Array(m + 1).fill(0);
+        // 状态转移：首行
+        for (let j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (let i = 1; i <= n; i++) {
+            // 状态转移：首列
+            let leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (let j = 1; j <= m; j++) {
+                const temp = dp[j];
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```
 
 === "TS"
 
     ```typescript title="edit_distance.ts"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：状态压缩后的动态规划 */
+    function editDistanceDPComp(s: string, t: string): number {
+        const n = s.length,
+            m = t.length;
+        const dp = new Array(m + 1).fill(0);
+        // 状态转移：首行
+        for (let j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // 状态转移：其余行
+        for (let i = 1; i <= n; i++) {
+            // 状态转移：首列
+            let leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i;
+            // 状态转移：其余列
+            for (let j = 1; j <= m; j++) {
+                const temp = dp[j];
+                if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```
 
 === "Dart"
 
     ```dart title="edit_distance.dart"
-    [class]{}-[func]{editDistanceDPComp}
+    /* 编辑距离：空间优化后的动态规划 */
+    int editDistanceDPComp(String s, String t) {
+      int n = s.length, m = t.length;
+      List<int> dp = List.filled(m + 1, 0);
+      // 状态转移：首行
+      for (int j = 1; j <= m; j++) {
+        dp[j] = j;
+      }
+      // 状态转移：其余行
+      for (int i = 1; i <= n; i++) {
+        // 状态转移：首列
+        int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+        dp[0] = i;
+        // 状态转移：其余列
+        for (int j = 1; j <= m; j++) {
+          int temp = dp[j];
+          if (s[i - 1] == t[j - 1]) {
+            // 若两字符相等，则直接跳过此两字符
+            dp[j] = leftup;
+          } else {
+            // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+            dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+          }
+          leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+        }
+      }
+      return dp[m];
+    }
     ```
 
 === "Rust"
 
     ```rust title="edit_distance.rs"
-    [class]{}-[func]{edit_distance_dp_comp}
+    /* 编辑距离：空间优化后的动态规划 */
+    fn edit_distance_dp_comp(s: &str, t: &str) -> i32 {
+        let (n, m) = (s.len(), t.len());
+        let mut dp = vec![0; m + 1];
+        // 状态转移：首行
+        for j in 1..m {
+            dp[j] = j as i32;
+        }
+        // 状态转移：其余行
+        for i in 1..=n {
+            // 状态转移：首列
+            let mut leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = i as i32;
+            // 状态转移：其余列
+            for j in 1..=m {
+                let temp = dp[j];
+                if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        dp[m]
+    }
     ```
 
 === "C"
@@ -273,5 +818,33 @@ $$
 === "Zig"
 
     ```zig title="edit_distance.zig"
-    [class]{}-[func]{editDistanceDPComp}
+    // 编辑距离：空间优化后的动态规划
+    fn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 {
+        comptime var n = s.len;
+        comptime var m = t.len;
+        var dp = [_]i32{0} ** (m + 1);
+        // 状态转移：首行
+        for (1..m + 1) |j| {
+            dp[j] = @intCast(j);
+        }
+        // 状态转移：其余行
+        for (1..n + 1) |i| {
+            // 状态转移：首列
+            var leftup = dp[0]; // 暂存 dp[i-1, j-1]
+            dp[0] = @intCast(i);
+            // 状态转移：其余列
+            for (1..m + 1) |j| {
+                var temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // 若两字符相等，则直接跳过此两字符
+                    dp[j] = leftup;
+                } else {
+                    // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+                    dp[j] = @min(@min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+            }
+        }
+        return dp[m];
+    }
     ```

zh/chapter_graph/graph_traversal.md

@@ -29,67 +29,357 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
 === "Python"
 
     ```python title="graph_bfs.py"
-    [class]{}-[func]{graph_bfs}
+    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+        """广度优先遍历 BFS"""
+        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set[Vertex]([start_vet])
+        # 队列用于实现 BFS
+        que = deque[Vertex]([start_vet])
+        # 以顶点 vet 为起点，循环直至访问完所有顶点
+        while len(que) > 0:
+            vet = que.popleft()  # 队首顶点出队
+            res.append(vet)  # 记录访问顶点
+            # 遍历该顶点的所有邻接顶点
+            for adj_vet in graph.adj_list[vet]:
+                if adj_vet in visited:
+                    continue  # 跳过已被访问过的顶点
+                que.append(adj_vet)  # 只入队未访问的顶点
+                visited.add(adj_vet)  # 标记该顶点已被访问
+        # 返回顶点遍历序列
+        return res
     ```
 
 === "C++"
 
     ```cpp title="graph_bfs.cpp"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
+        // 顶点遍历序列
+        vector<Vertex *> res;
+        // 哈希表，用于记录已被访问过的顶点
+        unordered_set<Vertex *> visited = {startVet};
+        // 队列用于实现 BFS
+        queue<Vertex *> que;
+        que.push(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (!que.empty()) {
+            Vertex *vet = que.front();
+            que.pop();          // 队首顶点出队
+            res.push_back(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (auto adjVet : graph.adjList[vet]) {
+                if (visited.count(adjVet))
+                    continue;            // 跳过已被访问过的顶点
+                que.push(adjVet);        // 只入队未访问的顶点
+                visited.emplace(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="graph_bfs.java"
-    [class]{graph_bfs}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new ArrayList<>();
+        // 哈希表，用于记录已被访问过的顶点
+        Set<Vertex> visited = new HashSet<>();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        Queue<Vertex> que = new LinkedList<>();
+        que.offer(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (!que.isEmpty()) {
+            Vertex vet = que.poll(); // 队首顶点出队
+            res.add(vet);            // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (Vertex adjVet : graph.adjList.get(vet)) {
+                if (visited.contains(adjVet))
+                    continue;        // 跳过已被访问过的顶点
+                que.offer(adjVet);   // 只入队未访问的顶点
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="graph_bfs.cs"
-    [class]{graph_bfs}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new List<Vertex>();
+        // 哈希表，用于记录已被访问过的顶点
+        HashSet<Vertex> visited = new HashSet<Vertex>() { startVet };
+        // 队列用于实现 BFS
+        Queue<Vertex> que = new Queue<Vertex>();
+        que.Enqueue(startVet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.Count > 0) {
+            Vertex vet = que.Dequeue(); // 队首顶点出队
+            res.Add(vet);               // 记录访问顶点
+            foreach (Vertex adjVet in graph.adjList[vet]) {
+                if (visited.Contains(adjVet)) {
+                    continue;          // 跳过已被访问过的顶点
+                }
+                que.Enqueue(adjVet);   // 只入队未访问的顶点
+                visited.Add(adjVet);   // 标记该顶点已被访问
+            }
+        }
+
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="graph_bfs.go"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphBFS(g *graphAdjList, startVet Vertex) []Vertex {
+        // 顶点遍历序列
+        res := make([]Vertex, 0)
+        // 哈希表，用于记录已被访问过的顶点
+        visited := make(map[Vertex]struct{})
+        visited[startVet] = struct{}{}
+        // 队列用于实现 BFS, 使用切片模拟队列
+        queue := make([]Vertex, 0)
+        queue = append(queue, startVet)
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        for len(queue) > 0 {
+            // 队首顶点出队
+            vet := queue[0]
+            queue = queue[1:]
+            // 记录访问顶点
+            res = append(res, vet)
+            // 遍历该顶点的所有邻接顶点
+            for _, adjVet := range g.adjList[vet] {
+                _, isExist := visited[adjVet]
+                // 只入队未访问的顶点
+                if !isExist {
+                    queue = append(queue, adjVet)
+                    visited[adjVet] = struct{}{}
+                }
+            }
+        }
+        // 返回顶点遍历序列
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="graph_bfs.swift"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = [startVet]
+        // 队列用于实现 BFS
+        var que: [Vertex] = [startVet]
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.isEmpty {
+            let vet = que.removeFirst() // 队首顶点出队
+            res.append(vet) // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for adjVet in graph.adjList[vet] ?? [] {
+                if visited.contains(adjVet) {
+                    continue // 跳过已被访问过的顶点
+                }
+                que.append(adjVet) // 只入队未访问的顶点
+                visited.insert(adjVet) // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="graph_bfs.js"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphBFS(graph, startVet) {
+        // 顶点遍历序列
+        const res = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited = new Set();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        const que = [startVet];
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.length) {
+            const vet = que.shift(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (const adjVet of graph.adjList.get(vet) ?? []) {
+                if (visited.has(adjVet)) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                que.push(adjVet); // 只入队未访问的顶点
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="graph_bfs.ts"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+        // 顶点遍历序列
+        const res: Vertex[] = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited: Set<Vertex> = new Set();
+        visited.add(startVet);
+        // 队列用于实现 BFS
+        const que = [startVet];
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que.length) {
+            const vet = que.shift(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+            // 遍历该顶点的所有邻接顶点
+            for (const adjVet of graph.adjList.get(vet) ?? []) {
+                if (visited.has(adjVet)) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                que.push(adjVet); // 只入队未访问
+                visited.add(adjVet); // 标记该顶点已被访问
+            }
+        }
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="graph_bfs.dart"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 BFS */
+    List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+      // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+      // 顶点遍历序列
+      List<Vertex> res = [];
+      // 哈希表，用于记录已被访问过的顶点
+      Set<Vertex> visited = {};
+      visited.add(startVet);
+      // 队列用于实现 BFS
+      Queue<Vertex> que = Queue();
+      que.add(startVet);
+      // 以顶点 vet 为起点，循环直至访问完所有顶点
+      while (que.isNotEmpty) {
+        Vertex vet = que.removeFirst(); // 队首顶点出队
+        res.add(vet); // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex adjVet in graph.adjList[vet]!) {
+          if (visited.contains(adjVet)) {
+            continue; // 跳过已被访问过的顶点
+          }
+          que.add(adjVet); // 只入队未访问的顶点
+          visited.add(adjVet); // 标记该顶点已被访问
+        }
+      }
+      // 返回顶点遍历序列
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="graph_bfs.rs"
-    [class]{}-[func]{graph_bfs}
+    /* 广度优先遍历 BFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        visited.insert(start_vet);
+        // 队列用于实现 BFS
+        let mut que = VecDeque::new();
+        que.push_back(start_vet);
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while !que.is_empty() {
+            let vet = que.pop_front().unwrap(); // 队首顶点出队
+            res.push(vet); // 记录访问顶点
+                        // 遍历该顶点的所有邻接顶点
+            if let Some(adj_vets) = graph.adj_list.get(&vet) {
+                for &adj_vet in adj_vets {
+                    if visited.contains(&adj_vet) {
+                        continue; // 跳过已被访问过的顶点
+                    }
+                    que.push_back(adj_vet); // 只入队未访问的顶点
+                    visited.insert(adj_vet); // 标记该顶点已被访问
+                }
+            }
+        }
+        // 返回顶点遍历序列
+        res
+    }
     ```
 
 === "C"
 
     ```c title="graph_bfs.c"
-    [class]{}-[func]{graphBFS}
+    /* 广度优先遍历 */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    Vertex **graphBFS(graphAdjList *t, Vertex *startVet) {
+        // 顶点遍历序列
+        Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * t->size);
+        memset(res, 0, sizeof(Vertex *) * t->size);
+        // 队列用于实现 BFS
+        queue *que = newQueue(t->size);
+        // 哈希表，用于记录已被访问过的顶点
+        hashTable *visited = newHash(t->size);
+        int resIndex = 0;
+        queuePush(que, startVet);         // 将第一个元素入队
+        hashMark(visited, startVet->pos); // 标记第一个入队的顶点
+        // 以顶点 vet 为起点，循环直至访问完所有顶点
+        while (que->head < que->tail) {
+            // 遍历该顶点的边链表，将所有与该顶点有连接的，并且未被标记的顶点入队
+            Node *n = queueTop(que)->linked->head->next;
+            while (n != 0) {
+                // 查询哈希表，若该索引的顶点已入队，则跳过，否则入队并标记
+                if (hashQuery(visited, n->val->pos) == 1) {
+                    n = n->next;
+                    continue; // 跳过已被访问过的顶点
+                }
+                queuePush(que, n->val);         // 只入队未访问的顶点
+                hashMark(visited, n->val->pos); // 标记该顶点已被访问
+            }
+            // 队首元素存入数组
+            res[resIndex] = queueTop(que); // 队首顶点加入顶点遍历序列
+            resIndex++;
+            queuePop(que); // 队首元素出队
+        }
+        // 释放内存
+        freeQueue(que);
+        freeHash(visited);
+        resIndex = 0;
+        // 返回顶点遍历序列
+        return res;
+    }
     ```
 
 === "Zig"
@@ -160,89 +450,339 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
 === "Python"
 
     ```python title="graph_dfs.py"
-    [class]{}-[func]{dfs}
+    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):
+        """深度优先遍历 DFS 辅助函数"""
+        res.append(vet)  # 记录访问顶点
+        visited.add(vet)  # 标记该顶点已被访问
+        # 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adj_list[vet]:
+            if adjVet in visited:
+                continue  # 跳过已被访问过的顶点
+            # 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet)
 
-    [class]{}-[func]{graph_dfs}
+    def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+        """深度优先遍历 DFS"""
+        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set[Vertex]()
+        dfs(graph, visited, res, start_vet)
+        return res
     ```
 
 === "C++"
 
     ```cpp title="graph_dfs.cpp"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
+        res.push_back(vet);   // 记录访问顶点
+        visited.emplace(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex *adjVet : graph.adjList[vet]) {
+            if (visited.count(adjVet))
+                continue; // 跳过已被访问过的顶点
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
+        // 顶点遍历序列
+        vector<Vertex *> res;
+        // 哈希表，用于记录已被访问过的顶点
+        unordered_set<Vertex *> visited;
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="graph_dfs.java"
-    [class]{graph_dfs}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.add(vet);     // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex adjVet : graph.adjList.get(vet)) {
+            if (visited.contains(adjVet))
+                continue; // 跳过已被访问过的顶点
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
 
-    [class]{graph_dfs}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new ArrayList<>();
+        // 哈希表，用于记录已被访问过的顶点
+        Set<Vertex> visited = new HashSet<>();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="graph_dfs.cs"
-    [class]{graph_dfs}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.Add(vet);     // 记录访问顶点
+        visited.Add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        foreach (Vertex adjVet in graph.adjList[vet]) {
+            if (visited.Contains(adjVet)) {
+                continue; // 跳过已被访问过的顶点                             
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
 
-    [class]{graph_dfs}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+        // 顶点遍历序列
+        List<Vertex> res = new List<Vertex>();
+        // 哈希表，用于记录已被访问过的顶点
+        HashSet<Vertex> visited = new HashSet<Vertex>();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="graph_dfs.go"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    func dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {
+        // append 操作会返回新的的引用，必须让原引用重新赋值为新slice的引用
+        *res = append(*res, vet)
+        visited[vet] = struct{}{}
+        // 遍历该顶点的所有邻接顶点
+        for _, adjVet := range g.adjList[vet] {
+            _, isExist := visited[adjVet]
+            // 递归访问邻接顶点
+            if !isExist {
+                dfs(g, visited, res, adjVet)
+            }
+        }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphDFS(g *graphAdjList, startVet Vertex) []Vertex {
+        // 顶点遍历序列
+        res := make([]Vertex, 0)
+        // 哈希表，用于记录已被访问过的顶点
+        visited := make(map[Vertex]struct{})
+        dfs(g, visited, &res, startVet)
+        // 返回顶点遍历序列
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="graph_dfs.swift"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    func dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {
+        res.append(vet) // 记录访问顶点
+        visited.insert(vet) // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adjList[vet] ?? [] {
+            if visited.contains(adjVet) {
+                continue // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)
+        }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    func graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+        // 顶点遍历序列
+        var res: [Vertex] = []
+        // 哈希表，用于记录已被访问过的顶点
+        var visited: Set<Vertex> = []
+        dfs(graph: graph, visited: &visited, res: &res, vet: startVet)
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="graph_dfs.js"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function dfs(graph, visited, res, vet) {
+        res.push(vet); // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet)) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphDFS(graph, startVet) {
+        // 顶点遍历序列
+        const res = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited = new Set();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="graph_dfs.ts"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    function dfs(
+        graph: GraphAdjList,
+        visited: Set<Vertex>,
+        res: Vertex[],
+        vet: Vertex
+    ): void {
+        res.push(vet); // 记录访问顶点
+        visited.add(vet); // 标记该顶点已被访问
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet)) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问过的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adjVet);
+        }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    function graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+        // 顶点遍历序列
+        const res: Vertex[] = [];
+        // 哈希表，用于记录已被访问过的顶点
+        const visited: Set<Vertex> = new Set();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="graph_dfs.dart"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    void dfs(
+      GraphAdjList graph,
+      Set<Vertex> visited,
+      List<Vertex> res,
+      Vertex vet,
+    ) {
+      res.add(vet); // 记录访问顶点
+      visited.add(vet); // 标记该顶点已被访问
+      // 遍历该顶点的所有邻接顶点
+      for (Vertex adjVet in graph.adjList[vet]!) {
+        if (visited.contains(adjVet)) {
+          continue; // 跳过已被访问过的顶点
+        }
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+      }
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+      // 顶点遍历序列
+      List<Vertex> res = [];
+      // 哈希表，用于记录已被访问过的顶点
+      Set<Vertex> visited = {};
+      dfs(graph, visited, res, startVet);
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="graph_dfs.rs"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    fn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {
+        res.push(vet); // 记录访问顶点
+        visited.insert(vet); // 标记该顶点已被访问
+                             // 遍历该顶点的所有邻接顶点
+        if let Some(adj_vets) = graph.adj_list.get(&vet) {
+            for &adj_vet in adj_vets {
+                if visited.contains(&adj_vet) {
+                    continue; // 跳过已被访问过的顶点
+                }
+                // 递归访问邻接顶点
+                dfs(graph, visited, res, adj_vet);
+            }
+        }
+    }
 
-    [class]{}-[func]{graph_dfs}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    fn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+        // 顶点遍历序列
+        let mut res = vec![];
+        // 哈希表，用于记录已被访问过的顶点
+        let mut visited = HashSet::new();
+        dfs(&graph, &mut visited, &mut res, start_vet);
+
+        res
+    }
     ```
 
 === "C"
 
     ```c title="graph_dfs.c"
-    [class]{}-[func]{dfs}
+    /* 深度优先遍历 DFS 辅助函数 */
+    int resIndex = 0;
+    void dfs(graphAdjList *graph, hashTable *visited, Vertex *vet, Vertex **res) {
+        if (hashQuery(visited, vet->pos) == 1) {
+            return; // 跳过已被访问过的顶点
+        }
+        hashMark(visited, vet->pos); // 标记顶点并将顶点存入数组
+        res[resIndex] = vet;         // 将顶点存入数组
+        resIndex++;
+        // 遍历该顶点链表
+        Node *n = vet->linked->head->next;
+        while (n != 0) {
+            // 递归访问邻接顶点
+            dfs(graph, visited, n->val, res);
+            n = n->next;
+        }
+        return;
+    }
 
-    [class]{}-[func]{graphDFS}
+    /* 深度优先遍历 DFS */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    Vertex **graphDFS(graphAdjList *graph, Vertex *startVet) {
+        // 顶点遍历序列
+        Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * graph->size);
+        memset(res, 0, sizeof(Vertex *) * graph->size);
+        // 哈希表，用于记录已被访问过的顶点
+        hashTable *visited = newHash(graph->size);
+        dfs(graph, visited, startVet, res);
+        // 释放哈希表内存并将数组索引归零
+        freeHash(visited);
+        resIndex = 0;
+        // 返回遍历数组
+        return res;
+    }
     ```
 
 === "Zig"

zh/chapter_greedy/fractional_knapsack_problem.md

@@ -42,89 +42,425 @@ comments: true
 === "Python"
 
     ```python title="fractional_knapsack.py"
-    [class]{Item}-[func]{}
+    class Item:
+        """物品"""
 
-    [class]{}-[func]{fractional_knapsack}
+        def __init__(self, w: int, v: int):
+            self.w = w  # 物品重量
+            self.v = v  # 物品价值
+
+    def fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:
+        """分数背包：贪心"""
+        # 创建物品列表，包含两个属性：重量、价值
+        items = [Item(w, v) for w, v in zip(wgt, val)]
+        # 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(key=lambda item: item.v / item.w, reverse=True)
+        # 循环贪心选择
+        res = 0
+        for item in items:
+            if item.w <= cap:
+                # 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v
+                cap -= item.w
+            else:
+                # 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap
+                # 已无剩余容量，因此跳出循环
+                break
+        return res
     ```
 
 === "C++"
 
     ```cpp title="fractional_knapsack.cpp"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+      public:
+        int w; // 物品重量
+        int v; // 物品价值
 
-    [class]{}-[func]{fractionalKnapsack}
+        Item(int w, int v) : w(w), v(v) {
+        }
+    };
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        vector<Item> items;
+        for (int i = 0; i < wgt.size(); i++) {
+            items.push_back(Item(wgt[i], val[i]));
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
+        // 循环贪心选择
+        double res = 0;
+        for (auto &item : items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double)item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="fractional_knapsack.java"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+        int w; // 物品重量
+        int v; // 物品价值
 
-    [class]{fractional_knapsack}-[func]{fractionalKnapsack}
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.length];
+        for (int i = 0; i < wgt.length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
+        // 循环贪心选择
+        double res = 0;
+        for (Item item : items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double) item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="fractional_knapsack.cs"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+        public int w; // 物品重量
+        public int v; // 物品价值
 
-    [class]{fractional_knapsack}-[func]{fractionalKnapsack}
+        public Item(int w, int v) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item[] items = new Item[wgt.Length];
+        for (int i = 0; i < wgt.Length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));
+        // 循环贪心选择
+        double res = 0;
+        foreach (Item item in items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (double)item.v / item.w * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="fractional_knapsack.go"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    type Item struct {
+        w int // 物品重量
+        v int // 物品价值
+    }
 
-    [class]{}-[func]{fractionalKnapsack}
+    /* 分数背包：贪心 */
+    func fractionalKnapsack(wgt []int, val []int, cap int) float64 {
+        // 创建物品列表，包含两个属性：重量、价值
+        items := make([]Item, len(wgt))
+        for i := 0; i < len(wgt); i++ {
+            items[i] = Item{wgt[i], val[i]}
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        sort.Slice(items, func(i, j int) bool {
+            return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)
+        })
+        // 循环贪心选择
+        res := 0.0
+        for _, item := range items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += float64(item.v)
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += float64(item.v) / float64(item.w) * float64(cap)
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="fractional_knapsack.swift"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+        var w: Int // 物品重量
+        var v: Int // 物品价值
 
-    [class]{}-[func]{fractionalKnapsack}
+        init(w: Int, v: Int) {
+            self.w = w
+            self.v = v
+        }
+    }
+
+    /* 分数背包：贪心 */
+    func fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {
+        // 创建物品列表，包含两个属性：重量、价值
+        var items = zip(wgt, val).map { Item(w: $0, v: $1) }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort(by: { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) })
+        // 循环贪心选择
+        var res = 0.0
+        var cap = cap
+        for item in items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += Double(item.v)
+                cap -= item.w
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += Double(item.v) / Double(item.w) * Double(cap)
+                // 已无剩余容量，因此跳出循环
+                break
+            }
+        }
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="fractional_knapsack.js"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+        constructor(w, v) {
+            this.w = w; // 物品重量
+            this.v = v; // 物品价值
+        }
+    }
 
-    [class]{}-[func]{fractionalKnapsack}
+    /* 分数背包：贪心 */
+    function fractionalKnapsack(wgt, val, cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        const items = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 循环贪心选择
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="fractional_knapsack.ts"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+        w: number; // 物品重量
+        v: number; // 物品价值
 
-    [class]{}-[func]{fractionalKnapsack}
+        constructor(w: number, v: number) {
+            this.w = w;
+            this.v = v;
+        }
+    }
+
+    /* 分数背包：贪心 */
+    function fractionalKnapsack(wgt: number[], val: number[], cap: number): number {
+        // 创建物品列表，包含两个属性：重量、价值
+        const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort((a, b) => b.v / b.w - a.v / a.w);
+        // 循环贪心选择
+        let res = 0;
+        for (const item of items) {
+            if (item.w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (item.v / item.w) * cap;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="fractional_knapsack.dart"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    class Item {
+      int w; // 物品重量
+      int v; // 物品价值
 
-    [class]{}-[func]{fractionalKnapsack}
+      Item(this.w, this.v);
+    }
+
+    /* 分数背包：贪心 */
+    double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
+      // 创建物品列表，包含两个属性：重量、价值
+      List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
+      // 按照单位价值 item.v / item.w 从高到低进行排序
+      items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
+      // 循环贪心选择
+      double res = 0;
+      for (Item item in items) {
+        if (item.w <= cap) {
+          // 若剩余容量充足，则将当前物品整个装进背包
+          res += item.v;
+          cap -= item.w;
+        } else {
+          // 若剩余容量不足，则将当前物品的一部分装进背包
+          res += item.v / item.w * cap;
+          // 已无剩余容量，因此跳出循环
+          break;
+        }
+      }
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="fractional_knapsack.rs"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    struct Item {
+        w: i32, // 物品重量
+        v: i32, // 物品价值
+    }
 
-    [class]{}-[func]{fractional_knapsack}
+    impl Item {
+        fn new(w: i32, v: i32) -> Self {
+            Self { w, v }
+        }
+    }
+
+    /* 分数背包：贪心 */
+    fn fractional_knapsack(wgt: &[i32], val: &[i32], mut cap: i32) -> f64 {
+        // 创建物品列表，包含两个属性：重量、价值
+        let mut items = wgt
+            .iter()
+            .zip(val.iter())
+            .map(|(&w, &v)| Item::new(w, v))
+            .collect::<Vec<Item>>();
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        items.sort_by(|a, b| {
+            (b.v as f64 / b.w as f64)
+                .partial_cmp(&(a.v as f64 / a.w as f64))
+                .unwrap()
+        });
+        // 循环贪心选择
+        let mut res = 0.0;
+        for item in &items {
+            if item.w <= cap {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += item.v as f64;
+                cap -= item.w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += item.v as f64 / item.w as f64 * cap as f64;
+                // 已无剩余容量，因此跳出循环
+                break;
+            }
+        }
+        res
+    }
     ```
 
 === "C"
 
     ```c title="fractional_knapsack.c"
-    [class]{Item}-[func]{}
+    /* 物品 */
+    struct Item {
+        int w; // 物品重量
+        int v; // 物品价值
+    };
 
-    [class]{}-[func]{fractionalKnapsack}
+    typedef struct Item Item;
+
+    /* 分数背包：贪心 */
+    float fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {
+        // 创建物品列表，包含两个属性：重量、价值
+        Item *items = malloc(sizeof(Item) * itemCount);
+        for (int i = 0; i < itemCount; i++) {
+            items[i] = (Item){.w = wgt[i], .v = val[i]};
+        }
+        // 按照单位价值 item.v / item.w 从高到低进行排序
+        qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);
+        // 循环贪心选择
+        float res = 0.0;
+        for (int i = 0; i < itemCount; i++) {
+            if (items[i].w <= cap) {
+                // 若剩余容量充足，则将当前物品整个装进背包
+                res += items[i].v;
+                cap -= items[i].w;
+            } else {
+                // 若剩余容量不足，则将当前物品的一部分装进背包
+                res += (float)cap / items[i].w * items[i].v;
+                cap = 0;
+                break;
+            }
+        }
+        free(items);
+        return res;
+    }
     ```
 
 === "Zig"

zh/chapter_greedy/greedy_algorithm.md

@@ -28,67 +28,259 @@ comments: true
 === "Python"
 
     ```python title="coin_change_greedy.py"
-    [class]{}-[func]{coin_change_greedy}
+    def coin_change_greedy(coins: list[int], amt: int) -> int:
+        """零钱兑换：贪心"""
+        # 假设 coins 列表有序
+        i = len(coins) - 1
+        count = 0
+        # 循环进行贪心选择，直到无剩余金额
+        while amt > 0:
+            # 找到小于且最接近剩余金额的硬币
+            while i > 0 and coins[i] > amt:
+                i -= 1
+            # 选择 coins[i]
+            amt -= coins[i]
+            count += 1
+        # 若未找到可行方案，则返回 -1
+        return count if amt == 0 else -1
     ```
 
 === "C++"
 
     ```cpp title="coin_change_greedy.cpp"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(vector<int> &coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.size() - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
     ```
 
 === "Java"
 
     ```java title="coin_change_greedy.java"
-    [class]{coin_change_greedy}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(int[] coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.length - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
     ```
 
 === "C#"
 
     ```csharp title="coin_change_greedy.cs"
-    [class]{coin_change_greedy}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(int[] coins, int amt) {
+        // 假设 coins 列表有序
+        int i = coins.Length - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
     ```
 
 === "Go"
 
     ```go title="coin_change_greedy.go"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    func coinChangeGreedy(coins []int, amt int) int {
+        // 假设 coins 列表有序
+        i := len(coins) - 1
+        count := 0
+        // 循环进行贪心选择，直到无剩余金额
+        for amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            for i > 0 && coins[i] > amt {
+                i--
+            }
+            // 选择 coins[i]
+            amt -= coins[i]
+            count++
+        }
+        // 若未找到可行方案，则返回 -1
+        if amt != 0 {
+            return -1
+        }
+        return count
+    }
     ```
 
 === "Swift"
 
     ```swift title="coin_change_greedy.swift"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    func coinChangeGreedy(coins: [Int], amt: Int) -> Int {
+        // 假设 coins 列表有序
+        var i = coins.count - 1
+        var count = 0
+        var amt = amt
+        // 循环进行贪心选择，直到无剩余金额
+        while amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            while i > 0 && coins[i] > amt {
+                i -= 1
+            }
+            // 选择 coins[i]
+            amt -= coins[i]
+            count += 1
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1
+    }
     ```
 
 === "JS"
 
     ```javascript title="coin_change_greedy.js"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    function coinChangeGreedy(coins, amt) {
+        // 假设 coins 数组有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt === 0 ? count : -1;
+    }
     ```
 
 === "TS"
 
     ```typescript title="coin_change_greedy.ts"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    function coinChangeGreedy(coins: number[], amt: number): number {
+        // 假设 coins 数组有序
+        let i = coins.length - 1;
+        let count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt === 0 ? count : -1;
+    }
     ```
 
 === "Dart"
 
     ```dart title="coin_change_greedy.dart"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(List<int> coins, int amt) {
+      // 假设 coins 列表有序
+      int i = coins.length - 1;
+      int count = 0;
+      // 循环进行贪心选择，直到无剩余金额
+      while (amt > 0) {
+        // 找到小于且最接近剩余金额的硬币
+        while (i > 0 && coins[i] > amt) {
+          i--;
+        }
+        // 选择 coins[i]
+        amt -= coins[i];
+        count++;
+      }
+      // 若未找到可行方案，则返回 -1
+      return amt == 0 ? count : -1;
+    }
     ```
 
 === "Rust"
 
     ```rust title="coin_change_greedy.rs"
-    [class]{}-[func]{coin_change_greedy}
+    /* 零钱兑换：贪心 */
+    fn coin_change_greedy(coins: &[i32], mut amt: i32) -> i32 {
+        // 假设 coins 列表有序
+        let mut i = coins.len() - 1;
+        let mut count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while amt > 0 {
+            // 找到小于且最接近剩余金额的硬币
+            while i > 0 && coins[i] > amt {
+                i -= 1;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count += 1;
+        }
+        // 若未找到可行方案，则返回 -1
+        if amt == 0 {
+            count
+        } else {
+            -1
+        }
+    }
     ```
 
 === "C"
 
     ```c title="coin_change_greedy.c"
-    [class]{}-[func]{coinChangeGreedy}
+    /* 零钱兑换：贪心 */
+    int coinChangeGreedy(int* coins, int size, int amt) {
+        // 假设 coins 列表有序
+        int i = size - 1;
+        int count = 0;
+        // 循环进行贪心选择，直到无剩余金额
+        while (amt > 0) {
+            // 找到小于且最接近剩余金额的硬币
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // 选择 coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // 若未找到可行方案，则返回 -1
+        return amt == 0 ? count : -1;
+    }
     ```
 
 === "Zig"

zh/chapter_greedy/max_capacity_problem.md

@@ -95,67 +95,277 @@ $$
 === "Python"
 
     ```python title="max_capacity.py"
-    [class]{}-[func]{max_capacity}
+    def max_capacity(ht: list[int]) -> int:
+        """最大容量：贪心"""
+        # 初始化 i, j 分列数组两端
+        i, j = 0, len(ht) - 1
+        # 初始最大容量为 0
+        res = 0
+        # 循环贪心选择，直至两板相遇
+        while i < j:
+            # 更新最大容量
+            cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            # 向内移动短板
+            if ht[i] < ht[j]:
+                i += 1
+            else:
+                j -= 1
+        return res
     ```
 
 === "C++"
 
     ```cpp title="max_capacity.cpp"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    int maxCapacity(vector<int> &ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.size() - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = min(ht[i], ht[j]) * (j - i);
+            res = max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Java"
 
     ```java title="max_capacity.java"
-    [class]{max_capacity}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    int maxCapacity(int[] ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.length - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
     ```
 
 === "C#"
 
     ```csharp title="max_capacity.cs"
-    [class]{max_capacity}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    int maxCapacity(int[] ht) {
+        // 初始化 i, j 分列数组两端
+        int i = 0, j = ht.Length - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int cap = Math.Min(ht[i], ht[j]) * (j - i);
+            res = Math.Max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Go"
 
     ```go title="max_capacity.go"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    func maxCapacity(ht []int) int {
+        // 初始化 i, j 分列数组两端
+        i, j := 0, len(ht)-1
+        // 初始最大容量为 0
+        res := 0
+        // 循环贪心选择，直至两板相遇
+        for i < j {
+            // 更新最大容量
+            capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)
+            res = int(math.Max(float64(res), float64(capacity)))
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i++
+            } else {
+                j--
+            }
+        }
+        return res
+    }
     ```
 
 === "Swift"
 
     ```swift title="max_capacity.swift"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    func maxCapacity(ht: [Int]) -> Int {
+        // 初始化 i, j 分列数组两端
+        var i = 0, j = ht.count - 1
+        // 初始最大容量为 0
+        var res = 0
+        // 循环贪心选择，直至两板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = min(ht[i], ht[j]) * (j - i)
+            res = max(res, cap)
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i += 1
+            } else {
+                j -= 1
+            }
+        }
+        return res
+    }
     ```
 
 === "JS"
 
     ```javascript title="max_capacity.js"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    function maxCapacity(ht) {
+        // 初始化 i, j 分列数组两端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量为 0
+        let res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
     ```
 
 === "TS"
 
     ```typescript title="max_capacity.ts"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    function maxCapacity(ht: number[]): number {
+        // 初始化 i, j 分列数组两端
+        let i = 0,
+            j = ht.length - 1;
+        // 初始最大容量为 0
+        let res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            const cap: number = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Dart"
 
     ```dart title="max_capacity.dart"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    int maxCapacity(List<int> ht) {
+      // 初始化 i, j 分列数组两端
+      int i = 0, j = ht.length - 1;
+      // 初始最大容量为 0
+      int res = 0;
+      // 循环贪心选择，直至两板相遇
+      while (i < j) {
+        // 更新最大容量
+        int cap = min(ht[i], ht[j]) * (j - i);
+        res = max(res, cap);
+        // 向内移动短板
+        if (ht[i] < ht[j]) {
+          i++;
+        } else {
+          j--;
+        }
+      }
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="max_capacity.rs"
-    [class]{}-[func]{max_capacity}
+    /* 最大容量：贪心 */
+    fn max_capacity(ht: &[i32]) -> i32 {
+        // 初始化 i, j 分列数组两端
+        let mut i = 0;
+        let mut j = ht.len() - 1;
+        // 初始最大容量为 0
+        let mut res = 0;
+        // 循环贪心选择，直至两板相遇
+        while i < j {
+            // 更新最大容量
+            let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;
+            res = std::cmp::max(res, cap);
+            // 向内移动短板
+            if ht[i] < ht[j] {
+                i += 1;
+            } else {
+                j -= 1;
+            }
+        }
+        res
+    }
     ```
 
 === "C"
 
     ```c title="max_capacity.c"
-    [class]{}-[func]{maxCapacity}
+    /* 最大容量：贪心 */
+    int maxCapacity(int ht[], int htLength) {
+        // 初始化 i, j 分列数组两端
+        int i = 0;
+        int j = htLength - 1;
+        // 初始最大容量为 0
+        int res = 0;
+        // 循环贪心选择，直至两板相遇
+        while (i < j) {
+            // 更新最大容量
+            int capacity = MIN(ht[i], ht[j]) * (j - i);
+            res = MAX(res, capacity);
+            // 向内移动短板
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
     ```
 
 === "Zig"

zh/chapter_greedy/max_product_cutting_problem.md

@@ -76,67 +76,271 @@ $$
 === "Python"
 
     ```python title="max_product_cutting.py"
-    [class]{}-[func]{max_product_cutting}
+    def max_product_cutting(n: int) -> int:
+        """最大切分乘积：贪心"""
+        # 当 n <= 3 时，必须切分出一个 1
+        if n <= 3:
+            return 1 * (n - 1)
+        # 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        a, b = n // 3, n % 3
+        if b == 1:
+            # 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return int(math.pow(3, a - 1)) * 2 * 2
+        if b == 2:
+            # 当余数为 2 时，不做处理
+            return int(math.pow(3, a)) * 2
+        # 当余数为 0 时，不做处理
+        return int(math.pow(3, a))
     ```
 
 === "C++"
 
     ```cpp title="max_product_cutting.cpp"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int)pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int)pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int)pow(3, a);
+    }
     ```
 
 === "Java"
 
     ```java title="max_product_cutting.java"
-    [class]{max_product_cutting}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int) Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int) Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int) Math.pow(3, a);
+    }
     ```
 
 === "C#"
 
     ```csharp title="max_product_cutting.cs"
-    [class]{max_product_cutting}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return (int)Math.Pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return (int)Math.Pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return (int)Math.Pow(3, a);
+    }
     ```
 
 === "Go"
 
     ```go title="max_product_cutting.go"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    func maxProductCutting(n int) int {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        a := n / 3
+        b := n % 3
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return int(math.Pow(3, float64(a-1))) * 2 * 2
+        }
+        if b == 2 {
+            // 当余数为 2 时，不做处理
+            return int(math.Pow(3, float64(a))) * 2
+        }
+        // 当余数为 0 时，不做处理
+        return int(math.Pow(3, float64(a)))
+    }
     ```
 
 === "Swift"
 
     ```swift title="max_product_cutting.swift"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    func maxProductCutting(n: Int) -> Int {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1)
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = n / 3
+        let b = n % 3
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return pow(3, a - 1) * 2 * 2
+        }
+        if b == 2 {
+            // 当余数为 2 时，不做处理
+            return pow(3, a) * 2
+        }
+        // 当余数为 0 时，不做处理
+        return pow(3, a)
+    }
     ```
 
 === "JS"
 
     ```javascript title="max_product_cutting.js"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    function maxProductCutting(n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = Math.floor(n / 3);
+        let b = n % 3;
+        if (b === 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 当余数为 2 时，不做处理
+            return Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return Math.pow(3, a);
+    }
     ```
 
 === "TS"
 
     ```typescript title="max_product_cutting.ts"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    function maxProductCutting(n: number): number {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a: number = Math.floor(n / 3);
+        let b: number = n % 3;
+        if (b === 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b === 2) {
+            // 当余数为 2 时，不做处理
+            return Math.pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return Math.pow(3, a);
+    }
     ```
 
 === "Dart"
 
     ```dart title="max_product_cutting.dart"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+      // 当 n <= 3 时，必须切分出一个 1
+      if (n <= 3) {
+        return 1 * (n - 1);
+      }
+      // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+      int a = n ~/ 3;
+      int b = n % 3;
+      if (b == 1) {
+        // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+        return (pow(3, a - 1) * 2 * 2).toInt();
+      }
+      if (b == 2) {
+        // 当余数为 2 时，不做处理
+        return (pow(3, a) * 2).toInt();
+      }
+      // 当余数为 0 时，不做处理
+      return pow(3, a).toInt();
+    }
     ```
 
 === "Rust"
 
     ```rust title="max_product_cutting.rs"
-    [class]{}-[func]{max_product_cutting}
+    /* 最大切分乘积：贪心 */
+    fn max_product_cutting(n: i32) -> i32 {
+        // 当 n <= 3 时，必须切分出一个 1
+        if n <= 3 {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        let a = n / 3;
+        let b = n % 3;
+        if b == 1 {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            3_i32.pow(a as u32 - 1) * 2 * 2
+        } else if b == 2 {
+            // 当余数为 2 时，不做处理
+            3_i32.pow(a as u32) * 2
+        } else {
+            // 当余数为 0 时，不做处理
+            3_i32.pow(a as u32)
+        }
+    }
     ```
 
 === "C"
 
     ```c title="max_product_cutting.c"
-    [class]{}-[func]{maxProductCutting}
+    /* 最大切分乘积：贪心 */
+    int maxProductCutting(int n) {
+        // 当 n <= 3 时，必须切分出一个 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+            return pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // 当余数为 2 时，不做处理
+            return pow(3, a) * 2;
+        }
+        // 当余数为 0 时，不做处理
+        return pow(3, a);
+    }
     ```
 
 === "Zig"

zh/chapter_hashing/hash_algorithm.md

@@ -55,133 +55,503 @@ index = hash(key) % capacity
 === "Python"
 
     ```python title="simple_hash.py"
-    [class]{}-[func]{add_hash}
+    def add_hash(key: str) -> int:
+        """加法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash += ord(c)
+        return hash % modulus
 
-    [class]{}-[func]{mul_hash}
+    def mul_hash(key: str) -> int:
+        """乘法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash = 31 * hash + ord(c)
+        return hash % modulus
 
-    [class]{}-[func]{xor_hash}
+    def xor_hash(key: str) -> int:
+        """异或哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash ^= ord(c)
+        return hash % modulus
 
-    [class]{}-[func]{rot_hash}
+    def rot_hash(key: str) -> int:
+        """旋转哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash = (hash << 4) ^ (hash >> 28) ^ ord(c)
+        return hash % modulus
     ```
 
 === "C++"
 
     ```cpp title="simple_hash.cpp"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (31 * hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash ^= (int)c;
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
     ```
 
 === "Java"
 
     ```java title="simple_hash.java"
-    [class]{simple_hash}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
 
-    [class]{simple_hash}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (31 * hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
 
-    [class]{simple_hash}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(String key) {
+        int hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash ^= (int) c;
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{simple_hash}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
     ```
 
 === "C#"
 
     ```csharp title="simple_hash.cs"
-    [class]{simple_hash}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{simple_hash}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (31 * hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{simple_hash}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash ^= c;
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{simple_hash}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;
+        }
+        return (int)hash;
+    }
     ```
 
 === "Go"
 
     ```go title="simple_hash.go"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    func addHash(key string) int {
+        var hash int64
+        var modulus int64
 
-    [class]{}-[func]{mulHash}
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 乘法哈希 */
+    func mulHash(key string) int {
+        var hash int64
+        var modulus int64
 
-    [class]{}-[func]{rotHash}
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = (31*hash + int64(b)) % modulus
+        }
+        return int(hash)
+    }
+
+    /* 异或哈希 */
+    func xorHash(key string) int {
+        hash := 0
+        modulus := 1000000007
+        for _, b := range []byte(key) {
+            fmt.Println(int(b))
+            hash ^= int(b)
+            hash = (31*hash + int(b)) % modulus
+        }
+        return hash & modulus
+    }
+
+    /* 旋转哈希 */
+    func rotHash(key string) int {
+        var hash int64
+        var modulus int64
+
+        modulus = 1000000007
+        for _, b := range []byte(key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+        }
+        return int(hash)
+    }
     ```
 
 === "Swift"
 
     ```swift title="simple_hash.swift"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    func addHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = (hash + Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    func mulHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = (31 * hash + Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    func xorHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash ^= Int(scalar.value)
+            }
+        }
+        return hash & MODULUS
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    func rotHash(key: String) -> Int {
+        var hash = 0
+        let MODULUS = 1_000_000_007
+        for c in key {
+            for scalar in c.unicodeScalars {
+                hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS
+            }
+        }
+        return hash
+    }
     ```
 
 === "JS"
 
     ```javascript title="simple_hash.js"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    function addHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    function mulHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    function xorHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash ^= c.charCodeAt(0);
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    function rotHash(key) {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
     ```
 
 === "TS"
 
     ```typescript title="simple_hash.ts"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    function addHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    function mulHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    function xorHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash ^= c.charCodeAt(0);
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    function rotHash(key: string): number {
+        let hash = 0;
+        const MODULUS = 1000000007;
+        for (const c of key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
+        }
+        return hash;
+    }
     ```
 
 === "Dart"
 
     ```dart title="simple_hash.dart"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = (hash + key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash ^= key.codeUnitAt(i);
+      }
+      return hash & MODULUS;
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(String key) {
+      int hash = 0;
+      final int MODULUS = 1000000007;
+      for (int i = 0; i < key.length; i++) {
+        hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
+      }
+      return hash;
+    }
     ```
 
 === "Rust"
 
     ```rust title="simple_hash.rs"
-    [class]{}-[func]{add_hash}
+    /* 加法哈希 */
+    fn add_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
 
-    [class]{}-[func]{mul_hash}
+        for c in key.chars() {
+            hash = (hash + c as i64) % MODULUS;
+        }
 
-    [class]{}-[func]{xor_hash}
+        hash as i32
+    } 
 
-    [class]{}-[func]{rot_hash}
+    /* 乘法哈希 */
+    fn mul_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash = (31 * hash + c as i64) % MODULUS;
+        }
+
+        hash as i32
+    }
+
+    /* 异或哈希 */
+    fn xor_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash ^= c as i64;
+        }
+
+        (hash & MODULUS) as i32
+    }
+
+    /* 旋转哈希 */
+    fn rot_hash(key: &str) -> i32 {
+        let mut hash = 0_i64;
+        const MODULUS: i64 = 1000000007;
+
+        for c in key.chars() {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;
+        }
+
+        hash as i32
+    }
     ```
 
 === "C"
 
     ```c title="simple_hash.c"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = (hash + (unsigned char)key[i]) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = (31 * hash + (unsigned char)key[i]) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(char *key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
 
-    [class]{}-[func]{rotHash}
+        for (int i = 0; i < strlen(key); i++) {
+            hash ^= (unsigned char)key[i];
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    int rotHash(char *key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (int i = 0; i < strlen(key); i++) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;
+        }
+
+        return (int)hash;
+    }
     ```
 
 === "Zig"

zh/chapter_heap/build_heap.md

@@ -30,73 +30,176 @@ comments: true
 === "Python"
 
     ```python title="my_heap.py"
-    [class]{MaxHeap}-[func]{__init__}
+    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"
-    [class]{MaxHeap}-[func]{MaxHeap}
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(vector<int> nums) {
+        // 将列表元素原封不动添加进堆
+        maxHeap = nums;
+        // 堆化除叶节点以外的其他所有节点
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="my_heap.java"
-    [class]{MaxHeap}-[func]{MaxHeap}
+    /* 构造方法，根据输入列表建堆 */
+    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"
-    [class]{MaxHeap}-[func]{MaxHeap}
+    /* 构造函数，根据输入列表建堆 */
+    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"
-    [class]{maxHeap}-[func]{newMaxHeap}
+    /* 构造函数，根据切片建堆 */
+    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"
-    [class]{MaxHeap}-[func]{init}
+    /* 构造方法，根据输入列表建堆 */
+    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"
-    [class]{MaxHeap}-[func]{constructor}
+    /* 构造方法，建立空堆或根据输入列表建堆 */
+    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"
-    [class]{MaxHeap}-[func]{constructor}
+    /* 构造方法，建立空堆或根据输入列表建堆 */
+    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"
-    [class]{MaxHeap}-[func]{MaxHeap}
+    /* 构造方法，根据输入列表建堆 */
+    MaxHeap(List<int> nums) {
+      // 将列表元素原封不动添加进堆
+      _maxHeap = nums;
+      // 堆化除叶节点以外的其他所有节点
+      for (int i = _parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="my_heap.rs"
-    [class]{MaxHeap}-[func]{new}
+    /* 构造方法，根据输入列表建堆 */
+    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"
-    [class]{maxHeap}-[func]{newMaxHeap}
+    /* 构造函数，根据切片建堆 */
+    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(h, size - 1); i >= 0; i--) {
+            // 堆化除叶节点以外的其他所有节点
+            siftDown(h, i);
+        }
+        return h;
+    }
     ```
 
 === "Zig"
 
     ```zig title="my_heap.zig"
-    [class]{MaxHeap}-[func]{init}
+    // 构造方法，根据输入列表建堆
+    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; 复杂度分析

zh/chapter_heap/top_k.md

@@ -79,61 +79,219 @@ comments: true
 === "Python"
 
     ```python title="top_k.py"
-    [class]{}-[func]{top_k_heap}
+    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"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 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"
-    [class]{top_k}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 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"
-    [class]{top_k}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 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"
 
     ```go title="top_k.go"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 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"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 k 个元素 */
+    func topKHeap(nums: [Int], k: Int) -> [Int] {
+        // 将数组的前 k 个元素入堆
+        var heap = Array(nums.prefix(k))
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for i in stride(from: k, to: nums.count, by: 1) {
+            // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if nums[i] > heap.first! {
+                heap.removeFirst()
+                heap.insert(nums[i], at: 0)
+            }
+        }
+        return heap
+    }
     ```
 
 === "JS"
 
     ```javascript title="top_k.js"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 k 个元素 */
+    function topKHeap(nums, k) {
+        // 使用大顶堆 MaxHeap ，对数组 nums 取相反数
+        const invertedNums = nums.map((num) => -num);
+        // 将数组的前 k 个元素入堆
+        const heap = new MaxHeap(invertedNums.slice(0, k));
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (let i = k; i < invertedNums.length; i++) {
+            // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (invertedNums[i] < heap.peek()) {
+                heap.pop();
+                heap.push(invertedNums[i]);
+            }
+        }
+        // 取出堆中元素
+        const maxHeap = heap.getMaxHeap();
+        // 对堆中元素取相反数
+        const invertedMaxHeap = maxHeap.map((num) => -num);
+        return invertedMaxHeap;
+    }
     ```
 
 === "TS"
 
     ```typescript title="top_k.ts"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 k 个元素 */
+    function topKHeap(nums: number[], k: number): number[] {
+        // 将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+        const invertedNums = nums.map((num) => -num);
+        // 将数组的前 k 个元素入堆
+        const heap = new MaxHeap(invertedNums.slice(0, k));
+        // 从第 k+1 个元素开始，保持堆的长度为 k
+        for (let i = k; i < invertedNums.length; i++) {
+            // 若当前元素小于堆顶元素，则将堆顶元素出堆、当前元素入堆
+            if (invertedNums[i] < heap.peek()) {
+                heap.pop();
+                heap.push(invertedNums[i]);
+            }
+        }
+        // 取出堆中元素
+        const maxHeap = heap.getMaxHeap();
+        // 对堆中元素取相反数
+        const invertedMaxHeap = maxHeap.map((num) => -num);
+        return invertedMaxHeap;
+    }
     ```
 
 === "Dart"
 
     ```dart title="top_k.dart"
-    [class]{}-[func]{topKHeap}
+    /* 基于堆查找数组中最大的 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"
-    [class]{}-[func]{top_k_heap}
+    /* 基于堆查找数组中最大的 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
+    }
     ```
 
 === "C"

zh/chapter_searching/binary_search.md

@@ -54,73 +54,282 @@ comments: true
 === "Python"
 
     ```python title="binary_search.py"
-    [class]{}-[func]{binary_search}
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找（双闭区间）"""
+        # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j = 0, len(nums) - 1
+        # 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j:
+            # 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # 此情况说明 target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # 此情况说明 target 在区间 [i, m-1] 中
+            else:
+                return m  # 找到目标元素，返回其索引
+        return -1  # 未找到目标元素，返回 -1
     ```
 
 === "C++"
 
     ```cpp title="binary_search.cpp"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    int binarySearch(vector<int> &nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.size() - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search.java"
-    [class]{binary_search}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    int binarySearch(int[] nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search.cs"
-    [class]{binary_search}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    int binarySearch(int[] nums, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = nums.Length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2;   // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search.go"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j := 0, len(nums)-1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        for i <= j {
+            m := i + (j-i)/2      // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search.swift"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    func binarySearch(nums: [Int], target: Int) -> Int {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i = 0
+        var j = nums.count - 1
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search.js"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    function binarySearch(nums, target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0,
+            j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            // 计算中点索引 m ，使用 parseInt() 向下取整
+            const m = parseInt(i + (j - i) / 2);
+            if (nums[m] < target)
+                // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target)
+                // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else return m; // 找到目标元素，返回其索引
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search.ts"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    function binarySearch(nums: number[], target: number): number {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let i = 0,
+            j = nums.length - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            // 计算中点索引 m
+            const m = Math.floor(i + (j - i) / 2);
+            if (nums[m] < target) {
+                // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if (nums[m] > target) {
+                // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {
+                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search.dart"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    int binarySearch(List<int> nums, int target) {
+      // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+      int i = 0, j = nums.length - 1;
+      // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j] 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m-1] 中
+          j = m - 1;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search.rs"
-    [class]{}-[func]{binary_search}
+    /* 二分查找（双闭区间） */
+    fn binary_search(nums: &[i32], target: i32) -> i32 {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let mut i = 0;
+        let mut j = nums.len() as i32 - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j {
+            let m = i + (j - i) / 2;      // 计算中点索引 m
+            if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                      // 找到目标元素，返回其索引
+                return m;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "C"
 
     ```c title="binary_search.c"
-    [class]{}-[func]{binarySearch}
+    /* 二分查找（双闭区间） */
+    int binarySearch(int *nums, int len, int target) {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        int i = 0, j = len - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Zig"
 
     ```zig title="binary_search.zig"
-    [class]{}-[func]{binarySearch}
+    // 二分查找（双闭区间）
+    fn binarySearch(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        var i: usize = 0;
+        var j: usize = nums.items.len - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while (i <= j) {
+            var m = i + (j - i) / 2;                // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 **时间复杂度 $O(\log n)$** ：在二分循环中，区间每轮缩小一半，循环次数为 $\log_2 n$ 。
@@ -136,73 +345,282 @@ comments: true
 === "Python"
 
     ```python title="binary_search.py"
-    [class]{}-[func]{binary_search_lcro}
+    def binary_search_lcro(nums: list[int], target: int) -> int:
+        """二分查找（左闭右开）"""
+        # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        i, j = 0, len(nums)
+        # 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # 此情况说明 target 在区间 [m+1, j) 中
+            elif nums[m] > target:
+                j = m  # 此情况说明 target 在区间 [i, m) 中
+            else:
+                return m  # 找到目标元素，返回其索引
+        return -1  # 未找到目标元素，返回 -1
     ```
 
 === "C++"
 
     ```cpp title="binary_search.cpp"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(vector<int> &nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.size();
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search.java"
-    [class]{binary_search}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(int[] nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search.cs"
-    [class]{binary_search}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(int[] nums, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = nums.Length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2;   // 计算中点索引 m
+            if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else                       // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search.go"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    func binarySearchLCRO(nums []int, target int) int {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        i, j := 0, len(nums)
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        for i < j {
+            m := i + (j-i)/2      // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+                j = m
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search.swift"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    func binarySearchLCRO(nums: [Int], target: Int) -> Int {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i = 0
+        var j = nums.count
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            } else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
+                j = m
+            } else { // 找到目标元素，返回其索引
+                return m
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search.js"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    function binarySearchLCRO(nums, target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0,
+            j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            // 计算中点索引 m ，使用 parseInt() 向下取整
+            const m = parseInt(i + (j - i) / 2);
+            if (nums[m] < target)
+                // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target)
+                // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            // 找到目标元素，返回其索引
+            else return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search.ts"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    function binarySearchLCRO(nums: number[], target: number): number {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let i = 0,
+            j = nums.length;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            // 计算中点索引 m
+            const m = Math.floor(i + (j - i) / 2);
+            if (nums[m] < target) {
+                // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums[m] > target) {
+                // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {
+                // 找到目标元素，返回其索引
+                return m;
+            }
+        }
+        return -1; // 未找到目标元素，返回 -1
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search.dart"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开区间） */
+    int binarySearchLCRO(List<int> nums, int target) {
+      // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+      int i = 0, j = nums.length;
+      // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+      while (i < j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j) 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m) 中
+          j = m;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search.rs"
-    [class]{}-[func]{binary_search_lcro}
+    /* 二分查找（左闭右开） */
+    fn binary_search_lcro(nums: &[i32], target: i32) -> i32 {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let mut i = 0;
+        let mut j = nums.len() as i32;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j {
+            let m = i + (j - i) / 2;      // 计算中点索引 m
+            if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m) 中
+                j = m - 1;
+            } else {                      // 找到目标元素，返回其索引
+                return m;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "C"
 
     ```c title="binary_search.c"
-    [class]{}-[func]{binarySearchLCRO}
+    /* 二分查找（左闭右开） */
+    int binarySearchLCRO(int *nums, int len, int target) {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        int i = 0, j = len;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i < j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            else // 找到目标元素，返回其索引
+                return m;
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 === "Zig"
 
     ```zig title="binary_search.zig"
-    [class]{}-[func]{binarySearchLCRO}
+    // 二分查找（左闭右开）
+    fn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        var i: usize = 0;
+        var j: usize = nums.items.len;
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while (i <= j) {
+            var m = i + (j - i) / 2;                // 计算中点索引 m
+            if (nums.items[m] < target) {           // 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1;
+            } else if (nums.items[m] > target) {    // 此情况说明 target 在区间 [i, m) 中
+                j = m;
+            } else {                                // 找到目标元素，返回其索引
+                return @intCast(m);
+            }
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
     ```
 
 如图 10-3 所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。

zh/chapter_searching/binary_search_edge.md

@@ -22,67 +22,175 @@ comments: true
 === "Python"
 
     ```python title="binary_search_edge.py"
-    [class]{}-[func]{binary_search_left_edge}
+    def binary_search_left_edge(nums: list[int], target: int) -> int:
+        """二分查找最左一个 target"""
+        # 等价于查找 target 的插入点
+        i = binary_search_insertion(nums, target)
+        # 未找到 target ，返回 -1
+        if i == len(nums) or nums[i] != target:
+            return -1
+        # 找到 target ，返回索引 i
+        return i
     ```
 
 === "C++"
 
     ```cpp title="binary_search_edge.cpp"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(vector<int> &nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.size() || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search_edge.java"
-    [class]{binary_search_edge}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(int[] nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binary_search_insertion.binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.length || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search_edge.cs"
-    [class]{binary_search_edge}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(int[] nums, int target) {
+        // 等价于查找 target 的插入点
+        int i = binary_search_insertion.binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i == nums.Length || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search_edge.go"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    func binarySearchLeftEdge(nums []int, target int) int {
+        // 等价于查找 target 的插入点
+        i := binarySearchInsertion(nums, target)
+        // 未找到 target ，返回 -1
+        if i == len(nums) || nums[i] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 i
+        return i
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search_edge.swift"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    func binarySearchLeftEdge(nums: [Int], target: Int) -> Int {
+        // 等价于查找 target 的插入点
+        let i = binarySearchInsertion(nums: nums, target: target)
+        // 未找到 target ，返回 -1
+        if i == nums.count || nums[i] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 i
+        return i
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search_edge.js"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    function binarySearchLeftEdge(nums, target) {
+        // 等价于查找 target 的插入点
+        const i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i === nums.length || nums[i] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search_edge.ts"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    function binarySearchLeftEdge(nums: Array<number>, target: number): number {
+        // 等价于查找 target 的插入点
+        const i = binarySearchInsertion(nums, target);
+        // 未找到 target ，返回 -1
+        if (i === nums.length || nums[i] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(List<int> nums, int target) {
+      // 等价于查找 target 的插入点
+      int i = binarySearchInsertion(nums, target);
+      // 未找到 target ，返回 -1
+      if (i == nums.length || nums[i] != target) {
+        return -1;
+      }
+      // 找到 target ，返回索引 i
+      return i;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search_edge.rs"
-    [class]{}-[func]{binary_search_left_edge}
+    /* 二分查找最左一个 target */
+    fn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {
+        // 等价于查找 target 的插入点
+        let i = binary_search_insertion(nums, target);
+        // 未找到 target ，返回 -1
+        if i == nums.len() as i32 || nums[i as usize] != target {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        i
+    }
     ```
 
 === "C"
 
     ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchLeftEdge}
+    /* 二分查找最左一个 target */
+    int binarySearchLeftEdge(int *nums, int numSize, int target) {
+        // 等价于查找 target 的插入点
+        int i = binarySearchInsertion(nums, numSize, target);
+        // 未找到 target ，返回 -1
+        if (i == numSize || nums[i] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 i
+        return i;
+    }
     ```
 
 === "Zig"
@@ -112,67 +220,197 @@ comments: true
 === "Python"
 
     ```python title="binary_search_edge.py"
-    [class]{}-[func]{binary_search_right_edge}
+    def binary_search_right_edge(nums: list[int], target: int) -> int:
+        """二分查找最右一个 target"""
+        # 转化为查找最左一个 target + 1
+        i = binary_search_insertion(nums, target + 1)
+        # j 指向最右一个 target ，i 指向首个大于 target 的元素
+        j = i - 1
+        # 未找到 target ，返回 -1
+        if j == -1 or nums[j] != target:
+            return -1
+        # 找到 target ，返回索引 j
+        return j
     ```
 
 === "C++"
 
     ```cpp title="binary_search_edge.cpp"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(vector<int> &nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search_edge.java"
-    [class]{binary_search_edge}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(int[] nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search_edge.cs"
-    [class]{binary_search_edge}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(int[] nums, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search_edge.go"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    func binarySearchRightEdge(nums []int, target int) int {
+        // 转化为查找最左一个 target + 1
+        i := binarySearchInsertion(nums, target+1)
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        j := i - 1
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 j
+        return j
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search_edge.swift"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    func binarySearchRightEdge(nums: [Int], target: Int) -> Int {
+        // 转化为查找最左一个 target + 1
+        let i = binarySearchInsertion(nums: nums, target: target + 1)
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        let j = i - 1
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j] != target {
+            return -1
+        }
+        // 找到 target ，返回索引 j
+        return j
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search_edge.js"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    function binarySearchRightEdge(nums, target) {
+        // 转化为查找最左一个 target + 1
+        const i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        const j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j === -1 || nums[j] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search_edge.ts"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    function binarySearchRightEdge(nums: Array<number>, target: number): number {
+        // 转化为查找最左一个 target + 1
+        const i = binarySearchInsertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        const j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j === -1 || nums[j] !== target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(List<int> nums, int target) {
+      // 转化为查找最左一个 target + 1
+      int i = binarySearchInsertion(nums, target + 1);
+      // j 指向最右一个 target ，i 指向首个大于 target 的元素
+      int j = i - 1;
+      // 未找到 target ，返回 -1
+      if (j == -1 || nums[j] != target) {
+        return -1;
+      }
+      // 找到 target ，返回索引 j
+      return j;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search_edge.rs"
-    [class]{}-[func]{binary_search_right_edge}
+    /* 二分查找最右一个 target */
+    fn binary_search_right_edge(nums: &[i32], target: i32) -> i32 {
+        // 转化为查找最左一个 target + 1
+        let i = binary_search_insertion(nums, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        let j = i - 1;
+        // 未找到 target ，返回 -1
+        if j == -1 || nums[j as usize] != target {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        j
+    }
     ```
 
 === "C"
 
     ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchRightEdge}
+    /* 二分查找最右一个 target */
+    int binarySearchRightEdge(int *nums, int numSize, int target) {
+        // 转化为查找最左一个 target + 1
+        int i = binarySearchInsertion(nums, numSize, target + 1);
+        // j 指向最右一个 target ，i 指向首个大于 target 的元素
+        int j = i - 1;
+        // 未找到 target ，返回 -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // 找到 target ，返回索引 j
+        return j;
+    }
     ```
 
 === "Zig"

zh/chapter_searching/binary_search_insertion.md

@@ -31,67 +31,239 @@ comments: true
 === "Python"
 
     ```python title="binary_search_insertion.py"
-    [class]{}-[func]{binary_search_insertion_simple}
+    def binary_search_insertion_simple(nums: list[int], target: int) -> int:
+        """二分查找插入点（无重复元素）"""
+        i, j = 0, len(nums) - 1  # 初始化双闭区间 [0, n-1]
+        while i <= j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # target 在区间 [i, m-1] 中
+            else:
+                return m  # 找到 target ，返回插入点 m
+        # 未找到 target ，返回插入点 i
+        return i
     ```
 
 === "C++"
 
     ```cpp title="binary_search_insertion.cpp"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(vector<int> &nums, int target) {
+        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search_insertion.java"
-    [class]{binary_search_insertion}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search_insertion.cs"
-    [class]{binary_search_insertion}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search_insertion.go"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    func binarySearchInsertionSimple(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1]
+        i, j := 0, len(nums)-1
+        for i <= j {
+            // 计算中点索引 m
+            m := i + (j-i)/2
+            if nums[m] < target {
+                // target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target {
+                // target 在区间 [i, m-1] 中
+                j = m - 1
+            } else {
+                // 找到 target ，返回插入点 m
+                return m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search_insertion.swift"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    func binarySearchInsertionSimple(nums: [Int], target: Int) -> Int {
+        var i = 0, j = nums.count - 1 // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if nums[m] > target {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                return m // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search_insertion.js"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    function binarySearchInsertionSimple(nums, target) {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search_insertion.ts"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    function binarySearchInsertionSimple(
+        nums: Array<number>,
+        target: number
+    ): number {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search_insertion.dart"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          i = m + 1; // target 在区间 [m+1, j] 中
+        } else if (nums[m] > target) {
+          j = m - 1; // target 在区间 [i, m-1] 中
+        } else {
+          return m; // 找到 target ，返回插入点 m
+        }
+      }
+      // 未找到 target ，返回插入点 i
+      return i;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search_insertion.rs"
-    [class]{}-[func]{binary_search_insertion}
+    /* 二分查找插入点（存在重复元素） */
+    pub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {
+        let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2;    // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1;  // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1;  // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1;  // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        i
+    }
     ```
 
 === "C"
 
     ```c title="binary_search_insertion.c"
-    [class]{}-[func]{binarySearchInsertionSimple}
+    /* 二分查找插入点（无重复元素） */
+    int binarySearchInsertionSimple(int *nums, int numSize, int target) {
+        int i = 0, j = numSize - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                return m; // 找到 target ，返回插入点 m
+            }
+        }
+        // 未找到 target ，返回插入点 i
+        return i;
+    }
     ```
 
 === "Zig"
@@ -159,67 +331,236 @@ comments: true
 === "Python"
 
     ```python title="binary_search_insertion.py"
-    [class]{}-[func]{binary_search_insertion}
+    def binary_search_insertion(nums: list[int], target: int) -> int:
+        """二分查找插入点（存在重复元素）"""
+        i, j = 0, len(nums) - 1  # 初始化双闭区间 [0, n-1]
+        while i <= j:
+            m = (i + j) // 2  # 计算中点索引 m
+            if nums[m] < target:
+                i = m + 1  # target 在区间 [m+1, j] 中
+            elif nums[m] > target:
+                j = m - 1  # target 在区间 [i, m-1] 中
+            else:
+                j = m - 1  # 首个小于 target 的元素在区间 [i, m-1] 中
+        # 返回插入点 i
+        return i
     ```
 
 === "C++"
 
     ```cpp title="binary_search_insertion.cpp"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(vector<int> &nums, int target) {
+        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_search_insertion.java"
-    [class]{binary_search_insertion}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_search_insertion.cs"
-    [class]{binary_search_insertion}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_search_insertion.go"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    func binarySearchInsertion(nums []int, target int) int {
+        // 初始化双闭区间 [0, n-1]
+        i, j := 0, len(nums)-1
+        for i <= j {
+            // 计算中点索引 m
+            m := i + (j-i)/2
+            if nums[m] < target {
+                // target 在区间 [m+1, j] 中
+                i = m + 1
+            } else if nums[m] > target {
+                // target 在区间 [i, m-1] 中
+                j = m - 1
+            } else {
+                // 首个小于 target 的元素在区间 [i, m-1] 中
+                j = m - 1
+            }
+        }
+        // 返回插入点 i
+        return i
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_search_insertion.swift"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    func binarySearchInsertion(nums: [Int], target: Int) -> Int {
+        var i = 0, j = nums.count - 1 // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2 // 计算中点索引 m
+            if nums[m] < target {
+                i = m + 1 // target 在区间 [m+1, j] 中
+            } else if nums[m] > target {
+                j = m - 1 // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1 // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_search_insertion.js"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    function binarySearchInsertion(nums, target) {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_search_insertion.ts"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    function binarySearchInsertion(nums: Array<number>, target: number): number {
+        let i = 0,
+            j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_search_insertion.dart"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(List<int> nums, int target) {
+      int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          i = m + 1; // target 在区间 [m+1, j] 中
+        } else if (nums[m] > target) {
+          j = m - 1; // target 在区间 [i, m-1] 中
+        } else {
+          j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+        }
+      }
+      // 返回插入点 i
+      return i;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_search_insertion.rs"
-    [class]{}-[func]{binary_search_insertion}
+    /* 二分查找插入点（存在重复元素） */
+    pub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {
+        let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2;    // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1;  // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1;  // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1;  // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        i
+    }
     ```
 
 === "C"
 
     ```c title="binary_search_insertion.c"
-    [class]{}-[func]{binarySearchInsertion}
+    /* 二分查找插入点（存在重复元素） */
+    int binarySearchInsertion(int *nums, int numSize, int target) {
+        int i = 0, j = numSize - 1; // 初始化双闭区间 [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // 计算中点索引 m
+            if (nums[m] < target) {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if (nums[m] > target) {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        // 返回插入点 i
+        return i;
+    }
     ```
 
 === "Zig"

zh/chapter_searching/replace_linear_by_hashing.md

@@ -21,73 +21,210 @@ comments: true
 === "Python"
 
     ```python title="two_sum.py"
-    [class]{}-[func]{two_sum_brute_force}
+    def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
+        """方法一：暴力枚举"""
+        # 两层循环，时间复杂度 O(n^2)
+        for i in range(len(nums) - 1):
+            for j in range(i + 1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return [i, j]
+        return []
     ```
 
 === "C++"
 
     ```cpp title="two_sum.cpp"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    vector<int> twoSumBruteForce(vector<int> &nums, int target) {
+        int size = nums.size();
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return {i, j};
+            }
+        }
+        return {};
+    }
     ```
 
 === "Java"
 
     ```java title="two_sum.java"
-    [class]{two_sum}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    int[] twoSumBruteForce(int[] nums, int target) {
+        int size = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return new int[] { i, j };
+            }
+        }
+        return new int[0];
+    }
     ```
 
 === "C#"
 
     ```csharp title="two_sum.cs"
-    [class]{two_sum}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    int[] twoSumBruteForce(int[] nums, int target) {
+        int size = nums.Length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return new int[] { i, j };
+            }
+        }
+        return Array.Empty<int>();
+    }
     ```
 
 === "Go"
 
     ```go title="two_sum.go"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    func twoSumBruteForce(nums []int, target int) []int {
+        size := len(nums)
+        // 两层循环，时间复杂度 O(n^2)
+        for i := 0; i < size-1; i++ {
+            for j := i + 1; i < size; j++ {
+                if nums[i]+nums[j] == target {
+                    return []int{i, j}
+                }
+            }
+        }
+        return nil
+    }
     ```
 
 === "Swift"
 
     ```swift title="two_sum.swift"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    func twoSumBruteForce(nums: [Int], target: Int) -> [Int] {
+        // 两层循环，时间复杂度 O(n^2)
+        for i in nums.indices.dropLast() {
+            for j in nums.indices.dropFirst(i + 1) {
+                if nums[i] + nums[j] == target {
+                    return [i, j]
+                }
+            }
+        }
+        return [0]
+    }
     ```
 
 === "JS"
 
     ```javascript title="two_sum.js"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    function twoSumBruteForce(nums, target) {
+        const n = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] === target) {
+                    return [i, j];
+                }
+            }
+        }
+        return [];
+    }
     ```
 
 === "TS"
 
     ```typescript title="two_sum.ts"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    function twoSumBruteForce(nums: number[], target: number): number[] {
+        const n = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] + nums[j] === target) {
+                    return [i, j];
+                }
+            }
+        }
+        return [];
+    }
     ```
 
 === "Dart"
 
     ```dart title="two_sum.dart"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一： 暴力枚举 */
+    List<int> twoSumBruteForce(List<int> nums, int target) {
+      int size = nums.length;
+      // 两层循环，时间复杂度 O(n^2)
+      for (var i = 0; i < size - 1; i++) {
+        for (var j = i + 1; j < size; j++) {
+          if (nums[i] + nums[j] == target) return [i, j];
+        }
+      }
+      return [0];
+    }
     ```
 
 === "Rust"
 
     ```rust title="two_sum.rs"
-    [class]{}-[func]{two_sum_brute_force}
+    /* 方法一：暴力枚举 */
+    pub fn two_sum_brute_force(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        let size = nums.len();
+        // 两层循环，时间复杂度 O(n^2)
+        for i in 0..size - 1 {
+            for j in i + 1..size {
+                if nums[i] + nums[j] == target {
+                    return Some(vec![i as i32, j as i32]);
+                }
+            }
+        }
+        None
+    }
     ```
 
 === "C"
 
     ```c title="two_sum.c"
-    [class]{}-[func]{twoSumBruteForce}
+    /* 方法一：暴力枚举 */
+    int *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {
+        for (int i = 0; i < numsSize; ++i) {
+            for (int j = i + 1; j < numsSize; ++j) {
+                if (nums[i] + nums[j] == target) {
+                    int *res = malloc(sizeof(int) * 2);
+                    res[0] = i, res[1] = j;
+                    *returnSize = 2;
+                    return res;
+                }
+            }
+        }
+        *returnSize = 0;
+        return NULL;
+    }
     ```
 
 === "Zig"
 
     ```zig title="two_sum.zig"
-    [class]{}-[func]{twoSumBruteForce}
+    // 方法一：暴力枚举
+    fn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {
+        var size: usize = nums.len;
+        var i: usize = 0;
+        // 两层循环，时间复杂度 O(n^2)
+        while (i < size - 1) : (i += 1) {
+            var j = i + 1;
+            while (j < size) : (j += 1) {
+                if (nums[i] + nums[j] == target) {
+                    return [_]i32{@intCast(i), @intCast(j)};
+                }
+            }
+        }
+        return null;
+    }
     ```
 
 此方法的时间复杂度为 $O(n^2)$ ，空间复杂度为 $O(1)$ ，在大数据量下非常耗时。
@@ -115,75 +252,255 @@ comments: true
 === "Python"
 
     ```python title="two_sum.py"
-    [class]{}-[func]{two_sum_hash_table}
+    def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
+        """方法二：辅助哈希表"""
+        # 辅助哈希表，空间复杂度 O(n)
+        dic = {}
+        # 单层循环，时间复杂度 O(n)
+        for i in range(len(nums)):
+            if target - nums[i] in dic:
+                return [dic[target - nums[i]], i]
+            dic[nums[i]] = i
+        return []
     ```
 
 === "C++"
 
     ```cpp title="two_sum.cpp"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    vector<int> twoSumHashTable(vector<int> &nums, int target) {
+        int size = nums.size();
+        // 辅助哈希表，空间复杂度 O(n)
+        unordered_map<int, int> dic;
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.find(target - nums[i]) != dic.end()) {
+                return {dic[target - nums[i]], i};
+            }
+            dic.emplace(nums[i], i);
+        }
+        return {};
+    }
     ```
 
 === "Java"
 
     ```java title="two_sum.java"
-    [class]{two_sum}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    int[] twoSumHashTable(int[] nums, int target) {
+        int size = nums.length;
+        // 辅助哈希表，空间复杂度 O(n)
+        Map<Integer, Integer> dic = new HashMap<>();
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.containsKey(target - nums[i])) {
+                return new int[] { dic.get(target - nums[i]), i };
+            }
+            dic.put(nums[i], i);
+        }
+        return new int[0];
+    }
     ```
 
 === "C#"
 
     ```csharp title="two_sum.cs"
-    [class]{two_sum}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    int[] twoSumHashTable(int[] nums, int target) {
+        int size = nums.Length;
+        // 辅助哈希表，空间复杂度 O(n)
+        Dictionary<int, int> dic = new();
+        // 单层循环，时间复杂度 O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.ContainsKey(target - nums[i])) {
+                return new int[] { dic[target - nums[i]], i };
+            }
+            dic.Add(nums[i], i);
+        }
+        return Array.Empty<int>();
+    }
     ```
 
 === "Go"
 
     ```go title="two_sum.go"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    func twoSumHashTable(nums []int, target int) []int {
+        // 辅助哈希表，空间复杂度 O(n)
+        hashTable := map[int]int{}
+        // 单层循环，时间复杂度 O(n)
+        for idx, val := range nums {
+            if preIdx, ok := hashTable[target-val]; ok {
+                return []int{preIdx, idx}
+            }
+            hashTable[val] = idx
+        }
+        return nil
+    }
     ```
 
 === "Swift"
 
     ```swift title="two_sum.swift"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    func twoSumHashTable(nums: [Int], target: Int) -> [Int] {
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic: [Int: Int] = [:]
+        // 单层循环，时间复杂度 O(n)
+        for i in nums.indices {
+            if let j = dic[target - nums[i]] {
+                return [j, i]
+            }
+            dic[nums[i]] = i
+        }
+        return [0]
+    }
     ```
 
 === "JS"
 
     ```javascript title="two_sum.js"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    function twoSumHashTable(nums, target) {
+        // 辅助哈希表，空间复杂度 O(n)
+        let m = {};
+        // 单层循环，时间复杂度 O(n)
+        for (let i = 0; i < nums.length; i++) {
+            if (m[target - nums[i]] !== undefined) {
+                return [m[target - nums[i]], i];
+            } else {
+                m[nums[i]] = i;
+            }
+        }
+        return [];
+    }
     ```
 
 === "TS"
 
     ```typescript title="two_sum.ts"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二：辅助哈希表 */
+    function twoSumHashTable(nums: number[], target: number): number[] {
+        // 辅助哈希表，空间复杂度 O(n)
+        let m: Map<number, number> = new Map();
+        // 单层循环，时间复杂度 O(n)
+        for (let i = 0; i < nums.length; i++) {
+            let index = m.get(target - nums[i]);
+            if (index !== undefined) {
+                return [index, i];
+            } else {
+                m.set(nums[i], i);
+            }
+        }
+        return [];
+    }
     ```
 
 === "Dart"
 
     ```dart title="two_sum.dart"
-    [class]{}-[func]{twoSumHashTable}
+    /* 方法二： 辅助哈希表 */
+    List<int> twoSumHashTable(List<int> nums, int target) {
+      int size = nums.length;
+      // 辅助哈希表，空间复杂度 O(n)
+      Map<int, int> dic = HashMap();
+      // 单层循环，时间复杂度 O(n)
+      for (var i = 0; i < size; i++) {
+        if (dic.containsKey(target - nums[i])) {
+          return [dic[target - nums[i]]!, i];
+        }
+        dic.putIfAbsent(nums[i], () => i);
+      }
+      return [0];
+    }
     ```
 
 === "Rust"
 
     ```rust title="two_sum.rs"
-    [class]{}-[func]{two_sum_hash_table}
+    /* 方法二：辅助哈希表 */
+    pub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        // 辅助哈希表，空间复杂度 O(n)
+        let mut dic = HashMap::new();
+        // 单层循环，时间复杂度 O(n)
+        for (i, num) in nums.iter().enumerate() {
+            match dic.get(&(target - num)) {
+                Some(v) => return Some(vec![*v as i32, i as i32]),
+                None => dic.insert(num, i as i32)
+            };
+        }
+        None
+    }
     ```
 
 === "C"
 
     ```c title="two_sum.c"
-    [class]{hashTable}-[func]{}
+    /* 哈希表 */
+    struct hashTable {
+        int key;
+        int val;
+        UT_hash_handle hh; // 基于 uthash.h 实现
+    };
 
-    [class]{}-[func]{twoSumHashTable}
+    typedef struct hashTable hashTable;
+
+    /* 哈希表查询 */
+    hashTable *find(hashTable *h, int key) {
+        hashTable *tmp;
+        HASH_FIND_INT(h, &key, tmp);
+        return tmp;
+    }
+
+    /* 哈希表元素插入 */
+    void insert(hashTable *h, int key, int val) {
+        hashTable *t = find(h, key);
+        if (t == NULL) {
+            hashTable *tmp = malloc(sizeof(hashTable));
+            tmp->key = key, tmp->val = val;
+            HASH_ADD_INT(h, key, tmp);
+        } else {
+            t->val = val;
+        }
+    }
+
+    /* 方法二：辅助哈希表 */
+    int *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {
+        hashTable *hashtable = NULL;
+        for (int i = 0; i < numsSize; i++) {
+            hashTable *t = find(hashtable, target - nums[i]);
+            if (t != NULL) {
+                int *res = malloc(sizeof(int) * 2);
+                res[0] = t->val, res[1] = i;
+                *returnSize = 2;
+                return res;
+            }
+            insert(hashtable, nums[i], i);
+        }
+        *returnSize = 0;
+        return NULL;
+    }
     ```
 
 === "Zig"
 
     ```zig title="two_sum.zig"
-    [class]{}-[func]{twoSumHashTable}
+    // 方法二：辅助哈希表
+    fn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {
+        var size: usize = nums.len;
+        // 辅助哈希表，空间复杂度 O(n)
+        var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);
+        defer dic.deinit();
+        var i: usize = 0;
+        // 单层循环，时间复杂度 O(n)
+        while (i < size) : (i += 1) {
+            if (dic.contains(target - nums[i])) {
+                return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};
+            }
+            try dic.put(nums[i], @intCast(i));
+        }
+        return null;
+    }
     ```
 
 此方法通过哈希查找将时间复杂度从 $O(n^2)$ 降低至 $O(n)$ ，大幅提升运行效率。

zh/chapter_sorting/bubble_sort.md

@@ -47,73 +47,234 @@ comments: true
 === "Python"
 
     ```python title="bubble_sort.py"
-    [class]{}-[func]{bubble_sort}
+    def bubble_sort(nums: list[int]):
+        """冒泡排序"""
+        n = len(nums)
+        # 外循环：未排序区间为 [0, i]
+        for i in range(n - 1, 0, -1):
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j in range(i):
+                if nums[j] > nums[j + 1]:
+                    # 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
     ```
 
 === "C++"
 
     ```cpp title="bubble_sort.cpp"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    void bubbleSort(vector<int> &nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.size() - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
+                }
+            }
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="bubble_sort.java"
-    [class]{bubble_sort}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    void bubbleSort(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="bubble_sort.cs"
-    [class]{bubble_sort}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    void bubbleSort(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="bubble_sort.go"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    func bubbleSort(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := len(nums) - 1; i > 0; i-- {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j := 0; j < i; j++ {
+                if nums[j] > nums[j+1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j+1] = nums[j+1], nums[j]
+                }
+            }
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="bubble_sort.swift"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    func bubbleSort(nums: inout [Int]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in stride(from: 0, to: i, by: 1) {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j]
+                    nums[j] = nums[j + 1]
+                    nums[j + 1] = tmp
+                }
+            }
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="bubble_sort.js"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    function bubbleSort(nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="bubble_sort.ts"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    function bubbleSort(nums: number[]): void {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="bubble_sort.dart"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    void bubbleSort(List<int> nums) {
+      // 外循环：未排序区间为 [0, i]
+      for (int i = nums.length - 1; i > 0; i--) {
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+        for (int j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            int tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+          }
+        }
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="bubble_sort.rs"
-    [class]{}-[func]{bubble_sort}
+    /* 冒泡排序 */
+    fn bubble_sort(nums: &mut [i32]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in (1..nums.len()).rev() {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in 0..i {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 === "C"
 
     ```c title="bubble_sort.c"
-    [class]{}-[func]{bubbleSort}
+    /* 冒泡排序 */
+    void bubbleSort(int nums[], int size) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = 0; i < size - 1; i++) {
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < size - 1 - i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                }
+            }
+        }
+    }
     ```
 
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-    [class]{}-[func]{bubbleSort}
+    // 冒泡排序
+    fn bubbleSort(nums: []i32) void {
+        // 外循环：未排序区间为 [0, i]
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var j: usize = 0;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
     ```
 
 ## 11.3.2 &nbsp; 效率优化
@@ -125,73 +286,277 @@ comments: true
 === "Python"
 
     ```python title="bubble_sort.py"
-    [class]{}-[func]{bubble_sort_with_flag}
+    def bubble_sort_with_flag(nums: list[int]):
+        """冒泡排序（标志优化）"""
+        n = len(nums)
+        # 外循环：未排序区间为 [0, i]
+        for i in range(n - 1, 0, -1):
+            flag = False  # 初始化标志位
+            # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j in range(i):
+                if nums[j] > nums[j + 1]:
+                    # 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
+                    flag = True  # 记录交换元素
+            if not flag:
+                break  # 此轮冒泡未交换任何元素，直接跳出
     ```
 
 === "C++"
 
     ```cpp title="bubble_sort.cpp"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(vector<int> &nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.size() - 1; i > 0; i--) {
+            bool flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    // 这里使用了 std::swap() 函数
+                    swap(nums[j], nums[j + 1]);
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag)
+                break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="bubble_sort.java"
-    [class]{bubble_sort}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化） */
+    void bubbleSortWithFlag(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            boolean flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag)
+                break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="bubble_sort.cs"
-    [class]{bubble_sort}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(int[] nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            bool flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;  // 记录交换元素
+                }
+            }
+            if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="bubble_sort.go"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    func bubbleSortWithFlag(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := len(nums) - 1; i > 0; i-- {
+            flag := false // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for j := 0; j < i; j++ {
+                if nums[j] > nums[j+1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    nums[j], nums[j+1] = nums[j+1], nums[j]
+                    flag = true // 记录交换元素
+                }
+            }
+            if flag == false { // 此轮冒泡未交换任何元素，直接跳出
+                break
+            }
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="bubble_sort.swift"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    func bubbleSortWithFlag(nums: inout [Int]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            var flag = false // 初始化标志位
+            for j in stride(from: 0, to: i, by: 1) {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j]
+                    nums[j] = nums[j + 1]
+                    nums[j + 1] = tmp
+                    flag = true // 记录交换元素
+                }
+            }
+            if !flag { // 此轮冒泡未交换任何元素，直接跳出
+                break
+            }
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="bubble_sort.js"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    function bubbleSortWithFlag(nums) {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            let flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="bubble_sort.ts"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    function bubbleSortWithFlag(nums: number[]): void {
+        // 外循环：未排序区间为 [0, i]
+        for (let i = nums.length - 1; i > 0; i--) {
+            let flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (let j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // 记录交换元素
+                }
+            }
+            if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="bubble_sort.dart"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(List<int> nums) {
+      // 外循环：未排序区间为 [0, i]
+      for (int i = nums.length - 1; i > 0; i--) {
+        bool flag = false; // 初始化标志位
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+        for (int j = 0; j < i; j++) {
+          if (nums[j] > nums[j + 1]) {
+            // 交换 nums[j] 与 nums[j + 1]
+            int tmp = nums[j];
+            nums[j] = nums[j + 1];
+            nums[j + 1] = tmp;
+            flag = true; // 记录交换元素
+          }
+        }
+        if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="bubble_sort.rs"
-    [class]{}-[func]{bubble_sort_with_flag}
+    /* 冒泡排序（标志优化） */
+    fn bubble_sort_with_flag(nums: &mut [i32]) {
+        // 外循环：未排序区间为 [0, i]
+        for i in (1..nums.len()).rev() {
+            let mut flag = false; // 初始化标志位
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            for j in 0..i {
+                if nums[j] > nums[j + 1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    let tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;  // 记录交换元素
+                }
+            }
+            if !flag {break};  // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 === "C"
 
     ```c title="bubble_sort.c"
-    [class]{}-[func]{bubbleSortWithFlag}
+    /* 冒泡排序（标志优化）*/
+    void bubbleSortWithFlag(int nums[], int size) {
+        // 外循环：未排序区间为 [0, i]
+        for (int i = 0; i < size - 1; i++) {
+            bool flag = false;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
+            for (int j = 0; j < size - 1 - i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    int temp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = temp;
+                    flag = true;
+                }
+            }
+            if (!flag)
+                break;
+        }
+    }
     ```
 
 === "Zig"
 
     ```zig title="bubble_sort.zig"
-    [class]{}-[func]{bubbleSortWithFlag}
+    // 冒泡排序（标志优化）
+    fn bubbleSortWithFlag(nums: []i32) void {
+        // 外循环：未排序区间为 [0, i]
+        var i: usize = nums.len - 1;
+        while (i > 0) : (i -= 1) {
+            var flag = false;   // 初始化标志位
+            var j: usize = 0;
+            // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+            while (j < i) : (j += 1) {
+                if (nums[j] > nums[j + 1]) {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    var tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true;
+                }
+            }
+            if (!flag) break;   // 此轮冒泡未交换任何元素，直接跳出
+        }
+    }
     ```
 
 ## 11.3.3 &nbsp; 算法特性

zh/chapter_sorting/bucket_sort.md

@@ -23,67 +23,367 @@ comments: true
 === "Python"
 
     ```python title="bucket_sort.py"
-    [class]{}-[func]{bucket_sort}
+    def bucket_sort(nums: list[float]):
+        """桶排序"""
+        # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        k = len(nums) // 2
+        buckets = [[] for _ in range(k)]
+        # 1. 将数组元素分配到各个桶中
+        for num in nums:
+            # 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            i = int(num * k)
+            # 将 num 添加进桶 i
+            buckets[i].append(num)
+        # 2. 对各个桶执行排序
+        for bucket in buckets:
+            # 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort()
+        # 3. 遍历桶合并结果
+        i = 0
+        for bucket in buckets:
+            for num in bucket:
+                nums[i] = num
+                i += 1
     ```
 
 === "C++"
 
     ```cpp title="bucket_sort.cpp"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(vector<float> &nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.size() / 2;
+        vector<vector<float>> buckets(k);
+        // 1. 将数组元素分配到各个桶中
+        for (float num : nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = num * k;
+            // 将 num 添加进桶 bucket_idx
+            buckets[i].push_back(num);
+        }
+        // 2. 对各个桶执行排序
+        for (vector<float> &bucket : buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            sort(bucket.begin(), bucket.end());
+        }
+        // 3. 遍历桶合并结果
+        int i = 0;
+        for (vector<float> &bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="bucket_sort.java"
-    [class]{bucket_sort}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(float[] nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.length / 2;
+        List<List<Float>> buckets = new ArrayList<>();
+        for (int i = 0; i < k; i++) {
+            buckets.add(new ArrayList<>());
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (float num : nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = (int) (num * k);
+            // 将 num 添加进桶 i
+            buckets.get(i).add(num);
+        }
+        // 2. 对各个桶执行排序
+        for (List<Float> bucket : buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            Collections.sort(bucket);
+        }
+        // 3. 遍历桶合并结果
+        int i = 0;
+        for (List<Float> bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="bucket_sort.cs"
-    [class]{bucket_sort}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(float[] nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = nums.Length / 2;
+        List<List<float>> buckets = new List<List<float>>();
+        for (int i = 0; i < k; i++) {
+            buckets.Add(new List<float>());
+        }
+        // 1. 将数组元素分配到各个桶中
+        foreach (float num in nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int i = (int)(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].Add(num);
+        }
+        // 2. 对各个桶执行排序
+        foreach (List<float> bucket in buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.Sort();
+        }
+        // 3. 遍历桶合并结果
+        int j = 0;
+        foreach (List<float> bucket in buckets) {
+            foreach (float num in bucket) {
+                nums[j++] = num;
+            }
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="bucket_sort.go"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    func bucketSort(nums []float64) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        k := len(nums) / 2
+        buckets := make([][]float64, k)
+        for i := 0; i < k; i++ {
+            buckets[i] = make([]float64, 0)
+        }
+        // 1. 将数组元素分配到各个桶中
+        for _, num := range nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            i := int(num * float64(k))
+            // 将 num 添加进桶 i
+            buckets[i] = append(buckets[i], num)
+        }
+        // 2. 对各个桶执行排序
+        for i := 0; i < k; i++ {
+            // 使用内置切片排序函数，也可以替换成其他排序算法
+            sort.Float64s(buckets[i])
+        }
+        // 3. 遍历桶合并结果
+        i := 0
+        for _, bucket := range buckets {
+            for _, num := range bucket {
+                nums[i] = num
+                i++
+            }
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="bucket_sort.swift"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    func bucketSort(nums: inout [Double]) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        let k = nums.count / 2
+        var buckets = (0 ..< k).map { _ in [Double]() }
+        // 1. 将数组元素分配到各个桶中
+        for num in nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            let i = Int(num * Double(k))
+            // 将 num 添加进桶 i
+            buckets[i].append(num)
+        }
+        // 2. 对各个桶执行排序
+        for i in buckets.indices {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            buckets[i].sort()
+        }
+        // 3. 遍历桶合并结果
+        var i = nums.startIndex
+        for bucket in buckets {
+            for num in bucket {
+                nums[i] = num
+                nums.formIndex(after: &i)
+            }
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="bucket_sort.js"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    function bucketSort(nums) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        const k = nums.length / 2;
+        const buckets = [];
+        for (let i = 0; i < k; i++) {
+            buckets.push([]);
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (const num of nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            const i = Math.floor(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for (const bucket of buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort((a, b) => a - b);
+        }
+        // 3. 遍历桶合并结果
+        let i = 0;
+        for (const bucket of buckets) {
+            for (const num of bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="bucket_sort.ts"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    function bucketSort(nums: number[]): void {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        const k = nums.length / 2;
+        const buckets: number[][] = [];
+        for (let i = 0; i < k; i++) {
+            buckets.push([]);
+        }
+        // 1. 将数组元素分配到各个桶中
+        for (const num of nums) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            const i = Math.floor(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for (const bucket of buckets) {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort((a, b) => a - b);
+        }
+        // 3. 遍历桶合并结果
+        let i = 0;
+        for (const bucket of buckets) {
+            for (const num of bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="bucket_sort.dart"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(List<double> nums) {
+      // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+      int k = nums.length ~/ 2;
+      List<List<double>> buckets = List.generate(k, (index) => []);
+
+      // 1. 将数组元素分配到各个桶中
+      for (double num in nums) {
+        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        int i = (num * k).toInt();
+        // 将 num 添加进桶 bucket_idx
+        buckets[i].add(num);
+      }
+      // 2. 对各个桶执行排序
+      for (List<double> bucket in buckets) {
+        bucket.sort();
+      }
+      // 3. 遍历桶合并结果
+      int i = 0;
+      for (List<double> bucket in buckets) {
+        for (double num in bucket) {
+          nums[i++] = num;
+        }
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="bucket_sort.rs"
-    [class]{}-[func]{bucket_sort}
+    /* 桶排序 */
+    fn bucket_sort(nums: &mut [f64]) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        let k = nums.len() / 2;
+        let mut buckets = vec![vec![]; k];
+        // 1. 将数组元素分配到各个桶中
+        for &mut num in &mut *nums {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            let i = (num * k as f64) as usize;
+            // 将 num 添加进桶 i
+            buckets[i].push(num);
+        }
+        // 2. 对各个桶执行排序
+        for bucket in &mut buckets {
+            // 使用内置排序函数，也可以替换成其他排序算法
+            bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());
+        }
+        // 3. 遍历桶合并结果
+        let mut i = 0;
+        for bucket in &mut buckets {
+            for &mut num in bucket {
+                nums[i] = num;
+                i += 1;
+            }
+        }
+    }
     ```
 
 === "C"
 
     ```c title="bucket_sort.c"
-    [class]{}-[func]{bucketSort}
+    /* 桶排序 */
+    void bucketSort(float nums[], int size) {
+        // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
+        int k = size / 2;
+        float **buckets = calloc(k, sizeof(float *));
+        for (int i = 0; i < k; i++) {
+            // 每个桶最多可以分配 k 个元素
+            buckets[i] = calloc(ARRAY_SIZE, sizeof(float));
+        }
+
+        // 1. 将数组元素分配到各个桶中
+        for (int i = 0; i < size; i++) {
+            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            int bucket_idx = nums[i] * k;
+            int j = 0;
+            // 如果桶中有数据且数据小于当前值 nums[i], 要将其放到当前桶的后面，相当于 cpp 中的 push_back
+            while (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {
+                j++;
+            }
+            float temp = nums[i];
+            while (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {
+                swap(&temp, &buckets[bucket_idx][j]);
+                j++;
+            }
+            buckets[bucket_idx][j] = temp;
+        }
+
+        // 2. 对各个桶执行排序
+        for (int i = 0; i < k; i++) {
+            qsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);
+        }
+
+        // 3. 遍历桶合并结果
+        for (int i = 0, j = 0; j < k; j++) {
+            for (int l = 0; l < ARRAY_SIZE; l++) {
+                if (buckets[j][l] > 0) {
+                    nums[i++] = buckets[j][l];
+                }
+            }
+        }
+
+        // 释放上述分配的内存
+        for (int i = 0; i < k; i++) {
+            free(buckets[i]);
+        }
+        free(buckets);
+    }
     ```
 
 === "Zig"

zh/chapter_sorting/counting_sort.md

@@ -21,67 +21,294 @@ comments: true
 === "Python"
 
     ```python title="counting_sort.py"
-    [class]{}-[func]{counting_sort_naive}
+    def counting_sort_naive(nums: list[int]):
+        """计数排序"""
+        # 简单实现，无法用于排序对象
+        # 1. 统计数组最大元素 m
+        m = 0
+        for num in nums:
+            m = max(m, num)
+        # 2. 统计各数字的出现次数
+        # counter[num] 代表 num 的出现次数
+        counter = [0] * (m + 1)
+        for num in nums:
+            counter[num] += 1
+        # 3. 遍历 counter ，将各元素填入原数组 nums
+        i = 0
+        for num in range(m + 1):
+            for _ in range(counter[num]):
+                nums[i] = num
+                i += 1
     ```
 
 === "C++"
 
     ```cpp title="counting_sort.cpp"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(vector<int> &nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        vector<int> counter(m + 1, 0);
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="counting_sort.java"
-    [class]{counting_sort}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="counting_sort.cs"
-    [class]{counting_sort}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="counting_sort.go"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    func countingSortNaive(nums []int) {
+        // 1. 统计数组最大元素 m
+        m := 0
+        for _, num := range nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        counter := make([]int, m+1)
+        for _, num := range nums {
+            counter[num]++
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        for i, num := 0, 0; num < m+1; num++ {
+            for j := 0; j < counter[num]; j++ {
+                nums[i] = num
+                i++
+            }
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="counting_sort.swift"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    func countingSortNaive(nums: inout [Int]) {
+        // 1. 统计数组最大元素 m
+        let m = nums.max()!
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        var counter = Array(repeating: 0, count: m + 1)
+        for num in nums {
+            counter[num] += 1
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        var i = 0
+        for num in stride(from: 0, to: m + 1, by: 1) {
+            for _ in stride(from: 0, to: counter[num], by: 1) {
+                nums[i] = num
+                i += 1
+            }
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="counting_sort.js"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    function countingSortNaive(nums) {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter = new Array(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let i = 0;
+        for (let num = 0; num < m + 1; num++) {
+            for (let j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="counting_sort.ts"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    function countingSortNaive(nums: number[]): void {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter: number[] = new Array<number>(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let i = 0;
+        for (let num = 0; num < m + 1; num++) {
+            for (let j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="counting_sort.dart"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+      // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 遍历 counter ，将各元素填入原数组 nums
+      int i = 0;
+      for (int num = 0; num < m + 1; num++) {
+        for (int j = 0; j < counter[num]; j++, i++) {
+          nums[i] = num;
+        }
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="counting_sort.rs"
-    [class]{}-[func]{counting_sort_naive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    fn counting_sort_naive(nums: &mut [i32]) {
+        // 1. 统计数组最大元素 m
+        let m = *nums.into_iter().max().unwrap();
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        let mut counter = vec![0; m as usize + 1];
+        for &num in &*nums {
+            counter[num as usize] += 1;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        let mut i = 0;
+        for num in 0..m + 1 {
+            for _ in 0..counter[num as usize] {
+                nums[i] = num;
+                i += 1;
+            }
+        }
+    }
     ```
 
 === "C"
 
     ```c title="counting_sort.c"
-    [class]{}-[func]{countingSortNaive}
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    void countingSortNaive(int nums[], int size) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int i = 0; i < size; i++) {
+            if (nums[i] > m) {
+                m = nums[i];
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int *counter = malloc(sizeof(int) * m);
+        for (int i = 0; i < size; i++) {
+            counter[nums[i]]++;
+        }
+        // 3. 遍历 counter ，将各元素填入原数组 nums
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
     ```
 
 === "Zig"
@@ -142,67 +369,401 @@ $$
 === "Python"
 
     ```python title="counting_sort.py"
-    [class]{}-[func]{counting_sort}
+    def counting_sort(nums: list[int]):
+        """计数排序"""
+        # 完整实现，可排序对象，并且是稳定排序
+        # 1. 统计数组最大元素 m
+        m = max(nums)
+        # 2. 统计各数字的出现次数
+        # counter[num] 代表 num 的出现次数
+        counter = [0] * (m + 1)
+        for num in nums:
+            counter[num] += 1
+        # 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        # 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in range(m):
+            counter[i + 1] += counter[i]
+        # 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        # 初始化数组 res 用于记录结果
+        n = len(nums)
+        res = [0] * n
+        for i in range(n - 1, -1, -1):
+            num = nums[i]
+            res[counter[num] - 1] = num  # 将 num 放置到对应索引处
+            counter[num] -= 1  # 令前缀和自减 1 ，得到下次放置 num 的索引
+        # 使用结果数组 res 覆盖原数组 nums
+        for i in range(n):
+            nums[i] = res[i]
     ```
 
 === "C++"
 
     ```cpp title="counting_sort.cpp"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(vector<int> &nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        vector<int> counter(m + 1, 0);
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.size();
+        vector<int> res(n);
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        nums = res;
+    }
     ```
 
 === "Java"
 
     ```java title="counting_sort.java"
-    [class]{counting_sort}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="counting_sort.cs"
-    [class]{counting_sort}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(int[] nums) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int n = nums.Length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="counting_sort.go"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    func countingSort(nums []int) {
+        // 1. 统计数组最大元素 m
+        m := 0
+        for _, num := range nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        counter := make([]int, m+1)
+        for _, num := range nums {
+            counter[num]++
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i := 0; i < m; i++ {
+            counter[i+1] += counter[i]
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        n := len(nums)
+        res := make([]int, n)
+        for i := n - 1; i >= 0; i-- {
+            num := nums[i]
+            // 将 num 放置到对应索引处
+            res[counter[num]-1] = num
+            // 令前缀和自减 1 ，得到下次放置 num 的索引
+            counter[num]--
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        copy(nums, res)
+    }
     ```
 
 === "Swift"
 
     ```swift title="counting_sort.swift"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    func countingSort(nums: inout [Int]) {
+        // 1. 统计数组最大元素 m
+        let m = nums.max()!
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        var counter = Array(repeating: 0, count: m + 1)
+        for num in nums {
+            counter[num] += 1
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in stride(from: 0, to: m, by: 1) {
+            counter[i + 1] += counter[i]
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        var res = Array(repeating: 0, count: nums.count)
+        for i in stride(from: nums.count - 1, through: 0, by: -1) {
+            let num = nums[i]
+            res[counter[num] - 1] = num // 将 num 放置到对应索引处
+            counter[num] -= 1 // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for i in stride(from: 0, to: nums.count, by: 1) {
+            nums[i] = res[i]
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="counting_sort.js"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    function countingSort(nums) {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter = new Array(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (let i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        const n = nums.length;
+        const res = new Array(n);
+        for (let i = n - 1; i >= 0; i--) {
+            const num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="counting_sort.ts"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    function countingSort(nums: number[]): void {
+        // 1. 统计数组最大元素 m
+        let m = 0;
+        for (const num of nums) {
+            m = Math.max(m, num);
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        const counter: number[] = new Array<number>(m + 1).fill(0);
+        for (const num of nums) {
+            counter[num]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (let i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        const n = nums.length;
+        const res: number[] = new Array<number>(n);
+        for (let i = n - 1; i >= 0; i--) {
+            const num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="counting_sort.dart"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(List<int> nums) {
+      // 1. 统计数组最大元素 m
+      int m = 0;
+      for (int num in nums) {
+        m = max(m, num);
+      }
+      // 2. 统计各数字的出现次数
+      // counter[num] 代表 num 的出现次数
+      List<int> counter = List.filled(m + 1, 0);
+      for (int num in nums) {
+        counter[num]++;
+      }
+      // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+      // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+      for (int i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+      }
+      // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+      // 初始化数组 res 用于记录结果
+      int n = nums.length;
+      List<int> res = List.filled(n, 0);
+      for (int i = n - 1; i >= 0; i--) {
+        int num = nums[i];
+        res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+        counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+      }
+      // 使用结果数组 res 覆盖原数组 nums
+      nums.setAll(0, res);
+    }
     ```
 
 === "Rust"
 
     ```rust title="counting_sort.rs"
-    [class]{}-[func]{counting_sort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    fn counting_sort(nums: &mut [i32]) {
+        // 1. 统计数组最大元素 m
+        let m = *nums.into_iter().max().unwrap();
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        let mut counter = vec![0; m as usize + 1];
+        for &num in &*nums {
+            counter[num as usize] += 1;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for i in 0..m as usize {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        let n = nums.len();
+        let mut res = vec![0; n];
+        for i in (0..n).rev() {
+            let num = nums[i];
+            res[counter[num as usize] - 1] = num; // 将 num 放置到对应索引处
+            counter[num as usize] -= 1; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        for i in 0..n {
+            nums[i] = res[i];
+        }
+    }
     ```
 
 === "C"
 
     ```c title="counting_sort.c"
-    [class]{}-[func]{countingSort}
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    void countingSort(int nums[], int size) {
+        // 1. 统计数组最大元素 m
+        int m = 0;
+        for (int i = 0; i < size; i++) {
+            if (nums[i] > m) {
+                m = nums[i];
+            }
+        }
+        // 2. 统计各数字的出现次数
+        // counter[num] 代表 num 的出现次数
+        int *counter = malloc(sizeof(int) * m);
+        for (int i = 0; i < size; i++) {
+            counter[nums[i]]++;
+        }
+        // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+        // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+        // 初始化数组 res 用于记录结果
+        int *res = malloc(sizeof(int) * size);
+        for (int i = size - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+            counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
+        }
+        // 使用结果数组 res 覆盖原数组 nums
+        memcpy(nums, res, size * sizeof(int));
+    }
     ```
 
 === "Zig"

zh/chapter_sorting/heap_sort.md

@@ -71,89 +71,467 @@ comments: true
 === "Python"
 
     ```python title="heap_sort.py"
-    [class]{}-[func]{sift_down}
+    def sift_down(nums: list[int], n: int, i: int):
+        """堆的长度为 n ，从节点 i 开始，从顶至底堆化"""
+        while True:
+            # 判断节点 i, l, r 中值最大的节点，记为 ma
+            l = 2 * i + 1
+            r = 2 * i + 2
+            ma = i
+            if l < n and nums[l] > nums[ma]:
+                ma = l
+            if r < n and nums[r] > nums[ma]:
+                ma = r
+            # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i:
+                break
+            # 交换两节点
+            nums[i], nums[ma] = nums[ma], nums[i]
+            # 循环向下堆化
+            i = ma
 
-    [class]{}-[func]{heap_sort}
+    def heap_sort(nums: list[int]):
+        """堆排序"""
+        # 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in range(len(nums) // 2 - 1, -1, -1):
+            sift_down(nums, len(nums), i)
+        # 从堆中提取最大元素，循环 n-1 轮
+        for i in range(len(nums) - 1, 0, -1):
+            # 交换根节点与最右叶节点（即交换首元素与尾元素）
+            nums[0], nums[i] = nums[i], nums[0]
+            # 以根节点为起点，从顶至底进行堆化
+            sift_down(nums, i, 0)
     ```
 
 === "C++"
 
     ```cpp title="heap_sort.cpp"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(vector<int> &nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i) {
+                break;
+            }
+            // 交换两节点
+            swap(nums[i], nums[ma]);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(vector<int> &nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.size() / 2 - 1; i >= 0; --i) {
+            siftDown(nums, nums.size(), i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.size() - 1; i > 0; --i) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            swap(nums[0], nums[i]);
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="heap_sort.java"
-    [class]{heap_sort}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int[] nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i)
+                break;
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{heap_sort}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(int[] nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="heap_sort.cs"
-    [class]{heap_sort}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int[] nums, int n, int i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i)
+                break;
+            // 交换两节点
+            (nums[ma], nums[i]) = (nums[i], nums[ma]);
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{heap_sort}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(int[] nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = nums.Length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.Length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            (nums[i], nums[0]) = (nums[0], nums[i]);
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="heap_sort.go"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    func siftDown(nums *[]int, n, i int) {
+        for true {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            l := 2*i + 1
+            r := 2*i + 2
+            ma := i
+            if l < n && (*nums)[l] > (*nums)[ma] {
+                ma = l
+            }
+            if r < n && (*nums)[r] > (*nums)[ma] {
+                ma = r
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break
+            }
+            // 交换两节点
+            (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]
+            // 循环向下堆化
+            i = ma
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    func heapSort(nums *[]int) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i := len(*nums)/2 - 1; i >= 0; i-- {
+            siftDown(nums, len(*nums), i)
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i := len(*nums) - 1; i > 0; i-- {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0)
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="heap_sort.swift"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    func siftDown(nums: inout [Int], n: Int, i: Int) {
+        var i = i
+        while true {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1
+            let r = 2 * i + 2
+            var ma = i
+            if l < n, nums[l] > nums[ma] {
+                ma = l
+            }
+            if r < n, nums[r] > nums[ma] {
+                ma = r
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break
+            }
+            // 交换两节点
+            nums.swapAt(i, ma)
+            // 循环向下堆化
+            i = ma
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    func heapSort(nums: inout [Int]) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {
+            siftDown(nums: &nums, n: nums.count, i: i)
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i in stride(from: nums.count - 1, to: 0, by: -1) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            nums.swapAt(0, i)
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums: &nums, n: i, i: 0)
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="heap_sort.js"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    function siftDown(nums, n, i) {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let ma = i;
+            if (l < n && nums[l] > nums[ma]) {
+                ma = l;
+            }
+            if (r < n && nums[r] > nums[ma]) {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma === i) {
+                break;
+            }
+            // 交换两节点
+            [nums[i], nums[ma]] = [nums[ma], nums[i]];
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    function heapSort(nums) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            [nums[0], nums[i]] = [nums[i], nums[0]];
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="heap_sort.ts"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    function siftDown(nums: number[], n: number, i: number): void {
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let ma = i;
+            if (l < n && nums[l] > nums[ma]) {
+                ma = l;
+            }
+            if (r < n && nums[r] > nums[ma]) {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma === i) {
+                break;
+            }
+            // 交换两节点
+            [nums[i], nums[ma]] = [nums[ma], nums[i]];
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    function heapSort(nums: number[]): void {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (let i = nums.length - 1; i > 0; i--) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            [nums[0], nums[i]] = [nums[i], nums[0]];
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="heap_sort.dart"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(List<int> nums, int n, int i) {
+      while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = 2 * i + 1;
+        int r = 2 * i + 2;
+        int ma = i;
+        if (l < n && nums[l] > nums[ma]) ma = l;
+        if (r < n && nums[r] > nums[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i) break;
+        // 交换两节点
+        int temp = nums[i];
+        nums[i] = nums[ma];
+        nums[ma] = temp;
+        // 循环向下堆化
+        i = ma;
+      }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(List<int> nums) {
+      // 建堆操作：堆化除叶节点以外的其他所有节点
+      for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {
+        siftDown(nums, nums.length, i);
+      }
+      // 从堆中提取最大元素，循环 n-1 轮
+      for (int i = nums.length - 1; i > 0; i--) {
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        int tmp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = tmp;
+        // 以根节点为起点，从顶至底进行堆化
+        siftDown(nums, i, 0);
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="heap_sort.rs"
-    [class]{}-[func]{sift_down}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    fn sift_down(nums: &mut [i32], n: usize, mut i: usize) {
+        loop {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            let l = 2 * i + 1;
+            let r = 2 * i + 2;
+            let mut ma = i;
+            if l < n && nums[l] > nums[ma] {
+                ma = l;
+            }
+            if r < n && nums[r] > nums[ma] {
+                ma = r;
+            }
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if ma == i {
+                break;
+            }
+            // 交换两节点
+            let temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heap_sort}
+    /* 堆排序 */
+    fn heap_sort(nums: &mut [i32]) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for i in (0..=nums.len() / 2 - 1).rev() {
+            sift_down(nums, nums.len(), i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for i in (1..=nums.len() - 1).rev() {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            let tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            sift_down(nums, i, 0);
+        }
+    }
     ```
 
 === "C"
 
     ```c title="heap_sort.c"
-    [class]{}-[func]{siftDown}
+    /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
+    void siftDown(int nums[], int n, int i) {
+        while (1) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i) {
+                break;
+            }
+            // 交换两节点
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // 循环向下堆化
+            i = ma;
+        }
+    }
 
-    [class]{}-[func]{heapSort}
+    /* 堆排序 */
+    void heapSort(int nums[], int n) {
+        // 建堆操作：堆化除叶节点以外的其他所有节点
+        for (int i = n / 2 - 1; i >= 0; --i) {
+            siftDown(nums, n, i);
+        }
+        // 从堆中提取最大元素，循环 n-1 轮
+        for (int i = n - 1; i > 0; --i) {
+            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // 以根节点为起点，从顶至底进行堆化
+            siftDown(nums, i, 0);
+        }
+    }
     ```
 
 === "Zig"

zh/chapter_sorting/insertion_sort.md

@@ -30,73 +30,222 @@ comments: true
 === "Python"
 
     ```python title="insertion_sort.py"
-    [class]{}-[func]{insertion_sort}
+    def insertion_sort(nums: list[int]):
+        """插入排序"""
+        # 外循环：已排序区间为 [0, i-1]
+        for i in range(1, len(nums)):
+            base = nums[i]
+            j = i - 1
+            # 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
+            while j >= 0 and nums[j] > base:
+                nums[j + 1] = nums[j]  # 将 nums[j] 向右移动一位
+                j -= 1
+            nums[j + 1] = base  # 将 base 赋值到正确位置
     ```
 
 === "C++"
 
     ```cpp title="insertion_sort.cpp"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    void insertionSort(vector<int> &nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.size(); i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="insertion_sort.java"
-    [class]{insertion_sort}-[func]{insertionSort}
+    /* 插入排序 */
+    void insertionSort(int[] nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.length; i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base;        // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="insertion_sort.cs"
-    [class]{insertion_sort}-[func]{insertionSort}
+    /* 插入排序 */
+    void insertionSort(int[] nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < nums.Length; i++) {
+            int bas = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > bas) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = bas;         // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="insertion_sort.go"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    func insertionSort(nums []int) {
+        // 外循环：未排序区间为 [0, i]
+        for i := 1; i < len(nums); i++ {
+            base := nums[i]
+            j := i - 1
+            // 内循环：将 base 插入到已排序部分的正确位置
+            for j >= 0 && nums[j] > base {
+                nums[j+1] = nums[j] // 将 nums[j] 向右移动一位
+                j--
+            }
+            nums[j+1] = base // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="insertion_sort.swift"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    func insertionSort(nums: inout [Int]) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for i in stride(from: 1, to: nums.count, by: 1) {
+            let base = nums[i]
+            var j = i - 1
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while j >= 0, nums[j] > base {
+                nums[j + 1] = nums[j] // 将 nums[j] 向右移动一位
+                j -= 1
+            }
+            nums[j + 1] = base // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="insertion_sort.js"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    function insertionSort(nums) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (let i = 1; i < nums.length; i++) {
+            let base = nums[i],
+                j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="insertion_sort.ts"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    function insertionSort(nums: number[]): void {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (let i = 1; i < nums.length; i++) {
+            const base = nums[i];
+            let j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+                j--;
+            }
+            nums[j + 1] = base; // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="insertion_sort.dart"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    void insertionSort(List<int> nums) {
+      // 外循环：已排序元素数量为 1, 2, ..., n
+      for (int i = 1; i < nums.length; i++) {
+        int base = nums[i], j = i - 1;
+        // 内循环：将 base 插入到已排序部分的正确位置
+        while (j >= 0 && nums[j] > base) {
+          nums[j + 1] = nums[j]; // 将 nums[j] 向右移动一位
+          j--;
+        }
+        nums[j + 1] = base; // 将 base 赋值到正确位置
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="insertion_sort.rs"
-    [class]{}-[func]{insertion_sort}
+    /* 插入排序 */
+    fn insertion_sort(nums: &mut [i32]) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for i in 1..nums.len() {
+            let (base, mut j) = (nums[i],  (i - 1) as i32);
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while j >= 0 && nums[j as usize] > base {
+                nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位
+                j -= 1;
+            }
+            nums[(j + 1) as usize] = base;  // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 === "C"
 
     ```c title="insertion_sort.c"
-    [class]{}-[func]{insertionSort}
+    /* 插入排序 */
+    void insertionSort(int nums[], int size) {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        for (int i = 1; i < size; i++) {
+            int base = nums[i], j = i - 1;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 0 && nums[j] > base) {
+                // 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j];
+                j--;
+            }
+            // 将 base 赋值到正确位置
+            nums[j + 1] = base;
+        }
+    }
     ```
 
 === "Zig"
 
     ```zig title="insertion_sort.zig"
-    [class]{}-[func]{insertionSort}
+    // 插入排序
+    fn insertionSort(nums: []i32) void {
+        // 外循环：已排序元素数量为 1, 2, ..., n
+        var i: usize = 1;
+        while (i < nums.len) : (i += 1) {
+            var base = nums[i];
+            var j: usize = i;
+            // 内循环：将 base 插入到已排序部分的正确位置
+            while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
+                nums[j] = nums[j - 1];  // 将 nums[j] 向右移动一位
+            }
+            nums[j] = base;             // 将 base 赋值到正确位置
+        }
+    }
     ```
 
 ## 11.4.2 &nbsp; 算法特性

zh/chapter_sorting/merge_sort.md

@@ -62,97 +62,562 @@ comments: true
 === "Python"
 
     ```python title="merge_sort.py"
-    [class]{}-[func]{merge}
+    def merge(nums: list[int], left: int, mid: int, right: int):
+        """合并左子数组和右子数组"""
+        # 左子数组区间 [left, mid]
+        # 右子数组区间 [mid + 1, right]
+        # 初始化辅助数组
+        tmp = list(nums[left : right + 1])
+        # 左子数组的起始索引和结束索引
+        left_start = 0
+        left_end = mid - left
+        # 右子数组的起始索引和结束索引
+        right_start = mid + 1 - left
+        right_end = right - left
+        # i, j 分别指向左子数组、右子数组的首元素
+        i = left_start
+        j = right_start
+        # 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in range(left, right + 1):
+            # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > left_end:
+                nums[k] = tmp[j]
+                j += 1
+            # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            elif j > right_end or tmp[i] <= tmp[j]:
+                nums[k] = tmp[i]
+                i += 1
+            # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else:
+                nums[k] = tmp[j]
+                j += 1
 
-    [class]{}-[func]{merge_sort}
+    def merge_sort(nums: list[int], left: int, right: int):
+        """归并排序"""
+        # 终止条件
+        if left >= right:
+            return  # 当子数组长度为 1 时终止递归
+        # 划分阶段
+        mid = (left + right) // 2  # 计算中点
+        merge_sort(nums, left, mid)  # 递归左子数组
+        merge_sort(nums, mid + 1, right)  # 递归右子数组
+        # 合并阶段
+        merge(nums, left, mid, right)
     ```
 
 === "C++"
 
     ```cpp title="merge_sort.cpp"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(vector<int> &nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    void mergeSort(vector<int> &nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "Java"
 
     ```java title="merge_sort.java"
-    [class]{merge_sort}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(int[] nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        int[] tmp = Arrays.copyOfRange(nums, left, right + 1);
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
 
-    [class]{merge_sort}-[func]{mergeSort}
+    /* 归并排序 */
+    void mergeSort(int[] nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return;                      // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "C#"
 
     ```csharp title="merge_sort.cs"
-    [class]{merge_sort}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(int[] nums, int left, int mid, int right) {
+        // 初始化辅助数组
+        int[] tmp = nums[left..(right + 1)];
+        // 左子数组的起始索引和结束索引  
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引       
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
 
-    [class]{merge_sort}-[func]{mergeSort}
+    /* 归并排序 */
+    void mergeSort(int[] nums, int left, int right) {
+        // 终止条件
+        if (left >= right) return;       // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "Go"
 
     ```go title="merge_sort.go"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    func merge(nums []int, left, mid, right int) {
+        // 初始化辅助数组 借助 copy 模块
+        tmp := make([]int, right-left+1)
+        for i := left; i <= right; i++ {
+            tmp[i-left] = nums[i]
+        }
+        // 左子数组的起始索引和结束索引
+        leftStart, leftEnd := left-left, mid-left
+        // 右子数组的起始索引和结束索引
+        rightStart, rightEnd := mid+1-left, right-left
+        // i, j 分别指向左子数组、右子数组的首元素
+        i, j := leftStart, rightStart
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k := left; k <= right; k++ {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > leftEnd {
+                nums[k] = tmp[j]
+                j++
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if j > rightEnd || tmp[i] <= tmp[j] {
+                nums[k] = tmp[i]
+                i++
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j]
+                j++
+            }
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    func mergeSort(nums []int, left, right int) {
+        // 终止条件
+        if left >= right {
+            return
+        }
+        // 划分阶段
+        mid := (left + right) / 2
+        mergeSort(nums, left, mid)
+        mergeSort(nums, mid+1, right)
+        // 合并阶段
+        merge(nums, left, mid, right)
+    }
     ```
 
 === "Swift"
 
     ```swift title="merge_sort.swift"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
+        // 初始化辅助数组
+        let tmp = Array(nums[left ..< (right + 1)])
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left
+        let leftEnd = mid - left
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left
+        let rightEnd = right - left
+        // i, j 分别指向左子数组、右子数组的首元素
+        var i = leftStart
+        var j = rightStart
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in left ... right {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > leftEnd {
+                nums[k] = tmp[j]
+                j += 1
+            }
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if j > rightEnd || tmp[i] <= tmp[j] {
+                nums[k] = tmp[i]
+                i += 1
+            }
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else {
+                nums[k] = tmp[j]
+                j += 1
+            }
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    func mergeSort(nums: inout [Int], left: Int, right: Int) {
+        // 终止条件
+        if left >= right { // 当子数组长度为 1 时终止递归
+            return
+        }
+        // 划分阶段
+        let mid = (left + right) / 2 // 计算中点
+        mergeSort(nums: &nums, left: left, right: mid) // 递归左子数组
+        mergeSort(nums: &nums, left: mid + 1, right: right) // 递归右子数组
+        // 合并阶段
+        merge(nums: &nums, left: left, mid: mid, right: right)
+    }
     ```
 
 === "JS"
 
     ```javascript title="merge_sort.js"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    function merge(nums, left, mid, right) {
+        // 初始化辅助数组
+        let tmp = nums.slice(left, right + 1);
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left,
+            leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left,
+            rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        let i = leftStart,
+            j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (let k = left; k <= right; k++) {
+            if (i > leftEnd) {
+                // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+                nums[k] = tmp[i++];
+            } else {
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+            }
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    function mergeSort(nums, left, right) {
+        // 终止条件
+        if (left >= right) return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = Math.floor((left + right) / 2); // 计算中点
+        mergeSort(nums, left, mid); // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "TS"
 
     ```typescript title="merge_sort.ts"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    function merge(nums: number[], left: number, mid: number, right: number): void {
+        // 初始化辅助数组
+        let tmp = nums.slice(left, right + 1);
+        // 左子数组的起始索引和结束索引
+        let leftStart = left - left,
+            leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        let rightStart = mid + 1 - left,
+            rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        let i = leftStart,
+            j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (let k = left; k <= right; k++) {
+            if (i > leftEnd) {
+                // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+                nums[k] = tmp[j++];
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if (j > rightEnd || tmp[i] <= tmp[j]) {
+                nums[k] = tmp[i++];
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j++];
+            }
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    function mergeSort(nums: number[], left: number, right: number): void {
+        // 终止条件
+        if (left >= right) return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = Math.floor((left + right) / 2); // 计算中点
+        mergeSort(nums, left, mid); // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "Dart"
 
     ```dart title="merge_sort.dart"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(List<int> nums, int left, int mid, int right) {
+      // 初始化辅助数组
+      List<int> tmp = nums.sublist(left, right + 1);
+      // 左子数组的起始索引和结束索引
+      int leftStart = left - left, leftEnd = mid - left;
+      // 右子数组的起始索引和结束索引
+      int rightStart = mid + 1 - left, rightEnd = right - left;
+      // i, j 分别指向左子数组、右子数组的首元素
+      int i = leftStart, j = rightStart;
+      // 通过覆盖原数组 nums 来合并左子数组和右子数组
+      for (int k = left; k <= right; k++) {
+        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        if (i > leftEnd)
+          nums[k] = tmp[j++];
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+        else if (j > rightEnd || tmp[i] <= tmp[j])
+          nums[k] = tmp[i++];
+        // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        else
+          nums[k] = tmp[j++];
+      }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    void mergeSort(List<int> nums, int left, int right) {
+      // 终止条件
+      if (left >= right) return; // 当子数组长度为 1 时终止递归
+      // 划分阶段
+      int mid = (left + right) ~/ 2; // 计算中点
+      mergeSort(nums, left, mid); // 递归左子数组
+      mergeSort(nums, mid + 1, right); // 递归右子数组
+      // 合并阶段
+      merge(nums, left, mid, right);
+    }
     ```
 
 === "Rust"
 
     ```rust title="merge_sort.rs"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    fn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {
+        // 初始化辅助数组
+        let tmp: Vec<i32> = nums[left..right + 1].to_vec();
+        // 左子数组的起始索引和结束索引
+        let (left_start, left_end) = (left - left, mid - left);
+        // 右子数组的起始索引和结束索引
+        let (right_start, right_end) = (mid + 1 - left, right-left);
+        // i, j 分别指向左子数组、右子数组的首元素
+        let (mut l_corrent, mut r_corrent) = (left_start, right_start);
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k in left..right + 1 {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if l_corrent > left_end {
+                nums[k] = tmp[r_corrent];
+                r_corrent += 1;
+            }
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if r_corrent > right_end || tmp[l_corrent] <= tmp[r_corrent] {
+                nums[k] = tmp[l_corrent];
+                l_corrent += 1;
+            }
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else {
+                nums[k] = tmp[r_corrent];
+                r_corrent += 1;
+            }
+        }
+    }
 
-    [class]{}-[func]{merge_sort}
+    /* 归并排序 */
+    fn merge_sort(left: usize, right: usize, nums: &mut [i32]) {
+        // 终止条件
+        if left >= right { return; }       // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        let mid = (left + right) / 2;     // 计算中点
+        merge_sort(left, mid, nums);      // 递归左子数组
+        merge_sort(mid + 1, right, nums);  // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "C"
 
     ```c title="merge_sort.c"
-    [class]{}-[func]{merge}
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    void merge(int *nums, int left, int mid, int right) {
+        int index;
+        // 初始化辅助数组
+        int tmp[right + 1 - left];
+        for (index = left; index < right + 1; index++) {
+            tmp[index - left] = nums[index];
+        }
+        // 左子数组的起始索引和结束索引
+        int leftStart = left - left, leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引
+        int rightStart = mid + 1 - left, rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        int i = leftStart, j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for (int k = left; k <= right; k++) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd)
+                nums[k] = tmp[j++];
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            else if (j > rightEnd || tmp[i] <= tmp[j])
+                nums[k] = tmp[i++];
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            else
+                nums[k] = tmp[j++];
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    /* 归并排序 */
+    void mergeSort(int *nums, int left, int right) {
+        // 终止条件
+        if (left >= right)
+            return; // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
+        mergeSort(nums, left, mid);      // 递归左子数组
+        mergeSort(nums, mid + 1, right); // 递归右子数组
+        // 合并阶段
+        merge(nums, left, mid, right);
+    }
     ```
 
 === "Zig"
 
     ```zig title="merge_sort.zig"
-    [class]{}-[func]{merge}
+    // 合并左子数组和右子数组
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
+    fn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {
+        // 初始化辅助数组
+        var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+        defer mem_arena.deinit();
+        const mem_allocator = mem_arena.allocator();
+        var tmp = try mem_allocator.alloc(i32, right + 1 - left);
+        std.mem.copy(i32, tmp, nums[left..right+1]);
+        // 左子数组的起始索引和结束索引  
+        var leftStart = left - left;
+        var leftEnd = mid - left;
+        // 右子数组的起始索引和结束索引       
+        var rightStart = mid + 1 - left;
+        var rightEnd = right - left;
+        // i, j 分别指向左子数组、右子数组的首元素
+        var i = leftStart;
+        var j = rightStart;
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        var k = left;
+        while (k <= right) : (k += 1) {
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if (i > leftEnd) {
+                nums[k] = tmp[j];
+                j += 1;
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if  (j > rightEnd or tmp[i] <= tmp[j]) {
+                nums[k] = tmp[i];
+                i += 1;
+            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j];
+                j += 1;
+            }
+        }
+    }
 
-    [class]{}-[func]{mergeSort}
+    // 归并排序
+    fn mergeSort(nums: []i32, left: usize, right: usize) !void {
+        // 终止条件
+        if (left >= right) return;              // 当子数组长度为 1 时终止递归
+        // 划分阶段
+        var mid = (left + right) / 2;           // 计算中点
+        try mergeSort(nums, left, mid);         // 递归左子数组
+        try mergeSort(nums, mid + 1, right);    // 递归右子数组
+        // 合并阶段
+        try merge(nums, left, mid, right);
+    }
     ```
 
 实现合并函数 `merge()` 存在以下难点。

zh/chapter_sorting/radix_sort.md

@@ -33,121 +33,655 @@ $$
 === "Python"
 
     ```python title="radix_sort.py"
-    [class]{}-[func]{digit}
+    def digit(num: int, exp: int) -> int:
+        """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
+        # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num // exp) % 10
 
-    [class]{}-[func]{counting_sort_digit}
+    def counting_sort_digit(nums: list[int], exp: int):
+        """计数排序（根据 nums 第 k 位排序）"""
+        # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter = [0] * 10
+        n = len(nums)
+        # 统计 0~9 各数字的出现次数
+        for i in range(n):
+            d = digit(nums[i], exp)  # 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1  # 统计数字 d 的出现次数
+        # 求前缀和，将“出现个数”转换为“数组索引”
+        for i in range(1, 10):
+            counter[i] += counter[i - 1]
+        # 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res = [0] * n
+        for i in range(n - 1, -1, -1):
+            d = digit(nums[i], exp)
+            j = counter[d] - 1  # 获取 d 在数组中的索引 j
+            res[j] = nums[i]  # 将当前元素填入索引 j
+            counter[d] -= 1  # 将 d 的数量减 1
+        # 使用结果覆盖原数组 nums
+        for i in range(n):
+            nums[i] = res[i]
 
-    [class]{}-[func]{radix_sort}
+    def radix_sort(nums: list[int]):
+        """基数排序"""
+        # 获取数组的最大元素，用于判断最大位数
+        m = max(nums)
+        # 按照从低位到高位的顺序遍历
+        exp = 1
+        while exp <= m:
+            # 对数组元素的第 k 位执行计数排序
+            # k = 1 -> exp = 1
+            # k = 2 -> exp = 10
+            # 即 exp = 10^(k-1)
+            counting_sort_digit(nums, exp)
+            exp *= 10
     ```
 
 === "C++"
 
     ```cpp title="radix_sort.cpp"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(vector<int> &nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        vector<int> counter(10, 0);
+        int n = nums.size();
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        vector<int> res(n, 0);
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    void radixSort(vector<int> &nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = *max_element(nums.begin(), nums.end());
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
     ```
 
 === "Java"
 
     ```java title="radix_sort.java"
-    [class]{radix_sort}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
 
-    [class]{radix_sort}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int[] nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int[] counter = new int[10];
+        int n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
 
-    [class]{radix_sort}-[func]{radixSort}
+    /* 基数排序 */
+    void radixSort(int[] nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = Integer.MIN_VALUE;
+        for (int num : nums)
+            if (num > m)
+                m = num;
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+    }
     ```
 
 === "C#"
 
     ```csharp title="radix_sort.cs"
-    [class]{radix_sort}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
 
-    [class]{radix_sort}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int[] nums, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int[] counter = new int[10];
+        int n = nums.Length;
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++;                // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{radix_sort}-[func]{radixSort}
+    /* 基数排序 */
+    void radixSort(int[] nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        int m = int.MinValue;
+        foreach (int num in nums) {
+            if (num > m) m = num;
+        }
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="radix_sort.go"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num, exp int) int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums []int, exp int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        counter := make([]int, 10)
+        n := len(nums)
+        // 统计 0~9 各数字的出现次数
+        for i := 0; i < n; i++ {
+            d := digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++             // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i := 1; i < 10; i++ {
+            counter[i] += counter[i-1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        res := make([]int, n)
+        for i := n - 1; i >= 0; i-- {
+            d := digit(nums[i], exp)
+            j := counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i]    // 将当前元素填入索引 j
+            counter[d]--        // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i := 0; i < n; i++ {
+            nums[i] = res[i]
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    func radixSort(nums []int) {
+        // 获取数组的最大元素，用于判断最大位数
+        max := math.MinInt
+        for _, num := range nums {
+            if num > max {
+                max = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp := 1; max >= exp; exp *= 10 {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp)
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="radix_sort.swift"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num: Int, exp: Int) -> Int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        (num / exp) % 10
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    func countingSortDigit(nums: inout [Int], exp: Int) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var counter = Array(repeating: 0, count: 10)
+        let n = nums.count
+        // 统计 0~9 各数字的出现次数
+        for i in nums.indices {
+            let d = digit(num: nums[i], exp: exp) // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1 // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i in 1 ..< 10 {
+            counter[i] += counter[i - 1]
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = Array(repeating: 0, count: n)
+        for i in stride(from: n - 1, through: 0, by: -1) {
+            let d = digit(num: nums[i], exp: exp)
+            let j = counter[d] - 1 // 获取 d 在数组中的索引 j
+            res[j] = nums[i] // 将当前元素填入索引 j
+            counter[d] -= 1 // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i in nums.indices {
+            nums[i] = res[i]
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    func radixSort(nums: inout [Int]) {
+        // 获取数组的最大元素，用于判断最大位数
+        var m = Int.min
+        for num in nums {
+            if num > m {
+                m = num
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums: &nums, exp: exp)
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="radix_sort.js"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    function digit(num, exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return Math.floor(num / exp) % 10;
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    function countingSortDigit(nums, exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        const counter = new Array(10).fill(0);
+        const n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (let i = 0; i < n; i++) {
+            const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (let i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        const res = new Array(n).fill(0);
+        for (let i = n - 1; i >= 0; i--) {
+            const d = digit(nums[i], exp);
+            const j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d]--; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    function radixSort(nums) {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = Number.MIN_VALUE;
+        for (const num of nums) {
+            if (num > m) {
+                m = num;
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (let exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="radix_sort.ts"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    function digit(num: number, exp: number): number {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return Math.floor(num / exp) % 10;
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    function countingSortDigit(nums: number[], exp: number): void {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        const counter = new Array(10).fill(0);
+        const n = nums.length;
+        // 统计 0~9 各数字的出现次数
+        for (let i = 0; i < n; i++) {
+            const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d]++; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (let i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        const res = new Array(n).fill(0);
+        for (let i = n - 1; i >= 0; i--) {
+            const d = digit(nums[i], exp);
+            const j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d]--; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (let i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    function radixSort(nums: number[]): void {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = Number.MIN_VALUE;
+        for (const num of nums) {
+            if (num > m) {
+                m = num;
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (let exp = 1; exp <= m; exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="radix_sort.dart"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+      // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+      return (num ~/ exp) % 10;
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(List<int> nums, int exp) {
+      // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+      List<int> counter = List<int>.filled(10, 0);
+      int n = nums.length;
+      // 统计 0~9 各数字的出现次数
+      for (int i = 0; i < n; i++) {
+        int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+        counter[d]++; // 统计数字 d 的出现次数
+      }
+      // 求前缀和，将“出现个数”转换为“数组索引”
+      for (int i = 1; i < 10; i++) {
+        counter[i] += counter[i - 1];
+      }
+      // 倒序遍历，根据桶内统计结果，将各元素填入 res
+      List<int> res = List<int>.filled(n, 0);
+      for (int i = n - 1; i >= 0; i--) {
+        int d = digit(nums[i], exp);
+        int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+        res[j] = nums[i]; // 将当前元素填入索引 j
+        counter[d]--; // 将 d 的数量减 1
+      }
+      // 使用结果覆盖原数组 nums
+      for (int i = 0; i < n; i++) nums[i] = res[i];
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    void radixSort(List<int> nums) {
+      // 获取数组的最大元素，用于判断最大位数
+      // dart 中 int 的长度是 64 位的
+      int m = -1 << 63;
+      for (int num in nums) if (num > m) m = num;
+      // 按照从低位到高位的顺序遍历
+      for (int exp = 1; exp <= m; exp *= 10)
+        // 对数组元素的第 k 位执行计数排序
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // 即 exp = 10^(k-1)
+        countingSortDigit(nums, exp);
+    }
     ```
 
 === "Rust"
 
     ```rust title="radix_sort.rs"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    fn digit(num: i32, exp: i32) -> usize {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return ((num / exp) % 10) as usize;
+    }
 
-    [class]{}-[func]{counting_sort_digit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    fn counting_sort_digit(nums: &mut [i32], exp: i32) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        let mut counter = [0; 10];
+        let n = nums.len();
+        // 统计 0~9 各数字的出现次数
+        for i in 0..n {
+            let d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for i in 1..10 {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        let mut res = vec![0; n];
+        for i in (0..n).rev() {
+            let d = digit(nums[i], exp);
+            let j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i]; // 将当前元素填入索引 j
+            counter[d] -= 1; // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for i in 0..n {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{}-[func]{radix_sort}
+    /* 基数排序 */
+    fn radix_sort(nums: &mut [i32]) {
+        // 获取数组的最大元素，用于判断最大位数
+        let m = *nums.into_iter().max().unwrap();
+        // 按照从低位到高位的顺序遍历
+        let mut exp = 1;
+        while exp <= m {
+            counting_sort_digit(nums, exp);
+            exp *= 10;
+        }
+    }
     ```
 
 === "C"
 
     ```c title="radix_sort.c"
-    [class]{}-[func]{digit}
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    /* 计数排序（根据 nums 第 k 位排序） */
+    void countingSortDigit(int nums[], int size, int exp) {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        int *counter = (int *)malloc((sizeof(int) * 10));
+        // 统计 0~9 各数字的出现次数
+        for (int i = 0; i < size; i++) {
+            // 获取 nums[i] 第 k 位，记为 d
+            int d = digit(nums[i], exp);
+            // 统计数字 d 的出现次数
+            counter[d]++;
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        int *res = (int *)malloc(sizeof(int) * size);
+        for (int i = size - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d]--;           // 将 d 的数量减 1
+        }
+        // 使用结果覆盖原数组 nums
+        for (int i = 0; i < size; i++) {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    /* 基数排序 */
+    void radixSort(int nums[], int size) {
+        // 获取数组的最大元素，用于判断最大位数
+        int max = INT32_MIN;
+        for (size_t i = 0; i < size - 1; i++) {
+            if (nums[i] > max) {
+                max = nums[i];
+            }
+        }
+        // 按照从低位到高位的顺序遍历
+        for (int exp = 1; max >= exp; exp *= 10)
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            countingSortDigit(nums, size, exp);
+    }
     ```
 
 === "Zig"
 
     ```zig title="radix_sort.zig"
-    [class]{}-[func]{digit}
+    // 获取元素 num 的第 k 位，其中 exp = 10^(k-1)
+    fn digit(num: i32, exp: i32) i32 {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return @mod(@divFloor(num, exp), 10);
+    }
 
-    [class]{}-[func]{countingSortDigit}
+    // 计数排序（根据 nums 第 k 位排序）
+    fn countingSortDigit(nums: []i32, exp: i32) !void {
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+        // defer mem_arena.deinit();
+        const mem_allocator = mem_arena.allocator();
+        var counter = try mem_allocator.alloc(usize, 10);
+        @memset(counter, 0);
+        var n = nums.len;
+        // 统计 0~9 各数字的出现次数
+        for (nums) |num| {
+            var d: u32 = @bitCast(digit(num, exp)); // 获取 nums[i] 第 k 位，记为 d
+            counter[d] += 1; // 统计数字 d 的出现次数
+        }
+        // 求前缀和，将“出现个数”转换为“数组索引”
+        var i: usize = 1;
+        while (i < 10) : (i += 1) {
+            counter[i] += counter[i - 1];
+        }
+        // 倒序遍历，根据桶内统计结果，将各元素填入 res
+        var res = try mem_allocator.alloc(i32, n);
+        i = n - 1;
+        while (i >= 0) : (i -= 1) {
+            var d: u32 = @bitCast(digit(nums[i], exp));
+            var j = counter[d] - 1; // 获取 d 在数组中的索引 j
+            res[j] = nums[i];       // 将当前元素填入索引 j
+            counter[d] -= 1;        // 将 d 的数量减 1
+            if (i == 0) break;
+        }
+        // 使用结果覆盖原数组 nums
+        i = 0;
+        while (i < n) : (i += 1) {
+            nums[i] = res[i];
+        }
+    }
 
-    [class]{}-[func]{radixSort}
+    // 基数排序
+    fn radixSort(nums: []i32) !void {
+        // 获取数组的最大元素，用于判断最大位数
+        var m: i32 = std.math.minInt(i32);
+        for (nums) |num| {
+            if (num > m) m = num;
+        }
+        // 按照从低位到高位的顺序遍历
+        var exp: i32 = 1;
+        while (exp <= m) : (exp *= 10) {
+            // 对数组元素的第 k 位执行计数排序
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // 即 exp = 10^(k-1)
+            try countingSortDigit(nums, exp);    
+        }
+    } 
     ```
 
 !!! question "为什么从最低位开始排序？"

zh/chapter_sorting/selection_sort.md

@@ -54,67 +54,228 @@ comments: true
 === "Python"
 
     ```python title="selection_sort.py"
-    [class]{}-[func]{selection_sort}
+    def selection_sort(nums: list[int]):
+        """选择排序"""
+        n = len(nums)
+        # 外循环：未排序区间为 [i, n-1]
+        for i in range(n - 1):
+            # 内循环：找到未排序区间内的最小元素
+            k = i
+            for j in range(i + 1, n):
+                if nums[j] < nums[k]:
+                    k = j  # 记录最小元素的索引
+            # 将该最小元素与未排序区间的首个元素交换
+            nums[i], nums[k] = nums[k], nums[i]
     ```
 
 === "C++"
 
     ```cpp title="selection_sort.cpp"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(vector<int> &nums) {
+        int n = nums.size();
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            swap(nums[i], nums[k]);
+        }
+    }
     ```
 
 === "Java"
 
     ```java title="selection_sort.java"
-    [class]{selection_sort}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(int[] nums) {
+        int n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
     ```
 
 === "C#"
 
     ```csharp title="selection_sort.cs"
-    [class]{selection_sort}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(int[] nums) {
+        int n = nums.Length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            (nums[k], nums[i]) = (nums[i], nums[k]);
+        }
+    }
     ```
 
 === "Go"
 
     ```go title="selection_sort.go"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    func selectionSort(nums []int) {
+        n := len(nums)
+        // 外循环：未排序区间为 [i, n-1]
+        for i := 0; i < n-1; i++ {
+            // 内循环：找到未排序区间内的最小元素
+            k := i
+            for j := i + 1; j < n; j++ {
+                if nums[j] < nums[k] {
+                    // 记录最小元素的索引
+                    k = j
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums[i], nums[k] = nums[k], nums[i]
+
+        }
+    }
     ```
 
 === "Swift"
 
     ```swift title="selection_sort.swift"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    func selectionSort(nums: inout [Int]) {
+        // 外循环：未排序区间为 [i, n-1]
+        for i in nums.indices.dropLast() {
+            // 内循环：找到未排序区间内的最小元素
+            var k = i
+            for j in nums.indices.dropFirst(i + 1) {
+                if nums[j] < nums[k] {
+                    k = j // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums.swapAt(i, k)
+        }
+    }
     ```
 
 === "JS"
 
     ```javascript title="selection_sort.js"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    function selectionSort(nums) {
+        let n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (let i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            let k = i;
+            for (let j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            [nums[i], nums[k]] = [nums[k], nums[i]];
+        }
+    }
     ```
 
 === "TS"
 
     ```typescript title="selection_sort.ts"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    function selectionSort(nums: number[]): void {
+        let n = nums.length;
+        // 外循环：未排序区间为 [i, n-1]
+        for (let i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            let k = i;
+            for (let j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k]) {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            [nums[i], nums[k]] = [nums[k], nums[i]];
+        }
+    }
     ```
 
 === "Dart"
 
     ```dart title="selection_sort.dart"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(List<int> nums) {
+      int n = nums.length;
+      // 外循环：未排序区间为 [i, n-1]
+      for (int i = 0; i < n - 1; i++) {
+        // 内循环：找到未排序区间内的最小元素
+        int k = i;
+        for (int j = i + 1; j < n; j++) {
+          if (nums[j] < nums[k]) k = j; // 记录最小元素的索引
+        }
+        // 将该最小元素与未排序区间的首个元素交换
+        int temp = nums[i];
+        nums[i] = nums[k];
+        nums[k] = temp;
+      }
+    }
     ```
 
 === "Rust"
 
     ```rust title="selection_sort.rs"
-    [class]{}-[func]{selection_sort}
+    /* 选择排序 */
+    fn selection_sort(nums: &mut [i32]) {
+        let n = nums.len();
+        // 外循环：未排序区间为 [i, n-1]
+        for i in 0..n-1 {
+            // 内循环：找到未排序区间内的最小元素
+            let mut k = i;
+            for j in i+1..n {
+                if nums[j] < nums[k] {
+                    k = j; // 记录最小元素的索引
+                }
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            nums.swap(i, k);
+        }
+    }
     ```
 
 === "C"
 
     ```c title="selection_sort.c"
-    [class]{}-[func]{selectionSort}
+    /* 选择排序 */
+    void selectionSort(int nums[], int n) {
+        // 外循环：未排序区间为 [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // 内循环：找到未排序区间内的最小元素
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // 记录最小元素的索引
+            }
+            // 将该最小元素与未排序区间的首个元素交换
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
     ```
 
 === "Zig"

zh/chapter_tree/binary_tree_traversal.md

@@ -25,73 +25,303 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_bfs.py"
-    [class]{}-[func]{level_order}
+    def level_order(root: TreeNode | None) -> list[int]:
+        """层序遍历"""
+        # 初始化队列，加入根节点
+        queue: deque[TreeNode] = deque()
+        queue.append(root)
+        # 初始化一个列表，用于保存遍历序列
+        res = []
+        while queue:
+            node: TreeNode = queue.popleft()  # 队列出队
+            res.append(node.val)  # 保存节点值
+            if node.left is not None:
+                queue.append(node.left)  # 左子节点入队
+            if node.right is not None:
+                queue.append(node.right)  # 右子节点入队
+        return res
     ```
 
 === "C++"
 
     ```cpp title="binary_tree_bfs.cpp"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    vector<int> levelOrder(TreeNode *root) {
+        // 初始化队列，加入根节点
+        queue<TreeNode *> queue;
+        queue.push(root);
+        // 初始化一个列表，用于保存遍历序列
+        vector<int> vec;
+        while (!queue.empty()) {
+            TreeNode *node = queue.front();
+            queue.pop();              // 队列出队
+            vec.push_back(node->val); // 保存节点值
+            if (node->left != nullptr)
+                queue.push(node->left); // 左子节点入队
+            if (node->right != nullptr)
+                queue.push(node->right); // 右子节点入队
+        }
+        return vec;
+    }
     ```
 
 === "Java"
 
     ```java title="binary_tree_bfs.java"
-    [class]{binary_tree_bfs}-[func]{levelOrder}
+    /* 层序遍历 */
+    List<Integer> levelOrder(TreeNode root) {
+        // 初始化队列，加入根节点
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        // 初始化一个列表，用于保存遍历序列
+        List<Integer> list = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll(); // 队列出队
+            list.add(node.val);           // 保存节点值
+            if (node.left != null)
+                queue.offer(node.left);   // 左子节点入队
+            if (node.right != null)
+                queue.offer(node.right);  // 右子节点入队
+        }
+        return list;
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_tree_bfs.cs"
-    [class]{binary_tree_bfs}-[func]{levelOrder}
+    /* 层序遍历 */
+    List<int> levelOrder(TreeNode root) {
+        // 初始化队列，加入根节点
+        Queue<TreeNode> queue = new();
+        queue.Enqueue(root);
+        // 初始化一个列表，用于保存遍历序列
+        List<int> list = new();
+        while (queue.Count != 0) {
+            TreeNode node = queue.Dequeue(); // 队列出队
+            list.Add(node.val);              // 保存节点值
+            if (node.left != null)
+                queue.Enqueue(node.left);    // 左子节点入队
+            if (node.right != null)
+                queue.Enqueue(node.right);   // 右子节点入队
+        }
+        return list;
+    }
     ```
 
 === "Go"
 
     ```go title="binary_tree_bfs.go"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    func levelOrder(root *TreeNode) []any {
+        // 初始化队列，加入根节点
+        queue := list.New()
+        queue.PushBack(root)
+        // 初始化一个切片，用于保存遍历序列
+        nums := make([]any, 0)
+        for queue.Len() > 0 {
+            // 队列出队
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            // 保存节点值
+            nums = append(nums, node.Val)
+            if node.Left != nil {
+                // 左子节点入队
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                // 右子节点入队
+                queue.PushBack(node.Right)
+            }
+        }
+        return nums
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_tree_bfs.swift"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    func levelOrder(root: TreeNode) -> [Int] {
+        // 初始化队列，加入根节点
+        var queue: [TreeNode] = [root]
+        // 初始化一个列表，用于保存遍历序列
+        var list: [Int] = []
+        while !queue.isEmpty {
+            let node = queue.removeFirst() // 队列出队
+            list.append(node.val) // 保存节点值
+            if let left = node.left {
+                queue.append(left) // 左子节点入队
+            }
+            if let right = node.right {
+                queue.append(right) // 右子节点入队
+            }
+        }
+        return list
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_tree_bfs.js"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    function levelOrder(root) {
+        // 初始化队列，加入根节点
+        const queue = [root];
+        // 初始化一个列表，用于保存遍历序列
+        const list = [];
+        while (queue.length) {
+            let node = queue.shift(); // 队列出队
+            list.push(node.val); // 保存节点值
+            if (node.left) queue.push(node.left); // 左子节点入队
+            if (node.right) queue.push(node.right); // 右子节点入队
+        }
+        return list;
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_tree_bfs.ts"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    function levelOrder(root: TreeNode | null): number[] {
+        // 初始化队列，加入根节点
+        const queue = [root];
+        // 初始化一个列表，用于保存遍历序列
+        const list: number[] = [];
+        while (queue.length) {
+            let node = queue.shift() as TreeNode; // 队列出队
+            list.push(node.val); // 保存节点值
+            if (node.left) {
+                queue.push(node.left); // 左子节点入队
+            }
+            if (node.right) {
+                queue.push(node.right); // 右子节点入队
+            }
+        }
+        return list;
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_tree_bfs.dart"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    List<int> levelOrder(TreeNode? root) {
+      // 初始化队列，加入根节点
+      Queue<TreeNode?> queue = Queue();
+      queue.add(root);
+      // 初始化一个列表，用于保存遍历序列
+      List<int> res = [];
+      while (queue.isNotEmpty) {
+        TreeNode? node = queue.removeFirst(); // 队列出队
+        res.add(node!.val); // 保存节点值
+        if (node.left != null) queue.add(node.left); // 左子节点入队
+        if (node.right != null) queue.add(node.right); // 右子节点入队
+      }
+      return res;
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_tree_bfs.rs"
-    [class]{}-[func]{level_order}
+    /* 层序遍历 */
+    fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
+        // 初始化队列，加入根结点
+        let mut que = VecDeque::new();
+        que.push_back(Rc::clone(&root));
+        // 初始化一个列表，用于保存遍历序列
+        let mut vec = Vec::new();
+
+        while let Some(node) = que.pop_front() {                 // 队列出队
+            vec.push(node.borrow().val);                         // 保存结点值
+            if let Some(left) = node.borrow().left.as_ref() {
+                que.push_back(Rc::clone(left));                  // 左子结点入队
+            }
+            if let Some(right) = node.borrow().right.as_ref() {
+                que.push_back(Rc::clone(right));                 // 右子结点入队
+            };
+        }
+        vec
+    }
     ```
 
 === "C"
 
     ```c title="binary_tree_bfs.c"
-    [class]{}-[func]{levelOrder}
+    /* 层序遍历 */
+    int *levelOrder(TreeNode *root, int *size) {
+        /* 辅助队列 */
+        int front, rear;
+        int index, *arr;
+        TreeNode *node;
+        TreeNode **queue;
+
+        /* 辅助队列 */
+        queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_NODE_SIZE);
+        // 队列指针
+        front = 0, rear = 0;
+        // 加入根节点
+        queue[rear++] = root;
+        // 初始化一个列表，用于保存遍历序列
+        /* 辅助数组 */
+        arr = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);
+        // 数组指针
+        index = 0;
+        while (front < rear) {
+            // 队列出队
+            node = queue[front++];
+            // 保存节点值
+            arr[index++] = node->val;
+            if (node->left != NULL) {
+                // 左子节点入队
+                queue[rear++] = node->left;
+            }
+            if (node->right != NULL) {
+                // 右子节点入队
+                queue[rear++] = node->right;
+            }
+        }
+        // 更新数组长度的值
+        *size = index;
+        arr = realloc(arr, sizeof(int) * (*size));
+
+        // 释放辅助数组空间
+        free(queue);
+        return arr;
+    }
     ```
 
 === "Zig"
 
     ```zig title="binary_tree_bfs.zig"
-    [class]{}-[func]{levelOrder}
+    // 层序遍历
+    fn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {
+        // 初始化队列，加入根节点
+        const L = std.TailQueue(*inc.TreeNode(T));
+        var queue = L{};
+        var root_node = try mem_allocator.create(L.Node);
+        root_node.data = root;
+        queue.append(root_node); 
+        // 初始化一个列表，用于保存遍历序列
+        var list = std.ArrayList(T).init(std.heap.page_allocator);
+        while (queue.len > 0) {
+            var queue_node = queue.popFirst().?;    // 队列出队
+            var node = queue_node.data;
+            try list.append(node.val);              // 保存节点值
+            if (node.left != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.left.?;
+                queue.append(tmp_node);             // 左子节点入队
+            }
+            if (node.right != null) {
+                var tmp_node = try mem_allocator.create(L.Node);
+                tmp_node.data = node.right.?;
+                queue.append(tmp_node);             // 右子节点入队
+            }        
+        }
+        return list;
+    }
     ```
 
 ### 2. &nbsp; 复杂度分析
@@ -116,121 +346,412 @@ comments: true
 === "Python"
 
     ```python title="binary_tree_dfs.py"
-    [class]{}-[func]{pre_order}
+    def pre_order(root: TreeNode | None):
+        """前序遍历"""
+        if root is None:
+            return
+        # 访问优先级：根节点 -> 左子树 -> 右子树
+        res.append(root.val)
+        pre_order(root=root.left)
+        pre_order(root=root.right)
 
-    [class]{}-[func]{in_order}
+    def in_order(root: TreeNode | None):
+        """中序遍历"""
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 根节点 -> 右子树
+        in_order(root=root.left)
+        res.append(root.val)
+        in_order(root=root.right)
 
-    [class]{}-[func]{post_order}
+    def post_order(root: TreeNode | None):
+        """后序遍历"""
+        if root is None:
+            return
+        # 访问优先级：左子树 -> 右子树 -> 根节点
+        post_order(root=root.left)
+        post_order(root=root.right)
+        res.append(root.val)
     ```
 
 === "C++"
 
     ```cpp title="binary_tree_dfs.cpp"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    void preOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        vec.push_back(root->val);
+        preOrder(root->left);
+        preOrder(root->right);
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    void inOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root->left);
+        vec.push_back(root->val);
+        inOrder(root->right);
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    void postOrder(TreeNode *root) {
+        if (root == nullptr)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root->left);
+        postOrder(root->right);
+        vec.push_back(root->val);
+    }
     ```
 
 === "Java"
 
     ```java title="binary_tree_dfs.java"
-    [class]{binary_tree_dfs}-[func]{preOrder}
+    /* 前序遍历 */
+    void preOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
 
-    [class]{binary_tree_dfs}-[func]{inOrder}
+    /* 中序遍历 */
+    void inOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.add(root.val);
+        inOrder(root.right);
+    }
 
-    [class]{binary_tree_dfs}-[func]{postOrder}
+    /* 后序遍历 */
+    void postOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.add(root.val);
+    }
     ```
 
 === "C#"
 
     ```csharp title="binary_tree_dfs.cs"
-    [class]{binary_tree_dfs}-[func]{preOrder}
+    /* 前序遍历 */
+    void preOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.Add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
 
-    [class]{binary_tree_dfs}-[func]{inOrder}
+    /* 中序遍历 */
+    void inOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.Add(root.val);
+        inOrder(root.right);
+    }
 
-    [class]{binary_tree_dfs}-[func]{postOrder}
+    /* 后序遍历 */
+    void postOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.Add(root.val);
+    }
     ```
 
 === "Go"
 
     ```go title="binary_tree_dfs.go"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    func preOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        nums = append(nums, node.Val)
+        preOrder(node.Left)
+        preOrder(node.Right)
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    func inOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(node.Left)
+        nums = append(nums, node.Val)
+        inOrder(node.Right)
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    func postOrder(node *TreeNode) {
+        if node == nil {
+            return
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(node.Left)
+        postOrder(node.Right)
+        nums = append(nums, node.Val)
+    }
     ```
 
 === "Swift"
 
     ```swift title="binary_tree_dfs.swift"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    func preOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.append(root.val)
+        preOrder(root: root.left)
+        preOrder(root: root.right)
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    func inOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root: root.left)
+        list.append(root.val)
+        inOrder(root: root.right)
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    func postOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root: root.left)
+        postOrder(root: root.right)
+        list.append(root.val)
+    }
     ```
 
 === "JS"
 
     ```javascript title="binary_tree_dfs.js"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    function preOrder(root) {
+        if (root === null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.push(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    function inOrder(root) {
+        if (root === null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.push(root.val);
+        inOrder(root.right);
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    function postOrder(root) {
+        if (root === null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.push(root.val);
+    }
     ```
 
 === "TS"
 
     ```typescript title="binary_tree_dfs.ts"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    function preOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.push(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    function inOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.push(root.val);
+        inOrder(root.right);
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    function postOrder(root: TreeNode | null): void {
+        if (root === null) {
+            return;
+        }
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.push(root.val);
+    }
     ```
 
 === "Dart"
 
     ```dart title="binary_tree_dfs.dart"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    void preOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：根节点 -> 左子树 -> 右子树
+      list.add(node.val);
+      preOrder(node.left);
+      preOrder(node.right);
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    void inOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：左子树 -> 根节点 -> 右子树
+      inOrder(node.left);
+      list.add(node.val);
+      inOrder(node.right);
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    void postOrder(TreeNode? node) {
+      if (node == null) return;
+      // 访问优先级：左子树 -> 右子树 -> 根节点
+      postOrder(node.left);
+      postOrder(node.right);
+      list.add(node.val);
+    }
     ```
 
 === "Rust"
 
     ```rust title="binary_tree_dfs.rs"
-    [class]{}-[func]{pre_order}
+    /* 前序遍历 */
+    fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
 
-    [class]{}-[func]{in_order}
+        if let Some(node) = root {
+            // 访问优先级：根结点 -> 左子树 -> 右子树
+            result.push(node.borrow().val);
+            result.append(&mut pre_order(node.borrow().left.as_ref()));
+            result.append(&mut pre_order(node.borrow().right.as_ref()));
+        }
+        result
+    }
 
-    [class]{}-[func]{post_order}
+    /* 中序遍历 */
+    fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
+
+        if let Some(node) = root {
+            // 访问优先级：左子树 -> 根结点 -> 右子树
+            result.append(&mut in_order(node.borrow().left.as_ref()));
+            result.push(node.borrow().val);
+            result.append(&mut in_order(node.borrow().right.as_ref()));
+        }
+        result
+    }
+
+    /* 后序遍历 */
+    fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut result = vec![];
+
+        if let Some(node) = root {
+            // 访问优先级：左子树 -> 右子树 -> 根结点
+            result.append(&mut post_order(node.borrow().left.as_ref()));
+            result.append(&mut post_order(node.borrow().right.as_ref()));
+            result.push(node.borrow().val);
+        }
+        result
+    }
     ```
 
 === "C"
 
     ```c title="binary_tree_dfs.c"
-    [class]{}-[func]{preOrder}
+    /* 前序遍历 */
+    void preOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        arr[(*size)++] = root->val;
+        preOrder(root->left, size);
+        preOrder(root->right, size);
+    }
 
-    [class]{}-[func]{inOrder}
+    /* 中序遍历 */
+    void inOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root->left, size);
+        arr[(*size)++] = root->val;
+        inOrder(root->right, size);
+    }
 
-    [class]{}-[func]{postOrder}
+    /* 后序遍历 */
+    void postOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root->left, size);
+        postOrder(root->right, size);
+        arr[(*size)++] = root->val;
+    }
     ```
 
 === "Zig"
 
     ```zig title="binary_tree_dfs.zig"
-    [class]{}-[func]{preOrder}
+    // 前序遍历
+    fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        try list.append(root.?.val);
+        try preOrder(T, root.?.left);
+        try preOrder(T, root.?.right);
+    }
 
-    [class]{}-[func]{inOrder}
+    // 中序遍历
+    fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        try inOrder(T, root.?.left);
+        try list.append(root.?.val);
+        try inOrder(T, root.?.right);
+    }
 
-    [class]{}-[func]{postOrder}
+    // 后序遍历
+    fn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        try postOrder(T, root.?.left);
+        try postOrder(T, root.?.right);
+        try list.append(root.?.val);
+    }
     ```
 
 !!! note