build

chapter_backtracking/subset_sum_problem.md

@@ -1239,10 +1239,10 @@ comments: true
 
     /* 求解子集和 II */
     vector *subsetSumII(vector *nums, int target) {
-        vector *state = newVector();                         // 状态（子集）
+        vector *state = newVector();                        // 状态（子集）
         qsort(nums->data, nums->size, sizeof(int *), comp); // 对 nums 进行排序
-        int start = 0;                                       // 子集和
-        vector *res = newVector();                           // 结果列表（子集列表）
+        int start = 0;                                      // 子集和
+        vector *res = newVector();                          // 结果列表（子集列表）
         backtrack(state, target, nums, start, res);
         return res;
     }

chapter_divide_and_conquer/binary_search_recur.md

@@ -273,9 +273,32 @@ status: new
 === "Swift"
 
     ```swift title="binary_search_recur.swift"
-    [class]{}-[func]{dfs}
+    /* 二分查找：问题 f(i, j) */
+    func dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if i > j {
+            return -1
+        }
+        // 计算中点索引 m
+        let m = (i + j) / 2
+        if nums[m] < target {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums: nums, target: target, i: m + 1, j: j)
+        } else if nums[m] > target {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums: nums, target: target, i: i, j: m - 1)
+        } else {
+            // 找到目标元素，返回其索引
+            return m
+        }
+    }
 
-    [class]{}-[func]{binarySearch}
+    /* 二分查找 */
+    func binarySearch(nums: [Int], target: Int) -> Int {
+        let n = nums.count
+        // 求解问题 f(0, n-1)
+        return dfs(nums: nums, target: target, i: 0, j: n - 1)
+    }
     ```
 
 === "Zig"

chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -316,9 +316,30 @@ status: new
 === "Swift"
 
     ```swift title="build_tree.swift"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    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
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    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"

chapter_divide_and_conquer/hanota_problem.md

@@ -159,7 +159,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    void hanota(vector<int> &A, vector<int> &B, vector<int> &C) {
+    void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
         int n = A.size();
         // 将 A 顶部 n 个圆盘借助 B 移到 C
         dfs(n, A, B, C);
@@ -189,7 +189,7 @@ status: new
         # 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
         dfs(i - 1, buf, src, tar)
 
-    def hanota(A: list[int], B: list[int], C: list[int]):
+    def solve_hanota(A: list[int], B: list[int], C: list[int]):
         """求解汉诺塔"""
         n = len(A)
         # 将 A 顶部 n 个圆盘借助 B 移到 C
@@ -225,7 +225,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    func hanota(A, B, C *list.List) {
+    func solveHanota(A, B, C *list.List) {
         n := A.Len()
         // 将 A 顶部 n 个圆盘借助 B 移到 C
         dfsHanota(n, A, B, C)
@@ -259,7 +259,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    function hanota(A, B, C) {
+    function solveHanota(A, B, C) {
         const n = A.length;
         // 将 A 顶部 n 个圆盘借助 B 移到 C
         dfs(n, A, B, C);
@@ -293,7 +293,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    function hanota(A: number[], B: number[], C: number[]): void {
+    function solveHanota(A: number[], B: number[], C: number[]): void {
         const n = A.length;
         // 将 A 顶部 n 个圆盘借助 B 移到 C
         dfs(n, A, B, C);
@@ -307,7 +307,7 @@ status: new
 
     [class]{}-[func]{dfs}
 
-    [class]{}-[func]{hanota}
+    [class]{}-[func]{solveHanota}
     ```
 
 === "C#"
@@ -348,11 +348,36 @@ status: new
 === "Swift"
 
     ```swift title="hanota.swift"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    func move(src: inout [Int], tar: inout [Int]) {
+        // 从 src 顶部拿出一个圆盘
+        let pan = src.popLast()!
+        // 将圆盘放入 tar 顶部
+        tar.append(pan)
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    func dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src: &src, tar: &tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src: &src, tar: &tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)
+    }
 
-    [class]{}-[func]{hanota}
+    /* 求解汉诺塔 */
+    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"
@@ -362,7 +387,7 @@ status: new
 
     [class]{}-[func]{dfs}
 
-    [class]{}-[func]{hanota}
+    [class]{}-[func]{solveHanota}
     ```
 
 === "Dart"
@@ -392,7 +417,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    void hanota(List<int> A, List<int> B, List<int> C) {
+    void solveHanota(List<int> A, List<int> B, List<int> C) {
       int n = A.length;
       // 将 A 顶部 n 个圆盘借助 B 移到 C
       dfs(n, A, B, C);
@@ -426,7 +451,7 @@ status: new
     }
 
     /* 求解汉诺塔 */
-    fn hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {
+    fn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {
         let n = A.len() as i32;
         // 将 A 顶部 n 个圆盘借助 B 移到 C
         dfs(n, A, B, C);

chapter_dynamic_programming/dp_solution_pipeline.md

@@ -250,7 +250,7 @@ $$
     /* 最小路径和：暴力搜索 */
     int minPathSumDFS(int[][] grid, int i, int j) {
         // 若为左上角单元格，则终止搜索
-        if (i == 0 && j == 0){
+        if (i == 0 && j == 0) {
             return grid[0][0];
         }
         // 若行列索引越界，则返回 +∞ 代价

chapter_graph/graph_operations.md

@@ -618,8 +618,6 @@ comments: true
         // 如果实际使用不大于预设空间，则直接初始化新空间
         if (t->size < t->capacity) {
             t->vertices[t->size] = val; // 初始化新顶点值
-
-            
             for (int i = 0; i < t->size; i++) {
                 t->adjMat[i][t->size] = 0; // 邻接矩新列阵置0
             }
@@ -659,7 +657,7 @@ comments: true
         free(t->adjMat);
 
         // 扩容后，指向新地址
-        t->adjMat = tempMat;  // 指向新的邻接矩阵地址
+        t->adjMat = tempMat; // 指向新的邻接矩阵地址
         t->capacity = t->size * 2;
         t->size++;
     }
@@ -725,12 +723,12 @@ comments: true
     /* 构造函数 */
     graphAdjMat *newGraphAjdMat(unsigned int numberVertices, int *vertices, unsigned int **adjMat) {
         // 申请内存
-        graphAdjMat *newGraph = (graphAdjMat *)malloc(sizeof(graphAdjMat));                                          // 为图分配内存
-        newGraph->vertices = (int *)malloc(sizeof(int) * numberVertices * 2);                                        // 为顶点列表分配内存
-        newGraph->adjMat = (unsigned int **)malloc(sizeof(unsigned int *) * numberVertices * 2);                     // 为邻接矩阵分配二维内存
+        graphAdjMat *newGraph = (graphAdjMat *)malloc(sizeof(graphAdjMat));   // 为图分配内存
+        newGraph->vertices = (int *)malloc(sizeof(int) * numberVertices * 2); // 为顶点列表分配内存
+        newGraph->adjMat = (unsigned int **)malloc(sizeof(unsigned int *) * numberVertices * 2); // 为邻接矩阵分配二维内存
         unsigned int *temp = (unsigned int *)malloc(sizeof(unsigned int) * numberVertices * 2 * numberVertices * 2); // 为邻接矩阵分配一维内存
-        newGraph->size = numberVertices;                                                                             // 初始化顶点数量
-        newGraph->capacity = numberVertices * 2;                                                                     // 初始化图容量
+        newGraph->size = numberVertices;                // 初始化顶点数量
+        newGraph->capacity = numberVertices * 2;        // 初始化图容量
 
         // 配置二维数组
         for (int i = 0; i < numberVertices * 2; i++) {
@@ -1741,7 +1739,7 @@ comments: true
         t->verticesList[t->size - 1] = 0; // 将被删除顶点的位置置 0
         t->size--;
 
-        //释放被删除顶点的内存
+        // 释放内存
         freeVertex(vet);
     }
 

chapter_hashing/hash_algorithm.md

@@ -123,7 +123,7 @@ index = hash(key) % capacity
         int hash = 0;
         const int MODULUS = 1000000007;
         for (unsigned char c : key) {
-            cout<<(int)c<<endl;
+            cout << (int)c << endl;
             hash ^= (int)c;
         }
         return hash & MODULUS;
@@ -647,13 +647,13 @@ $$
 === "JS"
 
     ```javascript title="built_in_hash.js"
-
+    // JavaScript 未提供内置 hash code 函数
     ```
 
 === "TS"
 
     ```typescript title="built_in_hash.ts"
-
+    // TypeScript 未提供内置 hash code 函数
     ```
 
 === "C"

chapter_sorting/bucket_sort.md

@@ -275,7 +275,7 @@ comments: true
         // 1. 将数组元素分配到各个桶中
         foreach (float num in nums) {
             // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
-            int i = (int) (num * k);
+            int i = (int)(num * k);
             // 将 num 添加进桶 i
             buckets[i].Add(num);
         }

chapter_sorting/selection_sort.md

@@ -186,7 +186,7 @@ comments: true
             int k = i;
             for (int j = i + 1; j < n; j++) {
                 if (nums[j] < nums[k])
-                    k = j;  // 记录最小元素的索引
+                    k = j; // 记录最小元素的索引
             }
             // 将该最小元素与未排序区间的首个元素交换
             int temp = nums[i];