From e434a3343c208d026dd1cf9432304d2e087dd39b Mon Sep 17 00:00:00 2001 From: krahets Date: Wed, 15 May 2024 19:00:27 +0800 Subject: [PATCH] build --- docs/chapter_array_and_linkedlist/array.md | 13 +++++-- docs/chapter_array_and_linkedlist/summary.md | 2 +- .../binary_search_recur.md | 29 +++++++++++++-- .../build_binary_tree_problem.md | 28 ++++++++++++-- .../hanota_problem.md | 37 ++++++++++++++++--- .../fractional_knapsack_problem.md | 36 ++++++++++++++++-- docs/chapter_greedy/greedy_algorithm.md | 19 +++++++++- docs/chapter_greedy/max_capacity_problem.md | 23 +++++++++++- .../max_product_cutting_problem.md | 14 ++++++- docs/chapter_introduction/what_is_dsa.md | 2 +- docs/chapter_sorting/bubble_sort.md | 8 +--- docs/chapter_sorting/bucket_sort.md | 6 +-- docs/chapter_sorting/counting_sort.md | 16 ++++---- docs/chapter_sorting/heap_sort.md | 12 ++---- en/docs/chapter_array_and_linkedlist/array.md | 7 +++- .../chapter_array_and_linkedlist/summary.md | 2 +- .../chapter_array_and_linkedlist/array.md | 13 +++++-- .../chapter_array_and_linkedlist/summary.md | 2 +- .../binary_search_recur.md | 29 +++++++++++++-- .../build_binary_tree_problem.md | 28 ++++++++++++-- .../hanota_problem.md | 37 ++++++++++++++++--- .../dp_problem_features.md | 4 +- .../dp_solution_pipeline.md | 4 +- .../edit_distance_problem.md | 4 +- .../knapsack_problem.md | 4 +- .../unbounded_knapsack_problem.md | 12 +++--- .../fractional_knapsack_problem.md | 36 ++++++++++++++++-- .../docs/chapter_greedy/greedy_algorithm.md | 19 +++++++++- .../chapter_greedy/max_capacity_problem.md | 23 +++++++++++- .../max_product_cutting_problem.md | 14 ++++++- zh-Hant/docs/chapter_heap/heap.md | 2 +- .../docs/chapter_introduction/what_is_dsa.md | 2 +- zh-Hant/docs/chapter_sorting/bubble_sort.md | 8 +--- zh-Hant/docs/chapter_sorting/bucket_sort.md | 6 +-- zh-Hant/docs/chapter_sorting/counting_sort.md | 16 ++++---- zh-Hant/docs/chapter_sorting/heap_sort.md | 12 ++---- 36 files changed, 412 insertions(+), 117 deletions(-) diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md index bdfd6a4a5..3f28b5fa5 100755 --- a/docs/chapter_array_and_linkedlist/array.md +++ b/docs/chapter_array_and_linkedlist/array.md @@ -99,7 +99,12 @@ comments: true ```rust title="array.rs" /* 初始化数组 */ - let arr: Vec = vec![0; 5]; // [0, 0, 0, 0, 0] + let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0] + let slice: &[i32] = &[0; 5]; + // 在 Rust 中，指定长度时（[i32; 5]）为数组，不指定长度时（&[i32]）为切片 + // 由于 Rust 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度 + // Vector 是 Rust 一般情况下用作动态数组的类型 + // 为了方便实现扩容 extend() 方法，以下将 vector 看作数组（array） let nums: Vec = vec![1, 3, 2, 5, 4]; ``` @@ -477,7 +482,7 @@ comments: true ```rust title="array.rs" /* 在数组的索引 index 处插入元素 num */ - fn insert(nums: &mut Vec, num: i32, index: usize) { + fn insert(nums: &mut [i32], num: i32, index: usize) { // 把索引 index 以及之后的所有元素向后移动一位 for i in (index + 1..nums.len()).rev() { nums[i] = nums[i - 1]; @@ -670,7 +675,7 @@ comments: true ```rust title="array.rs" /* 删除索引 index 处的元素 */ - fn remove(nums: &mut Vec, index: usize) { + fn remove(nums: &mut [i32], index: usize) { // 把索引 index 之后的所有元素向前移动一位 for i in index..nums.len() - 1 { nums[i] = nums[i + 1]; @@ -1350,7 +1355,7 @@ comments: true ```rust title="array.rs" /* 扩展数组长度 */ - fn extend(nums: Vec, enlarge: usize) -> Vec { + fn extend(nums: &[i32], enlarge: usize) -> Vec { // 初始化一个扩展长度后的数组 let mut res: Vec = vec![0; nums.len() + enlarge]; // 将原数组中的所有元素复制到新 diff --git a/docs/chapter_array_and_linkedlist/summary.md b/docs/chapter_array_and_linkedlist/summary.md index 07955e5cb..675d22fde 100644 --- a/docs/chapter_array_and_linkedlist/summary.md +++ b/docs/chapter_array_and_linkedlist/summary.md @@ -77,4 +77,4 @@ comments: true **Q**：初始化列表 `res = [0] * self.size()` 操作，会导致 `res` 的每个元素引用相同的地址吗？ -不会。但二维数组会有这个问题，例如初始化二维列表 `res = [[0] * self.size()]` ，则多次引用了同一个列表 `[0]` 。 +不会。但二维数组会有这个问题，例如初始化二维列表 `res = [[0]] * self.size()` ，则多次引用了同一个列表 `[0]` 。 diff --git a/docs/chapter_divide_and_conquer/binary_search_recur.md b/docs/chapter_divide_and_conquer/binary_search_recur.md index fbab2a78b..5ee60bcd8 100644 --- a/docs/chapter_divide_and_conquer/binary_search_recur.md +++ b/docs/chapter_divide_and_conquer/binary_search_recur.md @@ -422,9 +422,32 @@ comments: true === "Ruby" ```ruby title="binary_search_recur.rb" - [class]{}-[func]{dfs} - - [class]{}-[func]{binary_search} + ### 二分查找：问题 f(i, j) ### + def dfs(nums, target, i, j) + # 若区间为空，代表无目标元素，则返回 -1 + return -1 if i > j + + # 计算中点索引 m + m = (i + j) / 2 + + if nums[m] < target + # 递归子问题 f(m+1, j) + return dfs(nums, target, m + 1, j) + elsif nums[m] > target + # 递归子问题 f(i, m-1) + return dfs(nums, target, i, m - 1) + else + # 找到目标元素，返回其索引 + return m + end + end + + ### 二分查找 ### + def binary_search(nums, target) + n = nums.length + # 求解问题 f(0, n-1) + dfs(nums, target, 0, n - 1) + end ``` === "Zig" diff --git a/docs/chapter_divide_and_conquer/build_binary_tree_problem.md b/docs/chapter_divide_and_conquer/build_binary_tree_problem.md index 41b289560..fc99c18b4 100644 --- a/docs/chapter_divide_and_conquer/build_binary_tree_problem.md +++ b/docs/chapter_divide_and_conquer/build_binary_tree_problem.md @@ -485,9 +485,31 @@ comments: true === "Ruby" ```ruby title="build_tree.rb" - [class]{}-[func]{dfs} - - [class]{}-[func]{build_tree} + ### 构建二叉树：分治 ### + def dfs(preorder, inorder_map, i, l, r) + # 子树区间为空时终止 + return if r - l < 0 + + # 初始化根节点 + root = TreeNode.new(preorder[i]) + # 查询 m ，从而划分左右子树 + m = inorder_map[preorder[i]] + # 子问题：构建左子树 + root.left = dfs(preorder, inorder_map, i + 1, l, m - 1) + # 子问题：构建右子树 + root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r) + + # 返回根节点 + root + end + + ### 构建二叉树 ### + def build_tree(preorder, inorder) + # 初始化哈希表，存储 inorder 元素到索引的映射 + inorder_map = {} + inorder.each_with_index { |val, i| inorder_map[val] = i } + dfs(preorder, inorder_map, 0, 0, inorder.length - 1) + end ``` === "Zig" diff --git a/docs/chapter_divide_and_conquer/hanota_problem.md b/docs/chapter_divide_and_conquer/hanota_problem.md index 9222b4c1b..37fe6ba6a 100644 --- a/docs/chapter_divide_and_conquer/hanota_problem.md +++ b/docs/chapter_divide_and_conquer/hanota_problem.md @@ -409,7 +409,7 @@ comments: true /* 移动一个圆盘 */ fn move_pan(src: &mut Vec, tar: &mut Vec) { // 从 src 顶部拿出一个圆盘 - let pan = src.remove(src.len() - 1); + let pan = src.pop().unwrap(); // 将圆盘放入 tar 顶部 tar.push(pan); } @@ -510,11 +510,36 @@ comments: true === "Ruby" ```ruby title="hanota.rb" - [class]{}-[func]{move} - - [class]{}-[func]{dfs} - - [class]{}-[func]{solve_hanota} + ### 移动一个圆盘 ### + def move(src, tar) + # 从 src 顶部拿出一个圆盘 + pan = src.pop + # 将圆盘放入 tar 顶部 + tar << pan + end + + ### 求解汉诺塔问题 f(i) ### + def dfs(i, src, buf, tar) + # 若 src 只剩下一个圆盘，则直接将其移到 tar + if i == 1 + move(src, tar) + return + end + + # 子问题 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) + end + + ### 求解汉诺塔问题 ### + def solve_hanota(_A, _B, _C) + n = _A.length + # 将 A 顶部 n 个圆盘借助 B 移到 C + dfs(n, _A, _B, _C) + end ``` === "Zig" diff --git a/docs/chapter_greedy/fractional_knapsack_problem.md b/docs/chapter_greedy/fractional_knapsack_problem.md index 4dfa81560..e777e256a 100644 --- a/docs/chapter_greedy/fractional_knapsack_problem.md +++ b/docs/chapter_greedy/fractional_knapsack_problem.md @@ -496,9 +496,39 @@ comments: true === "Ruby" ```ruby title="fractional_knapsack.rb" - [class]{Item}-[func]{} - - [class]{}-[func]{fractional_knapsack} + ### 物品 ### + class Item + attr_accessor :w # 物品重量 + attr_accessor :v # 物品价值 + + def initialize(w, v) + @w = w + @v = v + end + end + + ### 分数背包：贪心 ### + def fractional_knapsack(wgt, val, cap) + # 创建物品列表，包含两个属性：重量，价值 + items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) } + # 按照单位价值 item.v / item.w 从高到低进行排序 + items.sort! { |a, b| (b.v.to_f / b.w) <=> (a.v.to_f / a.w) } + # 循环贪心选择 + res = 0 + for item in items + if item.w <= cap + # 若剩余容量充足，则将当前物品整个装进背包 + res += item.v + cap -= item.w + else + # 若剩余容量不足，则将当前物品的一部分装进背包 + res += (item.v.to_f / item.w) * cap + # 已无剩余容量，因此跳出循环 + break + end + end + res + end ``` === "Zig" diff --git a/docs/chapter_greedy/greedy_algorithm.md b/docs/chapter_greedy/greedy_algorithm.md index 963f0dc23..041c9fbaf 100644 --- a/docs/chapter_greedy/greedy_algorithm.md +++ b/docs/chapter_greedy/greedy_algorithm.md @@ -310,7 +310,24 @@ comments: true === "Ruby" ```ruby title="coin_change_greedy.rb" - [class]{}-[func]{coin_change_greedy} + ### 零钱兑换：贪心 ### + def coin_change_greedy(coins, amt) + # 假设 coins 列表有序 + i = coins.length - 1 + count = 0 + # 循环进行贪心选择，直到无剩余金额 + while amt > 0 + # 找到小于且最接近剩余金额的硬币 + while i > 0 && coins[i] > amt + i -= 1 + end + # 选择 coins[i] + amt -= coins[i] + count += 1 + end + # 若未找到可行方案， 则返回 -1 + amt == 0 ? count : -1 + end ``` === "Zig" diff --git a/docs/chapter_greedy/max_capacity_problem.md b/docs/chapter_greedy/max_capacity_problem.md index 74a3b6111..107eeeb97 100644 --- a/docs/chapter_greedy/max_capacity_problem.md +++ b/docs/chapter_greedy/max_capacity_problem.md @@ -397,7 +397,28 @@ $$ === "Ruby" ```ruby title="max_capacity.rb" - [class]{}-[func]{max_capacity} + ### 最大容量：贪心 ### + def max_capacity(ht) + # 初始化 i, j，使其分列数组两端 + i, j = 0, ht.length - 1 + # 初始最大容量为 0 + res = 0 + + # 循环贪心选择，直至两板相遇 + while i < j + # 更新最大容量 + cap = [ht[i], ht[j]].min * (j - i) + res = [res, cap].max + # 向内移动短板 + if ht[i] < ht[j] + i += 1 + else + j -= 1 + end + end + + res + end ``` === "Zig" diff --git a/docs/chapter_greedy/max_product_cutting_problem.md b/docs/chapter_greedy/max_product_cutting_problem.md index b1eae8f51..d224af634 100644 --- a/docs/chapter_greedy/max_product_cutting_problem.md +++ b/docs/chapter_greedy/max_product_cutting_problem.md @@ -371,7 +371,19 @@ $$ === "Ruby" ```ruby title="max_product_cutting.rb" - [class]{}-[func]{max_product_cutting} + ### 最大切分乘积：贪心 ### + def max_product_cutting(n) + # 当 n <= 3 时，必须切分出一个 1 + return 1 * (n - 1) if n <= 3 + # 贪心地切分出 3 ，a 为 3 的个数，b 为余数 + a, b = n / 3, n % 3 + # 当余数为 1 时，将一对 1 * 3 转化为 2 * 2 + return (3.pow(a - 1) * 2 * 2).to_i if b == 1 + # 当余数为 2 时，不做处理 + return (3.pow(a) * 2).to_i if b == 2 + # 当余数为 0 时，不做处理 + 3.pow(a).to_i + end ``` === "Zig" diff --git a/docs/chapter_introduction/what_is_dsa.md b/docs/chapter_introduction/what_is_dsa.md index ccb6605ee..475d265a5 100644 --- a/docs/chapter_introduction/what_is_dsa.md +++ b/docs/chapter_introduction/what_is_dsa.md @@ -14,7 +14,7 @@ comments: true ## 1.2.2   数据结构定义 -数据结构（data structure）是计算机中组织和存储数据的方式，具有以下设计目标。 +数据结构（data structure）是组织和存储数据的方式，涵盖数据内容、数据之间关系和数据操作方法，它具有以下设计目标。 - 空间占用尽量少，以节省计算机内存。 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。 diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md index 725378867..02b292974 100755 --- a/docs/chapter_sorting/bubble_sort.md +++ b/docs/chapter_sorting/bubble_sort.md @@ -225,9 +225,7 @@ comments: true for j in 0..i { if nums[j] > nums[j + 1] { // 交换 nums[j] 与 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; + nums.swap(j, j + 1); } } } @@ -538,9 +536,7 @@ comments: true for j in 0..i { if nums[j] > nums[j + 1] { // 交换 nums[j] 与 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; + nums.swap(j, j + 1); flag = true; // 记录交换元素 } } diff --git a/docs/chapter_sorting/bucket_sort.md b/docs/chapter_sorting/bucket_sort.md index dad1a80f1..bd332b0a0 100644 --- a/docs/chapter_sorting/bucket_sort.md +++ b/docs/chapter_sorting/bucket_sort.md @@ -314,7 +314,7 @@ comments: true let k = nums.len() / 2; let mut buckets = vec![vec![]; k]; // 1. 将数组元素分配到各个桶中 - for &mut num in &mut *nums { + for &num in nums.iter() { // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1] let i = (num * k as f64) as usize; // 将 num 添加进桶 i @@ -327,8 +327,8 @@ comments: true } // 3. 遍历桶合并结果 let mut i = 0; - for bucket in &mut buckets { - for &mut num in bucket { + for bucket in buckets.iter() { + for &num in bucket.iter() { nums[i] = num; i += 1; } diff --git a/docs/chapter_sorting/counting_sort.md b/docs/chapter_sorting/counting_sort.md index f11badfa9..e0eefcd6b 100644 --- a/docs/chapter_sorting/counting_sort.md +++ b/docs/chapter_sorting/counting_sort.md @@ -266,11 +266,11 @@ comments: true // 简单实现，无法用于排序对象 fn counting_sort_naive(nums: &mut [i32]) { // 1. 统计数组最大元素 m - let m = *nums.into_iter().max().unwrap(); + let m = *nums.iter().max().unwrap(); // 2. 统计各数字的出现次数 // counter[num] 代表 num 的出现次数 let mut counter = vec![0; m as usize + 1]; - for &num in &*nums { + for &num in nums.iter() { counter[num as usize] += 1; } // 3. 遍历 counter ，将各元素填入原数组 nums @@ -764,16 +764,16 @@ $$ // 完整实现，可排序对象，并且是稳定排序 fn counting_sort(nums: &mut [i32]) { // 1. 统计数组最大元素 m - let m = *nums.into_iter().max().unwrap(); + let m = *nums.iter().max().unwrap() as usize; // 2. 统计各数字的出现次数 // counter[num] 代表 num 的出现次数 - let mut counter = vec![0; m as usize + 1]; - for &num in &*nums { + let mut counter = vec![0; m + 1]; + for &num in nums.iter() { counter[num as usize] += 1; } // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引” // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引 - for i in 0..m as usize { + for i in 0..m { counter[i + 1] += counter[i]; } // 4. 倒序遍历 nums ，将各元素填入结果数组 res @@ -786,9 +786,7 @@ $$ counter[num as usize] -= 1; // 令前缀和自减 1 ，得到下次放置 num 的索引 } // 使用结果数组 res 覆盖原数组 nums - for i in 0..n { - nums[i] = res[i]; - } + nums.copy_from_slice(&res) } ``` diff --git a/docs/chapter_sorting/heap_sort.md b/docs/chapter_sorting/heap_sort.md index a477dbb04..253f4c8d9 100644 --- a/docs/chapter_sorting/heap_sort.md +++ b/docs/chapter_sorting/heap_sort.md @@ -463,9 +463,7 @@ comments: true break; } // 交换两节点 - let temp = nums[i]; - nums[i] = nums[ma]; - nums[ma] = temp; + nums.swap(i, ma); // 循环向下堆化 i = ma; } @@ -474,15 +472,13 @@ comments: true /* 堆排序 */ fn heap_sort(nums: &mut [i32]) { // 建堆操作：堆化除叶节点以外的其他所有节点 - for i in (0..=nums.len() / 2 - 1).rev() { + for i in (0..nums.len() / 2).rev() { sift_down(nums, nums.len(), i); } // 从堆中提取最大元素，循环 n-1 轮 - for i in (1..=nums.len() - 1).rev() { + for i in (1..nums.len()).rev() { // 交换根节点与最右叶节点（交换首元素与尾元素） - let tmp = nums[0]; - nums[0] = nums[i]; - nums[i] = tmp; + nums.swap(0, i); // 以根节点为起点，从顶至底进行堆化 sift_down(nums, i, 0); } diff --git a/en/docs/chapter_array_and_linkedlist/array.md b/en/docs/chapter_array_and_linkedlist/array.md index a78206906..4494f3044 100755 --- a/en/docs/chapter_array_and_linkedlist/array.md +++ b/en/docs/chapter_array_and_linkedlist/array.md @@ -99,7 +99,12 @@ Arrays can be initialized in two ways depending on the needs: either without ini ```rust title="array.rs" /* Initialize array */ - let arr: Vec = vec![0; 5]; // [0, 0, 0, 0, 0] + let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0] + let slice: &[i32] = &[0; 5]; + // In Rust, specifying the length ([i32; 5]) denotes an array, while not specifying it (&[i32]) denotes a slice. + // Since Rust's arrays are designed to have compile-time fixed length, only constants can be used to specify the length. + // Vectors are generally used as dynamic arrays in Rust. + // For convenience in implementing the extend() method, the vector will be considered as an array here. let nums: Vec = vec![1, 3, 2, 5, 4]; ``` diff --git a/en/docs/chapter_array_and_linkedlist/summary.md b/en/docs/chapter_array_and_linkedlist/summary.md index 5e1464de0..e2201dee2 100644 --- a/en/docs/chapter_array_and_linkedlist/summary.md +++ b/en/docs/chapter_array_and_linkedlist/summary.md @@ -78,7 +78,7 @@ On the other hand, linked lists are primarily necessary for binary trees and gra **Q**: Does initializing a list `res = [0] * self.size()` result in each element of `res` referencing the same address? -No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list `res = [[0] * self.size()]` would reference the same list `[0]` multiple times. +No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list `res = [[0]] * self.size()` would reference the same list `[0]` multiple times. **Q**: In deleting a node, is it necessary to break the reference to its successor node? diff --git a/zh-Hant/docs/chapter_array_and_linkedlist/array.md b/zh-Hant/docs/chapter_array_and_linkedlist/array.md index a0cb4a560..f1193725b 100755 --- a/zh-Hant/docs/chapter_array_and_linkedlist/array.md +++ b/zh-Hant/docs/chapter_array_and_linkedlist/array.md @@ -99,7 +99,12 @@ comments: true ```rust title="array.rs" /* 初始化陣列 */ - let arr: Vec = vec![0; 5]; // [0, 0, 0, 0, 0] + let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0] + let slice: &[i32] = &[0; 5]; + // 在 Rust 中，指定長度時（[i32; 5]）為陣列，不指定長度時（&[i32]）為切片 + // 由於 Rust 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度 + // Vector 是 Rust 一般情況下用作動態陣列的型別 + // 為了方便實現擴容 extend() 方法，以下將 vector 看作陣列（array） let nums: Vec = vec![1, 3, 2, 5, 4]; ``` @@ -477,7 +482,7 @@ comments: true ```rust title="array.rs" /* 在陣列的索引 index 處插入元素 num */ - fn insert(nums: &mut Vec, num: i32, index: usize) { + fn insert(nums: &mut [i32], num: i32, index: usize) { // 把索引 index 以及之後的所有元素向後移動一位 for i in (index + 1..nums.len()).rev() { nums[i] = nums[i - 1]; @@ -670,7 +675,7 @@ comments: true ```rust title="array.rs" /* 刪除索引 index 處的元素 */ - fn remove(nums: &mut Vec, index: usize) { + fn remove(nums: &mut [i32], index: usize) { // 把索引 index 之後的所有元素向前移動一位 for i in index..nums.len() - 1 { nums[i] = nums[i + 1]; @@ -1350,7 +1355,7 @@ comments: true ```rust title="array.rs" /* 擴展陣列長度 */ - fn extend(nums: Vec, enlarge: usize) -> Vec { + fn extend(nums: &[i32], enlarge: usize) -> Vec { // 初始化一個擴展長度後的陣列 let mut res: Vec = vec![0; nums.len() + enlarge]; // 將原陣列中的所有元素複製到新 diff --git a/zh-Hant/docs/chapter_array_and_linkedlist/summary.md b/zh-Hant/docs/chapter_array_and_linkedlist/summary.md index 120c088e7..04f98ace1 100644 --- a/zh-Hant/docs/chapter_array_and_linkedlist/summary.md +++ b/zh-Hant/docs/chapter_array_and_linkedlist/summary.md @@ -77,4 +77,4 @@ comments: true **Q**：初始化串列 `res = [0] * self.size()` 操作，會導致 `res` 的每個元素引用相同的位址嗎？ -不會。但二維陣列會有這個問題，例如初始化二維串列 `res = [[0] * self.size()]` ，則多次引用了同一個串列 `[0]` 。 +不會。但二維陣列會有這個問題，例如初始化二維串列 `res = [[0]] * self.size()` ，則多次引用了同一個串列 `[0]` 。 diff --git a/zh-Hant/docs/chapter_divide_and_conquer/binary_search_recur.md b/zh-Hant/docs/chapter_divide_and_conquer/binary_search_recur.md index 433315ef8..f417cdf2f 100644 --- a/zh-Hant/docs/chapter_divide_and_conquer/binary_search_recur.md +++ b/zh-Hant/docs/chapter_divide_and_conquer/binary_search_recur.md @@ -422,9 +422,32 @@ comments: true === "Ruby" ```ruby title="binary_search_recur.rb" - [class]{}-[func]{dfs} - - [class]{}-[func]{binary_search} + ### 二分搜尋：問題 f(i, j) ### + def dfs(nums, target, i, j) + # 若區間為空，代表無目標元素，則返回 -1 + return -1 if i > j + + # 計算中點索引 m + m = (i + j) / 2 + + if nums[m] < target + # 遞迴子問題 f(m+1, j) + return dfs(nums, target, m + 1, j) + elsif nums[m] > target + # 遞迴子問題 f(i, m-1) + return dfs(nums, target, i, m - 1) + else + # 找到目標元素，返回其索引 + return m + end + end + + ### 二分搜尋 ### + def binary_search(nums, target) + n = nums.length + # 求解問題 f(0, n-1) + dfs(nums, target, 0, n - 1) + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_divide_and_conquer/build_binary_tree_problem.md b/zh-Hant/docs/chapter_divide_and_conquer/build_binary_tree_problem.md index 7276dde74..a66b40d99 100644 --- a/zh-Hant/docs/chapter_divide_and_conquer/build_binary_tree_problem.md +++ b/zh-Hant/docs/chapter_divide_and_conquer/build_binary_tree_problem.md @@ -485,9 +485,31 @@ comments: true === "Ruby" ```ruby title="build_tree.rb" - [class]{}-[func]{dfs} - - [class]{}-[func]{build_tree} + ### 構建二元樹：分治 ### + def dfs(preorder, inorder_map, i, l, r) + # 子樹區間為空時終止 + return if r - l < 0 + + # 初始化根節點 + root = TreeNode.new(preorder[i]) + # 查詢 m ，從而劃分左右子樹 + m = inorder_map[preorder[i]] + # 子問題：構建左子樹 + root.left = dfs(preorder, inorder_map, i + 1, l, m - 1) + # 子問題：構建右子樹 + root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r) + + # 返回根節點 + root + end + + ### 構建二元樹 ### + def build_tree(preorder, inorder) + # 初始化雜湊表，儲存 inorder 元素到索引的對映 + inorder_map = {} + inorder.each_with_index { |val, i| inorder_map[val] = i } + dfs(preorder, inorder_map, 0, 0, inorder.length - 1) + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_divide_and_conquer/hanota_problem.md b/zh-Hant/docs/chapter_divide_and_conquer/hanota_problem.md index 70d530c0a..99f0e0df4 100644 --- a/zh-Hant/docs/chapter_divide_and_conquer/hanota_problem.md +++ b/zh-Hant/docs/chapter_divide_and_conquer/hanota_problem.md @@ -409,7 +409,7 @@ comments: true /* 移動一個圓盤 */ fn move_pan(src: &mut Vec, tar: &mut Vec) { // 從 src 頂部拿出一個圓盤 - let pan = src.remove(src.len() - 1); + let pan = src.pop().unwrap(); // 將圓盤放入 tar 頂部 tar.push(pan); } @@ -510,11 +510,36 @@ comments: true === "Ruby" ```ruby title="hanota.rb" - [class]{}-[func]{move} - - [class]{}-[func]{dfs} - - [class]{}-[func]{solve_hanota} + ### 移動一個圓盤 ### + def move(src, tar) + # 從 src 頂部拿出一個圓盤 + pan = src.pop + # 將圓盤放入 tar 頂部 + tar << pan + end + + ### 求解河內塔問題 f(i) ### + def dfs(i, src, buf, tar) + # 若 src 只剩下一個圓盤，則直接將其移到 tar + if i == 1 + move(src, tar) + return + end + + # 子問題 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) + end + + ### 求解河內塔問題 ### + def solve_hanota(_A, _B, _C) + n = _A.length + # 將 A 頂部 n 個圓盤藉助 B 移到 C + dfs(n, _A, _B, _C) + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_dynamic_programming/dp_problem_features.md b/zh-Hant/docs/chapter_dynamic_programming/dp_problem_features.md index b1a9a3173..37ce0496c 100644 --- a/zh-Hant/docs/chapter_dynamic_programming/dp_problem_features.md +++ b/zh-Hant/docs/chapter_dynamic_programming/dp_problem_features.md @@ -457,7 +457,7 @@ $$ === "JS" ```javascript title="min_cost_climbing_stairs_dp.js" - /* 爬樓梯最小代價：狀態壓縮後的動態規劃 */ + /* 爬樓梯最小代價：空間最佳化後的動態規劃 */ function minCostClimbingStairsDPComp(cost) { const n = cost.length - 1; if (n === 1 || n === 2) { @@ -477,7 +477,7 @@ $$ === "TS" ```typescript title="min_cost_climbing_stairs_dp.ts" - /* 爬樓梯最小代價：狀態壓縮後的動態規劃 */ + /* 爬樓梯最小代價：空間最佳化後的動態規劃 */ function minCostClimbingStairsDPComp(cost: Array): number { const n = cost.length - 1; if (n === 1 || n === 2) { diff --git a/zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md b/zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md index 82b1fa3c8..d221713cf 100644 --- a/zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md +++ b/zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md @@ -1361,7 +1361,7 @@ $$ === "JS" ```javascript title="min_path_sum.js" - /* 最小路徑和：狀態壓縮後的動態規劃 */ + /* 最小路徑和：空間最佳化後的動態規劃 */ function minPathSumDPComp(grid) { const n = grid.length, m = grid[0].length; @@ -1388,7 +1388,7 @@ $$ === "TS" ```typescript title="min_path_sum.ts" - /* 最小路徑和：狀態壓縮後的動態規劃 */ + /* 最小路徑和：空間最佳化後的動態規劃 */ function minPathSumDPComp(grid: Array>): number { const n = grid.length, m = grid[0].length; diff --git a/zh-Hant/docs/chapter_dynamic_programming/edit_distance_problem.md b/zh-Hant/docs/chapter_dynamic_programming/edit_distance_problem.md index 21353b30b..6edca247f 100644 --- a/zh-Hant/docs/chapter_dynamic_programming/edit_distance_problem.md +++ b/zh-Hant/docs/chapter_dynamic_programming/edit_distance_problem.md @@ -746,7 +746,7 @@ $$ === "JS" ```javascript title="edit_distance.js" - /* 編輯距離：狀態壓縮後的動態規劃 */ + /* 編輯距離：空間最佳化後的動態規劃 */ function editDistanceDPComp(s, t) { const n = s.length, m = t.length; @@ -780,7 +780,7 @@ $$ === "TS" ```typescript title="edit_distance.ts" - /* 編輯距離：狀態壓縮後的動態規劃 */ + /* 編輯距離：空間最佳化後的動態規劃 */ function editDistanceDPComp(s: string, t: string): number { const n = s.length, m = t.length; diff --git a/zh-Hant/docs/chapter_dynamic_programming/knapsack_problem.md b/zh-Hant/docs/chapter_dynamic_programming/knapsack_problem.md index f753de146..c00a981c9 100644 --- a/zh-Hant/docs/chapter_dynamic_programming/knapsack_problem.md +++ b/zh-Hant/docs/chapter_dynamic_programming/knapsack_problem.md @@ -1307,7 +1307,7 @@ $$ === "JS" ```javascript title="knapsack.js" - /* 0-1 背包：狀態壓縮後的動態規劃 */ + /* 0-1 背包：空間最佳化後的動態規劃 */ function knapsackDPComp(wgt, val, cap) { const n = wgt.length; // 初始化 dp 表 @@ -1329,7 +1329,7 @@ $$ === "TS" ```typescript title="knapsack.ts" - /* 0-1 背包：狀態壓縮後的動態規劃 */ + /* 0-1 背包：空間最佳化後的動態規劃 */ function knapsackDPComp( wgt: Array, val: Array, diff --git a/zh-Hant/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md b/zh-Hant/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md index 371f46368..048b06767 100644 --- a/zh-Hant/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md +++ b/zh-Hant/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md @@ -554,7 +554,7 @@ $$ === "JS" ```javascript title="unbounded_knapsack.js" - /* 完全背包：狀態壓縮後的動態規劃 */ + /* 完全背包：空間最佳化後的動態規劃 */ function unboundedKnapsackDPComp(wgt, val, cap) { const n = wgt.length; // 初始化 dp 表 @@ -578,7 +578,7 @@ $$ === "TS" ```typescript title="unbounded_knapsack.ts" - /* 完全背包：狀態壓縮後的動態規劃 */ + /* 完全背包：空間最佳化後的動態規劃 */ function unboundedKnapsackDPComp( wgt: Array, val: Array, @@ -1417,7 +1417,7 @@ $$ === "JS" ```javascript title="coin_change.js" - /* 零錢兌換：狀態壓縮後的動態規劃 */ + /* 零錢兌換：空間最佳化後的動態規劃 */ function coinChangeDPComp(coins, amt) { const n = coins.length; const MAX = amt + 1; @@ -1443,7 +1443,7 @@ $$ === "TS" ```typescript title="coin_change.ts" - /* 零錢兌換：狀態壓縮後的動態規劃 */ + /* 零錢兌換：空間最佳化後的動態規劃 */ function coinChangeDPComp(coins: Array, amt: number): number { const n = coins.length; const MAX = amt + 1; @@ -2190,7 +2190,7 @@ $$ === "JS" ```javascript title="coin_change_ii.js" - /* 零錢兌換 II：狀態壓縮後的動態規劃 */ + /* 零錢兌換 II：空間最佳化後的動態規劃 */ function coinChangeIIDPComp(coins, amt) { const n = coins.length; // 初始化 dp 表 @@ -2215,7 +2215,7 @@ $$ === "TS" ```typescript title="coin_change_ii.ts" - /* 零錢兌換 II：狀態壓縮後的動態規劃 */ + /* 零錢兌換 II：空間最佳化後的動態規劃 */ function coinChangeIIDPComp(coins: Array, amt: number): number { const n = coins.length; // 初始化 dp 表 diff --git a/zh-Hant/docs/chapter_greedy/fractional_knapsack_problem.md b/zh-Hant/docs/chapter_greedy/fractional_knapsack_problem.md index 9ed646117..df610ff56 100644 --- a/zh-Hant/docs/chapter_greedy/fractional_knapsack_problem.md +++ b/zh-Hant/docs/chapter_greedy/fractional_knapsack_problem.md @@ -496,9 +496,39 @@ comments: true === "Ruby" ```ruby title="fractional_knapsack.rb" - [class]{Item}-[func]{} - - [class]{}-[func]{fractional_knapsack} + ### 物品 ### + class Item + attr_accessor :w # 物品重量 + attr_accessor :v # 物品價值 + + def initialize(w, v) + @w = w + @v = v + end + end + + ### 分數背包：貪婪 ### + def fractional_knapsack(wgt, val, cap) + # 建立物品串列，包含兩個屬性：重量，價值 + items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) } + # 按照單位價值 item.v / item.w 從高到低進行排序 + items.sort! { |a, b| (b.v.to_f / b.w) <=> (a.v.to_f / a.w) } + # 迴圈貪婪選擇 + res = 0 + for item in items + if item.w <= cap + # 若剩餘容量充足，則將當前物品整個裝進背包 + res += item.v + cap -= item.w + else + # 若剩餘容量不足，則將當前物品的一部分裝進背包 + res += (item.v.to_f / item.w) * cap + # 已無剩餘容量，因此跳出迴圈 + break + end + end + res + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_greedy/greedy_algorithm.md b/zh-Hant/docs/chapter_greedy/greedy_algorithm.md index ce8b7cabc..7ba687ab6 100644 --- a/zh-Hant/docs/chapter_greedy/greedy_algorithm.md +++ b/zh-Hant/docs/chapter_greedy/greedy_algorithm.md @@ -310,7 +310,24 @@ comments: true === "Ruby" ```ruby title="coin_change_greedy.rb" - [class]{}-[func]{coin_change_greedy} + ### 零錢兌換：貪婪 ### + def coin_change_greedy(coins, amt) + # 假設 coins 串列有序 + i = coins.length - 1 + count = 0 + # 迴圈進行貪婪選擇，直到無剩餘金額 + while amt > 0 + # 找到小於且最接近剩餘金額的硬幣 + while i > 0 && coins[i] > amt + i -= 1 + end + # 選擇 coins[i] + amt -= coins[i] + count += 1 + end + # 若未找到可行方案， 則返回 -1 + amt == 0 ? count : -1 + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_greedy/max_capacity_problem.md b/zh-Hant/docs/chapter_greedy/max_capacity_problem.md index f48b8e9a5..fc452d716 100644 --- a/zh-Hant/docs/chapter_greedy/max_capacity_problem.md +++ b/zh-Hant/docs/chapter_greedy/max_capacity_problem.md @@ -397,7 +397,28 @@ $$ === "Ruby" ```ruby title="max_capacity.rb" - [class]{}-[func]{max_capacity} + ### 最大容量：貪婪 ### + def max_capacity(ht) + # 初始化 i, j，使其分列陣列兩端 + i, j = 0, ht.length - 1 + # 初始最大容量為 0 + res = 0 + + # 迴圈貪婪選擇，直至兩板相遇 + while i < j + # 更新最大容量 + cap = [ht[i], ht[j]].min * (j - i) + res = [res, cap].max + # 向內移動短板 + if ht[i] < ht[j] + i += 1 + else + j -= 1 + end + end + + res + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md b/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md index 79e5b114d..dda1e64dd 100644 --- a/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md +++ b/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md @@ -371,7 +371,19 @@ $$ === "Ruby" ```ruby title="max_product_cutting.rb" - [class]{}-[func]{max_product_cutting} + ### 最大切分乘積：貪婪 ### + def max_product_cutting(n) + # 當 n <= 3 時，必須切分出一個 1 + return 1 * (n - 1) if n <= 3 + # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數 + a, b = n / 3, n % 3 + # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2 + return (3.pow(a - 1) * 2 * 2).to_i if b == 1 + # 當餘數為 2 時，不做處理 + return (3.pow(a) * 2).to_i if b == 2 + # 當餘數為 0 時，不做處理 + 3.pow(a).to_i + end ``` === "Zig" diff --git a/zh-Hant/docs/chapter_heap/heap.md b/zh-Hant/docs/chapter_heap/heap.md index 77688b084..51ac78326 100644 --- a/zh-Hant/docs/chapter_heap/heap.md +++ b/zh-Hant/docs/chapter_heap/heap.md @@ -1874,6 +1874,6 @@ comments: true ## 8.1.3   堆積的常見應用 -- **優先佇列**：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 $O(\log n)$ ，而建隊操作為 $O(n)$ ，這些操作都非常高效。 +- **優先佇列**：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 $O(\log n)$ ，而建堆積操作為 $O(n)$ ，這些操作都非常高效。 - **堆積排序**：給定一組資料，我們可以用它們建立一個堆積，然後不斷地執行元素出堆積操作，從而得到有序資料。然而，我們通常會使用一種更優雅的方式實現堆積排序，詳見“堆積排序”章節。 - **獲取最大的 $k$ 個元素**：這是一個經典的演算法問題，同時也是一種典型應用，例如選擇熱度前 10 的新聞作為微博熱搜，選取銷量前 10 的商品等。 diff --git a/zh-Hant/docs/chapter_introduction/what_is_dsa.md b/zh-Hant/docs/chapter_introduction/what_is_dsa.md index 51d0f4972..65dd0d355 100644 --- a/zh-Hant/docs/chapter_introduction/what_is_dsa.md +++ b/zh-Hant/docs/chapter_introduction/what_is_dsa.md @@ -14,7 +14,7 @@ comments: true ## 1.2.2   資料結構定義 -資料結構（data structure）是計算機中組織和儲存資料的方式，具有以下設計目標。 +資料結構（data structure）是組織和儲存資料的方式，涵蓋資料內容、資料之間關係和資料操作方法，它具有以下設計目標。 - 空間佔用儘量少，以節省計算機記憶體。 - 資料操作儘可能快速，涵蓋資料訪問、新增、刪除、更新等。 diff --git a/zh-Hant/docs/chapter_sorting/bubble_sort.md b/zh-Hant/docs/chapter_sorting/bubble_sort.md index 0e42119ff..b1c45eede 100755 --- a/zh-Hant/docs/chapter_sorting/bubble_sort.md +++ b/zh-Hant/docs/chapter_sorting/bubble_sort.md @@ -225,9 +225,7 @@ comments: true for j in 0..i { if nums[j] > nums[j + 1] { // 交換 nums[j] 與 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; + nums.swap(j, j + 1); } } } @@ -538,9 +536,7 @@ comments: true for j in 0..i { if nums[j] > nums[j + 1] { // 交換 nums[j] 與 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; + nums.swap(j, j + 1); flag = true; // 記錄交換元素 } } diff --git a/zh-Hant/docs/chapter_sorting/bucket_sort.md b/zh-Hant/docs/chapter_sorting/bucket_sort.md index 38c0a7cfa..ef9fd887f 100644 --- a/zh-Hant/docs/chapter_sorting/bucket_sort.md +++ b/zh-Hant/docs/chapter_sorting/bucket_sort.md @@ -314,7 +314,7 @@ comments: true let k = nums.len() / 2; let mut buckets = vec![vec![]; k]; // 1. 將陣列元素分配到各個桶中 - for &mut num in &mut *nums { + for &num in nums.iter() { // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1] let i = (num * k as f64) as usize; // 將 num 新增進桶 i @@ -327,8 +327,8 @@ comments: true } // 3. 走訪桶合併結果 let mut i = 0; - for bucket in &mut buckets { - for &mut num in bucket { + for bucket in buckets.iter() { + for &num in bucket.iter() { nums[i] = num; i += 1; } diff --git a/zh-Hant/docs/chapter_sorting/counting_sort.md b/zh-Hant/docs/chapter_sorting/counting_sort.md index c7a7d7884..95ce71043 100644 --- a/zh-Hant/docs/chapter_sorting/counting_sort.md +++ b/zh-Hant/docs/chapter_sorting/counting_sort.md @@ -266,11 +266,11 @@ comments: true // 簡單實現，無法用於排序物件 fn counting_sort_naive(nums: &mut [i32]) { // 1. 統計陣列最大元素 m - let m = *nums.into_iter().max().unwrap(); + let m = *nums.iter().max().unwrap(); // 2. 統計各數字的出現次數 // counter[num] 代表 num 的出現次數 let mut counter = vec![0; m as usize + 1]; - for &num in &*nums { + for &num in nums.iter() { counter[num as usize] += 1; } // 3. 走訪 counter ，將各元素填入原陣列 nums @@ -764,16 +764,16 @@ $$ // 完整實現，可排序物件，並且是穩定排序 fn counting_sort(nums: &mut [i32]) { // 1. 統計陣列最大元素 m - let m = *nums.into_iter().max().unwrap(); + let m = *nums.iter().max().unwrap() as usize; // 2. 統計各數字的出現次數 // counter[num] 代表 num 的出現次數 - let mut counter = vec![0; m as usize + 1]; - for &num in &*nums { + let mut counter = vec![0; m + 1]; + for &num in nums.iter() { counter[num as usize] += 1; } // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引” // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引 - for i in 0..m as usize { + for i in 0..m { counter[i + 1] += counter[i]; } // 4. 倒序走訪 nums ，將各元素填入結果陣列 res @@ -786,9 +786,7 @@ $$ counter[num as usize] -= 1; // 令前綴和自減 1 ，得到下次放置 num 的索引 } // 使用結果陣列 res 覆蓋原陣列 nums - for i in 0..n { - nums[i] = res[i]; - } + nums.copy_from_slice(&res) } ``` diff --git a/zh-Hant/docs/chapter_sorting/heap_sort.md b/zh-Hant/docs/chapter_sorting/heap_sort.md index 5656885e0..703f3f667 100644 --- a/zh-Hant/docs/chapter_sorting/heap_sort.md +++ b/zh-Hant/docs/chapter_sorting/heap_sort.md @@ -463,9 +463,7 @@ comments: true break; } // 交換兩節點 - let temp = nums[i]; - nums[i] = nums[ma]; - nums[ma] = temp; + nums.swap(i, ma); // 迴圈向下堆積化 i = ma; } @@ -474,15 +472,13 @@ comments: true /* 堆積排序 */ fn heap_sort(nums: &mut [i32]) { // 建堆積操作：堆積化除葉節點以外的其他所有節點 - for i in (0..=nums.len() / 2 - 1).rev() { + for i in (0..nums.len() / 2).rev() { sift_down(nums, nums.len(), i); } // 從堆積中提取最大元素，迴圈 n-1 輪 - for i in (1..=nums.len() - 1).rev() { + for i in (1..nums.len()).rev() { // 交換根節點與最右葉節點（交換首元素與尾元素） - let tmp = nums[0]; - nums[0] = nums[i]; - nums[i] = tmp; + nums.swap(0, i); // 以根節點為起點，從頂至底進行堆積化 sift_down(nums, i, 0); }