diff --git a/chapter_divide_and_conquer/binary_search_recur.md b/chapter_divide_and_conquer/binary_search_recur.md new file mode 100644 index 000000000..4b4f70830 --- /dev/null +++ b/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) + +

Fig. 二分查找的分治过程

+ +如下代码所示，我们声明一个递归函数 `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 &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 &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} + ``` diff --git a/chapter_divide_and_conquer/build_binary_tree_problem.md b/chapter_divide_and_conquer/build_binary_tree_problem.md index d57f6a4be..ba26f72a5 100644 --- a/chapter_divide_and_conquer/build_binary_tree_problem.md +++ b/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 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 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 &preorder, vector &inorder, unordered_map &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 &preorder, vector &inorder) { + // 初始化哈希表，存储 inorder 元素到索引的映射 + unordered_map 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" diff --git a/chapter_divide_and_conquer/divide_and_conquer.md b/chapter_divide_and_conquer/divide_and_conquer.md index 33623fa61..86a0475ef 100644 --- a/chapter_divide_and_conquer/divide_and_conquer.md +++ b/chapter_divide_and_conquer/divide_and_conquer.md @@ -18,6 +18,8 @@ comments: true

Fig. 归并排序的分治策略

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

Fig. 桶排序的并行计算

-## 12.1.2.   分治常见应用 +## 12.1.3.   分治常见应用 一方面，分治可以用来解决许多经典算法问题： diff --git a/chapter_divide_and_conquer/hanota_problem.md b/chapter_divide_and_conquer/hanota_problem.md index 406211c50..b6f7a66de 100644 --- a/chapter_divide_and_conquer/hanota_problem.md +++ b/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 src, List tar) { + // 从 src 顶部拿出一个圆盘 + Integer pan = src.remove(src.size() - 1); + // 将圆盘放入 tar 顶部 + tar.add(pan); + } - [class]{hanota}-[func]{dfs} + /* 求解汉诺塔：问题 f(i) */ + void dfs(int i, List src, List buf, List 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 A, List B, List 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 &src, vector &tar) { + // 从 src 顶部拿出一个圆盘 + int pan = src.back(); + src.pop_back(); + // 将圆盘放入 tar 顶部 + tar.push_back(pan); + } - [class]{}-[func]{dfs} + /* 求解汉诺塔：问题 f(i) */ + void dfs(int i, vector &src, vector &buf, vector &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 &A, vector &B, vector &C) { + int n = A.size(); + // 将 A 顶部 n 个圆盘借助 B 移到 C + dfs(n, A, B, C); + } ``` === "Python"