gavin/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-03-12 17:51:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2025-09-11 03:53:49 +08:00
parent 3f088184e4
commit ae2e2535f4
24 changed files with 456 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
docs/chapter_array_and_linkedlist/array.md
View File

@@ -21,7 +21,7 @@ comments: true
```python title="array.py"
# 初始化数组
arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: list[int] = [1, 3, 2, 5, 4]
nums: list[int] = [1, 3, 2, 5, 4]
```
=== "C++"
@@ -136,8 +136,8 @@ comments: true
```zig title="array.zig"
// 初始化数组
var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
var nums = [_]i32{ 1, 3, 2, 5, 4 };
const arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
const nums = [_]i32{ 1, 3, 2, 5, 4 };
```
??? pythontutor "可视化运行"
@@ -330,11 +330,11 @@ comments: true
```zig title="array.zig"
// 随机访问元素
fn randomAccess(nums: []i32) i32 {
fn randomAccess(nums: []const i32) i32 {
// 在区间 [0, nums.len) 中随机抽取一个整数
var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
// 获取并返回随机元素
var randomNum = nums[randomIndex];
const randomNum = nums[random_index];
return randomNum;
}
```
@@ -984,18 +984,26 @@ comments: true
```zig title="array.zig"
// 遍历数组
fn traverse(nums: []i32) void {
fn traverse(nums: []const i32) void {
var count: i32 = 0;
// 通过索引遍历数组
var i: i32 = 0;
var i: usize = 0;
while (i < nums.len) : (i += 1) {
count += nums[i];
}
count = 0;
// 直接遍历数组元素
count = 0;
for (nums) |num| {
count += num;
}
// 同时遍历数据索引和元素
for (nums, 0..) |num, index| {
count += nums[index];
count += num;
}
}
```
@@ -1427,12 +1435,14 @@ comments: true
```zig title="array.zig"
// 扩展数组长度
fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
// 初始化一个扩展长度后的数组
var res = try mem_allocator.alloc(i32, nums.len + enlarge);
const res = try allocator.alloc(i32, nums.len + enlarge);
@memset(res, 0);
// 将原数组中的所有元素复制到新数组
std.mem.copy(i32, res, nums);
std.mem.copyForwards(i32, res, nums);
// 返回扩展后的新数组
return res;
}

40
docs/chapter_array_and_linkedlist/linked_list.md
View File

@@ -621,10 +621,10 @@ comments: true
```zig title="linked_list.zig"
// 在链表的节点 n0 之后插入节点 P
fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
P.?.next = n1;
n0.?.next = P;
fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
const n1 = n0.next;
P.next = n1;
n0.next = P;
}
```
@@ -835,12 +835,11 @@ comments: true
```zig title="linked_list.zig"
// 删除链表的节点 n0 之后的首个节点
fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
var P = n0.?.next;
var n1 = P.?.next;
n0.?.next = n1;
fn remove(comptime T: type, n0: *ListNode(T)) void {
// n0 -> P -> n1 => n0 -> n1
const P = n0.next;
const n1 = P.?.next;
n0.next = n1;
}
```
@@ -1052,12 +1051,15 @@ comments: true
```zig title="linked_list.zig"
// 访问链表中索引为 index 的节点
fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
var head: ?*ListNode(T) = node;
var i: i32 = 0;
while (i < index) : (i += 1) {
head = head.?.next;
if (head == null) return null;
if (head) |cur| {
head = cur.next;
} else {
return null;
}
}
return head;
}
@@ -1293,12 +1295,12 @@ comments: true
```zig title="linked_list.zig"
// 在链表中查找值为 target 的首个节点
fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
var head: ?*ListNode(T) = node;
var index: i32 = 0;
while (head != null) {
if (head.?.val == target) return index;
head = head.?.next;
while (head) |cur| {
if (cur.val == target) return index;
head = cur.next;
index += 1;
}
return -1;

234
docs/chapter_array_and_linkedlist/list.md
View File

@@ -2372,121 +2372,157 @@ comments: true
```zig title="my_list.zig"
// 列表类
fn MyList(comptime T: type) type {
return struct {
const Self = @This();
arr: []T = undefined, // 数组（存储列表元素）
arrCapacity: usize = 10, // 列表容量
numSize: usize = 0, // 列表长度（当前元素数量）
extendRatio: usize = 2, // 每次列表扩容的倍数
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 内存分配器
const MyList = struct {
const Self = @This();
// 构造函数（分配内存+初始化列表）
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
if (self.mem_arena == null) {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
@memset(self.arr, @as(T, 0));
}
items: []i32, // 数组（存储列表元素）
capacity: usize, // 列表容量
allocator: std.mem.Allocator, // 内存分配器
// 析构函数（释放内存）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
extend_ratio: usize = 2, // 每次列表扩容的倍数
// 获取列表长度（当前元素数量）
pub fn size(self: *Self) usize {
return self.numSize;
}
// 构造函数（分配内存+初始化列表）
pub fn init(allocator: std.mem.Allocator) Self {
return Self{
.items = &[_]i32{},
.capacity = 0,
.allocator = allocator,
};
}
// 获取列表容量
pub fn capacity(self: *Self) usize {
return self.arrCapacity;
}
// 析构函数（释放内存）
pub fn deinit(self: Self) void {
self.allocator.free(self.allocatedSlice());
}
// 访问元素
pub fn get(self: *Self, index: usize) T {
// 索引如果越界，则抛出异常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
return self.arr[index];
}
// 在尾部添加元素
pub fn add(self: *Self, item: i32) !void {
// 元素数量超出容量时，触发扩容机制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 更新元素
pub fn set(self: *Self, index: usize, num: T) void {
// 索引如果越界，则抛出异常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
self.arr[index] = num;
}
self.items.len += 1;
const new_item_ptr = &self.items[self.items.len - 1];
new_item_ptr.* = item;
}
// 在尾部添加元素
pub fn add(self: *Self, num: T) !void {
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
self.arr[self.size()] = num;
// 更新元素数量
self.numSize += 1;
}
// 获取列表长度（当前元素数量）
pub fn getSize(self: *Self) usize {
return self.items.len;
}
// 在中间插入元素
pub fn insert(self: *Self, index: usize, num: T) !void {
if (index < 0 or index >= self.size()) @panic("索引越界");
// 元素数量超出容量时，触发扩容机制
if (self.size() == self.capacity()) try self.extendCapacity();
// 将索引 index 以及之后的元素都向后移动一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.arr[j + 1] = self.arr[j];
// 获取列表容量
pub fn getCapacity(self: *Self) usize {
return self.capacity;
}
// 访问元素
pub fn get(self: *Self, index: usize) i32 {
// 索引如果越界，则抛出异常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
return self.items[index];
}
// 更新元素
pub fn set(self: *Self, index: usize, num: i32) void {
// 索引如果越界，则抛出异常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
self.items[index] = num;
}
// 在中间插入元素
pub fn insert(self: *Self, index: usize, item: i32) !void {
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
// 元素数量超出容量时，触发扩容机制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 将索引 index 以及之后的元素都向后移动一位
self.items.len += 1;
var i = self.items.len - 1;
while (i >= index) : (i -= 1) {
self.items[i] = self.items[i - 1];
}
self.items[index] = item;
}
// 删除元素
pub fn remove(self: *Self, index: usize) i32 {
if (index < 0 or index >= self.getSize()) {
@panic("索引越界");
}
// 将索引 index 之后的元素都向前移动一位
const item = self.items[index];
var i = index;
while (i < self.items.len - 1) : (i += 1) {
self.items[i] = self.items[i + 1];
}
self.items.len -= 1;
// 返回被删除的元素
return item;
}
// 将列表转换为数组
pub fn toArraySlice(self: *Self) ![]i32 {
return self.toOwnedSlice(false);
}
// 返回新的切片并设置是否要重置或清空列表容器
pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
const allocator = self.allocator;
const old_memory = self.allocatedSlice();
if (allocator.remap(old_memory, self.items.len)) |new_items| {
if (clear) {
self.* = init(allocator);
}
self.arr[index] = num;
// 更新元素数量
self.numSize += 1;
return new_items;
}
// 删除元素
pub fn remove(self: *Self, index: usize) T {
if (index < 0 or index >= self.size()) @panic("索引越界");
var num = self.arr[index];
// 将索引 index 之后的元素都向前移动一位
var j = index;
while (j < self.size() - 1) : (j += 1) {
self.arr[j] = self.arr[j + 1];
}
// 更新元素数量
self.numSize -= 1;
// 返回被删除的元素
return num;
const new_memory = try allocator.alloc(i32, self.items.len);
@memcpy(new_memory, self.items);
if (clear) {
self.clearAndFree();
}
return new_memory;
}
// 列表扩容
pub fn extendCapacity(self: *Self) !void {
// 新建一个长度为 size * extendRatio 的数组，并将原数组复制到新数组
var newCapacity = self.capacity() * self.extendRatio;
var extend = try self.mem_allocator.alloc(T, newCapacity);
@memset(extend, @as(T, 0));
// 将原数组中的所有元素复制到新数组
std.mem.copy(T, extend, self.arr);
self.arr = extend;
// 更新列表容量
self.arrCapacity = newCapacity;
}
// 列表扩容
fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
if (self.capacity >= new_capacity) return;
const capcacity = if (self.capacity == 0) 10 else self.capacity;
const better_capacity = capcacity * self.extend_ratio;
// 将列表转换为数组
pub fn toArray(self: *Self) ![]T {
// 仅转换有效长度范围内的列表元素
var arr = try self.mem_allocator.alloc(T, self.size());
@memset(arr, @as(T, 0));
for (arr, 0..) |*num, i| {
num.* = self.get(i);
}
return arr;
const old_memory = self.allocatedSlice();
if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
} else {
const new_memory = try self.allocator.alloc(i32, better_capacity);
@memcpy(new_memory[0..self.items.len], self.items);
self.allocator.free(old_memory);
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
}
};
}
}
fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
allocator.free(self.allocatedSlice());
self.items.len = 0;
self.capacity = 0;
}
fn allocatedSlice(self: Self) []i32 {
return self.items.ptr[0..self.capacity];
}
};
```
??? pythontutor "可视化运行"

26
docs/chapter_computational_complexity/iteration_and_recursion.md
View File

@@ -205,11 +205,11 @@ comments: true
fn forLoop(n: usize) i32 {
var res: i32 = 0;
// 循环求和 1, 2, ..., n-1, n
for (1..n+1) |i| {
res = res + @as(i32, @intCast(i));
for (1..n + 1) |i| {
res += @intCast(i);
}
return res;
}
}
```
??? pythontutor "可视化运行"
@@ -450,9 +450,8 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化条件变量
// 循环求和 1, 2, ..., n-1, n
while (i <= n) {
while (i <= n) : (i += 1) {
res += @intCast(i);
i += 1;
}
return res;
}
@@ -711,11 +710,12 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化条件变量
// 循环求和 1, 4, 10, ...
while (i <= n) {
res += @intCast(i);
while (i <= n) : ({
// 更新条件变量
i += 1;
i *= 2;
}) {
res += @intCast(i);
}
return res;
}
@@ -965,11 +965,11 @@ comments: true
defer res.deinit();
var buffer: [20]u8 = undefined;
// 循环 i = 1, 2, ..., n-1, n
for (1..n+1) |i| {
for (1..n + 1) |i| {
// 循环 j = 1, 2, ..., n-1, n
for (1..n+1) |j| {
var _str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{i, j});
try res.appendSlice(_str);
for (1..n + 1) |j| {
const str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{ i, j });
try res.appendSlice(str);
}
}
return res.toOwnedSlice();
@@ -1209,7 +1209,7 @@ comments: true
return 1;
}
// 递：递归调用
var res: i32 = recur(n - 1);
const res = recur(n - 1);
// 归：返回结果
return n + res;
}
@@ -1678,7 +1678,7 @@ comments: true
return n - 1;
}
// 递归调用 f(n) = f(n-1) + f(n-2)
var res: i32 = fib(n - 1) + fib(n - 2);
const res: i32 = fib(n - 1) + fib(n - 2);
// 返回结果 f(n)
return res;
}

4
docs/chapter_computational_complexity/performance_evaluation.md
View File

@@ -30,10 +30,10 @@ comments: true
由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为<u>渐近复杂度分析（asymptotic complexity analysis）</u>，简称<u>复杂度分析</u>。
复杂度分析能够体现算法运行所需的时间和空间资源与输入数据大小之间的关系。**它描述了随着输入数据大小的增加，算法执行所需时间和空间的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
复杂度分析能够体现算法运行所需的时间和空间资源与输入数据规模之间的关系。**它描述了随着输入数据规模的增加，算法执行所需时间和空间的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
- “时间和空间资源”分别对应<u>时间复杂度（time complexity）</u>和<u>空间复杂度（space complexity）</u>。
- “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
- “随着输入数据规模的增加”意味着复杂度反映了算法运行效率与输入数据规模之间的关系。
- “时间和空间的增长趋势”表示复杂度分析关注的不是运行时间或占用空间的具体值，而是时间或空间增长的“快慢”。
**复杂度分析克服了实际测试方法的弊端**，体现在以下几个方面。

22
docs/chapter_computational_complexity/space_complexity.md
View File

@@ -1208,13 +1208,13 @@ $$
fn constant(n: i32) void {
// 常量、变量、对象占用 O(1) 空间
const a: i32 = 0;
var b: i32 = 0;
var nums = [_]i32{0}**10000;
var node = inc.ListNode(i32){.val = 0};
const b: i32 = 0;
const nums = [_]i32{0} ** 10000;
const node = ListNode(i32){ .val = 0 };
var i: i32 = 0;
// 循环中的变量占用 O(1) 空间
while (i < n) : (i += 1) {
var c: i32 = 0;
const c: i32 = 0;
_ = c;
}
// 循环中的函数占用 O(1) 空间
@@ -1513,7 +1513,7 @@ $$
// 线性阶
fn linear(comptime n: i32) !void {
// 长度为 n 的数组占用 O(n) 空间
var nums = [_]i32{0}**n;
const nums = [_]i32{0} ** n;
// 长度为 n 的列表占用 O(n) 空间
var nodes = std.ArrayList(i32).init(std.heap.page_allocator);
defer nodes.deinit();
@@ -2146,8 +2146,8 @@ $$
// 平方阶（递归实现）
fn quadraticRecur(comptime n: i32) i32 {
if (n <= 0) return 0;
var nums = [_]i32{0}**n;
std.debug.print("递归 n = {} 中的 nums 长度 = {}\n", .{n, nums.len});
const nums = [_]i32{0} ** n;
std.debug.print("递归 n = {} 中的 nums 长度 = {}\n", .{ n, nums.len });
return quadraticRecur(n - 1);
}
```
@@ -2350,12 +2350,12 @@ $$
```zig title="space_complexity.zig"
// 指数阶（建立满二叉树）
fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
fn buildTree(allocator: std.mem.Allocator, n: i32) !?*TreeNode(i32) {
if (n == 0) return null;
const root = try mem_allocator.create(inc.TreeNode(i32));
const root = try allocator.create(TreeNode(i32));
root.init(0);
root.left = try buildTree(mem_allocator, n - 1);
root.right = try buildTree(mem_allocator, n - 1);
root.left = try buildTree(allocator, n - 1);
root.right = try buildTree(allocator, n - 1);
return root;
}
```

20
docs/chapter_computational_complexity/time_complexity.md
View File

@@ -1275,7 +1275,7 @@ $$
var count: i32 = 0;
const size: i32 = 100_000;
var i: i32 = 0;
while(i<size) : (i += 1) {
while (i < size) : (i += 1) {
count += 1;
}
return count;
@@ -2215,7 +2215,7 @@ $$
```zig title="time_complexity.zig"
// 平方阶（冒泡排序）
fn bubbleSort(nums: []i32) i32 {
var count: i32 = 0; // 计数器
var count: i32 = 0; // 计数器
// 外循环：未排序区间为 [0, i]
var i: i32 = @as(i32, @intCast(nums.len)) - 1;
while (i > 0) : (i -= 1) {
@@ -2224,10 +2224,10 @@ $$
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
var tmp = nums[j];
const tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交换包含 3 个单元操作
count += 3; // 元素交换包含 3 个单元操作
}
}
}
@@ -2870,11 +2870,9 @@ $$
// 对数阶（循环实现）
fn logarithmic(n: i32) i32 {
var count: i32 = 0;
var n_var = n;
while (n_var > 1)
{
n_var = n_var / 2;
count +=1;
var n_var: i32 = n;
while (n_var > 1) : (n_var = @divTrunc(n_var, 2)) {
count += 1;
}
return count;
}
@@ -3037,7 +3035,7 @@ $$
// 对数阶（递归实现）
fn logRecur(n: i32) i32 {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
return logRecur(@divTrunc(n, 2)) + 1;
}
```
@@ -3261,7 +3259,7 @@ $$
// 线性对数阶
fn linearLogRecur(n: i32) i32 {
if (n <= 1) return 1;
var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);
var count: i32 = linearLogRecur(@divTrunc(n, 2)) + linearLogRecur(@divTrunc(n, 2));
var i: i32 = 0;
while (i < n) : (i += 1) {
count += 1;

2
docs/chapter_dynamic_programming/dp_solution_pipeline.md
View File

@@ -417,7 +417,7 @@ $$
<p align="center"> 图 14-14 &nbsp; 暴力搜索递归树 </p>
每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 $m + n - 2$ 步，所以最差时间复杂度为 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分别为网格的行数和列数。请注意，这种计算方式未考虑临近网格边界的情况，当到达网络边界时只剩下一种选择，因此实际的路径数量会少一些。
每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 $m + n - 2$ 步，所以最差时间复杂度为 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分别为网格的行数和列数。请注意，这种计算方式未考虑临近网格边界的情况，当到达网格边界时只剩下一种选择，因此实际的路径数量会少一些。
### 2. &nbsp; 方法二：记忆化搜索

29
docs/chapter_graph/graph_operations.md
View File

@@ -882,7 +882,7 @@ comments: true
// 在邻接矩阵中添加一行
self.adj_mat.push(vec![0; n]);
// 在邻接矩阵中添加一列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.push(0);
}
}
@@ -897,7 +897,7 @@ comments: true
// 在邻接矩阵中删除索引 index 的行
self.adj_mat.remove(index);
// 在邻接矩阵中删除索引 index 的列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.remove(index);
}
}
@@ -1982,7 +1982,7 @@ comments: true
/* 基于邻接表实现的无向图类型 */
pub struct GraphAdjList {
// 邻接表，key：顶点，value：该顶点的所有邻接顶点
pub adj_list: HashMap<Vertex, Vec<Vertex>>,
pub adj_list: HashMap<Vertex, Vec<Vertex>>, // maybe HashSet<Vertex> for value part is better?
}
impl GraphAdjList {
@@ -2009,31 +2009,27 @@ comments: true
/* 添加边 */
pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 添加边 vet1 - vet2
self.adj_list.get_mut(&vet1).unwrap().push(vet2);
self.adj_list.get_mut(&vet2).unwrap().push(vet1);
self.adj_list.entry(vet1).or_default().push(vet2);
self.adj_list.entry(vet2).or_default().push(vet1);
}
/* 删除边 */
#[allow(unused)]
pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 删除边 vet1 - vet2
self.adj_list
.get_mut(&vet1)
.unwrap()
.retain(|&vet| vet != vet2);
.entry(vet1)
.and_modify(|v| v.retain(|&e| e != vet2));
self.adj_list
.get_mut(&vet2)
.unwrap()
.retain(|&vet| vet != vet1);
.entry(vet2)
.and_modify(|v| v.retain(|&e| e != vet1));
}
/* 添加顶点 */
@@ -2048,9 +2044,6 @@ comments: true
/* 删除顶点 */
#[allow(unused)]
pub fn remove_vertex(&mut self, vet: Vertex) {
if !self.adj_list.contains_key(&vet) {
panic!("value error");
}
// 在邻接表中删除顶点 vet 对应的链表
self.adj_list.remove(&vet);
// 遍历其他顶点的链表，删除所有包含 vet 的边

3
docs/chapter_graph/graph_traversal.md
View File

@@ -324,8 +324,7 @@ BFS 通常借助队列来实现，代码如下所示。队列具有“先入先
let mut que = VecDeque::new();
que.push_back(start_vet);
// 以顶点 vet 为起点，循环直至访问完所有顶点
while !que.is_empty() {
let vet = que.pop_front().unwrap(); // 队首顶点出队
while let Some(vet) = que.pop_front() {
res.push(vet); // 记录访问顶点
// 遍历该顶点的所有邻接顶点

2
docs/chapter_searching/searching_algorithm_revisited.md
View File

@@ -65,7 +65,7 @@ comments: true
</div>
搜索算法的选择还取决于数据体量、搜索性能要求、数据查询与更新频率等。
搜索算法的选择还取决规模、搜索性能要求、数据查询与更新频率等。
**线性搜索**

2
docs/chapter_searching/summary.md
View File

@@ -7,6 +7,6 @@ comments: true
- 二分查找依赖数据的有序性，通过循环逐步缩减一半搜索区间来进行查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据进行预处理，但时间复杂度 $O(n)$ 较高。
- 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 $O(\log n)$ 甚至 $O(1)$ ，但通常需要借助额外数据结构。
- 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
- 实际中，我们需要对数据规模、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适用于对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
- 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 $O(n)$ 降至 $O(1)$ 。

34
zh-Hant/docs/chapter_array_and_linkedlist/array.md
View File

@@ -21,7 +21,7 @@ comments: true
```python title="array.py"
# 初始化陣列
arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: list[int] = [1, 3, 2, 5, 4]
nums: list[int] = [1, 3, 2, 5, 4]
```
=== "C++"
@@ -136,8 +136,8 @@ comments: true
```zig title="array.zig"
// 初始化陣列
var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
var nums = [_]i32{ 1, 3, 2, 5, 4 };
const arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
const nums = [_]i32{ 1, 3, 2, 5, 4 };
```
??? pythontutor "視覺化執行"
@@ -330,11 +330,11 @@ comments: true
```zig title="array.zig"
// 隨機訪問元素
fn randomAccess(nums: []i32) i32 {
fn randomAccess(nums: []const i32) i32 {
// 在區間 [0, nums.len) 中隨機抽取一個整數
var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
// 獲取並返回隨機元素
var randomNum = nums[randomIndex];
const randomNum = nums[random_index];
return randomNum;
}
```
@@ -984,18 +984,26 @@ comments: true
```zig title="array.zig"
// 走訪陣列
fn traverse(nums: []i32) void {
fn traverse(nums: []const i32) void {
var count: i32 = 0;
// 透過索引走訪陣列
var i: i32 = 0;
var i: usize = 0;
while (i < nums.len) : (i += 1) {
count += nums[i];
}
count = 0;
// 直接走訪陣列元素
count = 0;
for (nums) |num| {
count += num;
}
// 同時走訪資料索引和元素
for (nums, 0..) |num, index| {
count += nums[index];
count += num;
}
}
```
@@ -1427,12 +1435,14 @@ comments: true
```zig title="array.zig"
// 擴展陣列長度
fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
// 初始化一個擴展長度後的陣列
var res = try mem_allocator.alloc(i32, nums.len + enlarge);
const res = try allocator.alloc(i32, nums.len + enlarge);
@memset(res, 0);
// 將原陣列中的所有元素複製到新陣列
std.mem.copy(i32, res, nums);
std.mem.copyForwards(i32, res, nums);
// 返回擴展後的新陣列
return res;
}

40
zh-Hant/docs/chapter_array_and_linkedlist/linked_list.md
View File

@@ -621,10 +621,10 @@ comments: true
```zig title="linked_list.zig"
// 在鏈結串列的節點 n0 之後插入節點 P
fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
P.?.next = n1;
n0.?.next = P;
fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
const n1 = n0.next;
P.next = n1;
n0.next = P;
}
```
@@ -835,12 +835,11 @@ comments: true
```zig title="linked_list.zig"
// 刪除鏈結串列的節點 n0 之後的首個節點
fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
var P = n0.?.next;
var n1 = P.?.next;
n0.?.next = n1;
fn remove(comptime T: type, n0: *ListNode(T)) void {
// n0 -> P -> n1 => n0 -> n1
const P = n0.next;
const n1 = P.?.next;
n0.next = n1;
}
```
@@ -1052,12 +1051,15 @@ comments: true
```zig title="linked_list.zig"
// 訪問鏈結串列中索引為 index 的節點
fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
var head: ?*ListNode(T) = node;
var i: i32 = 0;
while (i < index) : (i += 1) {
head = head.?.next;
if (head == null) return null;
if (head) |cur| {
head = cur.next;
} else {
return null;
}
}
return head;
}
@@ -1293,12 +1295,12 @@ comments: true
```zig title="linked_list.zig"
// 在鏈結串列中查詢值為 target 的首個節點
fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
var head: ?*ListNode(T) = node;
var index: i32 = 0;
while (head != null) {
if (head.?.val == target) return index;
head = head.?.next;
while (head) |cur| {
if (cur.val == target) return index;
head = cur.next;
index += 1;
}
return -1;

234
zh-Hant/docs/chapter_array_and_linkedlist/list.md
View File

@@ -2372,121 +2372,157 @@ comments: true
```zig title="my_list.zig"
// 串列類別
fn MyList(comptime T: type) type {
return struct {
const Self = @This();
arr: []T = undefined, // 陣列（儲存串列元素）
arrCapacity: usize = 10, // 串列容量
numSize: usize = 0, // 串列長度（當前元素數量）
extendRatio: usize = 2, // 每次串列擴容的倍數
mem_arena: ?std.heap.ArenaAllocator = null,
mem_allocator: std.mem.Allocator = undefined, // 記憶體分配器
const MyList = struct {
const Self = @This();
// 建構子（分配記憶體+初始化串列）
pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
if (self.mem_arena == null) {
self.mem_arena = std.heap.ArenaAllocator.init(allocator);
self.mem_allocator = self.mem_arena.?.allocator();
}
self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
@memset(self.arr, @as(T, 0));
}
items: []i32, // 陣列（儲存串列元素）
capacity: usize, // 串列容量
allocator: std.mem.Allocator, // 記憶體分配器
// 析構函式（釋放記憶體）
pub fn deinit(self: *Self) void {
if (self.mem_arena == null) return;
self.mem_arena.?.deinit();
}
extend_ratio: usize = 2, // 每次串列擴容的倍數
// 獲取串列長度（當前元素數量）
pub fn size(self: *Self) usize {
return self.numSize;
}
// 建構子（分配記憶體+初始化串列）
pub fn init(allocator: std.mem.Allocator) Self {
return Self{
.items = &[_]i32{},
.capacity = 0,
.allocator = allocator,
};
}
// 獲取串列容量
pub fn capacity(self: *Self) usize {
return self.arrCapacity;
}
// 析構函式（釋放記憶體）
pub fn deinit(self: Self) void {
self.allocator.free(self.allocatedSlice());
}
// 訪問元素
pub fn get(self: *Self, index: usize) T {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
return self.arr[index];
}
// 在尾部新增元素
pub fn add(self: *Self, item: i32) !void {
// 元素數量超出容量時，觸發擴容機制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 更新元素
pub fn set(self: *Self, index: usize, num: T) void {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.size()) @panic("索引越界");
self.arr[index] = num;
}
self.items.len += 1;
const new_item_ptr = &self.items[self.items.len - 1];
new_item_ptr.* = item;
}
// 在尾部新增元素
pub fn add(self: *Self, num: T) !void {
// 元素數量超出容量時，觸發擴容機制
if (self.size() == self.capacity()) try self.extendCapacity();
self.arr[self.size()] = num;
// 更新元素數量
self.numSize += 1;
}
// 獲取串列長度（當前元素數量）
pub fn getSize(self: *Self) usize {
return self.items.len;
}
// 在中間插入元素
pub fn insert(self: *Self, index: usize, num: T) !void {
if (index < 0 or index >= self.size()) @panic("索引越界");
// 元素數量超出容量時，觸發擴容機制
if (self.size() == self.capacity()) try self.extendCapacity();
// 將索引 index 以及之後的元素都向後移動一位
var j = self.size() - 1;
while (j >= index) : (j -= 1) {
self.arr[j + 1] = self.arr[j];
// 獲取串列容量
pub fn getCapacity(self: *Self) usize {
return self.capacity;
}
// 訪問元素
pub fn get(self: *Self, index: usize) i32 {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
return self.items[index];
}
// 更新元素
pub fn set(self: *Self, index: usize, num: i32) void {
// 索引如果越界，則丟擲異常，下同
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
self.items[index] = num;
}
// 在中間插入元素
pub fn insert(self: *Self, index: usize, item: i32) !void {
if (index < 0 or index >= self.items.len) {
@panic("索引越界");
}
// 元素數量超出容量時，觸發擴容機制
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
// 將索引 index 以及之後的元素都向後移動一位
self.items.len += 1;
var i = self.items.len - 1;
while (i >= index) : (i -= 1) {
self.items[i] = self.items[i - 1];
}
self.items[index] = item;
}
// 刪除元素
pub fn remove(self: *Self, index: usize) i32 {
if (index < 0 or index >= self.getSize()) {
@panic("索引越界");
}
// 將索引 index 之後的元素都向前移動一位
const item = self.items[index];
var i = index;
while (i < self.items.len - 1) : (i += 1) {
self.items[i] = self.items[i + 1];
}
self.items.len -= 1;
// 返回被刪除的元素
return item;
}
// 將串列轉換為陣列
pub fn toArraySlice(self: *Self) ![]i32 {
return self.toOwnedSlice(false);
}
// 返回新的切片並設定是否要重置或清空串列容器
pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
const allocator = self.allocator;
const old_memory = self.allocatedSlice();
if (allocator.remap(old_memory, self.items.len)) |new_items| {
if (clear) {
self.* = init(allocator);
}
self.arr[index] = num;
// 更新元素數量
self.numSize += 1;
return new_items;
}
// 刪除元素
pub fn remove(self: *Self, index: usize) T {
if (index < 0 or index >= self.size()) @panic("索引越界");
var num = self.arr[index];
// 將索引 index 之後的元素都向前移動一位
var j = index;
while (j < self.size() - 1) : (j += 1) {
self.arr[j] = self.arr[j + 1];
}
// 更新元素數量
self.numSize -= 1;
// 返回被刪除的元素
return num;
const new_memory = try allocator.alloc(i32, self.items.len);
@memcpy(new_memory, self.items);
if (clear) {
self.clearAndFree();
}
return new_memory;
}
// 串列擴容
pub fn extendCapacity(self: *Self) !void {
// 新建一個長度為 size * extendRatio 的陣列，並將原陣列複製到新陣列
var newCapacity = self.capacity() * self.extendRatio;
var extend = try self.mem_allocator.alloc(T, newCapacity);
@memset(extend, @as(T, 0));
// 將原陣列中的所有元素複製到新陣列
std.mem.copy(T, extend, self.arr);
self.arr = extend;
// 更新串列容量
self.arrCapacity = newCapacity;
}
// 串列擴容
fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
if (self.capacity >= new_capacity) return;
const capcacity = if (self.capacity == 0) 10 else self.capacity;
const better_capacity = capcacity * self.extend_ratio;
// 將串列轉換為陣列
pub fn toArray(self: *Self) ![]T {
// 僅轉換有效長度範圍內的串列元素
var arr = try self.mem_allocator.alloc(T, self.size());
@memset(arr, @as(T, 0));
for (arr, 0..) |*num, i| {
num.* = self.get(i);
}
return arr;
const old_memory = self.allocatedSlice();
if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
} else {
const new_memory = try self.allocator.alloc(i32, better_capacity);
@memcpy(new_memory[0..self.items.len], self.items);
self.allocator.free(old_memory);
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
}
};
}
}
fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
allocator.free(self.allocatedSlice());
self.items.len = 0;
self.capacity = 0;
}
fn allocatedSlice(self: Self) []i32 {
return self.items.ptr[0..self.capacity];
}
};
```
??? pythontutor "視覺化執行"

26
zh-Hant/docs/chapter_computational_complexity/iteration_and_recursion.md
View File

@@ -205,11 +205,11 @@ comments: true
fn forLoop(n: usize) i32 {
var res: i32 = 0;
// 迴圈求和 1, 2, ..., n-1, n
for (1..n+1) |i| {
res = res + @as(i32, @intCast(i));
for (1..n + 1) |i| {
res += @intCast(i);
}
return res;
}
}
```
??? pythontutor "視覺化執行"
@@ -450,9 +450,8 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化條件變數
// 迴圈求和 1, 2, ..., n-1, n
while (i <= n) {
while (i <= n) : (i += 1) {
res += @intCast(i);
i += 1;
}
return res;
}
@@ -711,11 +710,12 @@ comments: true
var res: i32 = 0;
var i: i32 = 1; // 初始化條件變數
// 迴圈求和 1, 4, 10, ...
while (i <= n) {
res += @intCast(i);
while (i <= n) : ({
// 更新條件變數
i += 1;
i *= 2;
}) {
res += @intCast(i);
}
return res;
}
@@ -965,11 +965,11 @@ comments: true
defer res.deinit();
var buffer: [20]u8 = undefined;
// 迴圈 i = 1, 2, ..., n-1, n
for (1..n+1) |i| {
for (1..n + 1) |i| {
// 迴圈 j = 1, 2, ..., n-1, n
for (1..n+1) |j| {
var _str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{i, j});
try res.appendSlice(_str);
for (1..n + 1) |j| {
const str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{ i, j });
try res.appendSlice(str);
}
}
return res.toOwnedSlice();
@@ -1209,7 +1209,7 @@ comments: true
return 1;
}
// 遞：遞迴呼叫
var res: i32 = recur(n - 1);
const res = recur(n - 1);
// 迴：返回結果
return n + res;
}
@@ -1678,7 +1678,7 @@ comments: true
return n - 1;
}
// 遞迴呼叫 f(n) = f(n-1) + f(n-2)
var res: i32 = fib(n - 1) + fib(n - 2);
const res: i32 = fib(n - 1) + fib(n - 2);
// 返回結果 f(n)
return res;
}

4
zh-Hant/docs/chapter_computational_complexity/performance_evaluation.md
View File

@@ -30,10 +30,10 @@ comments: true
由於實際測試具有較大的侷限性，我們可以考慮僅透過一些計算來評估演算法的效率。這種估算方法被稱為<u>漸近複雜度分析（asymptotic complexity analysis）</u>，簡稱<u>複雜度分析</u>。
複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料大小之間的關係。**它描述了隨著輸入資料大小的增加，演算法執行所需時間和空間的增長趨勢**。這個定義有些拗口，我們可以將其分為三個重點來理解。
複雜度分析能夠體現演算法執行所需的時間和空間資源與輸入資料規模之間的關係。**它描述了隨著輸入資料規模的增加，演算法執行所需時間和空間的增長趨勢**。這個定義有些拗口，我們可以將其分為三個重點來理解。
- “時間和空間資源”分別對應<u>時間複雜度（time complexity）</u>和<u>空間複雜度（space complexity）</u>。
- “隨著輸入資料大小的增加”意味著複雜度反映了演算法執行效率與輸入資料體量之間的關係。
- “隨著輸入資料規模的增加”意味著複雜度反映了演算法執行效率與輸入資料規模之間的關係。
- “時間和空間的增長趨勢”表示複雜度分析關注的不是執行時間或佔用空間的具體值，而是時間或空間增長的“快慢”。
**複雜度分析克服了實際測試方法的弊端**，體現在以下幾個方面。

22
zh-Hant/docs/chapter_computational_complexity/space_complexity.md
View File

@@ -1208,13 +1208,13 @@ $$
fn constant(n: i32) void {
// 常數、變數、物件佔用 O(1) 空間
const a: i32 = 0;
var b: i32 = 0;
var nums = [_]i32{0}**10000;
var node = inc.ListNode(i32){.val = 0};
const b: i32 = 0;
const nums = [_]i32{0} ** 10000;
const node = ListNode(i32){ .val = 0 };
var i: i32 = 0;
// 迴圈中的變數佔用 O(1) 空間
while (i < n) : (i += 1) {
var c: i32 = 0;
const c: i32 = 0;
_ = c;
}
// 迴圈中的函式佔用 O(1) 空間
@@ -1513,7 +1513,7 @@ $$
// 線性階
fn linear(comptime n: i32) !void {
// 長度為 n 的陣列佔用 O(n) 空間
var nums = [_]i32{0}**n;
const nums = [_]i32{0} ** n;
// 長度為 n 的串列佔用 O(n) 空間
var nodes = std.ArrayList(i32).init(std.heap.page_allocator);
defer nodes.deinit();
@@ -2146,8 +2146,8 @@ $$
// 平方階（遞迴實現）
fn quadraticRecur(comptime n: i32) i32 {
if (n <= 0) return 0;
var nums = [_]i32{0}**n;
std.debug.print("遞迴 n = {} 中的 nums 長度 = {}\n", .{n, nums.len});
const nums = [_]i32{0} ** n;
std.debug.print("遞迴 n = {} 中的 nums 長度 = {}\n", .{ n, nums.len });
return quadraticRecur(n - 1);
}
```
@@ -2350,12 +2350,12 @@ $$
```zig title="space_complexity.zig"
// 指數階（建立滿二元樹）
fn buildTree(mem_allocator: std.mem.Allocator, n: i32) !?*inc.TreeNode(i32) {
fn buildTree(allocator: std.mem.Allocator, n: i32) !?*TreeNode(i32) {
if (n == 0) return null;
const root = try mem_allocator.create(inc.TreeNode(i32));
const root = try allocator.create(TreeNode(i32));
root.init(0);
root.left = try buildTree(mem_allocator, n - 1);
root.right = try buildTree(mem_allocator, n - 1);
root.left = try buildTree(allocator, n - 1);
root.right = try buildTree(allocator, n - 1);
return root;
}
```

20
zh-Hant/docs/chapter_computational_complexity/time_complexity.md
View File

@@ -1275,7 +1275,7 @@ $$
var count: i32 = 0;
const size: i32 = 100_000;
var i: i32 = 0;
while(i<size) : (i += 1) {
while (i < size) : (i += 1) {
count += 1;
}
return count;
@@ -2215,7 +2215,7 @@ $$
```zig title="time_complexity.zig"
// 平方階（泡沫排序）
fn bubbleSort(nums: []i32) i32 {
var count: i32 = 0; // 計數器
var count: i32 = 0; // 計數器
// 外迴圈：未排序區間為 [0, i]
var i: i32 = @as(i32, @intCast(nums.len)) - 1;
while (i > 0) : (i -= 1) {
@@ -2224,10 +2224,10 @@ $$
while (j < i) : (j += 1) {
if (nums[j] > nums[j + 1]) {
// 交換 nums[j] 與 nums[j + 1]
var tmp = nums[j];
const tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交換包含 3 個單元操作
count += 3; // 元素交換包含 3 個單元操作
}
}
}
@@ -2870,11 +2870,9 @@ $$
// 對數階（迴圈實現）
fn logarithmic(n: i32) i32 {
var count: i32 = 0;
var n_var = n;
while (n_var > 1)
{
n_var = n_var / 2;
count +=1;
var n_var: i32 = n;
while (n_var > 1) : (n_var = @divTrunc(n_var, 2)) {
count += 1;
}
return count;
}
@@ -3037,7 +3035,7 @@ $$
// 對數階（遞迴實現）
fn logRecur(n: i32) i32 {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
return logRecur(@divTrunc(n, 2)) + 1;
}
```
@@ -3261,7 +3259,7 @@ $$
// 線性對數階
fn linearLogRecur(n: i32) i32 {
if (n <= 1) return 1;
var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);
var count: i32 = linearLogRecur(@divTrunc(n, 2)) + linearLogRecur(@divTrunc(n, 2));
var i: i32 = 0;
while (i < n) : (i += 1) {
count += 1;

2
zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md
View File

@@ -417,7 +417,7 @@ $$
<p align="center"> 圖 14-14 &nbsp; 暴力搜尋遞迴樹 </p>
每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 $m + n - 2$ 步，所以最差時間複雜度為 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網路邊界時只剩下一種選擇，因此實際的路徑數量會少一些。
每個狀態都有向下和向右兩種選擇，從左上角走到右下角總共需要 $m + n - 2$ 步，所以最差時間複雜度為 $O(2^{m + n})$ ，其中 $n$ 和 $m$ 分別為網格的行數和列數。請注意，這種計算方式未考慮臨近網格邊界的情況，當到達網格邊界時只剩下一種選擇，因此實際的路徑數量會少一些。
### 2. &nbsp; 方法二：記憶化搜尋

29
zh-Hant/docs/chapter_graph/graph_operations.md
View File

@@ -882,7 +882,7 @@ comments: true
// 在鄰接矩陣中新增一行
self.adj_mat.push(vec![0; n]);
// 在鄰接矩陣中新增一列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.push(0);
}
}
@@ -897,7 +897,7 @@ comments: true
// 在鄰接矩陣中刪除索引 index 的行
self.adj_mat.remove(index);
// 在鄰接矩陣中刪除索引 index 的列
for row in &mut self.adj_mat {
for row in self.adj_mat.iter_mut() {
row.remove(index);
}
}
@@ -1982,7 +1982,7 @@ comments: true
/* 基於鄰接表實現的無向圖型別 */
pub struct GraphAdjList {
// 鄰接表，key：頂點，value：該頂點的所有鄰接頂點
pub adj_list: HashMap<Vertex, Vec<Vertex>>,
pub adj_list: HashMap<Vertex, Vec<Vertex>>, // maybe HashSet<Vertex> for value part is better?
}
impl GraphAdjList {
@@ -2009,31 +2009,27 @@ comments: true
/* 新增邊 */
pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 新增邊 vet1 - vet2
self.adj_list.get_mut(&vet1).unwrap().push(vet2);
self.adj_list.get_mut(&vet2).unwrap().push(vet1);
self.adj_list.entry(vet1).or_default().push(vet2);
self.adj_list.entry(vet2).or_default().push(vet1);
}
/* 刪除邊 */
#[allow(unused)]
pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {
if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
{
if vet1 == vet2 {
panic!("value error");
}
// 刪除邊 vet1 - vet2
self.adj_list
.get_mut(&vet1)
.unwrap()
.retain(|&vet| vet != vet2);
.entry(vet1)
.and_modify(|v| v.retain(|&e| e != vet2));
self.adj_list
.get_mut(&vet2)
.unwrap()
.retain(|&vet| vet != vet1);
.entry(vet2)
.and_modify(|v| v.retain(|&e| e != vet1));
}
/* 新增頂點 */
@@ -2048,9 +2044,6 @@ comments: true
/* 刪除頂點 */
#[allow(unused)]
pub fn remove_vertex(&mut self, vet: Vertex) {
if !self.adj_list.contains_key(&vet) {
panic!("value error");
}
// 在鄰接表中刪除頂點 vet 對應的鏈結串列
self.adj_list.remove(&vet);
// 走訪其他頂點的鏈結串列，刪除所有包含 vet 的邊

3
zh-Hant/docs/chapter_graph/graph_traversal.md
View File

@@ -324,8 +324,7 @@ BFS 通常藉助佇列來實現，程式碼如下所示。佇列具有“先入
let mut que = VecDeque::new();
que.push_back(start_vet);
// 以頂點 vet 為起點，迴圈直至訪問完所有頂點
while !que.is_empty() {
let vet = que.pop_front().unwrap(); // 佇列首頂點出隊
while let Some(vet) = que.pop_front() {
res.push(vet); // 記錄訪問頂點
// 走訪該頂點的所有鄰接頂點

2
zh-Hant/docs/chapter_searching/searching_algorithm_revisited.md
View File

@@ -65,7 +65,7 @@ comments: true
</div>
搜尋演算法的選擇還取決於資料體量、搜尋效能要求、資料查詢與更新頻率等。
搜尋演算法的選擇還取決規模、搜尋效能要求、資料查詢與更新頻率等。
**線性搜尋**

2
zh-Hant/docs/chapter_searching/summary.md
View File

@@ -7,6 +7,6 @@ comments: true
- 二分搜尋依賴資料的有序性，透過迴圈逐步縮減一半搜尋區間來進行查詢。它要求輸入資料有序，且僅適用於陣列或基於陣列實現的資料結構。
- 暴力搜尋透過走訪資料結構來定位資料。線性搜尋適用於陣列和鏈結串列，廣度優先搜尋和深度優先搜尋適用於圖和樹。此類演算法通用性好，無須對資料進行預處理，但時間複雜度 $O(n)$ 較高。
- 雜湊查詢、樹查詢和二分搜尋屬於高效搜尋方法，可在特定資料結構中快速定位目標元素。此類演算法效率高，時間複雜度可達 $O(\log n)$ 甚至 $O(1)$ ，但通常需要藉助額外資料結構。
- 實際中，我們需要對資料體量、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。
- 實際中，我們需要對資料規模、搜尋效能要求、資料查詢和更新頻率等因素進行具體分析，從而選擇合適的搜尋方法。
- 線性搜尋適用於小型或頻繁更新的資料；二分搜尋適用於大型、排序的資料；雜湊查詢適用於對查詢效率要求較高且無須範圍查詢的資料；樹查詢適用於需要維護順序和支持範圍查詢的大型動態資料。
- 用雜湊查詢替換線性查詢是一種常用的最佳化執行時間的策略，可將時間複雜度從 $O(n)$ 降至 $O(1)$ 。