build

chapter_backtracking/n_queens_problem.md

@@ -52,6 +52,97 @@ comments: true
 
 请注意，$n$ 维方阵中 $row - col$ 的范围是 $[-n + 1, n - 1]$ ，$row + col$ 的范围是 $[0, 2n - 2]$ ，所以主对角线和次对角线的数量都为 $2n - 1$ ，即数组 `diag1` 和 `diag2` 的长度都为 $2n - 1$ 。
 
+=== "Python"
+
+    ```python title="n_queens.py"
+    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
+
+    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"
+    /* 回溯算法：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;
+            }
+        }
+    }
+
+    /* 求解 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"
@@ -108,15 +199,19 @@ comments: true
     }
     ```
 
-=== "C++"
+=== "C#"
 
-    ```cpp title="n_queens.cpp"
+    ```csharp title="n_queens.cs"
     /* 回溯算法：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) {
+    void backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
+            bool[] cols, bool[] diags1, bool[] diags2) {
         // 当放置完所有行时，记录解
         if (row == n) {
-            res.push_back(state);
+            List<List<string>> copyState = new List<List<string>>();
+            foreach (List<string> sRow in state) {
+                copyState.Add(new List<string>(sRow));
+            }
+            res.Add(copyState);
             return;
         }
         // 遍历所有列
@@ -139,13 +234,20 @@ comments: true
     }
 
     /* 求解 N 皇后 */
-    vector<vector<vector<string>>> nQueens(int n) {
+    List<List<List<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;
+        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);
 
@@ -153,52 +255,6 @@ comments: true
     }
     ```
 
-=== "Python"
-
-    ```python title="n_queens.py"
-    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
-
-    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
-    ```
-
 === "Go"
 
     ```go title="n_queens.go"
@@ -284,6 +340,54 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="n_queens.swift"
+    /* 回溯算法：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
+            }
+        }
+    }
+
+    /* 求解 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"
@@ -378,126 +482,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="n_queens.c"
-    [class]{}-[func]{backtrack}
-
-    [class]{}-[func]{nQueens}
-    ```
-
-=== "C#"
-
-    ```csharp title="n_queens.cs"
-    /* 回溯算法：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;
-            }
-        }
-    }
-
-    /* 求解 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="n_queens.swift"
-    /* 回溯算法：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
-            }
-        }
-    }
-
-    /* 求解 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="n_queens.zig"
-    [class]{}-[func]{backtrack}
-
-    [class]{}-[func]{nQueens}
-    ```
-
 === "Dart"
 
     ```dart title="n_queens.dart"
@@ -614,6 +598,22 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="n_queens.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
+=== "Zig"
+
+    ```zig title="n_queens.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{nQueens}
+    ```
+
 逐行放置 $n$ 次，考虑列约束，则从第一行到最后一行分别有 $n$、$n-1$、$\dots$、$2$、$1$ 个选择，**因此时间复杂度为 $O(n!)$** 。实际上，根据对角线约束的剪枝也能够大幅地缩小搜索空间，因而搜索效率往往优于以上时间复杂度。
 
 数组 `state` 使用 $O(n^2)$ 空间，数组 `cols`、`diags1` 和 `diags2` 皆使用 $O(n)$ 空间。最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。因此，**空间复杂度为 $O(n^2)$** 。

chapter_backtracking/permutations_problem.md

@@ -55,39 +55,35 @@ comments: true
 
 想清楚以上信息之后，我们就可以在框架代码中做“完形填空”了。为了缩短代码行数，我们不单独实现框架代码中的各个函数，而是将他们展开在 `backtrack()` 函数中。
 
-=== "Java"
+=== "Python"
 
-    ```java title="permutations_i.java"
-    /* 回溯算法：全排列 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);
-            }
-        }
-    }
+    ```python title="permutations_i.py"
+    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()
 
-    /* 全排列 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;
-    }
+    def permutations_i(nums: list[int]) -> list[list[int]]:
+        """全排列 I"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
     ```
 
 === "C++"
@@ -127,35 +123,74 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="permutations_i.py"
-    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()
+    ```java title="permutations_i.java"
+    /* 回溯算法：全排列 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);
+            }
+        }
+    }
 
-    def permutations_i(nums: list[int]) -> list[list[int]]:
-        """全排列 I"""
-        res = []
-        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
-        return res
+    /* 全排列 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"
+    /* 回溯算法：全排列 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);
+            }
+        }
+    }
+
+    /* 全排列 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"
@@ -195,6 +230,42 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="permutations_i.swift"
+    /* 回溯算法：全排列 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()
+            }
+        }
+    }
+
+    /* 全排列 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"
@@ -268,136 +339,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="permutations_i.c"
-    /* 回溯算法：全排列 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);
-            }
-        }
-    }
-
-    /* 全排列 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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="permutations_i.cs"
-    /* 回溯算法：全排列 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);
-            }
-        }
-    }
-
-    /* 全排列 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="permutations_i.swift"
-    /* 回溯算法：全排列 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()
-            }
-        }
-    }
-
-    /* 全排列 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="permutations_i.zig"
-    [class]{}-[func]{backtrack}
-
-    [class]{}-[func]{permutationsI}
-    ```
-
 === "Dart"
 
     ```dart title="permutations_i.dart"
@@ -473,6 +414,65 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="permutations_i.c"
+    /* 回溯算法：全排列 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);
+            }
+        }
+    }
+
+    /* 全排列 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"
+
+    ```zig title="permutations_i.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsI}
+    ```
+
 ## 13.2.2 &nbsp; 考虑相等元素的情况
 
 !!! question
@@ -505,41 +505,37 @@ comments: true
 
 在上一题的代码的基础上，我们考虑在每一轮选择中开启一个哈希表 `duplicated` ，用于记录该轮中已经尝试过的元素，并将重复元素剪枝。
 
-=== "Java"
+=== "Python"
 
-    ```java title="permutations_ii.java"
-    /* 回溯算法：全排列 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);
-            }
-        }
-    }
+    ```python title="permutations_ii.py"
+    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()
 
-    /* 全排列 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;
-    }
+    def permutations_ii(nums: list[int]) -> list[list[int]]:
+        """全排列 II"""
+        res = []
+        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+        return res
     ```
 
 === "C++"
@@ -581,37 +577,78 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="permutations_ii.py"
-    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()
+    ```java title="permutations_ii.java"
+    /* 回溯算法：全排列 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);
+            }
+        }
+    }
 
-    def permutations_ii(nums: list[int]) -> list[list[int]]:
-        """全排列 II"""
-        res = []
-        backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
-        return res
+    /* 全排列 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"
+    /* 回溯算法：全排列 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);
+            }
+        }
+    }
+
+    /* 全排列 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"
@@ -654,6 +691,44 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="permutations_ii.swift"
+    /* 回溯算法：全排列 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()
+            }
+        }
+    }
+
+    /* 全排列 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"
@@ -731,97 +806,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="permutations_ii.c"
-    [class]{}-[func]{backtrack}
-
-    [class]{}-[func]{permutationsII}
-    ```
-
-=== "C#"
-
-    ```csharp title="permutations_ii.cs"
-    /* 回溯算法：全排列 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);
-            }
-        }
-    }
-
-    /* 全排列 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="permutations_ii.swift"
-    /* 回溯算法：全排列 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()
-            }
-        }
-    }
-
-    /* 全排列 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="permutations_ii.zig"
-    [class]{}-[func]{backtrack}
-
-    [class]{}-[func]{permutationsII}
-    ```
-
 === "Dart"
 
     ```dart title="permutations_ii.dart"
@@ -901,6 +885,22 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="permutations_ii.c"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
+=== "Zig"
+
+    ```zig title="permutations_ii.zig"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutationsII}
+    ```
+
 假设元素两两之间互不相同，则 $n$ 个元素共有 $n!$  种排列（阶乘）；在记录结果时，需要复制长度为 $n$ 的列表，使用 $O(n)$ 时间。**因此时间复杂度为 $O(n!n)$** 。
 
 最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。`selected` 使用 $O(n)$ 空间。同一时刻最多共有 $n$ 个 `duplicated` ，使用 $O(n^2)$ 空间。**因此空间复杂度为 $O(n^2)$** 。

chapter_data_structure/basic_data_types.md

@@ -51,26 +51,6 @@ comments: true
 
 换句话说，**基本数据类型提供了数据的“内容类型”，而数据结构提供了数据的“组织方式”**。例如以下代码，我们用相同的数据结构（数组）来存储与表示不同的基本数据类型，包括 `int`、`float`、`char`、`bool` 等。
 
-=== "Java"
-
-    ```java title=""
-    // 使用多种基本数据类型来初始化数组
-    int[] numbers = new int[5];
-    float[] decimals = new float[5];
-    char[] characters = new char[5];
-    boolean[] bools = new boolean[5];
-    ```
-
-=== "C++"
-
-    ```cpp title=""
-    // 使用多种基本数据类型来初始化数组
-    int numbers[5];
-    float decimals[5];
-    char characters[5];
-    bool bools[5];
-    ```
-
 === "Python"
 
     ```python title=""
@@ -84,6 +64,36 @@ comments: true
     data = [0, 0.0, 'a', False, ListNode(0)]
     ```
 
+=== "C++"
+
+    ```cpp title=""
+    // 使用多种基本数据类型来初始化数组
+    int numbers[5];
+    float decimals[5];
+    char characters[5];
+    bool bools[5];
+    ```
+
+=== "Java"
+
+    ```java title=""
+    // 使用多种基本数据类型来初始化数组
+    int[] numbers = new int[5];
+    float[] decimals = new float[5];
+    char[] characters = new char[5];
+    boolean[] bools = new boolean[5];
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    // 使用多种基本数据类型来初始化数组
+    int[] numbers = new int[5];
+    float[] decimals = new float[5];
+    char[] characters = new char[5];
+    bool[] bools = new bool[5];
+    ```
+
 === "Go"
 
     ```go title=""
@@ -94,6 +104,16 @@ comments: true
     var bools = [5]bool{}
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 使用多种基本数据类型来初始化数组
+    let numbers = Array(repeating: Int(), count: 5)
+    let decimals = Array(repeating: Double(), count: 5)
+    let characters = Array(repeating: Character("a"), count: 5)
+    let bools = Array(repeating: Bool(), count: 5)
+    ```
+
 === "JS"
 
     ```javascript title=""
@@ -110,42 +130,6 @@ comments: true
     const bools: boolean[] = [];
     ```
 
-=== "C"
-
-    ```c title=""
-    // 使用多种基本数据类型来初始化数组
-    int numbers[10];
-    float decimals[10];
-    char characters[10];
-    bool bools[10];
-    ```
-
-=== "C#"
-
-    ```csharp title=""
-    // 使用多种基本数据类型来初始化数组
-    int[] numbers = new int[5];
-    float[] decimals = new float[5];
-    char[] characters = new char[5];
-    bool[] bools = new bool[5];
-    ```
-
-=== "Swift"
-
-    ```swift title=""
-    // 使用多种基本数据类型来初始化数组
-    let numbers = Array(repeating: Int(), count: 5)
-    let decimals = Array(repeating: Double(), count: 5)
-    let characters = Array(repeating: Character("a"), count: 5)
-    let bools = Array(repeating: Bool(), count: 5)
-    ```
-
-=== "Zig"
-
-    ```zig title=""
-    
-    ```
-
 === "Dart"
 
     ```dart title=""
@@ -161,3 +145,19 @@ comments: true
     ```rust title=""
 
     ```
+
+=== "C"
+
+    ```c title=""
+    // 使用多种基本数据类型来初始化数组
+    int numbers[10];
+    float decimals[10];
+    char characters[10];
+    bool bools[10];
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    
+    ```

chapter_divide_and_conquer/binary_search_recur.md

@@ -47,35 +47,31 @@ status: new
 
 在实现代码中，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search_recur.java"
-    /* 二分查找：问题 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;
-        }
-    }
+    ```python title="binary_search_recur.py"
+    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
 
-    /* 二分查找 */
-    int binarySearch(int[] nums, int target) {
-        int n = nums.length;
-        // 求解问题 f(0, n-1)
-        return dfs(nums, target, 0, n - 1);
-    }
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找"""
+        n = len(nums)
+        # 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1)
     ```
 
 === "C++"
@@ -109,31 +105,66 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search_recur.py"
-    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
+    ```java title="binary_search_recur.java"
+    /* 二分查找：问题 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;
+        }
+    }
 
-    def binary_search(nums: list[int], target: int) -> int:
-        """二分查找"""
-        n = len(nums)
-        # 求解问题 f(0, n-1)
-        return dfs(nums, target, 0, n - 1)
+    /* 二分查找 */
+    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"
+    /* 二分查找：问题 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;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(int[] nums, int target) {
+        int n = nums.Length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
     ```
 
 === "Go"
@@ -169,6 +200,37 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_recur.swift"
+    /* 二分查找：问题 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
+        }
+    }
+
+    /* 二分查找 */
+    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"
@@ -231,84 +293,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search_recur.c"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{binarySearch}
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search_recur.cs"
-    /* 二分查找：问题 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;
-        }
-    }
-
-    /* 二分查找 */
-    int binarySearch(int[] nums, int target) {
-        int n = nums.Length;
-        // 求解问题 f(0, n-1)
-        return dfs(nums, target, 0, n - 1);
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search_recur.swift"
-    /* 二分查找：问题 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
-        }
-    }
-
-    /* 二分查找 */
-    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)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search_recur.zig"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{binarySearch}
-    ```
-
 === "Dart"
 
     ```dart title="binary_search_recur.dart"
@@ -367,3 +351,19 @@ status: new
         dfs(nums, target, 0, n - 1)
     }
     ```
+
+=== "C"
+
+    ```c title="binary_search_recur.c"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_recur.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```

chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -72,70 +72,6 @@ status: new
 
 为了提升查询 $m$ 的效率，我们借助一个哈希表 `hmap` 来存储数组 `inorder` 中元素到索引的映射。
 
-=== "Java"
-
-    ```java title="build_tree.java"
-    /* 构建二叉树：分治 */
-    TreeNode dfs(int[] preorder, int[] inorder, Map<Integer, Integer> hmap, int i, int l, int r) {
-        // 子树区间为空时终止
-        if (r - l < 0)
-            return null;
-        // 初始化根节点
-        TreeNode root = new TreeNode(preorder[i]);
-        // 查询 m ，从而划分左右子树
-        int m = hmap.get(preorder[i]);
-        // 子问题：构建左子树
-        root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
-        // 子问题：构建右子树
-        root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
-        // 返回根节点
-        return root;
-    }
-
-    /* 构建二叉树 */
-    TreeNode buildTree(int[] preorder, int[] inorder) {
-        // 初始化哈希表，存储 inorder 元素到索引的映射
-        Map<Integer, Integer> hmap = new HashMap<>();
-        for (int i = 0; i < inorder.length; i++) {
-            hmap.put(inorder[i], i);
-        }
-        TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
-        return root;
-    }
-    ```
-
-=== "C++"
-
-    ```cpp title="build_tree.cpp"
-    /* 构建二叉树：分治 */
-    TreeNode *dfs(vector<int> &preorder, vector<int> &inorder, unordered_map<int, int> &hmap, int i, int l, int r) {
-        // 子树区间为空时终止
-        if (r - l < 0)
-            return NULL;
-        // 初始化根节点
-        TreeNode *root = new TreeNode(preorder[i]);
-        // 查询 m ，从而划分左右子树
-        int m = hmap[preorder[i]];
-        // 子问题：构建左子树
-        root->left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
-        // 子问题：构建右子树
-        root->right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
-        // 返回根节点
-        return root;
-    }
-
-    /* 构建二叉树 */
-    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
-        // 初始化哈希表，存储 inorder 元素到索引的映射
-        unordered_map<int, int> hmap;
-        for (int i = 0; i < inorder.size(); i++) {
-            hmap[inorder[i]] = i;
-        }
-        TreeNode *root = dfs(preorder, inorder, hmap, 0, 0, inorder.size() - 1);
-        return root;
-    }
-    ```
-
 === "Python"
 
     ```python title="build_tree.py"
@@ -170,6 +106,102 @@ status: new
         return root
     ```
 
+=== "C++"
+
+    ```cpp title="build_tree.cpp"
+    /* 构建二叉树：分治 */
+    TreeNode *dfs(vector<int> &preorder, vector<int> &inorder, unordered_map<int, int> &hmap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return NULL;
+        // 初始化根节点
+        TreeNode *root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = hmap[preorder[i]];
+        // 子问题：构建左子树
+        root->left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root->right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        unordered_map<int, int> hmap;
+        for (int i = 0; i < inorder.size(); i++) {
+            hmap[inorder[i]] = i;
+        }
+        TreeNode *root = dfs(preorder, inorder, hmap, 0, 0, inorder.size() - 1);
+        return root;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="build_tree.java"
+    /* 构建二叉树：分治 */
+    TreeNode dfs(int[] preorder, int[] inorder, Map<Integer, Integer> hmap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = hmap.get(preorder[i]);
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode buildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Map<Integer, Integer> hmap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            hmap.put(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.length - 1);
+        return root;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="build_tree.cs"
+    /* 构建二叉树：分治 */
+    TreeNode dfs(int[] preorder, int[] inorder, Dictionary<int, int> hmap, int i, int l, int r) {
+        // 子树区间为空时终止
+        if (r - l < 0)
+            return null;
+        // 初始化根节点
+        TreeNode root = new TreeNode(preorder[i]);
+        // 查询 m ，从而划分左右子树
+        int m = hmap[preorder[i]];
+        // 子问题：构建左子树
+        root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
+        // 子问题：构建右子树
+        root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
+        // 返回根节点
+        return root;
+    }
+
+    /* 构建二叉树 */
+    TreeNode buildTree(int[] preorder, int[] inorder) {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        Dictionary<int, int> hmap = new Dictionary<int, int>();
+        for (int i = 0; i < inorder.Length; i++) {
+            hmap.TryAdd(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.Length - 1);
+        return root;
+    }
+    ```
+
 === "Go"
 
     ```go title="build_tree.go"
@@ -204,6 +236,35 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="build_tree.swift"
+    /* 构建二叉树：分治 */
+    func dfs(preorder: [Int], inorder: [Int], hmap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
+        // 子树区间为空时终止
+        if r - l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        let root = TreeNode(x: preorder[i])
+        // 查询 m ，从而划分左右子树
+        let m = hmap[preorder[i]]!
+        // 子问题：构建左子树
+        root.left = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1, l: l, r: m - 1)
+        // 子问题：构建右子树
+        root.right = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1 + m - l, l: m + 1, r: r)
+        // 返回根节点
+        return root
+    }
+
+    /* 构建二叉树 */
+    func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        let hmap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
+        return dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: 0, l: 0, r: inorder.count - 1)
+    }
+    ```
+
 === "JS"
 
     ```javascript title="build_tree.js"
@@ -273,83 +334,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="build_tree.c"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{buildTree}
-    ```
-
-=== "C#"
-
-    ```csharp title="build_tree.cs"
-    /* 构建二叉树：分治 */
-    TreeNode dfs(int[] preorder, int[] inorder, Dictionary<int, int> hmap, int i, int l, int r) {
-        // 子树区间为空时终止
-        if (r - l < 0)
-            return null;
-        // 初始化根节点
-        TreeNode root = new TreeNode(preorder[i]);
-        // 查询 m ，从而划分左右子树
-        int m = hmap[preorder[i]];
-        // 子问题：构建左子树
-        root.left = dfs(preorder, inorder, hmap, i + 1, l, m - 1);
-        // 子问题：构建右子树
-        root.right = dfs(preorder, inorder, hmap, i + 1 + m - l, m + 1, r);
-        // 返回根节点
-        return root;
-    }
-
-    /* 构建二叉树 */
-    TreeNode buildTree(int[] preorder, int[] inorder) {
-        // 初始化哈希表，存储 inorder 元素到索引的映射
-        Dictionary<int, int> hmap = new Dictionary<int, int>();
-        for (int i = 0; i < inorder.Length; i++) {
-            hmap.TryAdd(inorder[i], i);
-        }
-        TreeNode root = dfs(preorder, inorder, hmap, 0, 0, inorder.Length - 1);
-        return root;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="build_tree.swift"
-    /* 构建二叉树：分治 */
-    func dfs(preorder: [Int], inorder: [Int], hmap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
-        // 子树区间为空时终止
-        if r - l < 0 {
-            return nil
-        }
-        // 初始化根节点
-        let root = TreeNode(x: preorder[i])
-        // 查询 m ，从而划分左右子树
-        let m = hmap[preorder[i]]!
-        // 子问题：构建左子树
-        root.left = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1, l: l, r: m - 1)
-        // 子问题：构建右子树
-        root.right = dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: i + 1 + m - l, l: m + 1, r: r)
-        // 返回根节点
-        return root
-    }
-
-    /* 构建二叉树 */
-    func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
-        // 初始化哈希表，存储 inorder 元素到索引的映射
-        let hmap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
-        return dfs(preorder: preorder, inorder: inorder, hmap: hmap, i: 0, l: 0, r: inorder.count - 1)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="build_tree.zig"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{buildTree}
-    ```
-
 === "Dart"
 
     ```dart title="build_tree.dart"
@@ -421,6 +405,22 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="build_tree.c"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{buildTree}
+    ```
+
+=== "Zig"
+
+    ```zig title="build_tree.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{buildTree}
+    ```
+
 图 12-8 展示了构建二叉树的递归过程，各个节点是在向下“递”的过程中建立的，而各条边（即引用）是在向上“归”的过程中建立的。
 
 === "<1>"

chapter_divide_and_conquer/hanota_problem.md

@@ -97,38 +97,34 @@ status: new
 
 在代码中，我们声明一个递归函数 `dfs(i, src, buf, tar)` ，它的作用是将柱 `src` 顶部的 $i$ 个圆盘借助缓冲柱 `buf` 移动至目标柱 `tar` 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="hanota.java"
-    /* 移动一个圆盘 */
-    void move(List<Integer> src, List<Integer> tar) {
-        // 从 src 顶部拿出一个圆盘
-        Integer pan = src.remove(src.size() - 1);
-        // 将圆盘放入 tar 顶部
-        tar.add(pan);
-    }
+    ```python title="hanota.py"
+    def move(src: list[int], tar: list[int]):
+        """移动一个圆盘"""
+        # 从 src 顶部拿出一个圆盘
+        pan = src.pop()
+        # 将圆盘放入 tar 顶部
+        tar.append(pan)
 
-    /* 求解汉诺塔：问题 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);
-    }
+    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)
 
-    /* 求解汉诺塔 */
-    void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
-        int n = A.size();
-        // 将 A 顶部 n 个圆盘借助 B 移到 C
-        dfs(n, A, B, C);
-    }
+    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++"
@@ -166,34 +162,73 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="hanota.py"
-    def move(src: list[int], tar: list[int]):
-        """移动一个圆盘"""
-        # 从 src 顶部拿出一个圆盘
-        pan = src.pop()
-        # 将圆盘放入 tar 顶部
-        tar.append(pan)
+    ```java title="hanota.java"
+    /* 移动一个圆盘 */
+    void move(List<Integer> src, List<Integer> tar) {
+        // 从 src 顶部拿出一个圆盘
+        Integer pan = src.remove(src.size() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.add(pan);
+    }
 
-    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)
+    /* 求解汉诺塔：问题 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);
+    }
 
-    def solve_hanota(A: list[int], B: list[int], C: list[int]):
-        """求解汉诺塔"""
-        n = len(A)
-        # 将 A 顶部 n 个圆盘借助 B 移到 C
-        dfs(n, A, B, C)
+    /* 求解汉诺塔 */
+    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"
+    /* 移动一个圆盘 */
+    void move(List<int> src, List<int> tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src[^1];
+        src.RemoveAt(src.Count - 1);
+        // 将圆盘放入 tar 顶部
+        tar.Add(pan);
+    }
+
+    /* 求解汉诺塔：问题 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);
+    }
+
+    /* 求解汉诺塔 */
+    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"
@@ -232,6 +267,41 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="hanota.swift"
+    /* 移动一个圆盘 */
+    func move(src: inout [Int], tar: inout [Int]) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.popLast()!
+        // 将圆盘放入 tar 顶部
+        tar.append(pan)
+    }
+
+    /* 求解汉诺塔：问题 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)
+    }
+
+    /* 求解汉诺塔 */
+    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"
@@ -300,96 +370,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="hanota.c"
-    [class]{}-[func]{move}
-
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{solveHanota}
-    ```
-
-=== "C#"
-
-    ```csharp title="hanota.cs"
-    /* 移动一个圆盘 */
-    void move(List<int> src, List<int> tar) {
-        // 从 src 顶部拿出一个圆盘
-        int pan = src[^1];
-        src.RemoveAt(src.Count - 1);
-        // 将圆盘放入 tar 顶部
-        tar.Add(pan);
-    }
-
-    /* 求解汉诺塔：问题 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);
-    }
-
-    /* 求解汉诺塔 */
-    void solveHanota(List<int> A, List<int> B, List<int> C) {
-        int n = A.Count;
-        // 将 A 顶部 n 个圆盘借助 B 移到 C
-        dfs(n, A, B, C);
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="hanota.swift"
-    /* 移动一个圆盘 */
-    func move(src: inout [Int], tar: inout [Int]) {
-        // 从 src 顶部拿出一个圆盘
-        let pan = src.popLast()!
-        // 将圆盘放入 tar 顶部
-        tar.append(pan)
-    }
-
-    /* 求解汉诺塔：问题 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)
-    }
-
-    /* 求解汉诺塔 */
-    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)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="hanota.zig"
-    [class]{}-[func]{move}
-
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{solveHanota}
-    ```
-
 === "Dart"
 
     ```dart title="hanota.dart"
@@ -458,6 +438,26 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="hanota.c"
+    [class]{}-[func]{move}
+
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{solveHanota}
+    ```
+
+=== "Zig"
+
+    ```zig title="hanota.zig"
+    [class]{}-[func]{move}
+
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{solveHanota}
+    ```
+
 如图 12-15 所示，汉诺塔问题形成一个高度为 $n$ 的递归树，每个节点代表一个子问题、对应一个开启的 `dfs()` 函数，**因此时间复杂度为 $O(2^n)$ ，空间复杂度为 $O(n)$** 。
 
 ![汉诺塔问题的递归树](hanota_problem.assets/hanota_recursive_tree.png)

chapter_dynamic_programming/dp_problem_features.md

@@ -41,25 +41,22 @@ $$
 
 根据状态转移方程，以及初始状态 $dp[1] = cost[1]$ 和 $dp[2] = cost[2]$ ，我们就可以得到动态规划代码。
 
-=== "Java"
+=== "Python"
 
-    ```java title="min_cost_climbing_stairs_dp.java"
-    /* 爬楼梯最小代价：动态规划 */
-    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];
-    }
+    ```python title="min_cost_climbing_stairs_dp.py"
+    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++"
@@ -83,22 +80,46 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="min_cost_climbing_stairs_dp.py"
-    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]
+    ```java title="min_cost_climbing_stairs_dp.java"
+    /* 爬楼梯最小代价：动态规划 */
+    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"
+    /* 爬楼梯最小代价：动态规划 */
+    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"
@@ -123,6 +144,28 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="min_cost_climbing_stairs_dp.swift"
+    /* 爬楼梯最小代价：动态规划 */
+    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] = 1
+        dp[2] = 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"
@@ -167,77 +210,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="min_cost_climbing_stairs_dp.c"
-    [class]{}-[func]{minCostClimbingStairsDP}
-    ```
-
-=== "C#"
-
-    ```csharp title="min_cost_climbing_stairs_dp.cs"
-    /* 爬楼梯最小代价：动态规划 */
-    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];
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="min_cost_climbing_stairs_dp.swift"
-    /* 爬楼梯最小代价：动态规划 */
-    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] = 1
-        dp[2] = 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]
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="min_cost_climbing_stairs_dp.zig"
-    // 爬楼梯最小代价：动态规划
-    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];
-    }
-    ```
-
 === "Dart"
 
     ```dart title="min_cost_climbing_stairs_dp.dart"
@@ -278,6 +250,34 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="min_cost_climbing_stairs_dp.c"
+    [class]{}-[func]{minCostClimbingStairsDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="min_cost_climbing_stairs_dp.zig"
+    // 爬楼梯最小代价：动态规划
+    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 展示了以上代码的动态规划过程。
 
 ![爬楼梯最小代价的动态规划过程](dp_problem_features.assets/min_cost_cs_dp.png)
@@ -286,22 +286,18 @@ $$
 
 本题也可以进行空间优化，将一维压缩至零维，使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="min_cost_climbing_stairs_dp.java"
-    /* 爬楼梯最小代价：空间优化后的动态规划 */
-    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;
-    }
+    ```python title="min_cost_climbing_stairs_dp.py"
+    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++"
@@ -322,18 +318,40 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="min_cost_climbing_stairs_dp.py"
-    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
+    ```java title="min_cost_climbing_stairs_dp.java"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    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"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    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"
@@ -357,6 +375,23 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="min_cost_climbing_stairs_dp.swift"
+    /* 爬楼梯最小代价：空间优化后的动态规划 */
+    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"
@@ -397,68 +432,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="min_cost_climbing_stairs_dp.c"
-    [class]{}-[func]{minCostClimbingStairsDPComp}
-    ```
-
-=== "C#"
-
-    ```csharp title="min_cost_climbing_stairs_dp.cs"
-    /* 爬楼梯最小代价：空间优化后的动态规划 */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="min_cost_climbing_stairs_dp.swift"
-    /* 爬楼梯最小代价：空间优化后的动态规划 */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="min_cost_climbing_stairs_dp.zig"
-    // 爬楼梯最小代价：空间优化后的动态规划
-    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;
-    }
-    ```
-
 === "Dart"
 
     ```dart title="min_cost_climbing_stairs_dp.dart"
@@ -493,6 +466,33 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="min_cost_climbing_stairs_dp.c"
+    [class]{}-[func]{minCostClimbingStairsDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="min_cost_climbing_stairs_dp.zig"
+    // 爬楼梯最小代价：空间优化后的动态规划
+    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; 无后效性
 
 无后效性是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。
@@ -535,28 +535,23 @@ $$
 
 最终，返回 $dp[n, 1] + dp[n, 2]$ 即可，两者之和代表爬到第 $n$ 阶的方案总数。
 
-=== "Java"
+=== "Python"
 
-    ```java title="climbing_stairs_constraint_dp.java"
-    /* 带约束爬楼梯：动态规划 */
-    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];
-    }
+    ```python title="climbing_stairs_constraint_dp.py"
+    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++"
@@ -583,23 +578,52 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="climbing_stairs_constraint_dp.py"
-    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]
+    ```java title="climbing_stairs_constraint_dp.java"
+    /* 带约束爬楼梯：动态规划 */
+    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"
+    /* 带约束爬楼梯：动态规划 */
+    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"
@@ -626,6 +650,30 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="climbing_stairs_constraint_dp.swift"
+    /* 带约束爬楼梯：动态规划 */
+    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"
@@ -674,84 +722,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="climbing_stairs_constraint_dp.c"
-    [class]{}-[func]{climbingStairsConstraintDP}
-    ```
-
-=== "C#"
-
-    ```csharp title="climbing_stairs_constraint_dp.cs"
-    /* 带约束爬楼梯：动态规划 */
-    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];
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="climbing_stairs_constraint_dp.swift"
-    /* 带约束爬楼梯：动态规划 */
-    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]
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="climbing_stairs_constraint_dp.zig"
-    // 带约束爬楼梯：动态规划
-    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];
-    }
-    ```
-
 === "Dart"
 
     ```dart title="climbing_stairs_constraint_dp.dart"
@@ -798,6 +768,36 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="climbing_stairs_constraint_dp.c"
+    [class]{}-[func]{climbingStairsConstraintDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="climbing_stairs_constraint_dp.zig"
+    // 带约束爬楼梯：动态规划
+    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];
+    }
+    ```
+
 在上面的案例中，由于仅需多考虑前面一个状态，我们仍然可以通过扩展状态定义，使得问题重新满足无后效性。然而，某些问题具有非常严重的“有后效性”。
 
 !!! question "爬楼梯与障碍生成"

chapter_dynamic_programming/edit_distance_problem.md

@@ -78,34 +78,28 @@ $$
 
 ### 2.   代码实现
 
-=== "Java"
+=== "Python"
 
-    ```java title="edit_distance.java"
-    /* 编辑距离：动态规划 */
-    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];
-    }
+    ```python title="edit_distance.py"
+    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++"
@@ -138,28 +132,64 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="edit_distance.py"
-    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]
+    ```java title="edit_distance.java"
+    /* 编辑距离：动态规划 */
+    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"
+    /* 编辑距离：动态规划 */
+    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"
@@ -196,6 +226,37 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="edit_distance.swift"
+    /* 编辑距离：动态规划 */
+    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"
@@ -268,104 +329,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="edit_distance.c"
-    [class]{}-[func]{editDistanceDP}
-    ```
-
-=== "C#"
-
-    ```csharp title="edit_distance.cs"
-    /* 编辑距离：动态规划 */
-    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];
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="edit_distance.swift"
-    /* 编辑距离：动态规划 */
-    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]
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="edit_distance.zig"
-    // 编辑距离：动态规划
-    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];
-    }
-    ```
-
 === "Dart"
 
     ```dart title="edit_distance.dart"
@@ -426,6 +389,43 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="edit_distance.c"
+    [class]{}-[func]{editDistanceDP}
+    ```
+
+=== "Zig"
+
+    ```zig title="edit_distance.zig"
+    // 编辑距离：动态规划
+    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 所示，编辑距离问题的状态转移过程与背包问题非常类似，都可以看作是填写一个二维网格的过程。
 
 === "<1>"
@@ -481,37 +481,32 @@ $$
 
 为此，我们可以使用一个变量 `leftup` 来暂存左上方的解 $dp[i-1, j-1]$ ，从而只需考虑左方和上方的解。此时的情况与完全背包问题相同，可使用正序遍历。
 
-=== "Java"
+=== "Python"
 
-    ```java title="edit_distance.java"
-    /* 编辑距离：空间优化后的动态规划 */
-    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];
-    }
+    ```python title="edit_distance.py"
+    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++"
@@ -547,32 +542,70 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="edit_distance.py"
-    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]
+    ```java title="edit_distance.java"
+    /* 编辑距离：空间优化后的动态规划 */
+    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"
+    /* 编辑距离：空间优化后的动态规划 */
+    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"
@@ -609,6 +642,40 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="edit_distance.swift"
+    /* 编辑距离：空间优化后的动态规划 */
+    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"
@@ -677,113 +744,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="edit_distance.c"
-    [class]{}-[func]{editDistanceDPComp}
-    ```
-
-=== "C#"
-
-    ```csharp title="edit_distance.cs"
-    /* 编辑距离：空间优化后的动态规划 */
-    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];
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="edit_distance.swift"
-    /* 编辑距离：空间优化后的动态规划 */
-    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]
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="edit_distance.zig"
-    // 编辑距离：空间优化后的动态规划
-    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];
-    }
-    ```
-
 === "Dart"
 
     ```dart title="edit_distance.dart"
@@ -849,3 +809,43 @@ $$
         dp[m]
     }
     ```
+
+=== "C"
+
+    ```c title="edit_distance.c"
+    [class]{}-[func]{editDistanceDPComp}
+    ```
+
+=== "Zig"
+
+    ```zig title="edit_distance.zig"
+    // 编辑距离：空间优化后的动态规划
+    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];
+    }
+    ```

chapter_graph/graph_traversal.md

@@ -26,35 +26,30 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
 
 为了防止重复遍历顶点，我们需要借助一个哈希表 `visited` 来记录哪些节点已被访问。
 
-=== "Java"
+=== "Python"
 
-    ```java title="graph_bfs.java"
-    /* 广度优先遍历 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;
-    }
+    ```python title="graph_bfs.py"
+    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++"
@@ -88,30 +83,66 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="graph_bfs.py"
-    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
+    ```java title="graph_bfs.java"
+    /* 广度优先遍历 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"
+    /* 广度优先遍历 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"
@@ -150,6 +181,36 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
+=== "Swift"
+
+    ```swift title="graph_bfs.swift"
+    /* 广度优先遍历 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"
@@ -212,116 +273,6 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
-=== "C"
-
-    ```c title="graph_bfs.c"
-    /* 广度优先遍历 */
-    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
-    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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="graph_bfs.cs"
-    /* 广度优先遍历 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="graph_bfs.swift"
-    /* 广度优先遍历 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="graph_bfs.zig"
-    [class]{}-[func]{graphBFS}
-    ```
-
 === "Dart"
 
     ```dart title="graph_bfs.dart"
@@ -388,6 +339,55 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
+=== "C"
+
+    ```c title="graph_bfs.c"
+    /* 广度优先遍历 */
+    // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    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"
+
+    ```zig title="graph_bfs.zig"
+    [class]{}-[func]{graphBFS}
+    ```
+
 代码相对抽象，建议对照图 9-10 来加深理解。
 
 === "<1>"
@@ -447,32 +447,29 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
 
 这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 `visited` 来记录已被访问的顶点，以避免重复访问顶点。
 
-=== "Java"
+=== "Python"
 
-    ```java title="graph_dfs.java"
-    /* 深度优先遍历 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);
-        }
-    }
+    ```python title="graph_dfs.py"
+    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)
 
-    /* 深度优先遍历 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;
-    }
+    def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+        """深度优先遍历 DFS"""
+        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+        # 顶点遍历序列
+        res = []
+        # 哈希表，用于记录已被访问过的顶点
+        visited = set[Vertex]()
+        dfs(graph, visited, res, start_vet)
+        return res
     ```
 
 === "C++"
@@ -503,29 +500,61 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="graph_dfs.py"
-    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)
+    ```java title="graph_dfs.java"
+    /* 深度优先遍历 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);
+        }
+    }
 
-    def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
-        """深度优先遍历 DFS"""
-        # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
-        # 顶点遍历序列
-        res = []
-        # 哈希表，用于记录已被访问过的顶点
-        visited = set[Vertex]()
-        dfs(graph, visited, res, start_vet)
-        return res
+    /* 深度优先遍历 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"
+    /* 深度优先遍历 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);
+        }
+    }
+
+    /* 深度优先遍历 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"
@@ -559,6 +588,35 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
+=== "Swift"
+
+    ```swift title="graph_dfs.swift"
+    /* 深度优先遍历 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)
+        }
+    }
+
+    /* 深度优先遍历 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"
@@ -623,111 +681,6 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
-=== "C"
-
-    ```c title="graph_dfs.c"
-    /* 深度优先遍历 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;
-    }
-
-    /* 深度优先遍历 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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="graph_dfs.cs"
-    /* 深度优先遍历 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);
-        }
-    }
-
-    /* 深度优先遍历 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="graph_dfs.swift"
-    /* 深度优先遍历 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)
-        }
-    }
-
-    /* 深度优先遍历 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="graph_dfs.zig"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{graphDFS}
-    ```
-
 === "Dart"
 
     ```dart title="graph_dfs.dart"
@@ -793,6 +746,53 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
     }
     ```
 
+=== "C"
+
+    ```c title="graph_dfs.c"
+    /* 深度优先遍历 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;
+    }
+
+    /* 深度优先遍历 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"
+
+    ```zig title="graph_dfs.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{graphDFS}
+    ```
+
 深度优先遍历的算法流程如图 9-12 所示。
 
 - **直虚线代表向下递推**，表示开启了一个新的递归方法来访问新顶点。

chapter_greedy/fractional_knapsack_problem.md

@@ -40,45 +40,35 @@ status: new
 
 我们建立了一个物品类 `Item` ，以便将物品按照单位价值进行排序。循环进行贪心选择，当背包已满时跳出并返回解。
 
-=== "Java"
+=== "Python"
 
-    ```java title="fractional_knapsack.java"
-    /* 物品 */
-    class Item {
-        int w; // 物品重量
-        int v; // 物品价值
+    ```python title="fractional_knapsack.py"
+    class Item:
+        """物品"""
 
-        public Item(int w, int v) {
-            this.w = w;
-            this.v = v;
-        }
-    }
+        def __init__(self, w: int, v: int):
+            self.w = w  # 物品重量
+            self.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;
-    }
+    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++"
@@ -121,35 +111,86 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="fractional_knapsack.py"
-    class Item:
-        """物品"""
+    ```java title="fractional_knapsack.java"
+    /* 物品 */
+    class Item {
+        int w; // 物品重量
+        int v; // 物品价值
 
-        def __init__(self, w: int, v: int):
-            self.w = w  # 物品重量
-            self.v = v  # 物品价值
+        public Item(int w, int v) {
+            this.w = w;
+            this.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
+    /* 分数背包：贪心 */
+    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 {
+        public int w; // 物品重量
+        public int v; // 物品价值
+
+        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"
@@ -190,6 +231,45 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="fractional_knapsack.swift"
+    /* 物品 */
+    class Item {
+        var w: Int // 物品重量
+        var v: Int // 物品价值
+
+        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"
@@ -263,102 +343,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="fractional_knapsack.c"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractionalKnapsack}
-    ```
-
-=== "C#"
-
-    ```csharp title="fractional_knapsack.cs"
-    /* 物品 */
-    class Item {
-        public int w; // 物品重量
-        public int v; // 物品价值
-
-        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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="fractional_knapsack.swift"
-    /* 物品 */
-    class Item {
-        var w: Int // 物品重量
-        var v: Int // 物品价值
-
-        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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="fractional_knapsack.zig"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractionalKnapsack}
-    ```
-
 === "Dart"
 
     ```dart title="fractional_knapsack.dart"
@@ -441,6 +425,22 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="fractional_knapsack.c"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
+=== "Zig"
+
+    ```zig title="fractional_knapsack.zig"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractionalKnapsack}
+    ```
+
 最差情况下，需要遍历整个物品列表，**因此时间复杂度为 $O(n)$** ，其中 $n$ 为物品数量。
 
 由于初始化了一个 `Item` 对象列表，**因此空间复杂度为 $O(n)$** 。

chapter_greedy/greedy_algorithm.md

@@ -26,27 +26,24 @@ status: new
 
 实现代码如下所示。你可能会不由地发出感叹：So Clean ！贪心算法仅用十行代码就解决了零钱兑换问题。
 
-=== "Java"
+=== "Python"
 
-    ```java title="coin_change_greedy.java"
-    /* 零钱兑换：贪心 */
-    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;
-    }
+    ```python title="coin_change_greedy.py"
+    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++"
@@ -72,24 +69,50 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="coin_change_greedy.py"
-    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
+    ```java title="coin_change_greedy.java"
+    /* 零钱兑换：贪心 */
+    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"
+    /* 零钱兑换：贪心 */
+    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"
@@ -118,6 +141,30 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="coin_change_greedy.swift"
+    /* 零钱兑换：贪心 */
+    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"
@@ -164,65 +211,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="coin_change_greedy.c"
-    [class]{}-[func]{coinChangeGreedy}
-    ```
-
-=== "C#"
-
-    ```csharp title="coin_change_greedy.cs"
-    /* 零钱兑换：贪心 */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="coin_change_greedy.swift"
-    /* 零钱兑换：贪心 */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="coin_change_greedy.zig"
-    [class]{}-[func]{coinChangeGreedy}
-    ```
-
 === "Dart"
 
     ```dart title="coin_change_greedy.dart"
@@ -273,6 +261,18 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="coin_change_greedy.c"
+    [class]{}-[func]{coinChangeGreedy}
+    ```
+
+=== "Zig"
+
+    ```zig title="coin_change_greedy.zig"
+    [class]{}-[func]{coinChangeGreedy}
+    ```
+
 ## 15.1.1   贪心优点与局限性
 
 **贪心算法不仅操作直接、实现简单，而且通常效率也很高**。在以上代码中，记硬币最小面值为 $\min(coins)$ ，则贪心选择最多循环 $amt / \min(coins)$ 次，时间复杂度为 $O(amt / \min(coins))$ 。这比动态规划解法的时间复杂度 $O(n \times amt)$ 提升了一个数量级。

chapter_greedy/max_capacity_problem.md

@@ -93,29 +93,26 @@ $$
 
 变量 $i$、$j$、$res$ 使用常数大小额外空间，**因此空间复杂度为 $O(1)$** 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="max_capacity.java"
-    /* 最大容量：贪心 */
-    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;
-    }
+    ```python title="max_capacity.py"
+    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++"
@@ -143,26 +140,54 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="max_capacity.py"
-    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
+    ```java title="max_capacity.java"
+    /* 最大容量：贪心 */
+    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"
+    /* 最大容量：贪心 */
+    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"
@@ -190,6 +215,31 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="max_capacity.swift"
+    /* 最大容量：贪心 */
+    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"
@@ -242,68 +292,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="max_capacity.c"
-    [class]{}-[func]{maxCapacity}
-    ```
-
-=== "C#"
-
-    ```csharp title="max_capacity.cs"
-    /* 最大容量：贪心 */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="max_capacity.swift"
-    /* 最大容量：贪心 */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="max_capacity.zig"
-    [class]{}-[func]{maxCapacity}
-    ```
-
 === "Dart"
 
     ```dart title="max_capacity.dart"
@@ -355,6 +343,18 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="max_capacity.c"
+    [class]{}-[func]{maxCapacity}
+    ```
+
+=== "Zig"
+
+    ```zig title="max_capacity.zig"
+    [class]{}-[func]{maxCapacity}
+    ```
+
 ### 3. &nbsp; 正确性证明
 
 之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。

chapter_greedy/max_product_cutting_problem.md

@@ -74,29 +74,24 @@ $$
 
 请注意，对于 $n \leq 3$ 的边界情况，必须拆分出一个 $1$ ，乘积为 $1 \times (n - 1)$ 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="max_product_cutting.java"
-    /* 最大切分乘积：贪心 */
-    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);
-    }
+    ```python title="max_product_cutting.py"
+    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++"
@@ -124,24 +119,54 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="max_product_cutting.py"
-    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))
+    ```java title="max_product_cutting.java"
+    /* 最大切分乘积：贪心 */
+    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"
+    /* 最大切分乘积：贪心 */
+    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"
@@ -169,6 +194,31 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="max_product_cutting.swift"
+    /* 最大切分乘积：贪心 */
+    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"
@@ -219,68 +269,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="max_product_cutting.c"
-    [class]{}-[func]{maxProductCutting}
-    ```
-
-=== "C#"
-
-    ```csharp title="max_product_cutting.cs"
-    /* 最大切分乘积：贪心 */
-    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);
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="max_product_cutting.swift"
-    /* 最大切分乘积：贪心 */
-    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)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="max_product_cutting.zig"
-    [class]{}-[func]{maxProductCutting}
-    ```
-
 === "Dart"
 
     ```dart title="max_product_cutting.dart"
@@ -331,6 +319,18 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="max_product_cutting.c"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
+=== "Zig"
+
+    ```zig title="max_product_cutting.zig"
+    [class]{}-[func]{maxProductCutting}
+    ```
+
 ![最大切分乘积的计算方法](max_product_cutting_problem.assets/max_product_cutting_greedy_calculation.png)
 
 <p align="center"> 图 15-16 &nbsp; 最大切分乘积的计算方法 </p>

chapter_hashing/hash_algorithm.md

@@ -51,48 +51,40 @@ index = hash(key) % capacity
 - **异或哈希**：将输入数据的每个元素通过异或操作累积到一个哈希值中。
 - **旋转哈希**：将每个字符的 ASCII 码累积到一个哈希值中，每次累积之前都会对哈希值进行旋转操作。
 
-=== "Java"
+=== "Python"
 
-    ```java title="simple_hash.java"
-    /* 加法哈希 */
-    int addHash(String key) {
-        long hash = 0;
-        final int MODULUS = 1000000007;
-        for (char c : key.toCharArray()) {
-            hash = (hash + (int) c) % MODULUS;
-        }
-        return (int) hash;
-    }
+    ```python title="simple_hash.py"
+    def add_hash(key: str) -> int:
+        """加法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash += ord(c)
+        return hash % modulus
 
-    /* 乘法哈希 */
-    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;
-    }
+    def mul_hash(key: str) -> int:
+        """乘法哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash = 31 * hash + ord(c)
+        return hash % modulus
 
-    /* 异或哈希 */
-    int xorHash(String key) {
-        int hash = 0;
-        final int MODULUS = 1000000007;
-        for (char c : key.toCharArray()) {
-            hash ^= (int) c;
-        }
-        return hash & MODULUS;
-    }
+    def xor_hash(key: str) -> int:
+        """异或哈希"""
+        hash = 0
+        modulus = 1000000007
+        for c in key:
+            hash ^= ord(c)
+        return hash % modulus
 
-    /* 旋转哈希 */
-    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;
-    }
+    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++"
@@ -140,40 +132,92 @@ index = hash(key) % capacity
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="simple_hash.py"
-    def add_hash(key: str) -> int:
-        """加法哈希"""
-        hash = 0
-        modulus = 1000000007
-        for c in key:
-            hash += ord(c)
-        return hash % modulus
+    ```java title="simple_hash.java"
+    /* 加法哈希 */
+    int addHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
 
-    def mul_hash(key: str) -> int:
-        """乘法哈希"""
-        hash = 0
-        modulus = 1000000007
-        for c in key:
-            hash = 31 * hash + ord(c)
-        return hash % modulus
+    /* 乘法哈希 */
+    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;
+    }
 
-    def xor_hash(key: str) -> int:
-        """异或哈希"""
-        hash = 0
-        modulus = 1000000007
-        for c in key:
-            hash ^= ord(c)
-        return hash % modulus
+    /* 异或哈希 */
+    int xorHash(String key) {
+        int hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash ^= (int) c;
+        }
+        return hash & MODULUS;
+    }
 
-    def rot_hash(key: str) -> int:
-        """旋转哈希"""
-        hash = 0
-        modulus = 1000000007
-        for c in key:
-            hash = (hash << 4) ^ (hash >> 28) ^ ord(c)
-        return hash % modulus
+    /* 旋转哈希 */
+    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"
+    /* 加法哈希 */
+    int addHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 乘法哈希 */
+    int mulHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (31 * hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* 异或哈希 */
+    int xorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash ^= c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* 旋转哈希 */
+    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"
@@ -228,6 +272,58 @@ index = hash(key) % capacity
     }
     ```
 
+=== "Swift"
+
+    ```swift title="simple_hash.swift"
+    /* 加法哈希 */
+    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
+    }
+
+    /* 乘法哈希 */
+    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
+    }
+
+    /* 异或哈希 */
+    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
+    }
+
+    /* 旋转哈希 */
+    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"
@@ -316,126 +412,6 @@ index = hash(key) % capacity
     }
     ```
 
-=== "C"
-
-    ```c title="simple_hash.c"
-    [class]{}-[func]{addHash}
-
-    [class]{}-[func]{mulHash}
-
-    [class]{}-[func]{xorHash}
-
-    [class]{}-[func]{rotHash}
-    ```
-
-=== "C#"
-
-    ```csharp title="simple_hash.cs"
-    /* 加法哈希 */
-    int addHash(string key) {
-        long hash = 0;
-        const int MODULUS = 1000000007;
-        foreach (char c in key) {
-            hash = (hash + c) % MODULUS;
-        }
-        return (int)hash;
-    }
-
-    /* 乘法哈希 */
-    int mulHash(string key) {
-        long hash = 0;
-        const int MODULUS = 1000000007;
-        foreach (char c in key) {
-            hash = (31 * hash + c) % MODULUS;
-        }
-        return (int)hash;
-    }
-
-    /* 异或哈希 */
-    int xorHash(string key) {
-        int hash = 0;
-        const int MODULUS = 1000000007;
-        foreach (char c in key) {
-            hash ^= c;
-        }
-        return hash & MODULUS;
-    }
-
-    /* 旋转哈希 */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="simple_hash.swift"
-    /* 加法哈希 */
-    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
-    }
-
-    /* 乘法哈希 */
-    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
-    }
-
-    /* 异或哈希 */
-    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
-    }
-
-    /* 旋转哈希 */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="simple_hash.zig"
-    [class]{}-[func]{addHash}
-
-    [class]{}-[func]{mulHash}
-
-    [class]{}-[func]{xorHash}
-
-    [class]{}-[func]{rotHash}
-    ```
-
 === "Dart"
 
     ```dart title="simple_hash.dart"
@@ -492,6 +468,30 @@ index = hash(key) % capacity
     [class]{}-[func]{rot_hash}
     ```
 
+=== "C"
+
+    ```c title="simple_hash.c"
+    [class]{}-[func]{addHash}
+
+    [class]{}-[func]{mulHash}
+
+    [class]{}-[func]{xorHash}
+
+    [class]{}-[func]{rotHash}
+    ```
+
+=== "Zig"
+
+    ```zig title="simple_hash.zig"
+    [class]{}-[func]{addHash}
+
+    [class]{}-[func]{mulHash}
+
+    [class]{}-[func]{xorHash}
+
+    [class]{}-[func]{rotHash}
+    ```
+
 观察发现，每种哈希算法的最后一步都是对大质数 $1000000007$ 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，或者说对合数取模的弊端是什么？这是一个有趣的问题。
 
 先抛出结论：**当我们使用大质数作为模数时，可以最大化地保证哈希值的均匀分布**。因为质数不会与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。
@@ -559,57 +559,6 @@ $$
 
     请注意，不同编程语言的内置哈希值计算函数的定义和方法不同。
 
-=== "Java"
-
-    ```java title="built_in_hash.java"
-    int num = 3;
-    int hashNum = Integer.hashCode(num);
-    // 整数 3 的哈希值为 3
-
-    boolean bol = true;
-    int hashBol = Boolean.hashCode(bol);
-    // 布尔量 true 的哈希值为 1231
-
-    double dec = 3.14159;
-    int hashDec = Double.hashCode(dec);
-    // 小数 3.14159 的哈希值为 -1340954729
-
-    String str = "Hello 算法";
-    int hashStr = str.hashCode();
-    // 字符串 Hello 算法 的哈希值为 -727081396
-
-    Object[] arr = { 12836, "小哈" };
-    int hashTup = Arrays.hashCode(arr);
-    // 数组 [12836, 小哈] 的哈希值为 1151158
-
-    ListNode obj = new ListNode(0);
-    int hashObj = obj.hashCode();
-    // 节点对象 utils.ListNode@7dc5e7b4 的哈希值为 2110121908
-    ```
-
-=== "C++"
-
-    ```cpp title="built_in_hash.cpp"
-    int num = 3;
-    size_t hashNum = hash<int>()(num);
-    // 整数 3 的哈希值为 3
-
-    bool bol = true;
-    size_t hashBol = hash<bool>()(bol);
-    // 布尔量 1 的哈希值为 1
-
-    double dec = 3.14159;
-    size_t hashDec = hash<double>()(dec);
-    // 小数 3.14159 的哈希值为 4614256650576692846
-
-    string str = "Hello 算法";
-    size_t hashStr = hash<string>()(str);
-    // 字符串 Hello 算法 的哈希值为 15466937326284535026
-
-    // 在 C++ 中，内置 std:hash() 仅提供基本数据类型的哈希值计算
-    // 数组、对象的哈希值计算需要自行实现
-    ```
-
 === "Python"
 
     ```python title="built_in_hash.py"
@@ -638,28 +587,55 @@ $$
     # 节点对象 <ListNode object at 0x1058fd810> 的哈希值为 274267521
     ```
 
-=== "Go"
+=== "C++"
 
-    ```go title="built_in_hash.go"
+    ```cpp title="built_in_hash.cpp"
+    int num = 3;
+    size_t hashNum = hash<int>()(num);
+    // 整数 3 的哈希值为 3
 
+    bool bol = true;
+    size_t hashBol = hash<bool>()(bol);
+    // 布尔量 1 的哈希值为 1
+
+    double dec = 3.14159;
+    size_t hashDec = hash<double>()(dec);
+    // 小数 3.14159 的哈希值为 4614256650576692846
+
+    string str = "Hello 算法";
+    size_t hashStr = hash<string>()(str);
+    // 字符串 Hello 算法 的哈希值为 15466937326284535026
+
+    // 在 C++ 中，内置 std:hash() 仅提供基本数据类型的哈希值计算
+    // 数组、对象的哈希值计算需要自行实现
     ```
 
-=== "JS"
+=== "Java"
 
-    ```javascript title="built_in_hash.js"
-    // JavaScript 未提供内置 hash code 函数
-    ```
+    ```java title="built_in_hash.java"
+    int num = 3;
+    int hashNum = Integer.hashCode(num);
+    // 整数 3 的哈希值为 3
 
-=== "TS"
+    boolean bol = true;
+    int hashBol = Boolean.hashCode(bol);
+    // 布尔量 true 的哈希值为 1231
 
-    ```typescript title="built_in_hash.ts"
-    // TypeScript 未提供内置 hash code 函数
-    ```
+    double dec = 3.14159;
+    int hashDec = Double.hashCode(dec);
+    // 小数 3.14159 的哈希值为 -1340954729
 
-=== "C"
+    String str = "Hello 算法";
+    int hashStr = str.hashCode();
+    // 字符串 Hello 算法 的哈希值为 -727081396
 
-    ```c title="built_in_hash.c"
+    Object[] arr = { 12836, "小哈" };
+    int hashTup = Arrays.hashCode(arr);
+    // 数组 [12836, 小哈] 的哈希值为 1151158
 
+    ListNode obj = new ListNode(0);
+    int hashObj = obj.hashCode();
+    // 节点对象 utils.ListNode@7dc5e7b4 的哈希值为 2110121908
     ```
 
 === "C#"
@@ -690,6 +666,12 @@ $$
     // 节点对象 0 的哈希值为 39053774;
     ```
 
+=== "Go"
+
+    ```go title="built_in_hash.go"
+
+    ```
+
 === "Swift"
 
     ```swift title="built_in_hash.swift"
@@ -718,10 +700,16 @@ $$
     // 节点对象 utils.ListNode 的哈希值为 -2434780518035996159
     ```
 
-=== "Zig"
+=== "JS"
 
-    ```zig title="built_in_hash.zig"
+    ```javascript title="built_in_hash.js"
+    // JavaScript 未提供内置 hash code 函数
+    ```
 
+=== "TS"
+
+    ```typescript title="built_in_hash.ts"
+    // TypeScript 未提供内置 hash code 函数
     ```
 
 === "Dart"
@@ -758,6 +746,18 @@ $$
 
     ```
 
+=== "C"
+
+    ```c title="built_in_hash.c"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="built_in_hash.zig"
+
+    ```
+
 在许多编程语言中，**只有不可变对象才可作为哈希表的 `key`** 。假如我们将列表（动态数组）作为 `key` ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 `value` 了。
 
 虽然自定义对象（比如链表节点）的成员变量是可变的，但它是可哈希的。**这是因为对象的哈希值通常是基于内存地址生成的**，即使对象的内容发生了变化，但它的内存地址不变，哈希值仍然是不变的。

chapter_heap/build_heap.md

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

chapter_heap/top_k.md

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

chapter_preface/suggestions.md

@@ -17,17 +17,17 @@ comments: true
 - 当涉及到编程语言之间不一致的名词时，本书均以 Python 为准，例如使用 $\text{None}$ 来表示“空”。
 - 本书部分放弃了编程语言的注释规范，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
 
-=== "Java"
+=== "Python"
 
-    ```java title=""
-    /* 标题注释，用于标注函数、类、测试样例等 */
+    ```python title=""
+    """标题注释，用于标注函数、类、测试样例等"""
     
-    // 内容注释，用于详解代码
+    # 内容注释，用于详解代码
     
-    /**
-     * 多行
-     * 注释
-     */
+    """
+    多行
+    注释
+    """
     ```
 
 === "C++"
@@ -43,17 +43,30 @@ comments: true
      */
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title=""
-    """标题注释，用于标注函数、类、测试样例等"""
+    ```java title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
     
-    # 内容注释，用于详解代码
+    // 内容注释，用于详解代码
     
-    """
-    多行
-    注释
-    """
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
     ```
 
 === "Go"
@@ -69,6 +82,19 @@ comments: true
      */
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
 === "JS"
 
     ```javascript title=""
@@ -95,6 +121,25 @@ comments: true
      */
     ```
 
+=== "Dart"
+
+    ```dart title=""
+    /* 标题注释，用于标注函数、类、测试样例等 */
+    
+    // 内容注释，用于详解代码
+    
+    /**
+     * 多行
+     * 注释
+     */
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 === "C"
 
     ```c title=""
@@ -108,32 +153,6 @@ comments: true
      */
     ```
 
-=== "C#"
-
-    ```csharp title=""
-    /* 标题注释，用于标注函数、类、测试样例等 */
-    
-    // 内容注释，用于详解代码
-    
-    /**
-     * 多行
-     * 注释
-     */
-    ```
-
-=== "Swift"
-
-    ```swift title=""
-    /* 标题注释，用于标注函数、类、测试样例等 */
-    
-    // 内容注释，用于详解代码
-    
-    /**
-     * 多行
-     * 注释
-     */
-    ```
-
 === "Zig"
 
     ```zig title=""
@@ -145,25 +164,6 @@ comments: true
     // 注释
     ```
 
-=== "Dart"
-
-    ```dart title=""
-    /* 标题注释，用于标注函数、类、测试样例等 */
-    
-    // 内容注释，用于详解代码
-    
-    /**
-     * 多行
-     * 注释
-     */
-    ```
-
-=== "Rust"
-
-    ```rust title=""
-
-    ```
-
 ## 0.2.2   在动画图解中高效学习
 
 相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，**重点和难点知识将主要通过动画和图解形式展示**，而文字则作为动画和图片的解释与补充。

chapter_searching/binary_search.md

@@ -51,26 +51,24 @@ comments: true
 
 值得注意的是，由于 $i$ 和 $j$ 都是 `int` 类型，**因此 $i + j$ 可能会超出 `int` 类型的取值范围**。为了避免大数越界，我们通常采用公式 $m = \lfloor {i + (j - i) / 2} \rfloor$ 来计算中点。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search.java"
-    /* 二分查找（双闭区间） */
-    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;
-    }
+    ```python title="binary_search.py"
+    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++"
@@ -95,24 +93,48 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search.py"
-    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
+    ```java title="binary_search.java"
+    /* 二分查找（双闭区间） */
+    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"
+    /* 二分查找（双闭区间） */
+    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"
@@ -138,6 +160,30 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+    /* 二分查找（双闭区间） */
+    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"
@@ -190,98 +236,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search.c"
-    /* 二分查找（双闭区间） */
-    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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search.cs"
-    /* 二分查找（双闭区间） */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search.swift"
-    /* 二分查找（双闭区间） */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search.zig"
-    // 二分查找（双闭区间）
-    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;
-    }
-    ```
-
 === "Dart"
 
     ```dart title="binary_search.dart"
@@ -332,6 +286,52 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search.c"
+    /* 二分查找（双闭区间） */
+    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"
+    // 二分查找（双闭区间）
+    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$ 。
 
 **空间复杂度 $O(1)$** ：指针 $i$ 和 $j$ 使用常数大小空间。
@@ -342,26 +342,23 @@ comments: true
 
 我们可以基于该表示实现具有相同功能的二分查找算法。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search.java"
-    /* 二分查找（左闭右开） */
-    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;
-    }
+    ```python title="binary_search.py"
+    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++"
@@ -386,23 +383,48 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search.py"
-    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
+    ```java title="binary_search.java"
+    /* 二分查找（左闭右开） */
+    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"
+    /* 二分查找（左闭右开） */
+    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"
@@ -428,6 +450,30 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search.swift"
+    /* 二分查找（左闭右开） */
+    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"
@@ -481,98 +527,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search.c"
-    /* 二分查找（左闭右开） */
-    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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search.cs"
-    /* 二分查找（左闭右开） */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search.swift"
-    /* 二分查找（左闭右开） */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search.zig"
-    // 二分查找（左闭右开）
-    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;
-    }
-    ```
-
 === "Dart"
 
     ```dart title="binary_search.dart"
@@ -623,6 +577,52 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search.c"
+    /* 二分查找（左闭右开） */
+    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"
+    // 二分查找（左闭右开）
+    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 所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
 
 由于“双闭区间”表示中的左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错，**因此一般建议采用“双闭区间”的写法**。

chapter_searching/binary_search_edge.md

@@ -20,20 +20,18 @@ status: new
 
 当遇到以上两种情况时，直接返回 $-1$ 即可。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search_edge.java"
-    /* 二分查找最左一个 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;
-    }
+    ```python title="binary_search_edge.py"
+    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++"
@@ -52,18 +50,36 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search_edge.py"
-    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
+    ```java title="binary_search_edge.java"
+    /* 二分查找最左一个 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"
+    /* 二分查找最左一个 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"
@@ -82,6 +98,22 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_edge.swift"
+    /* 二分查找最左一个 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"
@@ -114,50 +146,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchLeftEdge}
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search_edge.cs"
-    /* 二分查找最左一个 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search_edge.swift"
-    /* 二分查找最左一个 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search_edge.zig"
-    [class]{}-[func]{binarySearchLeftEdge}
-    ```
-
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
@@ -190,6 +178,18 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search_edge.c"
+    [class]{}-[func]{binarySearchLeftEdge}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_edge.zig"
+    [class]{}-[func]{binarySearchLeftEdge}
+    ```
+
 ## 10.3.2   查找右边界
 
 那么如何查找最右一个 `target` 呢？最直接的方式是修改代码，替换在 `nums[m] == target` 情况下的指针收缩操作。代码在此省略，有兴趣的同学可以自行实现。
@@ -208,22 +208,20 @@ status: new
 
 请注意，返回的插入点是 $i$ ，因此需要将其减 $1$ ，从而获得 $j$ 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search_edge.java"
-    /* 二分查找最右一个 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;
-    }
+    ```python title="binary_search_edge.py"
+    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++"
@@ -244,20 +242,40 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search_edge.py"
-    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
+    ```java title="binary_search_edge.java"
+    /* 二分查找最右一个 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"
+    /* 二分查找最右一个 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"
@@ -278,6 +296,24 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_edge.swift"
+    /* 二分查找最右一个 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"
@@ -314,54 +350,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search_edge.c"
-    [class]{}-[func]{binarySearchRightEdge}
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search_edge.cs"
-    /* 二分查找最右一个 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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search_edge.swift"
-    /* 二分查找最右一个 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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search_edge.zig"
-    [class]{}-[func]{binarySearchRightEdge}
-    ```
-
 === "Dart"
 
     ```dart title="binary_search_edge.dart"
@@ -398,6 +386,18 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search_edge.c"
+    [class]{}-[func]{binarySearchRightEdge}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_edge.zig"
+    [class]{}-[func]{binarySearchRightEdge}
+    ```
+
 ### 2.   转化为查找元素
 
 我们知道，当数组不包含 `target` 时，最终 $i$ 和 $j$ 会分别指向首个大于、小于 `target` 的元素。

chapter_searching/binary_search_insertion.md

@@ -29,25 +29,22 @@ status: new
 
 因此二分结束时一定有：$i$ 指向首个大于 `target` 的元素，$j$ 指向首个小于 `target` 的元素。**易得当数组不包含 `target` 时，插入索引为 $i$** 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search_insertion.java"
-    /* 二分查找插入点（无重复元素） */
-    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;
-    }
+    ```python title="binary_search_insertion.py"
+    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++"
@@ -71,22 +68,46 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search_insertion.py"
-    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
+    ```java title="binary_search_insertion.java"
+    /* 二分查找插入点（无重复元素） */
+    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"
+    /* 二分查找插入点（无重复元素） */
+    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"
@@ -115,6 +136,27 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_insertion.swift"
+    /* 二分查找插入点（无重复元素） */
+    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"
@@ -162,60 +204,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search_insertion.c"
-    [class]{}-[func]{binarySearchInsertionSimple}
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search_insertion.cs"
-    /* 二分查找插入点（无重复元素） */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search_insertion.swift"
-    /* 二分查找插入点（无重复元素） */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search_insertion.zig"
-    [class]{}-[func]{binarySearchInsertionSimple}
-    ```
-
 === "Dart"
 
     ```dart title="binary_search_insertion.dart"
@@ -258,6 +246,18 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search_insertion.c"
+    [class]{}-[func]{binarySearchInsertionSimple}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_insertion.zig"
+    [class]{}-[func]{binarySearchInsertionSimple}
+    ```
+
 ## 10.2.2 &nbsp; 存在重复元素的情况
 
 !!! question
@@ -314,25 +314,22 @@ status: new
 
 即便如此，我们仍然可以将判断条件保持展开，因为其逻辑更加清晰、可读性更好。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_search_insertion.java"
-    /* 二分查找插入点（存在重复元素） */
-    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;
-    }
+    ```python title="binary_search_insertion.py"
+    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++"
@@ -356,22 +353,46 @@ status: new
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_search_insertion.py"
-    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
+    ```java title="binary_search_insertion.java"
+    /* 二分查找插入点（存在重复元素） */
+    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"
+    /* 二分查找插入点（存在重复元素） */
+    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"
@@ -400,6 +421,27 @@ status: new
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_search_insertion.swift"
+    /* 二分查找插入点（存在重复元素） */
+    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"
@@ -444,60 +486,6 @@ status: new
     }
     ```
 
-=== "C"
-
-    ```c title="binary_search_insertion.c"
-    [class]{}-[func]{binarySearchInsertion}
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_search_insertion.cs"
-    /* 二分查找插入点（存在重复元素） */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_search_insertion.swift"
-    /* 二分查找插入点（存在重复元素） */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_search_insertion.zig"
-    [class]{}-[func]{binarySearchInsertion}
-    ```
-
 === "Dart"
 
     ```dart title="binary_search_insertion.dart"
@@ -540,6 +528,18 @@ status: new
     }
     ```
 
+=== "C"
+
+    ```c title="binary_search_insertion.c"
+    [class]{}-[func]{binarySearchInsertion}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_insertion.zig"
+    [class]{}-[func]{binarySearchInsertion}
+    ```
+
 !!! tip
 
     本节的代码都是“双闭区间”写法。有兴趣的读者可以自行实现“左闭右开”写法。

chapter_searching/replace_linear_by_hashing.md

@@ -18,21 +18,17 @@ comments: true
 
 <p align="center"> 图 10-9 &nbsp; 线性查找求解两数之和 </p>
 
-=== "Java"
+=== "Python"
 
-    ```java title="two_sum.java"
-    /* 方法一：暴力枚举 */
-    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];
-    }
+    ```python title="two_sum.py"
+    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++"
@@ -52,17 +48,38 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="two_sum.py"
-    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 []
+    ```java title="two_sum.java"
+    /* 方法一：暴力枚举 */
+    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"
+    /* 方法一：暴力枚举 */
+    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"
@@ -83,6 +100,23 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="two_sum.swift"
+    /* 方法一：暴力枚举 */
+    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"
@@ -119,80 +153,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="two_sum.c"
-    /* 方法一：暴力枚举 */
-    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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="two_sum.cs"
-    /* 方法一：暴力枚举 */
-    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>();
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="two_sum.swift"
-    /* 方法一：暴力枚举 */
-    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]
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="two_sum.zig"
-    // 方法一：暴力枚举
-    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;
-    }
-    ```
-
 === "Dart"
 
     ```dart title="two_sum.dart"
@@ -227,6 +187,46 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="two_sum.c"
+    /* 方法一：暴力枚举 */
+    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"
+    // 方法一：暴力枚举
+    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)$ ，在大数据量下非常耗时。
 
 ## 10.4.2 &nbsp; 哈希查找：以空间换时间
@@ -249,23 +249,19 @@ comments: true
 
 实现代码如下所示，仅需单层循环即可。
 
-=== "Java"
+=== "Python"
 
-    ```java title="two_sum.java"
-    /* 方法二：辅助哈希表 */
-    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];
-    }
+    ```python title="two_sum.py"
+    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++"
@@ -287,19 +283,42 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="two_sum.py"
-    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 []
+    ```java title="two_sum.java"
+    /* 方法二：辅助哈希表 */
+    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"
+    /* 方法二：辅助哈希表 */
+    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"
@@ -320,6 +339,24 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="two_sum.swift"
+    /* 方法二：辅助哈希表 */
+    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"
@@ -359,6 +396,43 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title="two_sum.dart"
+    /* 方法二： 辅助哈希表 */
+    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"
+    /* 方法二：辅助哈希表 */
+    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"
@@ -408,43 +482,6 @@ comments: true
     }
     ```
 
-=== "C#"
-
-    ```csharp title="two_sum.cs"
-    /* 方法二：辅助哈希表 */
-    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>();
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="two_sum.swift"
-    /* 方法二：辅助哈希表 */
-    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]
-    }
-    ```
-
 === "Zig"
 
     ```zig title="two_sum.zig"
@@ -466,43 +503,6 @@ comments: true
     }
     ```
 
-=== "Dart"
-
-    ```dart title="two_sum.dart"
-    /* 方法二： 辅助哈希表 */
-    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"
-    /* 方法二：辅助哈希表 */
-    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
-    }
-    ```
-
 此方法通过哈希查找将时间复杂度从 $O(n^2)$ 降低至 $O(n)$ ，大幅提升运行效率。
 
 由于需要维护一个额外的哈希表，因此空间复杂度为 $O(n)$ 。**尽管如此，该方法的整体时空效率更为均衡，因此它是本题的最优解法**。

chapter_sorting/bubble_sort.md

@@ -44,24 +44,19 @@ comments: true
 
 <p align="center"> 图 11-5 &nbsp; 冒泡排序流程 </p>
 
-=== "Java"
+=== "Python"
 
-    ```java title="bubble_sort.java"
-    /* 冒泡排序 */
-    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;
-                }
-            }
-        }
-    }
+    ```python title="bubble_sort.py"
+    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++"
@@ -83,19 +78,44 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="bubble_sort.py"
-    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]
+    ```java title="bubble_sort.java"
+    /* 冒泡排序 */
+    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"
+    /* 冒泡排序 */
+    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"
@@ -116,6 +136,26 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+    /* 冒泡排序 */
+    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"
@@ -156,87 +196,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="bubble_sort.c"
-    /* 冒泡排序 */
-    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;
-                }
-            }
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="bubble_sort.cs"
-    /* 冒泡排序 */
-    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;
-                }
-            }
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="bubble_sort.swift"
-    /* 冒泡排序 */
-    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
-                }
-            }
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="bubble_sort.zig"
-    // 冒泡排序
-    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;
-                }
-            }
-        }
-    }
-    ```
-
 === "Dart"
 
     ```dart title="bubble_sort.dart"
@@ -277,34 +236,70 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="bubble_sort.c"
+    /* 冒泡排序 */
+    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"
+    // 冒泡排序
+    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; 效率优化
 
 我们发现，如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位 `flag` 来监测这种情况，一旦出现就立即返回。
 
 经过优化，冒泡排序的最差和平均时间复杂度仍为 $O(n^2)$ ；但当输入数组完全有序时，可达到最佳时间复杂度 $O(n)$ 。
 
-=== "Java"
+=== "Python"
 
-    ```java title="bubble_sort.java"
-    /* 冒泡排序（标志优化） */
-    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; // 此轮冒泡未交换任何元素，直接跳出
-        }
-    }
+    ```python title="bubble_sort.py"
+    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++"
@@ -330,23 +325,51 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="bubble_sort.py"
-    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  # 此轮冒泡未交换任何元素，直接跳出
+    ```java title="bubble_sort.java"
+    /* 冒泡排序（标志优化） */
+    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"
+    /* 冒泡排序（标志优化）*/
+    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"
@@ -372,6 +395,30 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="bubble_sort.swift"
+    /* 冒泡排序（标志优化）*/
+    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"
@@ -418,101 +465,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="bubble_sort.c"
-    /* 冒泡排序（标志优化）*/
-    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;
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="bubble_sort.cs"
-    /* 冒泡排序（标志优化）*/
-    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;     // 此轮冒泡未交换任何元素，直接跳出
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="bubble_sort.swift"
-    /* 冒泡排序（标志优化）*/
-    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
-            }
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="bubble_sort.zig"
-    // 冒泡排序（标志优化）
-    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;   // 此轮冒泡未交换任何元素，直接跳出
-        }
-    }
-    ```
-
 === "Dart"
 
     ```dart title="bubble_sort.dart"
@@ -559,6 +511,54 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="bubble_sort.c"
+    /* 冒泡排序（标志优化）*/
+    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"
+    // 冒泡排序（标志优化）
+    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; 算法特性
 
 - **时间复杂度为 $O(n^2)$、自适应排序**：各轮“冒泡”遍历的数组长度依次为 $n - 1$、$n - 2$、$\dots$、$2$、$1$ ，总和为 $(n - 1) n / 2$ 。在引入 `flag` 优化后，最佳时间复杂度可达到 $O(n)$ 。

chapter_sorting/bucket_sort.md

@@ -20,6 +20,62 @@ comments: true
 
 <p align="center"> 图 11-13 &nbsp; 桶排序算法流程 </p>
 
+=== "Python"
+
+    ```python title="bucket_sort.py"
+    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"
+    /* 桶排序 */
+    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"
@@ -53,62 +109,39 @@ comments: true
     }
     ```
 
-=== "C++"
+=== "C#"
 
-    ```cpp title="bucket_sort.cpp"
+    ```csharp title="bucket_sort.cs"
     /* 桶排序 */
-    void bucketSort(vector<float> &nums) {
+    void bucketSort(float[] nums) {
         // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
-        int k = nums.size() / 2;
-        vector<vector<float>> buckets(k);
+        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. 将数组元素分配到各个桶中
-        for (float num : nums) {
+        foreach (float num in nums) {
             // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
-            int i = num * k;
-            // 将 num 添加进桶 bucket_idx
-            buckets[i].push_back(num);
+            int i = (int)(num * k);
+            // 将 num 添加进桶 i
+            buckets[i].Add(num);
         }
         // 2. 对各个桶执行排序
-        for (vector<float> &bucket : buckets) {
+        foreach (List<float> bucket in buckets) {
             // 使用内置排序函数，也可以替换成其他排序算法
-            sort(bucket.begin(), bucket.end());
+            bucket.Sort();
         }
         // 3. 遍历桶合并结果
-        int i = 0;
-        for (vector<float> &bucket : buckets) {
-            for (float num : bucket) {
-                nums[i++] = num;
+        int j = 0;
+        foreach (List<float> bucket in buckets) {
+            foreach (float num in bucket) {
+                nums[j++] = num;
             }
         }
     }
     ```
 
-=== "Python"
-
-    ```python title="bucket_sort.py"
-    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
-    ```
-
 === "Go"
 
     ```go title="bucket_sort.go"
@@ -143,6 +176,37 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="bucket_sort.swift"
+    /* 桶排序 */
+    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"
@@ -209,128 +273,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="bucket_sort.c"
-    /* 桶排序 */
-    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);
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="bucket_sort.cs"
-    /* 桶排序 */
-    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;
-            }
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="bucket_sort.swift"
-    /* 桶排序 */
-    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)
-            }
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="bucket_sort.zig"
-    [class]{}-[func]{bucketSort}
-    ```
-
 === "Dart"
 
     ```dart title="bucket_sort.dart"
@@ -392,6 +334,64 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="bucket_sort.c"
+    /* 桶排序 */
+    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"
+
+    ```zig title="bucket_sort.zig"
+    [class]{}-[func]{bucketSort}
+    ```
+
 ## 11.8.2 &nbsp; 算法特性
 
 桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。

chapter_sorting/counting_sort.md

@@ -18,31 +18,27 @@ comments: true
 
 <p align="center"> 图 11-16 &nbsp; 计数排序流程 </p>
 
-=== "Java"
+=== "Python"
 
-    ```java title="counting_sort.java"
-    /* 计数排序 */
-    // 简单实现，无法用于排序对象
-    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;
-            }
-        }
-    }
+    ```python title="counting_sort.py"
+    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++"
@@ -72,27 +68,58 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="counting_sort.py"
-    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
+    ```java title="counting_sort.java"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    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"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    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"
@@ -124,6 +151,31 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="counting_sort.swift"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    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"
@@ -178,93 +230,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="counting_sort.c"
-    /* 计数排序 */
-    // 简单实现，无法用于排序对象
-    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;
-            }
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="counting_sort.cs"
-    /* 计数排序 */
-    // 简单实现，无法用于排序对象
-    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;
-            }
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="counting_sort.swift"
-    /* 计数排序 */
-    // 简单实现，无法用于排序对象
-    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
-            }
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="counting_sort.zig"
-    [class]{}-[func]{countingSortNaive}
-    ```
-
 === "Dart"
 
     ```dart title="counting_sort.dart"
@@ -317,6 +282,41 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="counting_sort.c"
+    /* 计数排序 */
+    // 简单实现，无法用于排序对象
+    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"
+
+    ```zig title="counting_sort.zig"
+    [class]{}-[func]{countingSortNaive}
+    ```
+
 !!! note "计数排序与桶排序的联系"
 
     从桶排序的角度看，我们可以将计数排序中的计数数组 `counter` 的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。
@@ -366,42 +366,34 @@ $$
 
 计数排序的实现代码如下所示。
 
-=== "Java"
+=== "Python"
 
-    ```java title="counting_sort.java"
-    /* 计数排序 */
-    // 完整实现，可排序对象，并且是稳定排序
-    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];
-        }
-    }
+    ```python title="counting_sort.py"
+    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++"
@@ -440,34 +432,80 @@ $$
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="counting_sort.py"
-    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]
+    ```java title="counting_sort.java"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    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"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    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"
@@ -510,6 +548,40 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="counting_sort.swift"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    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"
@@ -586,121 +658,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="counting_sort.c"
-    /* 计数排序 */
-    // 完整实现，可排序对象，并且是稳定排序
-    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));
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="counting_sort.cs"
-    /* 计数排序 */
-    // 完整实现，可排序对象，并且是稳定排序
-    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];
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="counting_sort.swift"
-    /* 计数排序 */
-    // 完整实现，可排序对象，并且是稳定排序
-    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]
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="counting_sort.zig"
-    [class]{}-[func]{countingSort}
-    ```
-
 === "Dart"
 
     ```dart title="counting_sort.dart"
@@ -772,6 +729,49 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="counting_sort.c"
+    /* 计数排序 */
+    // 完整实现，可排序对象，并且是稳定排序
+    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"
+
+    ```zig title="counting_sort.zig"
+    [class]{}-[func]{countingSort}
+    ```
+
 ## 11.9.3 &nbsp; 算法特性
 
 - **时间复杂度 $O(n + m)$** ：涉及遍历 `nums` 和遍历 `counter` ，都使用线性时间。一般情况下 $n \gg m$ ，时间复杂度趋于 $O(n)$ 。

chapter_sorting/heap_sort.md

@@ -68,6 +68,82 @@ comments: true
 
 在代码实现中，我们使用了与堆章节相同的从顶至底堆化 `sift_down()` 函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 `sift_down()` 函数添加一个长度参数 $n$ ，用于指定堆的当前有效长度。
 
+=== "Python"
+
+    ```python title="heap_sort.py"
+    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
+
+    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"
+    /* 堆的长度为 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;
+        }
+    }
+
+    /* 堆排序 */
+    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"
@@ -112,11 +188,11 @@ comments: true
     }
     ```
 
-=== "C++"
+=== "C#"
 
-    ```cpp title="heap_sort.cpp"
+    ```csharp title="heap_sort.cs"
     /* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */
-    void siftDown(vector<int> &nums, int n, int i) {
+    void siftDown(int[] nums, int n, int i) {
         while (true) {
             // 判断节点 i, l, r 中值最大的节点，记为 ma
             int l = 2 * i + 1;
@@ -127,67 +203,31 @@ comments: true
             if (r < n && nums[r] > nums[ma])
                 ma = r;
             // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
-            if (ma == i) {
+            if (ma == i)
                 break;
-            }
             // 交换两节点
-            swap(nums[i], nums[ma]);
+            (nums[ma], nums[i]) = (nums[i], nums[ma]);
             // 循环向下堆化
             i = ma;
         }
     }
 
     /* 堆排序 */
-    void heapSort(vector<int> &nums) {
+    void heapSort(int[] nums) {
         // 建堆操作：堆化除叶节点以外的其他所有节点
-        for (int i = nums.size() / 2 - 1; i >= 0; --i) {
-            siftDown(nums, nums.size(), i);
+        for (int i = nums.Length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.Length, i);
         }
         // 从堆中提取最大元素，循环 n-1 轮
-        for (int i = nums.size() - 1; i > 0; --i) {
+        for (int i = nums.Length - 1; i > 0; i--) {
             // 交换根节点与最右叶节点（即交换首元素与尾元素）
-            swap(nums[0], nums[i]);
+            (nums[i], nums[0]) = (nums[0], nums[i]);
             // 以根节点为起点，从顶至底进行堆化
             siftDown(nums, i, 0);
         }
     }
     ```
 
-=== "Python"
-
-    ```python title="heap_sort.py"
-    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
-
-    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)
-    ```
-
 === "Go"
 
     ```go title="heap_sort.go"
@@ -231,6 +271,50 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="heap_sort.swift"
+    /* 堆的长度为 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
+        }
+    }
+
+    /* 堆排序 */
+    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"
@@ -317,143 +401,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="heap_sort.c"
-    /* 堆的长度为 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;
-        }
-    }
-
-    /* 堆排序 */
-    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);
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="heap_sort.cs"
-    /* 堆的长度为 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;
-        }
-    }
-
-    /* 堆排序 */
-    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);
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="heap_sort.swift"
-    /* 堆的长度为 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
-        }
-    }
-
-    /* 堆排序 */
-    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)
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="heap_sort.zig"
-    [class]{}-[func]{siftDown}
-
-    [class]{}-[func]{heapSort}
-    ```
-
 === "Dart"
 
     ```dart title="heap_sort.dart"
@@ -542,6 +489,59 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="heap_sort.c"
+    /* 堆的长度为 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;
+        }
+    }
+
+    /* 堆排序 */
+    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"
+
+    ```zig title="heap_sort.zig"
+    [class]{}-[func]{siftDown}
+
+    [class]{}-[func]{heapSort}
+    ```
+
 ## 11.7.2 &nbsp; 算法特性
 
 - **时间复杂度 $O(n \log n)$、非自适应排序**：建堆操作使用 $O(n)$ 时间。从堆中提取最大元素的时间复杂度为 $O(\log n)$ ，共循环 $n - 1$ 轮。

chapter_sorting/insertion_sort.md

@@ -27,22 +27,20 @@ comments: true
 
 <p align="center"> 图 11-7 &nbsp; 插入排序流程 </p>
 
-=== "Java"
+=== "Python"
 
-    ```java title="insertion_sort.java"
-    /* 插入排序 */
-    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 赋值到正确位置
-        }
-    }
+    ```python title="insertion_sort.py"
+    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++"
@@ -63,20 +61,40 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="insertion_sort.py"
-    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 赋值到正确位置
+    ```java title="insertion_sort.java"
+    /* 插入排序 */
+    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"
+    /* 插入排序 */
+    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"
@@ -98,6 +116,25 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="insertion_sort.swift"
+    /* 插入排序 */
+    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"
@@ -136,82 +173,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="insertion_sort.c"
-    /* 插入排序 */
-    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;
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="insertion_sort.cs"
-    /* 插入排序 */
-    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 赋值到正确位置
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="insertion_sort.swift"
-    /* 插入排序 */
-    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 赋值到正确位置
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="insertion_sort.zig"
-    // 插入排序
-    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 赋值到正确位置
-        }
-    }
-    ```
-
 === "Dart"
 
     ```dart title="insertion_sort.dart"
@@ -248,6 +209,45 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="insertion_sort.c"
+    /* 插入排序 */
+    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"
+    // 插入排序
+    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; 算法特性
 
 - **时间复杂度 $O(n^2)$、自适应排序**：最差情况下，每次插入操作分别需要循环 $n - 1$、$n-2$、$\dots$、$2$、$1$ 次，求和得到 $(n - 1) n / 2$ ，因此时间复杂度为 $O(n^2)$ 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 $O(n)$ 。

chapter_sorting/merge_sort.md

@@ -59,47 +59,50 @@ comments: true
 - **后序遍历**：先递归左子树，再递归右子树，最后处理根节点。
 - **归并排序**：先递归左子数组，再递归右子数组，最后处理合并。
 
-=== "Java"
+=== "Python"
 
-    ```java title="merge_sort.java"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [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++];
-        }
-    }
+    ```python title="merge_sort.py"
+    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
 
-    /* 归并排序 */
-    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);
-    }
+    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++"
@@ -145,50 +148,89 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="merge_sort.py"
-    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
+    ```java title="merge_sort.java"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [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++];
+        }
+    }
 
-    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)
+    /* 归并排序 */
+    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"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [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++];
+        }
+    }
+
+    /* 归并排序 */
+    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"
@@ -242,6 +284,59 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="merge_sort.swift"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [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
+            }
+        }
+    }
+
+    /* 归并排序 */
+    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"
@@ -334,202 +429,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="merge_sort.c"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [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++];
-        }
-    }
-
-    /* 归并排序 */
-    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"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [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++];
-        }
-    }
-
-    /* 归并排序 */
-    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);
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="merge_sort.swift"
-    /* 合并左子数组和右子数组 */
-    // 左子数组区间 [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
-            }
-        }
-    }
-
-    /* 归并排序 */
-    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)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="merge_sort.zig"
-    // 合并左子数组和右子数组
-    // 左子数组区间 [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;
-            }
-        }
-    }
-
-    // 归并排序
-    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);
-    }
-    ```
-
 === "Dart"
 
     ```dart title="merge_sort.dart"
@@ -620,6 +519,107 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="merge_sort.c"
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [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++];
+        }
+    }
+
+    /* 归并排序 */
+    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"
+    // 合并左子数组和右子数组
+    // 左子数组区间 [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;
+            }
+        }
+    }
+
+    // 归并排序
+    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()` 存在以下难点。
 
 - **需要特别注意各个变量的含义**。`nums` 的待合并区间为 `[left, right]` ，但由于 `tmp` 仅复制了 `nums` 该区间的元素，因此 `tmp` 对应区间为 `[0, right - left]` 。

chapter_sorting/radix_sort.md

@@ -30,6 +30,102 @@ $$
 
 此外，我们需要小幅改动计数排序代码，使之可以根据数字的第 $k$ 位进行排序。
 
+=== "Python"
+
+    ```python title="radix_sort.py"
+    def digit(num: int, exp: int) -> int:
+        """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
+        # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num // exp) % 10
+
+    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]
+
+    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"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 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];
+    }
+
+    /* 基数排序 */
+    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"
@@ -83,9 +179,9 @@ $$
     }
     ```
 
-=== "C++"
+=== "C#"
 
-    ```cpp title="radix_sort.cpp"
+    ```csharp title="radix_sort.cs"
     /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
     int digit(int num, int exp) {
         // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
@@ -93,10 +189,10 @@ $$
     }
 
     /* 计数排序（根据 nums 第 k 位排序） */
-    void countingSortDigit(vector<int> &nums, int exp) {
+    void countingSortDigit(int[] nums, int exp) {
         // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
-        vector<int> counter(10, 0);
-        int n = nums.size();
+        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
@@ -107,7 +203,7 @@ $$
             counter[i] += counter[i - 1];
         }
         // 倒序遍历，根据桶内统计结果，将各元素填入 res
-        vector<int> res(n, 0);
+        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
@@ -115,70 +211,29 @@ $$
             counter[d]--;           // 将 d 的数量减 1
         }
         // 使用结果覆盖原数组 nums
-        for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++) {
             nums[i] = res[i];
+        }
     }
 
     /* 基数排序 */
-    void radixSort(vector<int> &nums) {
+    void radixSort(int[] nums) {
         // 获取数组的最大元素，用于判断最大位数
-        int m = *max_element(nums.begin(), nums.end());
+        int m = int.MinValue;
+        foreach (int num in nums) {
+            if (num > m) m = num;
+        }
         // 按照从低位到高位的顺序遍历
-        for (int exp = 1; exp <= m; exp *= 10)
+        for (int exp = 1; exp <= m; exp *= 10) {
             // 对数组元素的第 k 位执行计数排序
             // k = 1 -> exp = 1
             // k = 2 -> exp = 10
             // 即 exp = 10^(k-1)
             countingSortDigit(nums, exp);
+        }
     }
     ```
 
-=== "Python"
-
-    ```python title="radix_sort.py"
-    def digit(num: int, exp: int) -> int:
-        """获取元素 num 的第 k 位，其中 exp = 10^(k-1)"""
-        # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
-        return (num // exp) % 10
-
-    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]
-
-    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
-    ```
-
 === "Go"
 
     ```go title="radix_sort.go"
@@ -236,6 +291,63 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="radix_sort.swift"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    func digit(num: Int, exp: Int) -> Int {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        (num / exp) % 10
+    }
+
+    /* 计数排序（根据 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]
+        }
+    }
+
+    /* 基数排序 */
+    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"
@@ -350,239 +462,6 @@ $$
     }
     ```
 
-=== "C"
-
-    ```c title="radix_sort.c"
-    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
-    int digit(int num, int exp) {
-        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
-        return (num / exp) % 10;
-    }
-
-    /* 计数排序（根据 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];
-        }
-    }
-
-    /* 基数排序 */
-    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);
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="radix_sort.cs"
-    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
-    int digit(int num, int exp) {
-        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
-        return (num / exp) % 10;
-    }
-
-    /* 计数排序（根据 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];
-        }
-    }
-
-    /* 基数排序 */
-    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);
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="radix_sort.swift"
-    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
-    func digit(num: Int, exp: Int) -> Int {
-        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
-        (num / exp) % 10
-    }
-
-    /* 计数排序（根据 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]
-        }
-    }
-
-    /* 基数排序 */
-    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)
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="radix_sort.zig"
-    // 获取元素 num 的第 k 位，其中 exp = 10^(k-1)
-    fn digit(num: i32, exp: i32) i32 {
-        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
-        return @mod(@divFloor(num, exp), 10);
-    }
-
-    // 计数排序（根据 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];
-        }
-    }
-
-    // 基数排序
-    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);    
-        }
-    } 
-    ```
-
 === "Dart"
 
     ```dart title="radix_sort.dart"
@@ -684,6 +563,127 @@ $$
     }
     ```
 
+=== "C"
+
+    ```c title="radix_sort.c"
+    /* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+    int digit(int num, int exp) {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return (num / exp) % 10;
+    }
+
+    /* 计数排序（根据 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];
+        }
+    }
+
+    /* 基数排序 */
+    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"
+    // 获取元素 num 的第 k 位，其中 exp = 10^(k-1)
+    fn digit(num: i32, exp: i32) i32 {
+        // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+        return @mod(@divFloor(num, exp), 10);
+    }
+
+    // 计数排序（根据 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];
+        }
+    }
+
+    // 基数排序
+    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 "为什么从最低位开始排序？"
 
     在连续的排序轮次中，后一轮排序会覆盖前一轮排序的结果。举例来说，如果第一轮排序结果 $a < b$ ，而第二轮排序结果 $a > b$ ，那么第二轮的结果将取代第一轮的结果。由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。

chapter_sorting/selection_sort.md

@@ -51,26 +51,21 @@ comments: true
 
 在代码中，我们用 $k$ 来记录未排序区间内的最小元素。
 
-=== "Java"
+=== "Python"
 
-    ```java title="selection_sort.java"
-    /* 选择排序 */
-    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;
-        }
-    }
+    ```python title="selection_sort.py"
+    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++"
@@ -93,21 +88,46 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="selection_sort.py"
-    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]
+    ```java title="selection_sort.java"
+    /* 选择排序 */
+    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"
+    /* 选择排序 */
+    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"
@@ -133,6 +153,26 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="selection_sort.swift"
+    /* 选择排序 */
+    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"
@@ -175,73 +215,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="selection_sort.c"
-    /* 选择排序 */
-    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;
-        }
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="selection_sort.cs"
-    /* 选择排序 */
-    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]);
-        }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="selection_sort.swift"
-    /* 选择排序 */
-    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)
-        }
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="selection_sort.zig"
-    [class]{}-[func]{selectionSort}
-    ```
-
 === "Dart"
 
     ```dart title="selection_sort.dart"
@@ -284,6 +257,33 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="selection_sort.c"
+    /* 选择排序 */
+    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"
+
+    ```zig title="selection_sort.zig"
+    [class]{}-[func]{selectionSort}
+    ```
+
 ## 11.2.1 &nbsp; 算法特性
 
 - **时间复杂度为 $O(n^2)$、非自适应排序**：外循环共 $n - 1$ 轮，第一轮的未排序区间长度为 $n$ ，最后一轮的未排序区间长度为 $2$ ，即各轮外循环分别包含 $n$、$n - 1$、$\dots$、$3$、$2$ 轮内循环，求和为 $\frac{(n - 1)(n + 2)}{2}$ 。

chapter_tree/binary_tree.md

@@ -6,16 +6,15 @@ comments: true
 
 「二叉树 binary tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用。
 
-=== "Java"
+=== "Python"
 
-    ```java title=""
-    /* 二叉树节点类 */
-    class TreeNode {
-        int val;         // 节点值
-        TreeNode left;   // 左子节点引用
-        TreeNode right;  // 右子节点引用
-        TreeNode(int x) { val = x; }
-    }
+    ```python title=""
+    class TreeNode:
+        """二叉树节点类"""
+        def __init__(self, val: int):
+            self.val: int = val                   # 节点值
+            self.left: Optional[TreeNode] = None  # 左子节点引用
+            self.right: Optional[TreeNode] = None # 右子节点引用
     ```
 
 === "C++"
@@ -30,15 +29,28 @@ comments: true
     };
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title=""
-    class TreeNode:
-        """二叉树节点类"""
-        def __init__(self, val: int):
-            self.val: int = val                   # 节点值
-            self.left: Optional[TreeNode] = None  # 左子节点引用
-            self.right: Optional[TreeNode] = None # 右子节点引用
+    ```java title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        int val;         // 节点值
+        TreeNode left;   // 左子节点引用
+        TreeNode right;  // 右子节点引用
+        TreeNode(int x) { val = x; }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        int val;          // 节点值
+        TreeNode? left;   // 左子节点引用
+        TreeNode? right;  // 右子节点引用
+        TreeNode(int x) { val = x; }
+    }
     ```
 
 === "Go"
@@ -60,6 +72,21 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+        var val: Int // 节点值
+        var left: TreeNode? // 左子节点引用
+        var right: TreeNode? // 右子节点引用
+
+        init(x: Int) {
+            val = x
+        }
+    }
+    ```
+
 === "JS"
 
     ```javascript title=""
@@ -88,6 +115,24 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title=""
+    /* 二叉树节点类 */
+    class TreeNode {
+      int val;         // 节点值
+      TreeNode? left;  // 左子节点引用
+      TreeNode? right; // 右子节点引用
+      TreeNode(this.val, [this.left, this.right]);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 === "C"
 
     ```c title=""
@@ -114,57 +159,12 @@ comments: true
     }
     ```
 
-=== "C#"
-
-    ```csharp title=""
-    /* 二叉树节点类 */
-    class TreeNode {
-        int val;          // 节点值
-        TreeNode? left;   // 左子节点引用
-        TreeNode? right;  // 右子节点引用
-        TreeNode(int x) { val = x; }
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title=""
-    /* 二叉树节点类 */
-    class TreeNode {
-        var val: Int // 节点值
-        var left: TreeNode? // 左子节点引用
-        var right: TreeNode? // 右子节点引用
-
-        init(x: Int) {
-            val = x
-        }
-    }
-    ```
-
 === "Zig"
 
     ```zig title=""
 
     ```
 
-=== "Dart"
-
-    ```dart title=""
-    /* 二叉树节点类 */
-    class TreeNode {
-      int val;         // 节点值
-      TreeNode? left;  // 左子节点引用
-      TreeNode? right; // 右子节点引用
-      TreeNode(this.val, [this.left, this.right]);
-    }
-    ```
-
-=== "Rust"
-
-    ```rust title=""
-
-    ```
-
 每个节点都有两个引用（指针），分别指向「左子节点 left-child node」和「右子节点 right-child node」，该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。
 
 **在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树**。如图 7-1 所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。
@@ -200,20 +200,21 @@ comments: true
 
 与链表类似，首先初始化节点，然后构建引用（指针）。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_tree.java"
-    // 初始化节点
-    TreeNode n1 = new TreeNode(1);
-    TreeNode n2 = new TreeNode(2);
-    TreeNode n3 = new TreeNode(3);
-    TreeNode n4 = new TreeNode(4);
-    TreeNode n5 = new TreeNode(5);
-    // 构建引用指向（即指针）
-    n1.left = n2;
-    n1.right = n3;
-    n2.left = n4;
-    n2.right = n5;
+    ```python title="binary_tree.py"
+    # 初始化二叉树
+    # 初始化节点
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
     ```
 
 === "C++"
@@ -233,21 +234,37 @@ comments: true
     n2->right = n5;
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_tree.py"
-    # 初始化二叉树
-    # 初始化节点
-    n1 = TreeNode(val=1)
-    n2 = TreeNode(val=2)
-    n3 = TreeNode(val=3)
-    n4 = TreeNode(val=4)
-    n5 = TreeNode(val=5)
-    # 构建引用指向（即指针）
-    n1.left = n2
-    n1.right = n3
-    n2.left = n4
-    n2.right = n5
+    ```java title="binary_tree.java"
+    // 初始化节点
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // 构建引用指向（即指针）
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
     ```
 
 === "Go"
@@ -267,6 +284,22 @@ comments: true
     n2.Right = n5
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    // 初始化节点
+    let n1 = TreeNode(x: 1)
+    let n2 = TreeNode(x: 2)
+    let n3 = TreeNode(x: 3)
+    let n4 = TreeNode(x: 4)
+    let n5 = TreeNode(x: 5)
+    // 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
 === "JS"
 
     ```javascript title="binary_tree.js"
@@ -301,62 +334,6 @@ comments: true
     n2.right = n5;
     ```
 
-=== "C"
-
-    ```c title="binary_tree.c"
-    /* 初始化二叉树 */
-    // 初始化节点
-    TreeNode *n1 = newTreeNode(1);
-    TreeNode *n2 = newTreeNode(2);
-    TreeNode *n3 = newTreeNode(3);
-    TreeNode *n4 = newTreeNode(4);
-    TreeNode *n5 = newTreeNode(5);
-    // 构建引用指向（即指针）
-    n1->left = n2;
-    n1->right = n3;
-    n2->left = n4;
-    n2->right = n5;
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_tree.cs"
-    /* 初始化二叉树 */
-    // 初始化节点
-    TreeNode n1 = new TreeNode(1);
-    TreeNode n2 = new TreeNode(2);
-    TreeNode n3 = new TreeNode(3);
-    TreeNode n4 = new TreeNode(4);
-    TreeNode n5 = new TreeNode(5);
-    // 构建引用指向（即指针）
-    n1.left = n2;
-    n1.right = n3;
-    n2.left = n4;
-    n2.right = n5;
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_tree.swift"
-    // 初始化节点
-    let n1 = TreeNode(x: 1)
-    let n2 = TreeNode(x: 2)
-    let n3 = TreeNode(x: 3)
-    let n4 = TreeNode(x: 4)
-    let n5 = TreeNode(x: 5)
-    // 构建引用指向（即指针）
-    n1.left = n2
-    n1.right = n3
-    n2.left = n4
-    n2.right = n5
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_tree.zig"
-
-    ```
-
 === "Dart"
 
     ```dart title="binary_tree.dart"
@@ -380,6 +357,29 @@ comments: true
 
     ```
 
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* 初始化二叉树 */
+    // 初始化节点
+    TreeNode *n1 = newTreeNode(1);
+    TreeNode *n2 = newTreeNode(2);
+    TreeNode *n3 = newTreeNode(3);
+    TreeNode *n4 = newTreeNode(4);
+    TreeNode *n5 = newTreeNode(5);
+    // 构建引用指向（即指针）
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
 ### 2.   插入与删除节点
 
 与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。图 7-3 给出了一个示例。
@@ -388,15 +388,16 @@ comments: true
 
 <p align="center"> 图 7-3 &nbsp; 在二叉树中插入与删除节点 </p>
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_tree.java"
-    TreeNode P = new TreeNode(0);
-    // 在 n1 -> n2 中间插入节点 P
-    n1.left = P;
-    P.left = n2;
-    // 删除节点 P
-    n1.left = n2;
+    ```python title="binary_tree.py"
+    # 插入与删除节点
+    p = TreeNode(0)
+    # 在 n1 -> n2 中间插入节点 P
+    n1.left = p
+    p.left = n2
+    # 删除节点 P
+    n1.left = n2
     ```
 
 === "C++"
@@ -411,16 +412,27 @@ comments: true
     n1->left = n2;
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_tree.py"
-    # 插入与删除节点
-    p = TreeNode(0)
-    # 在 n1 -> n2 中间插入节点 P
-    n1.left = p
-    p.left = n2
-    # 删除节点 P
-    n1.left = n2
+    ```java title="binary_tree.java"
+    TreeNode P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* 插入与删除节点 */
+    TreeNode P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除节点 P
+    n1.left = n2;
     ```
 
 === "Go"
@@ -435,6 +447,17 @@ comments: true
     n1.Left = n2
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    let P = TreeNode(x: 0)
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P
+    P.left = n2
+    // 删除节点 P
+    n1.left = n2
+    ```
+
 === "JS"
 
     ```javascript title="binary_tree.js"
@@ -459,47 +482,6 @@ comments: true
     n1.left = n2;
     ```
 
-=== "C"
-
-    ```c title="binary_tree.c"
-    /* 插入与删除节点 */
-    TreeNode *P = newTreeNode(0);
-    // 在 n1 -> n2 中间插入节点 P
-    n1->left = P;
-    P->left = n2;
-    // 删除节点 P
-    n1->left = n2;
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_tree.cs"
-    /* 插入与删除节点 */
-    TreeNode P = new TreeNode(0);
-    // 在 n1 -> n2 中间插入节点 P
-    n1.left = P;
-    P.left = n2;
-    // 删除节点 P
-    n1.left = n2;
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_tree.swift"
-    let P = TreeNode(x: 0)
-    // 在 n1 -> n2 中间插入节点 P
-    n1.left = P
-    P.left = n2
-    // 删除节点 P
-    n1.left = n2
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_tree.zig"
-
-    ```
-
 === "Dart"
 
     ```dart title="binary_tree.dart"
@@ -518,6 +500,24 @@ comments: true
 
     ```
 
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* 插入与删除节点 */
+    TreeNode *P = newTreeNode(0);
+    // 在 n1 -> n2 中间插入节点 P
+    n1->left = P;
+    P->left = n2;
+    // 删除节点 P
+    n1->left = n2;
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
 !!! note
 
     需要注意的是，插入节点可能会改变二叉树的原有逻辑结构，而删除节点通常意味着删除该节点及其所有子树。因此，在二叉树中，插入与删除操作通常是由一套操作配合完成的，以实现有实际意义的操作。

chapter_tree/binary_tree_traversal.md

@@ -22,26 +22,24 @@ comments: true
 
 广度优先遍历通常借助“队列”来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”的规则，两者背后的思想是一致的。
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_tree_bfs.java"
-    /* 层序遍历 */
-    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;
-    }
+    ```python title="binary_tree_bfs.py"
+    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++"
@@ -67,24 +65,48 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_tree_bfs.py"
-    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
+    ```java title="binary_tree_bfs.java"
+    /* 层序遍历 */
+    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"
+    /* 层序遍历 */
+    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"
@@ -115,6 +137,29 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree_bfs.swift"
+    /* 层序遍历 */
+    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"
@@ -157,129 +202,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="binary_tree_bfs.c"
-    /* 层序遍历 */
-    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;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_tree_bfs.cs"
-    /* 层序遍历 */
-    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;
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_tree_bfs.swift"
-    /* 层序遍历 */
-    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
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_tree_bfs.zig"
-    // 层序遍历
-    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;
-    }
-    ```
-
 === "Dart"
 
     ```dart title="binary_tree_bfs.dart"
@@ -324,6 +246,84 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="binary_tree_bfs.c"
+    /* 层序遍历 */
+    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"
+    // 层序遍历
+    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; 复杂度分析
 
 - **时间复杂度 $O(n)$** ：所有节点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为节点数量。
@@ -343,38 +343,35 @@ comments: true
 
 深度优先搜索通常基于递归实现：
 
-=== "Java"
+=== "Python"
 
-    ```java title="binary_tree_dfs.java"
-    /* 前序遍历 */
-    void preOrder(TreeNode root) {
-        if (root == null)
-            return;
-        // 访问优先级：根节点 -> 左子树 -> 右子树
-        list.add(root.val);
-        preOrder(root.left);
-        preOrder(root.right);
-    }
+    ```python title="binary_tree_dfs.py"
+    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)
 
-    /* 中序遍历 */
-    void inOrder(TreeNode root) {
-        if (root == null)
-            return;
-        // 访问优先级：左子树 -> 根节点 -> 右子树
-        inOrder(root.left);
-        list.add(root.val);
-        inOrder(root.right);
-    }
+    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)
 
-    /* 后序遍历 */
-    void postOrder(TreeNode root) {
-        if (root == null)
-            return;
-        // 访问优先级：左子树 -> 右子树 -> 根节点
-        postOrder(root.left);
-        postOrder(root.right);
-        list.add(root.val);
-    }
+    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++"
@@ -411,35 +408,69 @@ comments: true
     }
     ```
 
-=== "Python"
+=== "Java"
 
-    ```python title="binary_tree_dfs.py"
-    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)
+    ```java title="binary_tree_dfs.java"
+    /* 前序遍历 */
+    void preOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
 
-    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)
+    /* 中序遍历 */
+    void inOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.add(root.val);
+        inOrder(root.right);
+    }
 
-    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)
+    /* 后序遍历 */
+    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"
+    /* 前序遍历 */
+    void preOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.Add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root.left);
+        list.Add(root.val);
+        inOrder(root.right);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode? root) {
+        if (root == null) return;
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        postOrder(root.left);
+        postOrder(root.right);
+        list.Add(root.val);
+    }
     ```
 
 === "Go"
@@ -479,6 +510,43 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title="binary_tree_dfs.swift"
+    /* 前序遍历 */
+    func preOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        list.append(root.val)
+        preOrder(root: root.left)
+        preOrder(root: root.right)
+    }
+
+    /* 中序遍历 */
+    func inOrder(root: TreeNode?) {
+        guard let root = root else {
+            return
+        }
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root: root.left)
+        list.append(root.val)
+        inOrder(root: root.right)
+    }
+
+    /* 后序遍历 */
+    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"
@@ -547,139 +615,6 @@ comments: true
     }
     ```
 
-=== "C"
-
-    ```c title="binary_tree_dfs.c"
-    /* 前序遍历 */
-    void preOrder(TreeNode *root, int *size) {
-        if (root == NULL)
-            return;
-        // 访问优先级：根节点 -> 左子树 -> 右子树
-        arr[(*size)++] = root->val;
-        preOrder(root->left, size);
-        preOrder(root->right, size);
-    }
-
-    /* 中序遍历 */
-    void inOrder(TreeNode *root, int *size) {
-        if (root == NULL)
-            return;
-        // 访问优先级：左子树 -> 根节点 -> 右子树
-        inOrder(root->left, size);
-        arr[(*size)++] = root->val;
-        inOrder(root->right, size);
-    }
-
-    /* 后序遍历 */
-    void postOrder(TreeNode *root, int *size) {
-        if (root == NULL)
-            return;
-        // 访问优先级：左子树 -> 右子树 -> 根节点
-        postOrder(root->left, size);
-        postOrder(root->right, size);
-        arr[(*size)++] = root->val;
-    }
-    ```
-
-=== "C#"
-
-    ```csharp title="binary_tree_dfs.cs"
-    /* 前序遍历 */
-    void preOrder(TreeNode? root) {
-        if (root == null) return;
-        // 访问优先级：根节点 -> 左子树 -> 右子树
-        list.Add(root.val);
-        preOrder(root.left);
-        preOrder(root.right);
-    }
-
-    /* 中序遍历 */
-    void inOrder(TreeNode? root) {
-        if (root == null) return;
-        // 访问优先级：左子树 -> 根节点 -> 右子树
-        inOrder(root.left);
-        list.Add(root.val);
-        inOrder(root.right);
-    }
-
-    /* 后序遍历 */
-    void postOrder(TreeNode? root) {
-        if (root == null) return;
-        // 访问优先级：左子树 -> 右子树 -> 根节点
-        postOrder(root.left);
-        postOrder(root.right);
-        list.Add(root.val);
-    }
-    ```
-
-=== "Swift"
-
-    ```swift title="binary_tree_dfs.swift"
-    /* 前序遍历 */
-    func preOrder(root: TreeNode?) {
-        guard let root = root else {
-            return
-        }
-        // 访问优先级：根节点 -> 左子树 -> 右子树
-        list.append(root.val)
-        preOrder(root: root.left)
-        preOrder(root: root.right)
-    }
-
-    /* 中序遍历 */
-    func inOrder(root: TreeNode?) {
-        guard let root = root else {
-            return
-        }
-        // 访问优先级：左子树 -> 根节点 -> 右子树
-        inOrder(root: root.left)
-        list.append(root.val)
-        inOrder(root: root.right)
-    }
-
-    /* 后序遍历 */
-    func postOrder(root: TreeNode?) {
-        guard let root = root else {
-            return
-        }
-        // 访问优先级：左子树 -> 右子树 -> 根节点
-        postOrder(root: root.left)
-        postOrder(root: root.right)
-        list.append(root.val)
-    }
-    ```
-
-=== "Zig"
-
-    ```zig title="binary_tree_dfs.zig"
-    // 前序遍历
-    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);
-    }
-
-    // 中序遍历
-    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);
-    }
-
-    // 后序遍历
-    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);
-    }
-    ```
-
 === "Dart"
 
     ```dart title="binary_tree_dfs.dart"
@@ -754,6 +689,71 @@ comments: true
     }
     ```
 
+=== "C"
+
+    ```c title="binary_tree_dfs.c"
+    /* 前序遍历 */
+    void preOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        arr[(*size)++] = root->val;
+        preOrder(root->left, size);
+        preOrder(root->right, size);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode *root, int *size) {
+        if (root == NULL)
+            return;
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        inOrder(root->left, size);
+        arr[(*size)++] = root->val;
+        inOrder(root->right, size);
+    }
+
+    /* 后序遍历 */
+    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"
+    // 前序遍历
+    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);
+    }
+
+    // 中序遍历
+    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);
+    }
+
+    // 后序遍历
+    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
 
     深度优先搜索也可以基于迭代实现，有兴趣的同学可以自行研究。