build

chapter_divide_and_conquer/binary_search_recur.md

@@ -0,0 +1,189 @@
+---
+comments: true
+---
+
+# 12.2.   分治搜索策略
+
+我们已经学过，搜索算法分为两大类：暴力搜索、自适应搜索。暴力搜索的时间复杂度为 $O(n)$ 。自适应搜索利用特有的数据组织形式或先验信息，可达到 $O(\log n)$ 甚至 $O(1)$ 的时间复杂度。
+
+实际上，**$O(\log n)$ 的搜索算法通常都是基于分治策略实现的**，例如：
+
+- 二分查找的每一步都将问题（在数组中搜索目标元素）分解为一个小问题（在数组的一半中搜索目标元素），这个过程一直持续到数组为空或找到目标元素为止。
+- 树是分治关系的代表，在二叉搜索树、AVL 树、堆等数据结构中，各种操作的时间复杂度皆为 $O(\log n)$ 。
+
+分治之所以能够提升搜索效率，是因为暴力搜索每轮只能排除一个选项，**而基于分治的搜索每轮可以排除一半选项**。
+
+## 12.2.1.   基于分治实现二分
+
+接下来，我们尝试从分治策略的角度分析二分查找的性质：
+
+- **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
+- **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
+- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
+
+在之前章节中，我们基于递推（迭代）实现二分查找。现在，我们尝试基于递归分治来实现它。
+
+问题定义为：**在数组 `nums` 的区间 $[i, j]$ 内查找元素 `target`** ，记为 $f(i, j)$ 。
+
+设数组长度为 $n$ ，则二分查找的流程为：从原问题 $f(0, n-1)$ 开始，每轮排除一半索引区间，递归求解规模减小一半的子问题，直至找到 `target` 或区间为空时返回。
+
+下图展示了在数组中二分查找目标元素 $6$ 的分治过程。
+
+![二分查找的分治过程](binary_search_recur.assets/binary_search_recur.png)
+
+<p align="center"> Fig. 二分查找的分治过程 </p>
+
+如下代码所示，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
+
+=== "Java"
+
+    ```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;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(int[] nums, int target) {
+        int n = nums.length;
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_search_recur.cpp"
+    /* 二分查找：问题 f(i, j) */
+    int dfs(vector<int> &nums, int target, int i, int j) {
+        // 若区间为空，代表无目标元素，则返回 -1
+        if (i > j) {
+            return -1;
+        }
+        // 计算中点索引 m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // 递归子问题 f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // 递归子问题 f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+
+    /* 二分查找 */
+    int binarySearch(vector<int> &nums, int target) {
+        int n = nums.size();
+        // 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+    ```
+
+=== "Python"
+
+    ```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
+
+    def binary_search(nums: list[int], target: int) -> int:
+        """二分查找"""
+        n = len(nums)
+        # 求解问题 f(0, n-1)
+        return dfs(nums, target, 0, n - 1)
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_recur.go"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "JavaScript"
+
+    ```javascript title="binary_search_recur.js"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="binary_search_recur.ts"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "C"
+
+    ```c title="binary_search_recur.c"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_search_recur.cs"
+    [class]{binary_search_recur}-[func]{dfs}
+
+    [class]{binary_search_recur}-[func]{binarySearch}
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_search_recur.swift"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_search_recur.zig"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_search_recur.dart"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binarySearch}
+    ```

chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 12.2.   构建二叉树问题
+# 12.3.   构建二叉树问题
 
 !!! question
 
@@ -64,17 +64,65 @@ comments: true
 === "Java"
 
     ```java title="build_tree.java"
-    [class]{build_tree}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    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;
+    }
 
-    [class]{build_tree}-[func]{buildTree}
+    /* 构建二叉树 */
+    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"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    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;
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    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"

chapter_divide_and_conquer/divide_and_conquer.md

@@ -18,6 +18,8 @@ comments: true
 
 <p align="center"> Fig. 归并排序的分治策略 </p>
 
+## 12.1.1. &nbsp; 如何判断分治问题
+
 一个问题是否适合使用分治解决，通常可以参考以下几个判断依据：
 
 1. **问题可以被分解**：原问题可以被分解成规模更小、类似的子问题，以及能够以相同方式递归地进行划分。
@@ -30,7 +32,7 @@ comments: true
 2. 每个子数组都可以独立地进行排序，因此子问题是独立的；
 3. 两个有序子数组（子问题的解）可以被合并为一个有序数组（原问题的解）；
 
-## 12.1.1. &nbsp; 通过分治提升效率
+## 12.1.2. &nbsp; 通过分治提升效率
 
 分治不仅可以有效地解决算法问题，**往往还可以提升算法效率**。在排序算法中，归并排序相较于选择、冒泡、插入排序更快，就是因为其应用了分治策略。
 
@@ -76,7 +78,7 @@ $$
 
 <p align="center"> Fig. 桶排序的并行计算 </p>
 
-## 12.1.2. &nbsp; 分治常见应用
+## 12.1.3. &nbsp; 分治常见应用
 
 一方面，分治可以用来解决许多经典算法问题：
 

chapter_divide_and_conquer/hanota_problem.md

@@ -2,7 +2,7 @@
 comments: true
 ---
 
-# 12.3.   汉诺塔问题
+# 12.4.   汉诺塔问题
 
 在归并排序和构建二叉树中，我们将原问题分解为两个规模为原问题一半的子问题。然而，对于即将介绍的汉诺塔问题，我们采用不同的分解策略。
 
@@ -87,21 +87,70 @@ comments: true
 === "Java"
 
     ```java title="hanota.java"
-    [class]{hanota}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(List<Integer> src, List<Integer> tar) {
+        // 从 src 顶部拿出一个圆盘
+        Integer pan = src.remove(src.size() - 1);
+        // 将圆盘放入 tar 顶部
+        tar.add(pan);
+    }
 
-    [class]{hanota}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{hanota}-[func]{hanota}
+    /* 求解汉诺塔 */
+    void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "C++"
 
     ```cpp title="hanota.cpp"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    void move(vector<int> &src, vector<int> &tar) {
+        // 从 src 顶部拿出一个圆盘
+        int pan = src.back();
+        src.pop_back();
+        // 将圆盘放入 tar 顶部
+        tar.push_back(pan);
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfs(i - 1, src, tar, buf);
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar);
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfs(i - 1, buf, src, tar);
+    }
 
-    [class]{}-[func]{hanota}
+    /* 求解汉诺塔 */
+    void hanota(vector<int> &A, vector<int> &B, vector<int> &C) {
+        int n = A.size();
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfs(n, A, B, C);
+    }
     ```
 
 === "Python"