图 4-8 常见链表种类
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md index 4111af26e..fe798e359 100755 --- a/docs/chapter_array_and_linkedlist/list.md +++ b/docs/chapter_array_and_linkedlist/list.md @@ -151,15 +151,6 @@ comments: true nums = [1, 3, 2, 5, 4] ``` -=== "Zig" - - ```zig title="list.zig" - // 初始化列表 - var nums = std.ArrayList(i32).init(std.heap.page_allocator); - defer nums.deinit(); - try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 }); - ``` - ??? pythontutor "可视化运行" @@ -292,16 +283,6 @@ comments: true nums[1] = 0 # 将索引 1 处的元素更新为 0 ``` -=== "Zig" - - ```zig title="list.zig" - // 访问元素 - var num = nums.items[1]; // 访问索引 1 处的元素 - - // 更新元素 - nums.items[1] = 0; // 将索引 1 处的元素更新为 0 - ``` - ??? pythontutor "可视化运行" @@ -557,26 +538,6 @@ comments: true nums.delete_at(3) # 删除索引 3 处的元素 ``` -=== "Zig" - - ```zig title="list.zig" - // 清空列表 - nums.clearRetainingCapacity(); - - // 在尾部添加元素 - try nums.append(1); - try nums.append(3); - try nums.append(2); - try nums.append(5); - try nums.append(4); - - // 在中间插入元素 - try nums.insert(3, 6); // 在索引 3 处插入数字 6 - - // 删除元素 - _ = nums.orderedRemove(3); // 删除索引 3 处的元素 - ``` - ??? pythontutor "可视化运行" @@ -779,23 +740,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="list.zig" - // 通过索引遍历列表 - var count: i32 = 0; - var i: i32 = 0; - while (i < nums.items.len) : (i += 1) { - count += nums[i]; - } - - // 直接遍历列表元素 - count = 0; - for (nums.items) |num| { - count += num; - } - ``` - ??? pythontutor "可视化运行" @@ -908,16 +852,6 @@ comments: true nums += nums1 ``` -=== "Zig" - - ```zig title="list.zig" - // 拼接两个列表 - var nums1 = std.ArrayList(i32).init(std.heap.page_allocator); - defer nums1.deinit(); - try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 }); - try nums.insertSlice(nums.items.len, nums1.items); // 将列表 nums1 拼接到 nums 之后 - ``` - ??? pythontutor "可视化运行" @@ -1017,13 +951,6 @@ comments: true nums = nums.sort { |a, b| a <=> b } # 排序后，列表元素从小到大排列 ``` -=== "Zig" - - ```zig title="list.zig" - // 排序列表 - std.sort.sort(i32, nums.items, {}, comptime std.sort.asc(i32)); - ``` - ??? pythontutor "可视化运行" @@ -2368,163 +2295,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="my_list.zig" - // 列表类 - const MyList = struct { - const Self = @This(); - - items: []i32, // 数组（存储列表元素） - capacity: usize, // 列表容量 - allocator: std.mem.Allocator, // 内存分配器 - - extend_ratio: usize = 2, // 每次列表扩容的倍数 - - // 构造函数（分配内存+初始化列表） - pub fn init(allocator: std.mem.Allocator) Self { - return Self{ - .items = &[_]i32{}, - .capacity = 0, - .allocator = allocator, - }; - } - - // 析构函数（释放内存） - pub fn deinit(self: Self) void { - self.allocator.free(self.allocatedSlice()); - } - - // 在尾部添加元素 - pub fn add(self: *Self, item: i32) !void { - // 元素数量超出容量时，触发扩容机制 - const newlen = self.items.len + 1; - try self.ensureTotalCapacity(newlen); - - // 更新元素 - self.items.len += 1; - const new_item_ptr = &self.items[self.items.len - 1]; - new_item_ptr.* = item; - } - - // 获取列表长度（当前元素数量） - pub fn getSize(self: *Self) usize { - return self.items.len; - } - - // 获取列表容量 - 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); - } - return new_items; - } - - const new_memory = try allocator.alloc(i32, self.items.len); - @memcpy(new_memory, self.items); - if (clear) { - self.clearAndFree(); - } - return new_memory; - } - - // 列表扩容 - 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; - - 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 "可视化运行" diff --git a/docs/chapter_backtracking/backtracking_algorithm.md b/docs/chapter_backtracking/backtracking_algorithm.md index 0dc8c6a79..ea28484de 100644 --- a/docs/chapter_backtracking/backtracking_algorithm.md +++ b/docs/chapter_backtracking/backtracking_algorithm.md @@ -232,12 +232,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="preorder_traversal_i_compact.zig" - [class]{}-[func]{preOrder} - ``` - ??? pythontutor "可视化运行" @@ -549,12 +543,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="preorder_traversal_ii_compact.zig" - [class]{}-[func]{preOrder} - ``` - ??? pythontutor "可视化运行" @@ -909,12 +897,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="preorder_traversal_iii_compact.zig" - [class]{}-[func]{preOrder} - ``` - ??? pythontutor "可视化运行" @@ -1266,12 +1248,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - - ``` - 接下来，我们基于框架代码来解决例题三。状态 `state` 为节点遍历路径，选择 `choices` 为当前节点的左子节点和右子节点，结果 `res` 是路径列表： === "Python" @@ -1948,22 +1924,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="preorder_traversal_iii_template.zig" - [class]{}-[func]{isSolution} - - [class]{}-[func]{recordSolution} - - [class]{}-[func]{isValid} - - [class]{}-[func]{makeChoice} - - [class]{}-[func]{undoChoice} - - [class]{}-[func]{backtrack} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_backtracking/n_queens_problem.md b/docs/chapter_backtracking/n_queens_problem.md index 2aed6bd44..8aec7c995 100644 --- a/docs/chapter_backtracking/n_queens_problem.md +++ b/docs/chapter_backtracking/n_queens_problem.md @@ -744,14 +744,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="n_queens.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{nQueens} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_backtracking/permutations_problem.md b/docs/chapter_backtracking/permutations_problem.md index e2b4f1fe2..21d0c4783 100644 --- a/docs/chapter_backtracking/permutations_problem.md +++ b/docs/chapter_backtracking/permutations_problem.md @@ -538,14 +538,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="permutations_i.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{permutationsI} - ``` - ??? pythontutor "可视化运行" @@ -1093,14 +1085,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="permutations_ii.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{permutationsII} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_backtracking/subset_sum_problem.md b/docs/chapter_backtracking/subset_sum_problem.md index d667f5e0d..eef470afb 100644 --- a/docs/chapter_backtracking/subset_sum_problem.md +++ b/docs/chapter_backtracking/subset_sum_problem.md @@ -501,14 +501,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="subset_sum_i_naive.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{subsetSumINaive} - ``` - ??? pythontutor "可视化运行" @@ -1070,14 +1062,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="subset_sum_i.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{subsetSumI} - ``` - ??? pythontutor "可视化运行" @@ -1689,14 +1673,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="subset_sum_ii.zig" - [class]{}-[func]{backtrack} - - [class]{}-[func]{subsetSumII} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_computational_complexity/iteration_and_recursion.md b/docs/chapter_computational_complexity/iteration_and_recursion.md index e3d0d280c..699f50d80 100644 --- a/docs/chapter_computational_complexity/iteration_and_recursion.md +++ b/docs/chapter_computational_complexity/iteration_and_recursion.md @@ -198,20 +198,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="iteration.zig" - // for 循环 - fn forLoop(n: usize) i32 { - var res: i32 = 0; - // 循环求和 1, 2, ..., n-1, n - for (1..n + 1) |i| { - res += @intCast(i); - } - return res; - } - ``` - ??? pythontutor "可视化运行" @@ -442,21 +428,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="iteration.zig" - // while 循环 - fn whileLoop(n: i32) i32 { - var res: i32 = 0; - var i: i32 = 1; // 初始化条件变量 - // 循环求和 1, 2, ..., n-1, n - while (i <= n) : (i += 1) { - res += @intCast(i); - } - return res; - } - ``` - ??? pythontutor "可视化运行" @@ -702,25 +673,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="iteration.zig" - // while 循环（两次更新） - fn whileLoopII(n: i32) i32 { - var res: i32 = 0; - var i: i32 = 1; // 初始化条件变量 - // 循环求和 1, 4, 10, ... - while (i <= n) : ({ - // 更新条件变量 - i += 1; - i *= 2; - }) { - res += @intCast(i); - } - return res; - } - ``` - ??? pythontutor "可视化运行" @@ -956,26 +908,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="iteration.zig" - // 双层 for 循环 - fn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 { - var res = std.ArrayList(u8).init(allocator); - defer res.deinit(); - var buffer: [20]u8 = undefined; - // 循环 i = 1, 2, ..., n-1, n - for (1..n + 1) |i| { - // 循环 j = 1, 2, ..., n-1, n - for (1..n + 1) |j| { - const str = try std.fmt.bufPrint(&buffer, "({d}, {d}), ", .{ i, j }); - try res.appendSlice(str); - } - } - return res.toOwnedSlice(); - } - ``` - ??? pythontutor "可视化运行" @@ -1199,22 +1131,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="recursion.zig" - // 递归函数 - fn recur(n: i32) i32 { - // 终止条件 - if (n == 1) { - return 1; - } - // 递：递归调用 - const res = recur(n - 1); - // 归：返回结果 - return n + res; - } - ``` - ??? pythontutor "可视化运行" @@ -1428,20 +1344,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="recursion.zig" - // 尾递归函数 - fn tailRecur(n: i32, res: i32) i32 { - // 终止条件 - if (n == 0) { - return res; - } - // 尾递归调用 - return tailRecur(n - 1, res + n); - } - ``` - ??? pythontutor "可视化运行" @@ -1668,22 +1570,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="recursion.zig" - // 斐波那契数列 - fn fib(n: i32) i32 { - // 终止条件 f(1) = 0, f(2) = 1 - if (n == 1 or n == 2) { - return n - 1; - } - // 递归调用 f(n) = f(n-1) + f(n-2) - const res: i32 = fib(n - 1) + fib(n - 2); - // 返回结果 f(n) - return res; - } - ``` - ??? pythontutor "可视化运行" @@ -2029,31 +1915,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="recursion.zig" - // 使用迭代模拟递归 - fn forLoopRecur(comptime n: i32) i32 { - // 使用一个显式的栈来模拟系统调用栈 - var stack: [n]i32 = undefined; - var res: i32 = 0; - // 递：递归调用 - var i: usize = n; - while (i > 0) { - stack[i - 1] = @intCast(i); - i -= 1; - } - // 归：返回结果 - var index: usize = n; - while (index > 0) { - index -= 1; - res += stack[index]; - } - // res = 1+2+3+...+n - return res; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md index 94d76842e..c107ddd6b 100755 --- a/docs/chapter_computational_complexity/space_complexity.md +++ b/docs/chapter_computational_complexity/space_complexity.md @@ -367,12 +367,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - - ``` - ## 2.4.2 推算方法 空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。 @@ -535,12 +529,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - - ``` - **在递归函数中，需要注意统计栈帧空间**。观察以下代码： === "Python" @@ -813,12 +801,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - - ``` - 函数 `loop()` 和 `recur()` 的时间复杂度都为 $O(n)$ ，但空间复杂度不同。 - 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。 @@ -1195,40 +1177,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 函数 - fn function() i32 { - // 执行某些操作 - return 0; - } - - // 常数阶 - fn constant(n: i32) void { - // 常量、变量、对象占用 O(1) 空间 - const a: i32 = 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) { - const c: i32 = 0; - _ = c; - } - // 循环中的函数占用 O(1) 空间 - i = 0; - while (i < n) : (i += 1) { - _ = function(); - } - _ = a; - _ = b; - _ = nums; - _ = node; - } - ``` - ??? pythontutor "可视化运行" @@ -1507,33 +1455,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 线性阶 - fn linear(comptime n: i32) !void { - // 长度为 n 的数组占用 O(n) 空间 - const nums = [_]i32{0} ** n; - // 长度为 n 的列表占用 O(n) 空间 - var nodes = std.ArrayList(i32).init(std.heap.page_allocator); - defer nodes.deinit(); - var i: i32 = 0; - while (i < n) : (i += 1) { - try nodes.append(i); - } - // 长度为 n 的哈希表占用 O(n) 空间 - var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator); - defer map.deinit(); - var j: i32 = 0; - while (j < n) : (j += 1) { - const string = try std.fmt.allocPrint(std.heap.page_allocator, "{d}", .{j}); - defer std.heap.page_allocator.free(string); - try map.put(i, string); - } - _ = nums; - } - ``` - ??? pythontutor "可视化运行" @@ -1694,17 +1615,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 线性阶（递归实现） - fn linearRecur(comptime n: i32) void { - std.debug.print("递归 n = {}\n", .{n}); - if (n == 1) return; - linearRecur(n - 1); - } - ``` - ??? pythontutor "可视化运行" @@ -1938,27 +1848,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 平方阶 - fn quadratic(n: i32) !void { - // 二维列表占用 O(n^2) 空间 - var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator); - defer nodes.deinit(); - var i: i32 = 0; - while (i < n) : (i += 1) { - var tmp = std.ArrayList(i32).init(std.heap.page_allocator); - defer tmp.deinit(); - var j: i32 = 0; - while (j < n) : (j += 1) { - try tmp.append(0); - } - try nodes.append(tmp); - } - } - ``` - ??? pythontutor "可视化运行" @@ -2140,18 +2029,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 平方阶（递归实现） - fn quadraticRecur(comptime n: i32) i32 { - if (n <= 0) return 0; - const nums = [_]i32{0} ** n; - std.debug.print("递归 n = {} 中的 nums 长度 = {}\n", .{ n, nums.len }); - return quadraticRecur(n - 1); - } - ``` - ??? pythontutor "可视化运行" @@ -2346,20 +2223,6 @@ $$ end ``` -=== "Zig" - - ```zig title="space_complexity.zig" - // 指数阶（建立满二叉树） - fn buildTree(allocator: std.mem.Allocator, n: i32) !?*TreeNode(i32) { - if (n == 0) return null; - const root = try allocator.create(TreeNode(i32)); - root.init(0); - root.left = try buildTree(allocator, n - 1); - root.right = try buildTree(allocator, n - 1); - return root; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md index 825e1f646..387558fa7 100755 --- a/docs/chapter_computational_complexity/time_complexity.md +++ b/docs/chapter_computational_complexity/time_complexity.md @@ -205,21 +205,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - // 在某运行平台下 - fn algorithm(n: usize) void { - var a: i32 = 2; // 1 ns - a += 1; // 1 ns - a *= 2; // 10 ns - // 循环 n 次 - for (0..n) |_| { // 1 ns - std.debug.print("{}\n", .{0}); // 5 ns - } - } - ``` - 根据以上方法，可以得到算法的运行时间为 $(6n + 12)$ ns ： $$ @@ -503,29 +488,6 @@ $$ end ``` -=== "Zig" - - ```zig title="" - // 算法 A 的时间复杂度：常数阶 - fn algorithm_A(n: usize) void { - _ = n; - std.debug.print("{}\n", .{0}); - } - // 算法 B 的时间复杂度：线性阶 - fn algorithm_B(n: i32) void { - for (0..n) |_| { - std.debug.print("{}\n", .{0}); - } - } - // 算法 C 的时间复杂度：常数阶 - fn algorithm_C(n: i32) void { - _ = n; - for (0..1000000) |_| { - std.debug.print("{}\n", .{0}); - } - } - ``` - 图 2-7 展示了以上三个算法函数的时间复杂度。 - 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为“常数阶”。 @@ -727,20 +689,6 @@ $$ end ``` -=== "Zig" - - ```zig title="" - fn algorithm(n: usize) void { - var a: i32 = 1; // +1 - a += 1; // +1 - a *= 2; // +1 - // 循环 n 次 - for (0..n) |_| { // +1（每轮都执行 i ++） - std.debug.print("{}\n", .{0}); // +1 - } - } - ``` - 设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的操作数量为： $$ @@ -1020,27 +968,6 @@ $T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因 end ``` -=== "Zig" - - ```zig title="" - fn algorithm(n: usize) void { - var a: i32 = 1; // +0（技巧 1） - a = a + @as(i32, @intCast(n)); // +0（技巧 1） - - // +n（技巧 2） - for(0..(5 * n + 1)) |_| { - std.debug.print("{}\n", .{0}); - } - - // +n*n（技巧 3） - for(0..(2 * n)) |_| { - for(0..(n + 1)) |_| { - std.debug.print("{}\n", .{0}); - } - } - } - ``` - 以下公式展示了使用上述技巧前后的统计结果，两者推算出的时间复杂度都为 $O(n^2)$ 。 $$ @@ -1266,22 +1193,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 常数阶 - fn constant(n: i32) i32 { - _ = n; - var count: i32 = 0; - const size: i32 = 100_000; - var i: i32 = 0; - while (i < size) : (i += 1) { - count += 1; - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -1448,20 +1359,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 线性阶 - fn linear(n: i32) i32 { - var count: i32 = 0; - var i: i32 = 0; - while (i < n) : (i += 1) { - count += 1; - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -1651,20 +1548,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 线性阶（遍历数组） - fn arrayTraversal(nums: []i32) i32 { - var count: i32 = 0; - // 循环次数与数组长度成正比 - for (nums) |_| { - count += 1; - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -1883,24 +1766,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 平方阶 - fn quadratic(n: i32) i32 { - var count: i32 = 0; - var i: i32 = 0; - // 循环次数与数据大小 n 成平方关系 - while (i < n) : (i += 1) { - var j: i32 = 0; - while (j < n) : (j += 1) { - count += 1; - } - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -2210,31 +2075,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 平方阶（冒泡排序） - fn bubbleSort(nums: []i32) i32 { - var count: i32 = 0; // 计数器 - // 外循环：未排序区间为 [0, i] - var i: i32 = @as(i32, @intCast(nums.len)) - 1; - while (i > 0) : (i -= 1) { - var j: usize = 0; - // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 - while (j < i) : (j += 1) { - if (nums[j] > nums[j + 1]) { - // 交换 nums[j] 与 nums[j + 1] - const tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; - count += 3; // 元素交换包含 3 个单元操作 - } - } - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -2484,27 +2324,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 指数阶（循环实现） - fn exponential(n: i32) i32 { - var count: i32 = 0; - var bas: i32 = 1; - var i: i32 = 0; - // 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1) - while (i < n) : (i += 1) { - var j: i32 = 0; - while (j < bas) : (j += 1) { - count += 1; - } - bas *= 2; - } - // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1 - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -2657,16 +2476,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 指数阶（递归实现） - fn expRecur(n: i32) i32 { - if (n == 1) return 1; - return expRecur(n - 1) + expRecur(n - 1) + 1; - } - ``` - ??? pythontutor "可视化运行" @@ -2864,20 +2673,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 对数阶（循环实现） - fn logarithmic(n: i32) i32 { - var count: i32 = 0; - var n_var: i32 = n; - while (n_var > 1) : (n_var = @divTrunc(n_var, 2)) { - count += 1; - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -3029,16 +2824,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 对数阶（递归实现） - fn logRecur(n: i32) i32 { - if (n <= 1) return 0; - return logRecur(@divTrunc(n, 2)) + 1; - } - ``` - ??? pythontutor "可视化运行" @@ -3253,21 +3038,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 线性对数阶 - fn linearLogRecur(n: i32) i32 { - if (n <= 1) return 1; - var count: i32 = linearLogRecur(@divTrunc(n, 2)) + linearLogRecur(@divTrunc(n, 2)); - var i: i32 = 0; - while (i < n) : (i += 1) { - count += 1; - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -3494,22 +3264,6 @@ $$ end ``` -=== "Zig" - - ```zig title="time_complexity.zig" - // 阶乘阶（递归实现） - fn factorialRecur(n: i32) i32 { - if (n == 0) return 1; - var count: i32 = 0; - var i: i32 = 0; - // 从 1 个分裂出 n 个 - while (i < n) : (i += 1) { - count += factorialRecur(n - 1); - } - return count; - } - ``` - ??? pythontutor "可视化运行" @@ -3904,33 +3658,6 @@ $$ end ``` -=== "Zig" - - ```zig title="worst_best_time_complexity.zig" - // 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 - fn randomNumbers(comptime n: usize) [n]i32 { - var nums: [n]i32 = undefined; - // 生成数组 nums = { 1, 2, 3, ..., n } - for (&nums, 0..) |*num, i| { - num.* = @as(i32, @intCast(i)) + 1; - } - // 随机打乱数组元素 - const rand = std.crypto.random; - rand.shuffle(i32, &nums); - return nums; - } - - // 查找数组 nums 中数字 1 所在索引 - fn findOne(nums: []i32) i32 { - for (nums, 0..) |num, i| { - // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1) - // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n) - if (num == 1) return @intCast(i); - } - return -1; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_data_structure/basic_data_types.md b/docs/chapter_data_structure/basic_data_types.md index 90a2cc49b..1db5460c6 100644 --- a/docs/chapter_data_structure/basic_data_types.md +++ b/docs/chapter_data_structure/basic_data_types.md @@ -178,24 +178,6 @@ comments: true data = [0, 0.0, 'a', false, ListNode(0)] ``` -=== "Zig" - - ```zig title="" - const hello = [5]u8{ 'h', 'e', 'l', 'l', 'o' }; - // 以上代码展示了定义一个字面量数组的方式，其中你可以选择指明数组的大小或者使用 _ 代替。使用 _ 时，Zig 会尝试自动计算数组的长度 - - const matrix_4x4 = [4][4]f32{ - [_]f32{ 1.0, 0.0, 0.0, 0.0 }, - [_]f32{ 0.0, 1.0, 0.0, 1.0 }, - [_]f32{ 0.0, 0.0, 1.0, 0.0 }, - [_]f32{ 0.0, 0.0, 0.0, 1.0 }, - }; - // 多维数组（矩阵）实际上就是嵌套数组，我们很容易就可以创建一个多维数组出来 - - const array = [_:0]u8{ 1, 2, 3, 4 }; - // 定义一个哨兵终止数组，本质上来说，这是为了兼容 C 中的规定的字符串结尾字符\0。我们使用语法 [N:x]T 来描述一个元素为类型 T，长度为 N 的数组，在它对应 N 的索引处的值应该是 x - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_divide_and_conquer/binary_search_recur.md b/docs/chapter_divide_and_conquer/binary_search_recur.md index aad12dd48..f7ce7677d 100644 --- a/docs/chapter_divide_and_conquer/binary_search_recur.md +++ b/docs/chapter_divide_and_conquer/binary_search_recur.md @@ -450,14 +450,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_search_recur.zig" - [class]{}-[func]{dfs} - - [class]{}-[func]{binarySearch} - ``` - ??? pythontutor "可视化运行" 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 fc99c18b4..15f1cc9c7 100644 --- a/docs/chapter_divide_and_conquer/build_binary_tree_problem.md +++ b/docs/chapter_divide_and_conquer/build_binary_tree_problem.md @@ -512,14 +512,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="build_tree.zig" - [class]{}-[func]{dfs} - - [class]{}-[func]{buildTree} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_divide_and_conquer/hanota_problem.md b/docs/chapter_divide_and_conquer/hanota_problem.md index 37fe6ba6a..e796cfd8a 100644 --- a/docs/chapter_divide_and_conquer/hanota_problem.md +++ b/docs/chapter_divide_and_conquer/hanota_problem.md @@ -542,16 +542,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="hanota.zig" - [class]{}-[func]{move} - - [class]{}-[func]{dfs} - - [class]{}-[func]{solveHanota} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_divide_and_conquer/summary.md b/docs/chapter_divide_and_conquer/summary.md index 008c51bf0..faec91d0a 100644 --- a/docs/chapter_divide_and_conquer/summary.md +++ b/docs/chapter_divide_and_conquer/summary.md @@ -4,6 +4,8 @@ comments: true # 12.5 小结 +### 1. 重点回顾 + - 分治是一种常见的算法设计策略，包括分（划分）和治（合并）两个阶段，通常基于递归实现。 - 判断是否是分治算法问题的依据包括：问题能否分解、子问题是否独立、子问题能否合并。 - 归并排序是分治策略的典型应用，其递归地将数组划分为等长的两个子数组，直到只剩一个元素时开始逐层合并，从而完成排序。 diff --git a/docs/chapter_dynamic_programming/dp_problem_features.md b/docs/chapter_dynamic_programming/dp_problem_features.md index 5d1ae07a2..db17d2f6a 100644 --- a/docs/chapter_dynamic_programming/dp_problem_features.md +++ b/docs/chapter_dynamic_programming/dp_problem_features.md @@ -318,28 +318,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_cost_climbing_stairs_dp.zig" - // 爬楼梯最小代价：动态规划 - fn minCostClimbingStairsDP(comptime cost: []i32) i32 { - comptime var n = cost.len - 1; - if (n == 1 or n == 2) { - return cost[n]; - } - // 初始化 dp 表，用于存储子问题的解 - var dp = [_]i32{-1} ** (n + 1); - // 初始状态：预设最小子问题的解 - dp[1] = cost[1]; - dp[2] = cost[2]; - // 状态转移：从较小子问题逐步求解较大子问题 - for (3..n + 1) |i| { - dp[i] = @min(dp[i - 1], dp[i - 2]) + cost[i]; - } - return dp[n]; - } - ``` - ??? pythontutor "可视化运行" @@ -603,27 +581,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_cost_climbing_stairs_dp.zig" - // 爬楼梯最小代价：空间优化后的动态规划 - fn minCostClimbingStairsDPComp(cost: []i32) i32 { - var n = cost.len - 1; - if (n == 1 or n == 2) { - return cost[n]; - } - var a = cost[1]; - var b = cost[2]; - // 状态转移：从较小子问题逐步求解较大子问题 - for (3..n + 1) |i| { - var tmp = b; - b = @min(a, tmp) + cost[i]; - a = tmp; - } - return b; - } - ``` - ??? pythontutor "可视化运行" @@ -985,30 +942,6 @@ $$ end ``` -=== "Zig" - - ```zig title="climbing_stairs_constraint_dp.zig" - // 带约束爬楼梯：动态规划 - fn climbingStairsConstraintDP(comptime n: usize) i32 { - if (n == 1 or n == 2) { - return 1; - } - // 初始化 dp 表，用于存储子问题的解 - var dp = [_][3]i32{ [_]i32{ -1, -1, -1 } } ** (n + 1); - // 初始状态：预设最小子问题的解 - dp[1][1] = 1; - dp[1][2] = 0; - dp[2][1] = 0; - dp[2][2] = 1; - // 状态转移：从较小子问题逐步求解较大子问题 - for (3..n + 1) |i| { - dp[i][1] = dp[i - 1][2]; - dp[i][2] = dp[i - 2][1] + dp[i - 2][2]; - } - return dp[n][1] + dp[n][2]; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_dynamic_programming/dp_solution_pipeline.md b/docs/chapter_dynamic_programming/dp_solution_pipeline.md index 6253b15c5..e1644d7d8 100644 --- a/docs/chapter_dynamic_programming/dp_solution_pipeline.md +++ b/docs/chapter_dynamic_programming/dp_solution_pipeline.md @@ -383,27 +383,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_path_sum.zig" - // 最小路径和：暴力搜索 - fn minPathSumDFS(grid: anytype, i: i32, j: i32) i32 { - // 若为左上角单元格，则终止搜索 - if (i == 0 and j == 0) { - return grid[0][0]; - } - // 若行列索引越界，则返回 +∞ 代价 - if (i < 0 or j < 0) { - return std.math.maxInt(i32); - } - // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价 - var up = minPathSumDFS(grid, i - 1, j); - var left = minPathSumDFS(grid, i, j - 1); - // 返回从左上角到 (i, j) 的最小路径代价 - return @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))]; - } - ``` - ??? pythontutor "可视化运行" @@ -763,33 +742,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_path_sum.zig" - // 最小路径和：记忆化搜索 - fn minPathSumDFSMem(grid: anytype, mem: anytype, i: i32, j: i32) i32 { - // 若为左上角单元格，则终止搜索 - if (i == 0 and j == 0) { - return grid[0][0]; - } - // 若行列索引越界，则返回 +∞ 代价 - if (i < 0 or j < 0) { - return std.math.maxInt(i32); - } - // 若已有记录，则直接返回 - if (mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] != -1) { - return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))]; - } - // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价 - var up = minPathSumDFSMem(grid, mem, i - 1, j); - var left = minPathSumDFSMem(grid, mem, i, j - 1); - // 返回从左上角到 (i, j) 的最小路径代价 - // 记录并返回左上角到 (i, j) 的最小路径代价 - mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] = @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))]; - return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))]; - } - ``` - ??? pythontutor "可视化运行" @@ -1165,34 +1117,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_path_sum.zig" - // 最小路径和：动态规划 - fn minPathSumDP(comptime grid: anytype) i32 { - comptime var n = grid.len; - comptime var m = grid[0].len; - // 初始化 dp 表 - var dp = [_][m]i32{[_]i32{0} ** m} ** n; - dp[0][0] = grid[0][0]; - // 状态转移：首行 - for (1..m) |j| { - dp[0][j] = dp[0][j - 1] + grid[0][j]; - } - // 状态转移：首列 - for (1..n) |i| { - dp[i][0] = dp[i - 1][0] + grid[i][0]; - } - // 状态转移：其余行和列 - for (1..n) |i| { - for (1..m) |j| { - dp[i][j] = @min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]; - } - } - return dp[n - 1][m - 1]; - } - ``` - ??? pythontutor "可视化运行" @@ -1581,32 +1505,6 @@ $$ end ``` -=== "Zig" - - ```zig title="min_path_sum.zig" - // 最小路径和：空间优化后的动态规划 - fn minPathSumDPComp(comptime grid: anytype) i32 { - comptime var n = grid.len; - comptime var m = grid[0].len; - // 初始化 dp 表 - var dp = [_]i32{0} ** m; - // 状态转移：首行 - dp[0] = grid[0][0]; - for (1..m) |j| { - dp[j] = dp[j - 1] + grid[0][j]; - } - // 状态转移：其余行 - for (1..n) |i| { - // 状态转移：首列 - dp[0] = dp[0] + grid[i][0]; - for (1..m) |j| { - dp[j] = @min(dp[j - 1], dp[j]) + grid[i][j]; - } - } - return dp[m - 1]; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_dynamic_programming/edit_distance_problem.md b/docs/chapter_dynamic_programming/edit_distance_problem.md index 154d03f04..aeed93930 100644 --- a/docs/chapter_dynamic_programming/edit_distance_problem.md +++ b/docs/chapter_dynamic_programming/edit_distance_problem.md @@ -477,37 +477,6 @@ $$ end ``` -=== "Zig" - - ```zig title="edit_distance.zig" - // 编辑距离：动态规划 - fn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 { - comptime var n = s.len; - comptime var m = t.len; - var dp = [_][m + 1]i32{[_]i32{0} ** (m + 1)} ** (n + 1); - // 状态转移：首行首列 - for (1..n + 1) |i| { - dp[i][0] = @intCast(i); - } - for (1..m + 1) |j| { - dp[0][j] = @intCast(j); - } - // 状态转移：其余行和列 - for (1..n + 1) |i| { - for (1..m + 1) |j| { - if (s[i - 1] == t[j - 1]) { - // 若两字符相等，则直接跳过此两字符 - dp[i][j] = dp[i - 1][j - 1]; - } else { - // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1 - dp[i][j] = @min(@min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1; - } - } - } - return dp[n][m]; - } - ``` - ??? pythontutor "可视化运行" @@ -997,40 +966,6 @@ $$ end ``` -=== "Zig" - - ```zig title="edit_distance.zig" - // 编辑距离：空间优化后的动态规划 - fn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 { - comptime var n = s.len; - comptime var m = t.len; - var dp = [_]i32{0} ** (m + 1); - // 状态转移：首行 - for (1..m + 1) |j| { - dp[j] = @intCast(j); - } - // 状态转移：其余行 - for (1..n + 1) |i| { - // 状态转移：首列 - var leftup = dp[0]; // 暂存 dp[i-1, j-1] - dp[0] = @intCast(i); - // 状态转移：其余列 - for (1..m + 1) |j| { - var temp = dp[j]; - if (s[i - 1] == t[j - 1]) { - // 若两字符相等，则直接跳过此两字符 - dp[j] = leftup; - } else { - // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1 - dp[j] = @min(@min(dp[j - 1], dp[j]), leftup) + 1; - } - leftup = temp; // 更新为下一轮的 dp[i-1, j-1] - } - } - return dp[m]; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md index d2b0c3815..6ae1e0455 100644 --- a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md +++ b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md @@ -420,39 +420,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="climbing_stairs_backtrack.zig" - // 回溯 - fn backtrack(choices: []i32, state: i32, n: i32, res: std.ArrayList(i32)) void { - // 当爬到第 n 阶时，方案数量加 1 - if (state == n) { - res.items[0] = res.items[0] + 1; - } - // 遍历所有选择 - for (choices) |choice| { - // 剪枝：不允许越过第 n 阶 - if (state + choice > n) { - continue; - } - // 尝试：做出选择，更新状态 - backtrack(choices, state + choice, n, res); - // 回退 - } - } - - // 爬楼梯：回溯 - fn climbingStairsBacktrack(n: usize) !i32 { - var choices = [_]i32{ 1, 2 }; // 可选择向上爬 1 阶或 2 阶 - var state: i32 = 0; // 从第 0 阶开始爬 - var res = std.ArrayList(i32).init(std.heap.page_allocator); - defer res.deinit(); - try res.append(0); // 使用 res[0] 记录方案数量 - backtrack(&choices, state, @intCast(n), res); - return res.items[0]; - } - ``` - ??? pythontutor "可视化运行" @@ -728,26 +695,6 @@ $$ end ``` -=== "Zig" - - ```zig title="climbing_stairs_dfs.zig" - // 搜索 - fn dfs(i: usize) i32 { - // 已知 dp[1] 和 dp[2] ，返回之 - if (i == 1 or i == 2) { - return @intCast(i); - } - // dp[i] = dp[i-1] + dp[i-2] - var count = dfs(i - 1) + dfs(i - 2); - return count; - } - - // 爬楼梯：搜索 - fn climbingStairsDFS(comptime n: usize) i32 { - return dfs(n); - } - ``` - ??? pythontutor "可视化运行" @@ -1115,34 +1062,6 @@ $$ end ``` -=== "Zig" - - ```zig title="climbing_stairs_dfs_mem.zig" - // 记忆化搜索 - fn dfs(i: usize, mem: []i32) i32 { - // 已知 dp[1] 和 dp[2] ，返回之 - if (i == 1 or i == 2) { - return @intCast(i); - } - // 若存在记录 dp[i] ，则直接返回之 - if (mem[i] != -1) { - return mem[i]; - } - // dp[i] = dp[i-1] + dp[i-2] - var count = dfs(i - 1, mem) + dfs(i - 2, mem); - // 记录 dp[i] - mem[i] = count; - return count; - } - - // 爬楼梯：记忆化搜索 - fn climbingStairsDFSMem(comptime n: usize) i32 { - // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录 - var mem = [_]i32{ -1 } ** (n + 1); - return dfs(n, &mem); - } - ``` - ??? pythontutor "可视化运行" @@ -1419,28 +1338,6 @@ $$ end ``` -=== "Zig" - - ```zig title="climbing_stairs_dp.zig" - // 爬楼梯：动态规划 - fn climbingStairsDP(comptime n: usize) i32 { - // 已知 dp[1] 和 dp[2] ，返回之 - if (n == 1 or n == 2) { - return @intCast(n); - } - // 初始化 dp 表，用于存储子问题的解 - var dp = [_]i32{-1} ** (n + 1); - // 初始状态：预设最小子问题的解 - dp[1] = 1; - dp[2] = 2; - // 状态转移：从较小子问题逐步求解较大子问题 - for (3..n + 1) |i| { - dp[i] = dp[i - 1] + dp[i - 2]; - } - return dp[n]; - } - ``` - ??? pythontutor "可视化运行" @@ -1678,25 +1575,6 @@ $$ end ``` -=== "Zig" - - ```zig title="climbing_stairs_dp.zig" - // 爬楼梯：空间优化后的动态规划 - fn climbingStairsDPComp(comptime n: usize) i32 { - if (n == 1 or n == 2) { - return @intCast(n); - } - var a: i32 = 1; - var b: i32 = 2; - for (3..n + 1) |_| { - var tmp = b; - b = a + b; - a = tmp; - } - return b; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_dynamic_programming/knapsack_problem.md b/docs/chapter_dynamic_programming/knapsack_problem.md index b5c72f954..137dccaa4 100644 --- a/docs/chapter_dynamic_programming/knapsack_problem.md +++ b/docs/chapter_dynamic_programming/knapsack_problem.md @@ -338,27 +338,6 @@ $$ end ``` -=== "Zig" - - ```zig title="knapsack.zig" - // 0-1 背包：暴力搜索 - fn knapsackDFS(wgt: []i32, val: []i32, i: usize, c: usize) i32 { - // 若已选完所有物品或背包无剩余容量，则返回价值 0 - if (i == 0 or c == 0) { - return 0; - } - // 若超过背包容量，则只能选择不放入背包 - if (wgt[i - 1] > c) { - return knapsackDFS(wgt, val, i - 1, c); - } - // 计算不放入和放入物品 i 的最大价值 - var no = knapsackDFS(wgt, val, i - 1, c); - var yes = knapsackDFS(wgt, val, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1]; - // 返回两种方案中价值更大的那一个 - return @max(no, yes); - } - ``` - ??? pythontutor "可视化运行" @@ -727,32 +706,6 @@ $$ end ``` -=== "Zig" - - ```zig title="knapsack.zig" - // 0-1 背包：记忆化搜索 - fn knapsackDFSMem(wgt: []i32, val: []i32, mem: anytype, i: usize, c: usize) i32 { - // 若已选完所有物品或背包无剩余容量，则返回价值 0 - if (i == 0 or c == 0) { - return 0; - } - // 若已有记录，则直接返回 - if (mem[i][c] != -1) { - return mem[i][c]; - } - // 若超过背包容量，则只能选择不放入背包 - if (wgt[i - 1] > c) { - return knapsackDFSMem(wgt, val, mem, i - 1, c); - } - // 计算不放入和放入物品 i 的最大价值 - var no = knapsackDFSMem(wgt, val, mem, i - 1, c); - var yes = knapsackDFSMem(wgt, val, mem, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1]; - // 记录并返回两种方案中价值更大的那一个 - mem[i][c] = @max(no, yes); - return mem[i][c]; - } - ``` - ??? pythontutor "可视化运行" @@ -1104,30 +1057,6 @@ $$ end ``` -=== "Zig" - - ```zig title="knapsack.zig" - // 0-1 背包：动态规划 - fn knapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 { - comptime var n = wgt.len; - // 初始化 dp 表 - var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1); - // 状态转移 - for (1..n + 1) |i| { - for (1..cap + 1) |c| { - if (wgt[i - 1] > c) { - // 若超过背包容量，则不选物品 i - dp[i][c] = dp[i - 1][c]; - } else { - // 不选和选物品 i 这两种方案的较大值 - dp[i][c] = @max(dp[i - 1][c], dp[i - 1][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); - } - } - } - return dp[n][cap]; - } - ``` - ??? pythontutor "可视化运行" @@ -1510,29 +1439,6 @@ $$ end ``` -=== "Zig" - - ```zig title="knapsack.zig" - // 0-1 背包：空间优化后的动态规划 - fn knapsackDPComp(wgt: []i32, val: []i32, comptime cap: usize) i32 { - var n = wgt.len; - // 初始化 dp 表 - var dp = [_]i32{0} ** (cap + 1); - // 状态转移 - for (1..n + 1) |i| { - // 倒序遍历 - var c = cap; - while (c > 0) : (c -= 1) { - if (wgt[i - 1] < c) { - // 不选和选物品 i 这两种方案的较大值 - dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); - } - } - } - return dp[cap]; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_dynamic_programming/summary.md b/docs/chapter_dynamic_programming/summary.md index 6c0453646..b09752f2a 100644 --- a/docs/chapter_dynamic_programming/summary.md +++ b/docs/chapter_dynamic_programming/summary.md @@ -4,6 +4,8 @@ comments: true # 14.7 小结 +### 1. 重点回顾 + - 动态规划对问题进行分解，并通过存储子问题的解来规避重复计算，提高计算效率。 - 不考虑时间的前提下，所有动态规划问题都可以用回溯（暴力搜索）进行求解，但递归树中存在大量的重叠子问题，效率极低。通过引入记忆化列表，可以存储所有计算过的子问题的解，从而保证重叠子问题只被计算一次。 - 记忆化搜索是一种从顶至底的递归式解法，而与之对应的动态规划是一种从底至顶的递推式解法，其如同“填写表格”一样。由于当前状态仅依赖某些局部状态，因此我们可以消除 $dp$ 表的一个维度，从而降低空间复杂度。 diff --git a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md index 632158ff9..e1caa811f 100644 --- a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md +++ b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md @@ -371,30 +371,6 @@ $$ end ``` -=== "Zig" - - ```zig title="unbounded_knapsack.zig" - // 完全背包：动态规划 - fn unboundedKnapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 { - comptime var n = wgt.len; - // 初始化 dp 表 - var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1); - // 状态转移 - for (1..n + 1) |i| { - for (1..cap + 1) |c| { - if (wgt[i - 1] > c) { - // 若超过背包容量，则不选物品 i - dp[i][c] = dp[i - 1][c]; - } else { - // 不选和选物品 i 这两种方案的较大值 - dp[i][c] = @max(dp[i - 1][c], dp[i][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); - } - } - } - return dp[n][cap]; - } - ``` - ??? pythontutor "可视化运行" @@ -769,30 +745,6 @@ $$ end ``` -=== "Zig" - - ```zig title="unbounded_knapsack.zig" - // 完全背包：空间优化后的动态规划 - fn unboundedKnapsackDPComp(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 { - comptime var n = wgt.len; - // 初始化 dp 表 - var dp = [_]i32{0} ** (cap + 1); - // 状态转移 - for (1..n + 1) |i| { - for (1..cap + 1) |c| { - if (wgt[i - 1] > c) { - // 若超过背包容量，则不选物品 i - dp[c] = dp[c]; - } else { - // 不选和选物品 i 这两种方案的较大值 - dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); - } - } - } - return dp[cap]; - } - ``` - ??? pythontutor "可视化运行" @@ -1240,39 +1192,6 @@ $$ end ``` -=== "Zig" - - ```zig title="coin_change.zig" - // 零钱兑换：动态规划 - fn coinChangeDP(comptime coins: []i32, comptime amt: usize) i32 { - comptime var n = coins.len; - comptime var max = amt + 1; - // 初始化 dp 表 - var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1); - // 状态转移：首行首列 - for (1..amt + 1) |a| { - dp[0][a] = max; - } - // 状态转移：其余行和列 - for (1..n + 1) |i| { - for (1..amt + 1) |a| { - if (coins[i - 1] > @as(i32, @intCast(a))) { - // 若超过目标金额，则不选硬币 i - dp[i][a] = dp[i - 1][a]; - } else { - // 不选和选硬币 i 这两种方案的较小值 - dp[i][a] = @min(dp[i - 1][a], dp[i][a - @as(usize, @intCast(coins[i - 1]))] + 1); - } - } - } - if (dp[n][amt] != max) { - return @intCast(dp[n][amt]); - } else { - return -1; - } - } - ``` - ??? pythontutor "可视化运行" @@ -1688,37 +1607,6 @@ $$ end ``` -=== "Zig" - - ```zig title="coin_change.zig" - // 零钱兑换：空间优化后的动态规划 - fn coinChangeDPComp(comptime coins: []i32, comptime amt: usize) i32 { - comptime var n = coins.len; - comptime var max = amt + 1; - // 初始化 dp 表 - var dp = [_]i32{0} ** (amt + 1); - @memset(&dp, max); - dp[0] = 0; - // 状态转移 - for (1..n + 1) |i| { - for (1..amt + 1) |a| { - if (coins[i - 1] > @as(i32, @intCast(a))) { - // 若超过目标金额，则不选硬币 i - dp[a] = dp[a]; - } else { - // 不选和选硬币 i 这两种方案的较小值 - dp[a] = @min(dp[a], dp[a - @as(usize, @intCast(coins[i - 1]))] + 1); - } - } - } - if (dp[amt] != max) { - return @intCast(dp[amt]); - } else { - return -1; - } - } - ``` - ??? pythontutor "可视化运行" @@ -2121,34 +2009,6 @@ $$ end ``` -=== "Zig" - - ```zig title="coin_change_ii.zig" - // 零钱兑换 II：动态规划 - fn coinChangeIIDP(comptime coins: []i32, comptime amt: usize) i32 { - comptime var n = coins.len; - // 初始化 dp 表 - var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1); - // 初始化首列 - for (0..n + 1) |i| { - dp[i][0] = 1; - } - // 状态转移 - for (1..n + 1) |i| { - for (1..amt + 1) |a| { - if (coins[i - 1] > @as(i32, @intCast(a))) { - // 若超过目标金额，则不选硬币 i - dp[i][a] = dp[i - 1][a]; - } else { - // 不选和选硬币 i 这两种方案的较小值 - dp[i][a] = dp[i - 1][a] + dp[i][a - @as(usize, @intCast(coins[i - 1]))]; - } - } - } - return dp[n][amt]; - } - ``` - ??? pythontutor "可视化运行" @@ -2485,31 +2345,6 @@ $$ end ``` -=== "Zig" - - ```zig title="coin_change_ii.zig" - // 零钱兑换 II：空间优化后的动态规划 - fn coinChangeIIDPComp(comptime coins: []i32, comptime amt: usize) i32 { - comptime var n = coins.len; - // 初始化 dp 表 - var dp = [_]i32{0} ** (amt + 1); - dp[0] = 1; - // 状态转移 - for (1..n + 1) |i| { - for (1..amt + 1) |a| { - if (coins[i - 1] > @as(i32, @intCast(a))) { - // 若超过目标金额，则不选硬币 i - dp[a] = dp[a]; - } else { - // 不选和选硬币 i 这两种方案的较小值 - dp[a] = dp[a] + dp[a - @as(usize, @intCast(coins[i - 1]))]; - } - } - } - return dp[amt]; - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_graph/graph_operations.md b/docs/chapter_graph/graph_operations.md index 4b572065f..44ae93b85 100644 --- a/docs/chapter_graph/graph_operations.md +++ b/docs/chapter_graph/graph_operations.md @@ -1206,12 +1206,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="graph_adjacency_matrix.zig" - [class]{GraphAdjMat}-[func]{} - ``` - ??? pythontutor "可视化运行" @@ -2370,12 +2364,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="graph_adjacency_list.zig" - [class]{GraphAdjList}-[func]{} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_graph/graph_traversal.md b/docs/chapter_graph/graph_traversal.md index 5a0a4b34e..8b90550e3 100644 --- a/docs/chapter_graph/graph_traversal.md +++ b/docs/chapter_graph/graph_traversal.md @@ -475,12 +475,6 @@ BFS 通常借助队列来实现，代码如下所示。队列具有“先入先 end ``` -=== "Zig" - - ```zig title="graph_bfs.zig" - [class]{}-[func]{graphBFS} - ``` - ??? pythontutor "可视化运行" @@ -941,14 +935,6 @@ BFS 通常借助队列来实现，代码如下所示。队列具有“先入先 end ``` -=== "Zig" - - ```zig title="graph_dfs.zig" - [class]{}-[func]{dfs} - - [class]{}-[func]{graphDFS} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_greedy/fractional_knapsack_problem.md b/docs/chapter_greedy/fractional_knapsack_problem.md index 0f324a742..066b890e1 100644 --- a/docs/chapter_greedy/fractional_knapsack_problem.md +++ b/docs/chapter_greedy/fractional_knapsack_problem.md @@ -531,14 +531,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="fractional_knapsack.zig" - [class]{Item}-[func]{} - - [class]{}-[func]{fractionalKnapsack} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_greedy/greedy_algorithm.md b/docs/chapter_greedy/greedy_algorithm.md index 041c9fbaf..4b9f55ef9 100644 --- a/docs/chapter_greedy/greedy_algorithm.md +++ b/docs/chapter_greedy/greedy_algorithm.md @@ -330,12 +330,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="coin_change_greedy.zig" - [class]{}-[func]{coinChangeGreedy} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_greedy/max_capacity_problem.md b/docs/chapter_greedy/max_capacity_problem.md index 546470712..07f37414e 100644 --- a/docs/chapter_greedy/max_capacity_problem.md +++ b/docs/chapter_greedy/max_capacity_problem.md @@ -421,12 +421,6 @@ $$ end ``` -=== "Zig" - - ```zig title="max_capacity.zig" - [class]{}-[func]{maxCapacity} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_greedy/max_product_cutting_problem.md b/docs/chapter_greedy/max_product_cutting_problem.md index 4478fa4b5..086e5c283 100644 --- a/docs/chapter_greedy/max_product_cutting_problem.md +++ b/docs/chapter_greedy/max_product_cutting_problem.md @@ -386,12 +386,6 @@ $$ end ``` -=== "Zig" - - ```zig title="max_product_cutting.zig" - [class]{}-[func]{maxProductCutting} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_greedy/summary.md b/docs/chapter_greedy/summary.md index f857d0305..d3210c3b5 100644 --- a/docs/chapter_greedy/summary.md +++ b/docs/chapter_greedy/summary.md @@ -4,6 +4,8 @@ comments: true # 15.5 小结 +### 1. 重点回顾 + - 贪心算法通常用于解决最优化问题，其原理是在每个决策阶段都做出局部最优的决策，以期获得全局最优解。 - 贪心算法会迭代地做出一个又一个的贪心选择，每轮都将问题转化成一个规模更小的子问题，直到问题被解决。 - 贪心算法不仅实现简单，还具有很高的解题效率。相比于动态规划，贪心算法的时间复杂度通常更低。 diff --git a/docs/chapter_hashing/hash_algorithm.md b/docs/chapter_hashing/hash_algorithm.md index 7d3fff8a0..83ded99b6 100644 --- a/docs/chapter_hashing/hash_algorithm.md +++ b/docs/chapter_hashing/hash_algorithm.md @@ -642,18 +642,6 @@ index = hash(key) % capacity end ``` -=== "Zig" - - ```zig title="simple_hash.zig" - [class]{}-[func]{addHash} - - [class]{}-[func]{mulHash} - - [class]{}-[func]{xorHash} - - [class]{}-[func]{rotHash} - ``` - ??? pythontutor "可视化运行" @@ -1012,12 +1000,6 @@ $$ # 节点对象 #图 7-14 任意类型二叉树的数组表示
@@ -1334,12 +1328,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="array_binary_tree.zig" - [class]{ArrayBinaryTree}-[func]{} - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md index 3648fe73f..e2ee21221 100644 --- a/docs/chapter_tree/avl_tree.md +++ b/docs/chapter_tree/avl_tree.md @@ -236,12 +236,6 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二 end ``` -=== "Zig" - - ```zig title="" - - ``` - “节点高度”是指从该节点到它的最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的高度为 $0$ ，而空节点的高度为 $-1$ 。我们将创建两个工具函数，分别用于获取和更新节点的高度： === "Python" @@ -481,23 +475,6 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 获取节点高度 - fn height(self: *Self, node: ?*inc.TreeNode(T)) i32 { - _ = self; - // 空节点高度为 -1 ，叶节点高度为 0 - return if (node == null) -1 else node.?.height; - } - - // 更新节点高度 - fn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void { - // 节点高度等于最高子树高度 + 1 - node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1; - } - ``` - ### 2. 节点平衡因子 节点的平衡因子（balance factor）定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为 $0$ 。我们同样将获取节点平衡因子的功能封装成函数，方便后续使用： @@ -669,18 +646,6 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 获取平衡因子 - fn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 { - // 空节点平衡因子为 0 - if (node == null) return 0; - // 节点平衡因子 = 左子树高度 - 右子树高度 - return self.height(node.?.left) - self.height(node.?.right); - } - ``` - !!! tip 设平衡因子为 $f$ ，则一棵 AVL 树的任意节点的平衡因子皆满足 $-1 \le f \le 1$ 。 @@ -956,24 +921,6 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 右旋操作 - fn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) { - var child = node.?.left; - var grandChild = child.?.right; - // 以 child 为原点，将 node 向右旋转 - child.?.right = node; - node.?.left = grandChild; - // 更新节点高度 - self.updateHeight(node); - self.updateHeight(child); - // 返回旋转后子树的根节点 - return child; - } - ``` - ### 2. 左旋 相应地，如果考虑上述失衡二叉树的“镜像”，则需要执行图 7-28 所示的“左旋”操作。 @@ -1229,24 +1176,6 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 左旋操作 - fn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) { - var child = node.?.right; - var grandChild = child.?.left; - // 以 child 为原点，将 node 向左旋转 - child.?.left = node; - node.?.right = grandChild; - // 更新节点高度 - self.updateHeight(node); - self.updateHeight(child); - // 返回旋转后子树的根节点 - return child; - } - ``` - ### 3. 先左旋后右旋 对于图 7-30 中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 `child` 执行“左旋”，再对 `node` 执行“右旋”。 @@ -1730,40 +1659,6 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 执行旋转操作，使该子树重新恢复平衡 - fn rotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) { - // 获取节点 node 的平衡因子 - var balance_factor = self.balanceFactor(node); - // 左偏树 - if (balance_factor > 1) { - if (self.balanceFactor(node.?.left) >= 0) { - // 右旋 - return self.rightRotate(node); - } else { - // 先左旋后右旋 - node.?.left = self.leftRotate(node.?.left); - return self.rightRotate(node); - } - } - // 右偏树 - if (balance_factor < -1) { - if (self.balanceFactor(node.?.right) <= 0) { - // 左旋 - return self.leftRotate(node); - } else { - // 先右旋后左旋 - node.?.right = self.rightRotate(node.?.right); - return self.leftRotate(node); - } - } - // 平衡树，无须旋转，直接返回 - return node; - } - ``` - ## 7.5.3 AVL 树常用操作 ### 1. 插入节点 @@ -2142,38 +2037,6 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 插入节点 - fn insert(self: *Self, val: T) !void { - self.root = (try self.insertHelper(self.root, val)).?; - } - - // 递归插入节点（辅助方法） - fn insertHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) !?*inc.TreeNode(T) { - var node = node_; - if (node == null) { - var tmp_node = try self.mem_allocator.create(inc.TreeNode(T)); - tmp_node.init(val); - return tmp_node; - } - // 1. 查找插入位置并插入节点 - if (val < node.?.val) { - node.?.left = try self.insertHelper(node.?.left, val); - } else if (val > node.?.val) { - node.?.right = try self.insertHelper(node.?.right, val); - } else { - return node; // 重复节点不插入，直接返回 - } - self.updateHeight(node); // 更新节点高度 - // 2. 执行旋转操作，使该子树重新恢复平衡 - node = self.rotate(node); - // 返回子树的根节点 - return node; - } - ``` - ### 2. 删除节点 类似地，在二叉搜索树的删除节点方法的基础上，需要从底至顶执行旋转操作，使所有失衡节点恢复平衡。代码如下所示： @@ -2775,51 +2638,6 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区 end ``` -=== "Zig" - - ```zig title="avl_tree.zig" - // 删除节点 - fn remove(self: *Self, val: T) void { - self.root = self.removeHelper(self.root, val).?; - } - - // 递归删除节点（辅助方法） - fn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) { - var node = node_; - if (node == null) return null; - // 1. 查找节点并删除 - if (val < node.?.val) { - node.?.left = self.removeHelper(node.?.left, val); - } else if (val > node.?.val) { - node.?.right = self.removeHelper(node.?.right, val); - } else { - if (node.?.left == null or node.?.right == null) { - var child = if (node.?.left != null) node.?.left else node.?.right; - // 子节点数量 = 0 ，直接删除 node 并返回 - if (child == null) { - return null; - // 子节点数量 = 1 ，直接删除 node - } else { - node = child; - } - } else { - // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点 - var temp = node.?.right; - while (temp.?.left != null) { - temp = temp.?.left; - } - node.?.right = self.removeHelper(node.?.right, temp.?.val); - node.?.val = temp.?.val; - } - } - self.updateHeight(node); // 更新节点高度 - // 2. 执行旋转操作，使该子树重新恢复平衡 - node = self.rotate(node); - // 返回子树的根节点 - return node; - } - ``` - ### 3. 查找节点 AVL 树的节点查找操作与二叉搜索树一致，在此不再赘述。 diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index 0602ab231..1cdd5bcc2 100755 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -338,30 +338,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_search_tree.zig" - // 查找节点 - fn search(self: *Self, num: T) ?*inc.TreeNode(T) { - var cur = self.root; - // 循环查找，越过叶节点后跳出 - while (cur != null) { - // 目标节点在 cur 的右子树中 - if (cur.?.val < num) { - cur = cur.?.right; - // 目标节点在 cur 的左子树中 - } else if (cur.?.val > num) { - cur = cur.?.left; - // 找到目标节点，跳出循环 - } else { - break; - } - } - // 返回目标节点 - return cur; - } - ``` - ??? pythontutor "可视化运行" @@ -826,42 +802,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_search_tree.zig" - // 插入节点 - fn insert(self: *Self, num: T) !void { - // 若树为空，则初始化根节点 - if (self.root == null) { - self.root = try self.mem_allocator.create(inc.TreeNode(T)); - return; - } - var cur = self.root; - var pre: ?*inc.TreeNode(T) = null; - // 循环查找，越过叶节点后跳出 - while (cur != null) { - // 找到重复节点，直接返回 - if (cur.?.val == num) return; - pre = cur; - // 插入位置在 cur 的右子树中 - if (cur.?.val < num) { - cur = cur.?.right; - // 插入位置在 cur 的左子树中 - } else { - cur = cur.?.left; - } - } - // 插入节点 - var node = try self.mem_allocator.create(inc.TreeNode(T)); - node.init(num); - if (pre.?.val < num) { - pre.?.right = node; - } else { - pre.?.left = node; - } - } - ``` - ??? pythontutor "可视化运行" @@ -1648,56 +1588,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_search_tree.zig" - // 删除节点 - fn remove(self: *Self, num: T) void { - // 若树为空，直接提前返回 - if (self.root == null) return; - var cur = self.root; - var pre: ?*inc.TreeNode(T) = null; - // 循环查找，越过叶节点后跳出 - while (cur != null) { - // 找到待删除节点，跳出循环 - if (cur.?.val == num) break; - pre = cur; - // 待删除节点在 cur 的右子树中 - if (cur.?.val < num) { - cur = cur.?.right; - // 待删除节点在 cur 的左子树中 - } else { - cur = cur.?.left; - } - } - // 若无待删除节点，则直接返回 - if (cur == null) return; - // 子节点数量 = 0 or 1 - if (cur.?.left == null or cur.?.right == null) { - // 当子节点数量 = 0 / 1 时， child = null / 该子节点 - var child = if (cur.?.left != null) cur.?.left else cur.?.right; - // 删除节点 cur - if (pre.?.left == cur) { - pre.?.left = child; - } else { - pre.?.right = child; - } - // 子节点数量 = 2 - } else { - // 获取中序遍历中 cur 的下一个节点 - var tmp = cur.?.right; - while (tmp.?.left != null) { - tmp = tmp.?.left; - } - var tmp_val = tmp.?.val; - // 递归删除节点 tmp - self.remove(tmp.?.val); - // 用 tmp 覆盖 cur - cur.?.val = tmp_val; - } - } - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index 84e788d8e..93548fd37 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -205,12 +205,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="" - - ``` - 每个节点都有两个引用（指针），分别指向左子节点（left-child node）和右子节点（right-child node），该节点被称为这两个子节点的父节点（parent node）。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的左子树（left subtree），同理可得右子树（right subtree）。 **在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树**。如图 7-1 所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。 @@ -463,12 +457,6 @@ comments: true n2.right = n5 ``` -=== "Zig" - - ```zig title="binary_tree.zig" - - ``` - ??? pythontutor "可视化运行" @@ -638,12 +626,6 @@ comments: true n1.left = n2 ``` -=== "Zig" - - ```zig title="binary_tree.zig" - - ``` - ??? pythontutor "可视化运行" diff --git a/docs/chapter_tree/binary_tree_traversal.md b/docs/chapter_tree/binary_tree_traversal.md index d0a90e11c..9dbbc550a 100755 --- a/docs/chapter_tree/binary_tree_traversal.md +++ b/docs/chapter_tree/binary_tree_traversal.md @@ -334,38 +334,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_tree_bfs.zig" - // 层序遍历 - fn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) { - // 初始化队列，加入根节点 - const L = std.TailQueue(*inc.TreeNode(T)); - var queue = L{}; - var root_node = try mem_allocator.create(L.Node); - root_node.data = root; - queue.append(root_node); - // 初始化一个列表，用于保存遍历序列 - var list = std.ArrayList(T).init(std.heap.page_allocator); - while (queue.len > 0) { - var queue_node = queue.popFirst().?; // 队列出队 - var node = queue_node.data; - try list.append(node.val); // 保存节点值 - if (node.left != null) { - var tmp_node = try mem_allocator.create(L.Node); - tmp_node.data = node.left.?; - queue.append(tmp_node); // 左子节点入队 - } - if (node.right != null) { - var tmp_node = try mem_allocator.create(L.Node); - tmp_node.data = node.right.?; - queue.append(tmp_node); // 右子节点入队 - } - } - return list; - } - ``` - ??? pythontutor "可视化运行" @@ -851,37 +819,6 @@ comments: true end ``` -=== "Zig" - - ```zig title="binary_tree_dfs.zig" - // 前序遍历 - fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void { - if (root == null) return; - // 访问优先级：根节点 -> 左子树 -> 右子树 - try list.append(root.?.val); - try preOrder(T, root.?.left); - try preOrder(T, root.?.right); - } - - // 中序遍历 - fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void { - if (root == null) return; - // 访问优先级：左子树 -> 根节点 -> 右子树 - try inOrder(T, root.?.left); - try list.append(root.?.val); - try inOrder(T, root.?.right); - } - - // 后序遍历 - fn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void { - if (root == null) return; - // 访问优先级：左子树 -> 右子树 -> 根节点 - try postOrder(T, root.?.left); - try postOrder(T, root.?.right); - try list.append(root.?.val); - } - ``` - ??? pythontutor "可视化运行" diff --git a/en/docs/chapter_appendix/contribution.md b/en/docs/chapter_appendix/contribution.md index 924351851..339629089 100644 --- a/en/docs/chapter_appendix/contribution.md +++ b/en/docs/chapter_appendix/contribution.md @@ -2,45 +2,45 @@ comments: true --- -# 16.2 Contributing +# 16.2 Contributing Together -Due to the limited abilities of the author, some omissions and errors are inevitable in this book. Please understand. If you discover any typos, broken links, missing content, textual ambiguities, unclear explanations, or unreasonable text structures, please assist us in making corrections to provide readers with better quality learning resources. +Due to limited capacity, there may be inevitable omissions and errors in this book. We appreciate your understanding and are grateful for your help in correcting them. If you discover typos, broken links, missing content, ambiguous wording, unclear explanations, or structural issues, please help us make corrections to provide readers with higher-quality learning resources. -The GitHub IDs of all [contributors](https://github.com/krahets/hello-algo/graphs/contributors) will be displayed on the repository, web, and PDF versions of the homepage of this book to thank them for their selfless contributions to the open-source community. +The GitHub IDs of all [contributors](https://github.com/krahets/hello-algo/graphs/contributors) will be displayed on the homepage of the book repository, the web version, and the PDF version to acknowledge their selfless contributions to the open source community. -!!! success "The charm of open source" +!!! success "The Charm of Open Source" - The interval between two printings of a paper book is often long, making content updates very inconvenient. - - In this open-source book, however, the content update cycle is shortened to just a few days or even hours. + The interval between two printings of a physical book is often quite long, making content updates very inconvenient. -### 1. Content fine-tuning + In this open source book, the time for content updates has been shortened to just days or even hours. -As shown in Figure 16-3, there is an "edit icon" in the upper right corner of each page. You can follow these steps to modify text or code. +### 1. Minor Content Adjustments -1. Click the "edit icon". If prompted to "fork this repository", please agree to do so. -2. Modify the Markdown source file content, check the accuracy of the content, and try to keep the formatting consistent. -3. Fill in the modification description at the bottom of the page, then click the "Propose file change" button. After the page redirects, click the "Create pull request" button to initiate the pull request. +As shown in Figure 16-3, there is an "edit icon" in the top-right corner of each page. You can modify text or code by following these steps. -{ class="animation-figure" } +1. Click the "edit icon". If you encounter a prompt asking you to "Fork this repository", please approve the operation. +2. Modify the content of the Markdown source file, verify the correctness of the content, and maintain consistent formatting as much as possible. +3. Fill in a description of your changes at the bottom of the page, then click the "Propose file change" button. After the page transitions, click the "Create pull request" button to submit your pull request. -Figure 16-3 Edit page button
+{ class="animation-figure" } -Figures cannot be directly modified and require the creation of a new [Issue](https://github.com/krahets/hello-algo/issues) or a comment to describe the problem. We will redraw and replace the figures as soon as possible. +Figure 16-3 Page edit button
-### 2. Content creation +Images cannot be directly modified. Please describe the issue by creating a new [Issue](https://github.com/krahets/hello-algo/issues) or leaving a comment. We will promptly redraw and replace the images. -If you are interested in participating in this open-source project, including translating code into other programming languages or expanding article content, then the following Pull Request workflow needs to be implemented. +### 2. Content Creation -1. Log in to GitHub and Fork the [code repository](https://github.com/krahets/hello-algo) of this book to your personal account. -2. Go to your Forked repository web page and use the `git clone` command to clone the repository to your local machine. -3. Create content locally and perform complete tests to verify the correctness of the code. -4. Commit the changes made locally, then push them to the remote repository. -5. Refresh the repository webpage and click the "Create pull request" button to initiate the pull request. +If you are interested in contributing to this open source project, including translating code into other programming languages or expanding article content, you will need to follow the Pull Request workflow below. -### 3. Docker deployment +1. Log in to GitHub and Fork the book's [code repository](https://github.com/krahets/hello-algo) to your personal account. +2. Enter your forked repository webpage and use the `git clone` command to clone the repository to your local machine. +3. Create content locally and conduct comprehensive tests to verify code correctness. +4. Commit your local changes and push them to the remote repository. +5. Refresh the repository webpage and click the "Create pull request" button to submit your pull request. -In the `hello-algo` root directory, execute the following Docker script to access the project at `http://localhost:8000`: +### 3. Docker Deployment + +From the root directory of `hello-algo`, run the following Docker script to access the project at `http://localhost:8000`: ```shell docker-compose up -d diff --git a/en/docs/chapter_appendix/index.md b/en/docs/chapter_appendix/index.md index 807cc622a..fdc1e490c 100644 --- a/en/docs/chapter_appendix/index.md +++ b/en/docs/chapter_appendix/index.md @@ -9,6 +9,6 @@ icon: material/help-circle-outline ## Chapter contents -- [16.1 Installation](installation.md) -- [16.2 Contributing](contribution.md) -- [16.3 Terminology](terminology.md) +- [16.1 Programming Environment Installation](installation.md) +- [16.2 Contributing Together](contribution.md) +- [16.3 Terminology Table](terminology.md) diff --git a/en/docs/chapter_appendix/installation.md b/en/docs/chapter_appendix/installation.md index fc8b3b357..be665333d 100644 --- a/en/docs/chapter_appendix/installation.md +++ b/en/docs/chapter_appendix/installation.md @@ -2,75 +2,75 @@ comments: true --- -# 16.1 Installation +# 16.1 Programming Environment Installation -## 16.1.1 Install IDE +## 16.1.1 Installing Ide -We recommend using the open-source, lightweight VS Code as your local Integrated Development Environment (IDE). Visit the [VS Code official website](https://code.visualstudio.com/) and choose the version of VS Code appropriate for your operating system to download and install. +We recommend using the open-source and lightweight VS Code as the local integrated development environment (IDE). Visit the [VS Code official website](https://code.visualstudio.com/), and download and install the appropriate version of VS Code according to your operating system. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 16-1 Download VS Code from the official website
+Figure 16-1 Download VS Code from the Official Website
-VS Code has a powerful extension ecosystem, supporting the execution and debugging of most programming languages. For example, after installing the "Python Extension Pack," you can debug Python code. The installation steps are shown in Figure 16-2. +VS Code has a powerful ecosystem of extensions that supports running and debugging most programming languages. For example, after installing the "Python Extension Pack" extension, you can debug Python code. The installation steps are shown in the following figure. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 16-2 Install VS Code Extension Pack
+Figure 16-2 Install VS Code Extensions
-## 16.1.2 Install language environments +## 16.1.2 Installing Language Environments -### 1. Python environment +### 1. Python Environment -1. Download and install [Miniconda3](https://docs.conda.io/en/latest/miniconda.html), requiring Python 3.10 or newer. -2. In the VS Code extension marketplace, search for `python` and install the Python Extension Pack. -3. (Optional) Enter `pip install black` in the command line to install the code formatting tool. +1. Download and install [Miniconda3](https://docs.conda.io/en/latest/miniconda.html), which requires Python 3.10 or newer. +2. Search for `python` in the VS Code extension marketplace and install the Python Extension Pack. +3. (Optional) Enter `pip install black` on the command line to install the code formatter. -### 2. C/C++ environment +### 2. C/c++ Environment -1. Windows systems need to install [MinGW](https://sourceforge.net/projects/mingw-w64/files/) ([Configuration tutorial](https://blog.csdn.net/qq_33698226/article/details/129031241)); MacOS comes with Clang, so no installation is necessary. -2. In the VS Code extension marketplace, search for `c++` and install the C/C++ Extension Pack. +1. Windows systems need to install [MinGW](https://sourceforge.net/projects/mingw-w64/files/) ([configuration tutorial](https://blog.csdn.net/qq_33698226/article/details/129031241)); macOS comes with Clang built-in and does not require installation. +2. Search for `c++` in the VS Code extension marketplace and install the C/C++ Extension Pack. 3. (Optional) Open the Settings page, search for the `Clang_format_fallback Style` code formatting option, and set it to `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }`. -### 3. Java environment +### 3. Java Environment 1. Download and install [OpenJDK](https://jdk.java.net/18/) (version must be > JDK 9). -2. In the VS Code extension marketplace, search for `java` and install the Extension Pack for Java. +2. Search for `java` in the VS Code extension marketplace and install the Extension Pack for Java. -### 4. C# environment +### 4. C# Environment 1. Download and install [.Net 8.0](https://dotnet.microsoft.com/en-us/download). -2. In the VS Code extension marketplace, search for `C# Dev Kit` and install the C# Dev Kit ([Configuration tutorial](https://code.visualstudio.com/docs/csharp/get-started)). -3. You can also use Visual Studio ([Installation tutorial](https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022)). +2. Search for `C# Dev Kit` in the VS Code extension marketplace and install C# Dev Kit ([configuration tutorial](https://code.visualstudio.com/docs/csharp/get-started)). +3. You can also use Visual Studio ([installation tutorial](https://learn.microsoft.com/zh-cn/visualstudio/install/install-visual-studio?view=vs-2022)). -### 5. Go environment +### 5. Go Environment -1. Download and install [go](https://go.dev/dl/). -2. In the VS Code extension marketplace, search for `go` and install Go. -3. Press `Ctrl + Shift + P` to call up the command bar, enter go, choose `Go: Install/Update Tools`, select all and install. +1. Download and install [Go](https://go.dev/dl/). +2. Search for `go` in the VS Code extension marketplace and install Go. +3. Press `Ctrl + Shift + P` to open the command palette, type `go`, select `Go: Install/Update Tools`, check all options and install. -### 6. Swift environment +### 6. Swift Environment 1. Download and install [Swift](https://www.swift.org/download/). -2. In the VS Code extension marketplace, search for `swift` and install [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang). +2. Search for `swift` in the VS Code extension marketplace and install [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang). -### 7. JavaScript environment +### 7. Javascript Environment 1. Download and install [Node.js](https://nodejs.org/en/). -2. (Optional) In the VS Code extension marketplace, search for `Prettier` and install the code formatting tool. +2. (Optional) Search for `Prettier` in the VS Code extension marketplace and install the code formatter. -### 8. TypeScript environment +### 8. Typescript Environment 1. Follow the same installation steps as the JavaScript environment. 2. Install [TypeScript Execute (tsx)](https://github.com/privatenumber/tsx?tab=readme-ov-file#global-installation). -3. In the VS Code extension marketplace, search for `typescript` and install [Pretty TypeScript Errors](https://marketplace.visualstudio.com/items?itemName=yoavbls.pretty-ts-errors). +3. Search for `typescript` in the VS Code extension marketplace and install [Pretty TypeScript Errors](https://marketplace.visualstudio.com/items?itemName=yoavbls.pretty-ts-errors). -### 9. Dart environment +### 9. Dart Environment 1. Download and install [Dart](https://dart.dev/get-dart). -2. In the VS Code extension marketplace, search for `dart` and install [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code). +2. Search for `dart` in the VS Code extension marketplace and install [Dart](https://marketplace.visualstudio.com/items?itemName=Dart-Code.dart-code). -### 10. Rust environment +### 10. Rust Environment 1. Download and install [Rust](https://www.rust-lang.org/tools/install). -2. In the VS Code extension marketplace, search for `rust` and install [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). +2. Search for `rust` in the VS Code extension marketplace and install [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). diff --git a/en/docs/chapter_appendix/terminology.md b/en/docs/chapter_appendix/terminology.md index e8e0957e0..085304a38 100644 --- a/en/docs/chapter_appendix/terminology.md +++ b/en/docs/chapter_appendix/terminology.md @@ -2,19 +2,19 @@ comments: true --- -# 16.3 Glossary +# 16.3 Terminology Table -Table 16-1 lists the important terms that appear in the book, and it is worth noting the following points. +The following table lists important terms that appear in this book. It is worth noting the following points: -- It is recommended to remember the English names of the terms to facilitate reading English literature. -- Some terms have different names in Simplified and Traditional Chinese. +- We recommend remembering the English names of terms to help with reading English literature. +- Some terms have different names in Simplified Chinese and Traditional Chinese.Table 16-1 Important Terms in Data Structures and Algorithms
Figure 4-1 Array definition and storage method
-## 4.1.1 Common operations on arrays +## 4.1.1 Common Array Operations -### 1. Initializing arrays +### 1. Initializing Arrays -Arrays can be initialized in two ways depending on the needs: either without initial values or with specified initial values. When initial values are not specified, most programming languages will set the array elements to $0$: +We can choose between two array initialization methods based on our needs: without initial values or with given initial values. When no initial values are specified, most programming languages will initialize array elements to $0$: === "Python" @@ -31,7 +31,7 @@ Arrays can be initialized in two ways depending on the needs: either without ini // Stored on stack int arr[5]; int nums[5] = { 1, 3, 2, 5, 4 }; - // Stored on heap (manual memory release needed) + // Stored on heap (requires manual memory release) int* arr1 = new int[5]; int* nums1 = new int[5] { 1, 3, 2, 5, 4 }; ``` @@ -57,9 +57,9 @@ Arrays can be initialized in two ways depending on the needs: either without ini ```go title="array.go" /* Initialize array */ var arr [5]int - // In Go, specifying the length ([5]int) denotes an array, while not specifying it ([]int) denotes a slice. - // Since Go's arrays are designed to have compile-time fixed length, only constants can be used to specify the length. - // For convenience in implementing the extend() method, the Slice will be considered as an Array here. + // In Go, specifying length ([5]int) creates an array; not specifying length ([]int) creates a slice + // Since Go's arrays are designed to have their length determined at compile time, only constants can be used to specify the length + // For convenience in implementing the extend() method, slices are treated as arrays below nums := []int{1, 3, 2, 5, 4} ``` @@ -101,10 +101,10 @@ Arrays can be initialized in two ways depending on the needs: either without ini /* Initialize array */ 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. + // In Rust, specifying length ([i32; 5]) creates an array; not specifying length (&[i32]) creates a slice + // Since Rust's arrays are designed to have their length determined at compile time, only constants can be used to specify the length + // Vector is the type generally used as a dynamic array in Rust + // For convenience in implementing the extend() method, vectors are treated as arrays below let nums: VecFigure 4-2 Memory address calculation for array elements
-As observed in Figure 4-2, array indexing conventionally begins at $0$. While this might appear counterintuitive, considering counting usually starts at $1$, within the address calculation formula, **an index is essentially an offset from the memory address**. For the first element's address, this offset is $0$, validating its index as $0$. +Observing Figure 4-2, we find that the first element of an array has an index of $0$, which may seem counterintuitive since counting from $1$ would be more natural. However, from the perspective of the address calculation formula, **an index is essentially an offset from the memory address**. The address offset of the first element is $0$, so it is reasonable for its index to be $0$. -Accessing elements in an array is highly efficient, allowing us to randomly access any element in $O(1)$ time. +Accessing elements in an array is highly efficient; we can randomly access any element in the array in $O(1)$ time. === "Python" ```python title="array.py" def random_access(nums: list[int]) -> int: - """Random access to elements""" + """Random access to element""" # Randomly select a number from the interval [0, len(nums)-1] random_index = random.randint(0, len(nums) - 1) - # Retrieve and return a random element + # Retrieve and return the random element random_num = nums[random_index] return random_num ``` @@ -157,11 +164,11 @@ Accessing elements in an array is highly efficient, allowing us to randomly acce === "C++" ```cpp title="array.cpp" - /* Random access to elements */ + /* Random access to element */ int randomAccess(int *nums, int size) { - // Randomly select a number in the range [0, size) + // Randomly select a number from interval [0, size) int randomIndex = rand() % size; - // Retrieve and return a random element + // Retrieve and return the random element int randomNum = nums[randomIndex]; return randomNum; } @@ -170,11 +177,11 @@ Accessing elements in an array is highly efficient, allowing us to randomly acce === "Java" ```java title="array.java" - /* Random access to elements */ + /* Random access to element */ int randomAccess(int[] nums) { // Randomly select a number in the interval [0, nums.length) int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length); - // Retrieve and return a random element + // Retrieve and return the random element int randomNum = nums[randomIndex]; return randomNum; } @@ -183,101 +190,166 @@ Accessing elements in an array is highly efficient, allowing us to randomly acce === "C#" ```csharp title="array.cs" - [class]{array}-[func]{RandomAccess} + /* Random access to element */ + int RandomAccess(int[] nums) { + Random random = new(); + // Randomly select a number in interval [0, nums.Length) + int randomIndex = random.Next(nums.Length); + // Retrieve and return the random element + int randomNum = nums[randomIndex]; + return randomNum; + } ``` === "Go" ```go title="array.go" - [class]{}-[func]{randomAccess} + /* Random access to element */ + func randomAccess(nums []int) (randomNum int) { + // Randomly select a number in the interval [0, nums.length) + randomIndex := rand.Intn(len(nums)) + // Retrieve and return the random element + randomNum = nums[randomIndex] + return + } ``` === "Swift" ```swift title="array.swift" - [class]{}-[func]{randomAccess} + /* Random access to element */ + func randomAccess(nums: [Int]) -> Int { + // Randomly select a number in interval [0, nums.count) + let randomIndex = nums.indices.randomElement()! + // Retrieve and return the random element + let randomNum = nums[randomIndex] + return randomNum + } ``` === "JS" ```javascript title="array.js" - [class]{}-[func]{randomAccess} + /* Random access to element */ + function randomAccess(nums) { + // Randomly select a number in the interval [0, nums.length) + const random_index = Math.floor(Math.random() * nums.length); + // Retrieve and return the random element + const random_num = nums[random_index]; + return random_num; + } ``` === "TS" ```typescript title="array.ts" - [class]{}-[func]{randomAccess} + /* Random access to element */ + function randomAccess(nums: number[]): number { + // Randomly select a number in the interval [0, nums.length) + const random_index = Math.floor(Math.random() * nums.length); + // Retrieve and return the random element + const random_num = nums[random_index]; + return random_num; + } ``` === "Dart" ```dart title="array.dart" - [class]{}-[func]{randomAccess} + /* Random access to element */ + int randomAccess(ListFigure 4-3 Example of inserting an element into an array
-{ class="animation-figure" } - -Figure 4-3 Array element insertion example
- -It's important to note that due to the fixed length of an array, inserting an element will unavoidably result in the loss of the last element in the array. Solutions to address this issue will be explored in the "List" chapter. +It is worth noting that since the length of an array is fixed, inserting an element will inevitably cause the element at the end of the array to be "lost". We will leave the solution to this problem for discussion in the "List" chapter. === "Python" ```python title="array.py" def insert(nums: list[int], num: int, index: int): - """Insert element num at `index`""" - # Move all elements after `index` one position backward + """Insert element num at index index in the array""" + # Move all elements at and after index index backward by one position for i in range(len(nums) - 1, index, -1): nums[i] = nums[i - 1] - # Assign num to the element at index + # Assign num to the element at index index nums[index] = num ``` === "C++" ```cpp title="array.cpp" - /* Insert element num at `index` */ + /* Insert element num at index index in the array */ void insert(int *nums, int size, int num, int index) { - // Move all elements after `index` one position backward + // Move all elements at and after index index backward by one position for (int i = size - 1; i > index; i--) { nums[i] = nums[i - 1]; } - // Assign num to the element at index + // Assign num to the element at index index nums[index] = num; } ``` @@ -285,13 +357,13 @@ It's important to note that due to the fixed length of an array, inserting an el === "Java" ```java title="array.java" - /* Insert element num at `index` */ + /* Insert element num at index index in the array */ void insert(int[] nums, int num, int index) { - // Move all elements after `index` one position backward + // Move all elements at and after index index backward by one position for (int i = nums.length - 1; i > index; i--) { nums[i] = nums[i - 1]; } - // Assign num to the element at index + // Assign num to the element at index index nums[index] = num; } ``` @@ -299,85 +371,160 @@ It's important to note that due to the fixed length of an array, inserting an el === "C#" ```csharp title="array.cs" - [class]{array}-[func]{Insert} + /* Insert element num at index index in the array */ + void Insert(int[] nums, int num, int index) { + // Move all elements at and after index index backward by one position + for (int i = nums.Length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // Assign num to the element at index index + nums[index] = num; + } ``` === "Go" ```go title="array.go" - [class]{}-[func]{insert} + /* Insert element num at index index in the array */ + func insert(nums []int, num int, index int) { + // Move all elements at and after index index backward by one position + for i := len(nums) - 1; i > index; i-- { + nums[i] = nums[i-1] + } + // Assign num to the element at index index + nums[index] = num + } ``` === "Swift" ```swift title="array.swift" - [class]{}-[func]{insert} + /* Insert element num at index index in the array */ + func insert(nums: inout [Int], num: Int, index: Int) { + // Move all elements at and after index index backward by one position + for i in nums.indices.dropFirst(index).reversed() { + nums[i] = nums[i - 1] + } + // Assign num to the element at index index + nums[index] = num + } ``` === "JS" ```javascript title="array.js" - [class]{}-[func]{insert} + /* Insert element num at index index in the array */ + function insert(nums, num, index) { + // Move all elements at and after index index backward by one position + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // Assign num to the element at index index + nums[index] = num; + } ``` === "TS" ```typescript title="array.ts" - [class]{}-[func]{insert} + /* Insert element num at index index in the array */ + function insert(nums: number[], num: number, index: number): void { + // Move all elements at and after index index backward by one position + for (let i = nums.length - 1; i > index; i--) { + nums[i] = nums[i - 1]; + } + // Assign num to the element at index index + nums[index] = num; + } ``` === "Dart" ```dart title="array.dart" - [class]{}-[func]{insert} + /* Insert element _num at array index index */ + void insert(ListFigure 4-4 Example of removing an element from an array
-{ class="animation-figure" } - -Figure 4-4 Array element deletion example
- -Please note that after deletion, the former last element becomes "meaningless," hence requiring no specific modification. +Note that after the deletion is complete, the original last element becomes "meaningless", so we do not need to specifically modify it. === "Python" ```python title="array.py" def remove(nums: list[int], index: int): - """Remove the element at `index`""" - # Move all elements after `index` one position forward + """Remove the element at index index""" + # Move all elements after index index forward by one position for i in range(index, len(nums) - 1): nums[i] = nums[i + 1] ``` @@ -385,9 +532,9 @@ Please note that after deletion, the former last element becomes "meaningless," === "C++" ```cpp title="array.cpp" - /* Remove the element at `index` */ + /* Remove the element at index index */ void remove(int *nums, int size, int index) { - // Move all elements after `index` one position forward + // Move all elements after index index forward by one position for (int i = index; i < size - 1; i++) { nums[i] = nums[i + 1]; } @@ -397,9 +544,9 @@ Please note that after deletion, the former last element becomes "meaningless," === "Java" ```java title="array.java" - /* Remove the element at `index` */ + /* Remove the element at index index */ void remove(int[] nums, int index) { - // Move all elements after `index` one position forward + // Move all elements after index index forward by one position for (int i = index; i < nums.length - 1; i++) { nums[i] = nums[i + 1]; } @@ -409,78 +556,133 @@ Please note that after deletion, the former last element becomes "meaningless," === "C#" ```csharp title="array.cs" - [class]{array}-[func]{Remove} + /* Remove the element at index index */ + void Remove(int[] nums, int index) { + // Move all elements after index index forward by one position + for (int i = index; i < nums.Length - 1; i++) { + nums[i] = nums[i + 1]; + } + } ``` === "Go" ```go title="array.go" - [class]{}-[func]{remove} + /* Remove the element at index index */ + func remove(nums []int, index int) { + // Move all elements after index index forward by one position + for i := index; i < len(nums)-1; i++ { + nums[i] = nums[i+1] + } + } ``` === "Swift" ```swift title="array.swift" - [class]{}-[func]{remove} + /* Remove the element at index index */ + func remove(nums: inout [Int], index: Int) { + // Move all elements after index index forward by one position + for i in nums.indices.dropFirst(index).dropLast() { + nums[i] = nums[i + 1] + } + } ``` === "JS" ```javascript title="array.js" - [class]{}-[func]{remove} + /* Remove the element at index index */ + function remove(nums, index) { + // Move all elements after index index forward by one position + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } ``` === "TS" ```typescript title="array.ts" - [class]{}-[func]{remove} + /* Remove the element at index index */ + function remove(nums: number[], index: number): void { + // Move all elements after index index forward by one position + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } ``` === "Dart" ```dart title="array.dart" - [class]{}-[func]{remove} + /* Remove the element at index index */ + void remove(ListFigure 4-5 Linked list definition and storage method
-As shown in Figure 4-5, we see that the basic building block of a linked list is the node object. Each node comprises two key components: the node's "value" and a "reference" to the next node. +Observing Figure 4-5, the basic unit of a linked list is a node object. Each node contains two pieces of data: the node's "value" and a "reference" to the next node. -- The first node in a linked list is the "head node", and the final one is the "tail node". -- The tail node points to "null", designated as `null` in Java, `nullptr` in C++, and `None` in Python. -- In languages that support pointers, like C, C++, Go, and Rust, this "reference" is typically implemented as a "pointer". +- The first node of a linked list is called the "head node", and the last node is called the "tail node". +- The tail node points to "null", which is denoted as `null`, `nullptr`, and `None` in Java, C++, and Python, respectively. +- In languages that support pointers, such as C, C++, Go, and Rust, the aforementioned "reference" should be replaced with "pointer". -As the code below illustrates, a `ListNode` in a linked list, besides holding a value, must also maintain an additional reference (or pointer). Therefore, **a linked list occupies more memory space than an array when storing the same quantity of data.**. +As shown in the following code, a linked list node `ListNode` contains not only a value but also an additional reference (pointer). Therefore, **linked lists occupy more memory space than arrays when storing the same amount of data**. === "Python" @@ -168,39 +168,39 @@ As the code below illustrates, a `ListNode` in a linked list, besides holding a === "Kotlin" ```kotlin title="" - - ``` - -=== "Zig" - - ```zig title="" - // Linked list node class - pub fn ListNode(comptime T: type) type { - return struct { - const Self = @This(); - - val: T = 0, // Node value - next: ?*Self = null, // Pointer to the next node - - // Constructor - pub fn init(self: *Self, x: i32) void { - self.val = x; - self.next = null; - } - }; + /* Linked list node class */ + // Constructor + class ListNode(x: Int) { + val _val: Int = x // Node value + val next: ListNode? = null // Reference to the next node } ``` -## 4.2.1 Common operations on linked lists +=== "Ruby" -### 1. Initializing a linked list + ```ruby title="" + # Linked list node class + class ListNode + attr_accessor :val # Node value + attr_accessor :next # Reference to the next node -Constructing a linked list is a two-step process: first, initializing each node object, and second, forming the reference links between the nodes. After initialization, we can traverse all nodes sequentially from the head node by following the `next` reference. + def initialize(val=0, next_node=nil) + @val = val + @next = next_node + end + end + ``` + +## 4.2.1 Common Linked List Operations + +### 1. Initializing a Linked List + +Building a linked list involves two steps: first, initializing each node object; second, constructing the reference relationships between nodes. Once initialization is complete, we can traverse all nodes starting from the head node of the linked list through the reference `next`. === "Python" ```python title="linked_list.py" - # Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 + # Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 # Initialize each node n0 = ListNode(1) n1 = ListNode(3) @@ -217,7 +217,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "C++" ```cpp title="linked_list.cpp" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node ListNode* n0 = new ListNode(1); ListNode* n1 = new ListNode(3); @@ -234,7 +234,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "Java" ```java title="linked_list.java" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node ListNode n0 = new ListNode(1); ListNode n1 = new ListNode(3); @@ -251,7 +251,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "C#" ```csharp title="linked_list.cs" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node ListNode n0 = new(1); ListNode n1 = new(3); @@ -268,7 +268,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "Go" ```go title="linked_list.go" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node n0 := NewListNode(1) n1 := NewListNode(3) @@ -285,7 +285,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "Swift" ```swift title="linked_list.swift" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node let n0 = ListNode(x: 1) let n1 = ListNode(x: 3) @@ -302,7 +302,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "JS" ```javascript title="linked_list.js" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node const n0 = new ListNode(1); const n1 = new ListNode(3); @@ -319,7 +319,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "TS" ```typescript title="linked_list.ts" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node const n0 = new ListNode(1); const n1 = new ListNode(3); @@ -336,7 +336,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "Dart" ```dart title="linked_list.dart" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */\ // Initialize each node ListNode n0 = ListNode(1); ListNode n1 = ListNode(3); @@ -353,7 +353,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "Rust" ```rust title="linked_list.rs" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node let n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None })); let n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None })); @@ -371,7 +371,7 @@ Constructing a linked list is a two-step process: first, initializing each node === "C" ```c title="linked_list.c" - /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */ + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node ListNode* n0 = newListNode(1); ListNode* n1 = newListNode(3); @@ -388,37 +388,53 @@ Constructing a linked list is a two-step process: first, initializing each node === "Kotlin" ```kotlin title="linked_list.kt" - - ``` - -=== "Zig" - - ```zig title="linked_list.zig" - // Initialize linked list + /* Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 */ // Initialize each node - var n0 = inc.ListNode(i32){.val = 1}; - var n1 = inc.ListNode(i32){.val = 3}; - var n2 = inc.ListNode(i32){.val = 2}; - var n3 = inc.ListNode(i32){.val = 5}; - var n4 = inc.ListNode(i32){.val = 4}; + val n0 = ListNode(1) + val n1 = ListNode(3) + val n2 = ListNode(2) + val n3 = ListNode(5) + val n4 = ListNode(4) // Build references between nodes - n0.next = &n1; - n1.next = &n2; - n2.next = &n3; - n3.next = &n4; + n0.next = n1; + n1.next = n2; + n2.next = n3; + n3.next = n4; ``` -The array as a whole is a variable, for instance, the array `nums` includes elements like `nums[0]`, `nums[1]`, and so on, whereas a linked list is made up of several distinct node objects. **We typically refer to a linked list by its head node**, for example, the linked list in the previous code snippet is referred to as `n0`. +=== "Ruby" -### 2. Inserting nodes + ```ruby title="linked_list.rb" + # Initialize linked list 1 -> 3 -> 2 -> 5 -> 4 + # Initialize each node + n0 = ListNode.new(1) + n1 = ListNode.new(3) + n2 = ListNode.new(2) + n3 = ListNode.new(5) + n4 = ListNode.new(4) + # Build references between nodes + n0.next = n1 + n1.next = n2 + n2.next = n3 + n3.next = n4 + ``` -Inserting a node into a linked list is very easy. As shown in Figure 4-6, let's assume we aim to insert a new node `P` between two adjacent nodes `n0` and `n1`. **This can be achieved by simply modifying two node references (pointers)**, with a time complexity of $O(1)$. +??? pythontutor "Code Visualization" -By comparison, inserting an element into an array has a time complexity of $O(n)$, which becomes less efficient when dealing with large data volumes. + + -{ class="animation-figure" } +An array is a single variable; for example, an array `nums` contains elements `nums[0]`, `nums[1]`, etc. A linked list, however, is composed of multiple independent node objects. **We typically use the head node as the reference to the linked list**; for example, the linked list in the above code can be referred to as linked list `n0`. -Figure 4-6 Linked list node insertion example
+### 2. Inserting a Node + +Inserting a node in a linked list is very easy. As shown in Figure 4-6, suppose we want to insert a new node `P` between two adjacent nodes `n0` and `n1`. **We only need to change two node references (pointers)**, with a time complexity of $O(1)$. + +In contrast, the time complexity of inserting an element in an array is $O(n)$, which is inefficient when dealing with large amounts of data. + +{ class="animation-figure" } + +Figure 4-6 Example of inserting a node into a linked list
=== "Python" @@ -455,78 +471,124 @@ By comparison, inserting an element into an array has a time complexity of $O(n) === "C#" ```csharp title="linked_list.cs" - [class]{linked_list}-[func]{Insert} + /* Insert node P after node n0 in the linked list */ + void Insert(ListNode n0, ListNode P) { + ListNode? n1 = n0.next; + P.next = n1; + n0.next = P; + } ``` === "Go" ```go title="linked_list.go" - [class]{}-[func]{insertNode} + /* Insert node P after node n0 in the linked list */ + func insertNode(n0 *ListNode, P *ListNode) { + n1 := n0.Next + P.Next = n1 + n0.Next = P + } ``` === "Swift" ```swift title="linked_list.swift" - [class]{}-[func]{insert} + /* Insert node P after node n0 in the linked list */ + func insert(n0: ListNode, P: ListNode) { + let n1 = n0.next + P.next = n1 + n0.next = P + } ``` === "JS" ```javascript title="linked_list.js" - [class]{}-[func]{insert} + /* Insert node P after node n0 in the linked list */ + function insert(n0, P) { + const n1 = n0.next; + P.next = n1; + n0.next = P; + } ``` === "TS" ```typescript title="linked_list.ts" - [class]{}-[func]{insert} + /* Insert node P after node n0 in the linked list */ + function insert(n0: ListNode, P: ListNode): void { + const n1 = n0.next; + P.next = n1; + n0.next = P; + } ``` === "Dart" ```dart title="linked_list.dart" - [class]{}-[func]{insert} + /* Insert node P after node n0 in the linked list */ + void insert(ListNode n0, ListNode P) { + ListNode? n1 = n0.next; + P.next = n1; + n0.next = P; + } ``` === "Rust" ```rust title="linked_list.rs" - [class]{}-[func]{insert} + /* Insert node P after node n0 in the linked list */ + #[allow(non_snake_case)] + pub fn insertFigure 4-7 Linked list node deletion
+Figure 4-7 Removing a node from a linked list
=== "Python" @@ -574,78 +636,157 @@ It's important to note that even though node `P` continues to point to `n1` afte === "C#" ```csharp title="linked_list.cs" - [class]{linked_list}-[func]{Remove} + /* Remove the first node after node n0 in the linked list */ + void Remove(ListNode n0) { + if (n0.next == null) + return; + // n0 -> P -> n1 + ListNode P = n0.next; + ListNode? n1 = P.next; + n0.next = n1; + } ``` === "Go" ```go title="linked_list.go" - [class]{}-[func]{removeItem} + /* Remove the first node after node n0 in the linked list */ + func removeItem(n0 *ListNode) { + if n0.Next == nil { + return + } + // n0 -> P -> n1 + P := n0.Next + n1 := P.Next + n0.Next = n1 + } ``` === "Swift" ```swift title="linked_list.swift" - [class]{}-[func]{remove} + /* Remove the first node after node n0 in the linked list */ + func remove(n0: ListNode) { + if n0.next == nil { + return + } + // n0 -> P -> n1 + let P = n0.next + let n1 = P?.next + n0.next = n1 + } ``` === "JS" ```javascript title="linked_list.js" - [class]{}-[func]{remove} + /* Remove the first node after node n0 in the linked list */ + function remove(n0) { + if (!n0.next) return; + // n0 -> P -> n1 + const P = n0.next; + const n1 = P.next; + n0.next = n1; + } ``` === "TS" ```typescript title="linked_list.ts" - [class]{}-[func]{remove} + /* Remove the first node after node n0 in the linked list */ + function remove(n0: ListNode): void { + if (!n0.next) { + return; + } + // n0 -> P -> n1 + const P = n0.next; + const n1 = P.next; + n0.next = n1; + } ``` === "Dart" ```dart title="linked_list.dart" - [class]{}-[func]{remove} + /* Remove the first node after node n0 in the linked list */ + void remove(ListNode n0) { + if (n0.next == null) return; + // n0 -> P -> n1 + ListNode P = n0.next!; + ListNode? n1 = P.next; + n0.next = n1; + } ``` === "Rust" ```rust title="linked_list.rs" - [class]{}-[func]{remove} + /* Remove the first node after node n0 in the linked list */ + #[allow(non_snake_case)] + pub fn removeTable 4-1 Efficiency comparison of arrays and linked lists
+Table 4-1 Comparison of array and linked list efficiencies
Figure 4-8 Common types of linked lists
-## 4.2.4 Typical applications of linked lists +## 4.2.4 Typical Applications of Linked Lists -Singly linked lists are frequently utilized in implementing stacks, queues, hash tables, and graphs. +Singly linked lists are commonly used to implement stacks, queues, hash tables, and graphs. -- **Stacks and queues**: In singly linked lists, if insertions and deletions occur at the same end, it behaves like a stack (last-in-first-out). Conversely, if insertions are at one end and deletions at the other, it functions like a queue (first-in-first-out). -- **Hash tables**: Linked lists are used in chaining, a popular method for resolving hash collisions. Here, all collided elements are grouped into a linked list. -- **Graphs**: Adjacency lists, a standard method for graph representation, associate each graph vertex with a linked list. This list contains elements that represent vertices connected to the corresponding vertex. +- **Stacks and queues**: When insertion and deletion operations both occur at one end of the linked list, it exhibits last-in-first-out characteristics, corresponding to a stack. When insertion operations occur at one end of the linked list and deletion operations occur at the other end, it exhibits first-in-first-out characteristics, corresponding to a queue. +- **Hash tables**: Separate chaining is one of the mainstream solutions for resolving hash collisions. In this approach, all colliding elements are placed in a linked list. +- **Graphs**: An adjacency list is a common way to represent a graph, where each vertex in the graph is associated with a linked list, and each element in the linked list represents another vertex connected to that vertex. -Doubly linked lists are ideal for scenarios requiring rapid access to preceding and succeeding elements. +Doubly linked lists are commonly used in scenarios where quick access to the previous and next elements is needed. -- **Advanced data structures**: In structures like red-black trees and B-trees, accessing a node's parent is essential. This is achieved by incorporating a reference to the parent node in each node, akin to a doubly linked list. -- **Browser history**: In web browsers, doubly linked lists facilitate navigating the history of visited pages when users click forward or back. -- **LRU algorithm**: Doubly linked lists are apt for Least Recently Used (LRU) cache eviction algorithms, enabling swift identification of the least recently used data and facilitating fast node addition and removal. +- **Advanced data structures**: For example, in red-black trees and B-trees, we need to access the parent node of a node, which can be achieved by saving a reference to the parent node in the node, similar to a doubly linked list. +- **Browser history**: In web browsers, when a user clicks the forward or backward button, the browser needs to know the previous and next web pages the user visited. The characteristics of doubly linked lists make this operation simple. +- **LRU algorithm**: In cache eviction (LRU) algorithms, we need to quickly find the least recently used data and support quick addition and deletion of nodes. Using a doubly linked list is very suitable for this. -Circular linked lists are ideal for applications that require periodic operations, such as resource scheduling in operating systems. +Circular linked lists are commonly used in scenarios that require periodic operations, such as operating system resource scheduling. -- **Round-robin scheduling algorithm**: In operating systems, the round-robin scheduling algorithm is a common CPU scheduling method, requiring cycling through a group of processes. Each process is assigned a time slice, and upon expiration, the CPU rotates to the next process. This cyclical operation can be efficiently realized using a circular linked list, allowing for a fair and time-shared system among all processes. -- **Data buffers**: Circular linked lists are also used in data buffers, like in audio and video players, where the data stream is divided into multiple buffer blocks arranged in a circular fashion for seamless playback. +- **Round-robin scheduling algorithm**: In operating systems, round-robin scheduling is a common CPU scheduling algorithm that needs to cycle through a set of processes. Each process is assigned a time slice, and when the time slice expires, the CPU switches to the next process. This cyclic operation can be implemented using a circular linked list. +- **Data buffers**: In some data buffer implementations, circular linked lists may also be used. For example, in audio and video players, the data stream may be divided into multiple buffer blocks and placed in a circular linked list to achieve seamless playback. diff --git a/en/docs/chapter_array_and_linkedlist/list.md b/en/docs/chapter_array_and_linkedlist/list.md index 7dbc02836..ac64cbfef 100755 --- a/en/docs/chapter_array_and_linkedlist/list.md +++ b/en/docs/chapter_array_and_linkedlist/list.md @@ -4,27 +4,27 @@ comments: true # 4.3 List -A list is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, addition, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays. +A list is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, insertion, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays. -- A linked list inherently serves as a list, supporting operations for adding, deleting, searching, and modifying elements, with the flexibility to dynamically adjust its size. -- Arrays also support these operations, but due to their immutable length, they can be considered as a list with a length limit. +- A linked list can naturally be viewed as a list, supporting element insertion, deletion, search, and modification operations, and can flexibly expand dynamically. +- An array also supports element insertion, deletion, search, and modification, but since its length is immutable, it can only be viewed as a list with length limitations. -When implementing lists using arrays, **the immutability of length reduces the practicality of the list**. This is because predicting the amount of data to be stored in advance is often challenging, making it difficult to choose an appropriate list length. If the length is too small, it may not meet the requirements; if too large, it may waste memory space. +When implementing lists using arrays, **the immutable length property reduces the practicality of the list**. This is because we usually cannot determine in advance how much data we need to store, making it difficult to choose an appropriate list length. If the length is too small, it may fail to meet usage requirements; if the length is too large, it will waste memory space. -To solve this problem, we can implement lists using a dynamic array. It inherits the advantages of arrays and can dynamically expand during program execution. +To solve this problem, we can use a dynamic array to implement a list. It inherits all the advantages of arrays and can dynamically expand during program execution. -In fact, **many programming languages' standard libraries implement lists using dynamic arrays**, such as Python's `list`, Java's `ArrayList`, C++'s `vector`, and C#'s `List`. In the following discussion, we will consider "list" and "dynamic array" as synonymous concepts. +In fact, **the lists provided in the standard libraries of many programming languages are implemented based on dynamic arrays**, such as `list` in Python, `ArrayList` in Java, `vector` in C++, and `List` in C#. In the following discussion, we will treat "list" and "dynamic array" as equivalent concepts. -## 4.3.1 Common list operations +## 4.3.1 Common List Operations -### 1. Initializing a list +### 1. Initialize a List -We typically use two initialization methods: "without initial values" and "with initial values". +We typically use two initialization methods: "without initial values" and "with initial values": === "Python" ```python title="list.py" - # Initialize list + # Initialize a list # Without initial values nums1: list[int] = [] # With initial values @@ -34,8 +34,8 @@ We typically use two initialization methods: "without initial values" and "with === "C++" ```cpp title="list.cpp" - /* Initialize list */ - // Note, in C++ the vector is the equivalent of nums described here + /* Initialize a list */ + // Note that vector in C++ is equivalent to nums as described in this article // Without initial values vectorTable 4-2 Computer storage devices
+Table 4-2 Computer Storage Devices
Figure 4-9 Computer storage system
+Figure 4-9 Computer Storage System
!!! tip - The storage hierarchy in computers reflects a careful balance between speed, capacity, and cost. This type of trade-off is common across various industries, where finding the optimal balance between benefits and limitations is essential. + The storage hierarchy of computers embodies a delicate balance among speed, capacity, and cost. In fact, such trade-offs are common across all industrial fields, requiring us to find the optimal balance point between different advantages and constraints. -Overall, **hard disks provide long-term storage for large volumes of data, memory serves as temporary storage for data being processed during program execution, and cache stores frequently accessed data and instructions to enhance execution efficiency**. Together, they ensure the efficient operation of computer systems. +In summary, **hard disk is used for long-term storage of large amounts of data, RAM is used for temporary storage of data being processed during program execution, and cache is used for storage of frequently accessed data and instructions**, to improve program execution efficiency. The three work together to ensure efficient operation of the computer system. -As shown in Figure 4-10, during program execution, data is read from the hard disk into memory for CPU computation. The cache, acting as an extension of the CPU, **intelligently preloads data from memory**, enabling faster data access for the CPU. This greatly improves program execution efficiency while reducing reliance on slower memory. +As shown in the diagram below, during program execution, data is read from the hard disk into RAM for CPU computation. Cache can be viewed as part of the CPU, **it intelligently loads data from RAM**, providing the CPU with high-speed data reading, thereby significantly improving program execution efficiency and reducing reliance on slower RAM. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 4-10 Data flow between hard disk, memory, and cache
+Figure 4-10 Data Flow Among Hard Disk, RAM, and Cache
-## 4.4.2 Memory efficiency of data structures +## 4.4.2 Memory Efficiency of Data Structures -In terms of memory space utilization, arrays and linked lists have their advantages and limitations. +In terms of memory space utilization, arrays and linked lists each have advantages and limitations. -On one hand, **memory is limited and cannot be shared by multiple programs**, so optimizing space usage in data structures is crucial. Arrays are space-efficient because their elements are tightly packed, without requiring extra memory for references (pointers) as in linked lists. However, arrays require pre-allocating a contiguous block of memory, which can lead to waste if the allocated space exceeds the actual need. Expanding an array also incurs additional time and space overhead. In contrast, linked lists allocate and free memory dynamically for each node, offering greater flexibility at the cost of additional memory for pointers. +On one hand, **memory is limited, and the same memory cannot be shared by multiple programs**, so we hope data structures can utilize space as efficiently as possible. Array elements are tightly packed and do not require additional space to store references (pointers) between linked list nodes, thus having higher space efficiency. However, arrays need to allocate sufficient contiguous memory space at once, which may lead to memory waste, and array expansion requires additional time and space costs. In comparison, linked lists perform dynamic memory allocation and deallocation on a "node" basis, providing greater flexibility. -On the other hand, during program execution, **repeated memory allocation and deallocation increase memory fragmentation**, reducing memory utilization efficiency. Arrays, due to their continuous storage method, are relatively less likely to cause memory fragmentation. In contrast, linked lists store elements in non-contiguous locations, and frequent insertions and deletions can exacerbate memory fragmentation. +On the other hand, during program execution, **as memory is repeatedly allocated and freed, the degree of fragmentation of free memory becomes increasingly severe**, leading to reduced memory utilization efficiency. Arrays, due to their contiguous storage approach, are relatively less prone to memory fragmentation. Conversely, linked list elements are distributed in storage, and frequent insertion and deletion operations are more likely to cause memory fragmentation. -## 4.4.3 Cache efficiency of data structures +## 4.4.3 Cache Efficiency of Data Structures -Although caches are much smaller in space capacity than memory, they are much faster and play a crucial role in program execution speed. Due to their limited capacity, caches can only store a subset of frequently accessed data. When the CPU attempts to access data not present in the cache, a cache miss occurs, requiring the CPU to retrieve the needed data from slower memory, which can impact performance. +Although cache has much smaller space capacity than memory, it is much faster than memory and plays a crucial role in program execution speed. Since cache capacity is limited and can only store a small portion of frequently accessed data, when the CPU attempts to access data that is not in the cache, a cache miss occurs, and the CPU must load the required data from the slower memory. -Clearly, **the fewer the cache misses, the higher the CPU's data read-write efficiency**, and the better the program performance. The proportion of successful data retrieval from the cache by the CPU is called the cache hit rate, a metric often used to measure cache efficiency. +Clearly, **the fewer "cache misses," the higher the efficiency of CPU data reads and writes**, and the better the program performance. We call the proportion of data that the CPU successfully obtains from the cache the cache hit rate, a metric typically used to measure cache efficiency. -To achieve higher efficiency, caches adopt the following data loading mechanisms. +To achieve the highest efficiency possible, cache employs the following data loading mechanisms. -- **Cache lines**: Caches operate by storing and loading data in units called cache lines, rather than individual bytes. This approach improves efficiency by transferring larger blocks of data at once. -- **Prefetch mechanism**: Processors predict data access patterns (e.g., sequential or fixed-stride access) and preload data into the cache based on these patterns to increase the cache hit rate. -- **Spatial locality**: When a specific piece of data is accessed, nearby data is likely to be accessed soon. To leverage this, caches load adjacent data along with the requested data, improving hit rates. -- **Temporal locality**: If data is accessed, it's likely to be accessed again in the near future. Caches use this principle to retain recently accessed data to improve the hit rate. +- **Cache lines**: The cache does not store and load data on a byte-by-byte basis, but rather as cache lines. Compared to byte-by-byte transmission, cache line transmission is more efficient. +- **Prefetching mechanism**: The processor attempts to predict data access patterns (e.g., sequential access, fixed-stride jumping access, etc.) and loads data into the cache according to specific patterns, thereby improving hit rate. +- **Spatial locality**: If a piece of data is accessed, nearby data may also be accessed in the near future. Therefore, when the cache loads a particular piece of data, it also loads nearby data to improve hit rate. +- **Temporal locality**: If a piece of data is accessed, it is likely to be accessed again in the near future. Cache leverages this principle by retaining recently accessed data to improve hit rate. -In fact, **arrays and linked lists have different cache utilization efficiencies**, which is mainly reflected in the following aspects. +In fact, **arrays and linked lists have different efficiencies in utilizing cache**, manifested in the following aspects. -- **Occupied space**: Linked list elements take up more space than array elements, resulting in less effective data being held in the cache. -- **Cache lines**: Linked list data is scattered throughout the memory, and cache is "loaded by row", so the proportion of invalid data loaded is higher. -- **Prefetch mechanism**: The data access pattern of arrays is more "predictable" than that of linked lists, that is, it is easier for the system to guess the data that is about to be loaded. -- **Spatial locality**: Arrays are stored in a continuous memory space, so data near the data being loaded is more likely to be accessed soon. +- **Space occupied**: Linked list elements occupy more space than array elements, resulting in fewer effective data in the cache. +- **Cache lines**: Linked list data are scattered throughout memory, while cache loads "by lines," so the proportion of invalid data loaded is higher. +- **Prefetching mechanism**: Arrays have more "predictable" data access patterns than linked lists, making it easier for the system to guess which data will be loaded next. +- **Spatial locality**: Arrays are stored in centralized memory space, so data near loaded data is more likely to be accessed soon. -Overall, **arrays have a higher cache hit rate and are generally more efficient in operation than linked lists**. This makes data structures based on arrays more popular in solving algorithmic problems. +Overall, **arrays have higher cache hit rates, thus they usually outperform linked lists in operation efficiency**. This makes data structures implemented based on arrays more popular when solving algorithmic problems. -It should be noted that **high cache efficiency does not mean that arrays are always better than linked lists**. The choice of data structure should depend on specific application requirements. For example, both arrays and linked lists can implement the "stack" data structure (which will be detailed in the next chapter), but they are suitable for different scenarios. +It is important to note that **high cache efficiency does not mean arrays are superior to linked lists in all cases**. In practical applications, which data structure to choose should be determined based on specific requirements. For example, both arrays and linked lists can implement the "stack" data structure (which will be discussed in detail in the next chapter), but they are suitable for different scenarios. -- In algorithm problems, we tend to choose stacks based on arrays because they provide higher operational efficiency and random access capabilities, with the only cost being the need to pre-allocate a certain amount of memory space for the array. -- If the data volume is very large, highly dynamic, and the expected size of the stack is difficult to estimate, then a stack based on a linked list is a better choice. Linked lists can distribute a large amount of data in different parts of the memory and avoid the additional overhead of array expansion. +- When solving algorithm problems, we tend to prefer stack implementations based on arrays, because they provide higher operation efficiency and the ability of random access, at the cost of needing to pre-allocate a certain amount of memory space for the array. +- If the data volume is very large, the dynamic nature is high, and the expected size of the stack is difficult to estimate, then a stack implementation based on linked lists is more suitable. Linked lists can distribute large amounts of data across different parts of memory and avoid the additional overhead produced by array expansion. diff --git a/en/docs/chapter_array_and_linkedlist/summary.md b/en/docs/chapter_array_and_linkedlist/summary.md index e2201dee2..ecdbb6350 100644 --- a/en/docs/chapter_array_and_linkedlist/summary.md +++ b/en/docs/chapter_array_and_linkedlist/summary.md @@ -4,82 +4,87 @@ comments: true # 4.5 Summary -### 1. Key review +### 1. Key Review -- Arrays and linked lists are two basic data structures, representing two storage methods in computer memory: contiguous space storage and non-contiguous space storage. Their characteristics complement each other. -- Arrays support random access and use less memory; however, they are inefficient in inserting and deleting elements and have a fixed length after initialization. -- Linked lists implement efficient node insertion and deletion through changing references (pointers) and can flexibly adjust their length; however, they have lower node access efficiency and consume more memory. -- Common types of linked lists include singly linked lists, circular linked lists, and doubly linked lists, each with its own application scenarios. -- Lists are ordered collections of elements that support addition, deletion, and modification, typically implemented based on dynamic arrays, retaining the advantages of arrays while allowing flexible length adjustment. -- The advent of lists significantly enhanced the practicality of arrays but may lead to some memory space wastage. -- During program execution, data is mainly stored in memory. Arrays provide higher memory space efficiency, while linked lists are more flexible in memory usage. -- Caches provide fast data access to CPUs through mechanisms like cache lines, prefetching, spatial locality, and temporal locality, significantly enhancing program execution efficiency. -- Due to higher cache hit rates, arrays are generally more efficient than linked lists. When choosing a data structure, the appropriate choice should be made based on specific needs and scenarios. +- Arrays and linked lists are two fundamental data structures, representing two different ways data can be stored in computer memory: contiguous memory storage and scattered memory storage. The characteristics of the two complement each other. +- Arrays support random access and use less memory; however, inserting and deleting elements is inefficient, and the length is immutable after initialization. +- Linked lists achieve efficient insertion and deletion of nodes by modifying references (pointers), and can flexibly adjust length; however, node access is inefficient and memory consumption is higher. Common linked list types include singly linked lists, circular linked lists, and doubly linked lists. +- A list is an ordered collection of elements that supports insertion, deletion, search, and modification, typically implemented based on dynamic arrays. It retains the advantages of arrays while allowing flexible adjustment of length. +- The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space. +- During program execution, data is primarily stored in memory. Arrays provide higher memory space efficiency, while linked lists offer greater flexibility in memory usage. +- Caches provide fast data access to the CPU through mechanisms such as cache lines, prefetching, and spatial and temporal locality, significantly improving program execution efficiency. +- Because arrays have higher cache hit rates, they are generally more efficient than linked lists. When choosing a data structure, appropriate selection should be made based on specific requirements and scenarios. ### 2. Q & A -**Q**: Does storing arrays on the stack versus the heap affect time and space efficiency? +**Q**: Does storing an array on the stack versus on the heap affect time efficiency and space efficiency? -Arrays stored on both the stack and heap are stored in contiguous memory spaces, and data operation efficiency is essentially the same. However, stacks and heaps have their own characteristics, leading to the following differences. +Arrays stored on the stack and on the heap are both stored in contiguous memory space, so data operation efficiency is basically the same. However, the stack and heap have their own characteristics, leading to the following differences. -1. Allocation and release efficiency: The stack is a smaller memory block, allocated automatically by the compiler; the heap memory is relatively larger and can be dynamically allocated in the code, more prone to fragmentation. Therefore, allocation and release operations on the heap are generally slower than on the stack. -2. Size limitation: Stack memory is relatively small, while the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays. -3. Flexibility: The size of arrays on the stack needs to be determined at compile-time, while the size of arrays on the heap can be dynamically determined at runtime. +1. Allocation and deallocation efficiency: The stack is a relatively small piece of memory, with allocation automatically handled by the compiler; the heap is relatively larger and can be dynamically allocated in code, more prone to fragmentation. Therefore, allocation and deallocation operations on the heap are usually slower than on the stack. +2. Size limitations: Stack memory is relatively small, and the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays. +3. Flexibility: The size of an array on the stack must be determined at compile time, while the size of an array on the heap can be determined dynamically at runtime. -**Q**: Why do arrays require elements of the same type, while linked lists do not emphasize same-type elements? +**Q**: Why do arrays require elements of the same type, while linked lists do not emphasize this requirement? -Linked lists consist of nodes connected by references (pointers), and each node can store data of different types, such as int, double, string, object, etc. +Linked lists are composed of nodes, with nodes connected through references (pointers), and each node can store different types of data, such as `int`, `double`, `string`, `object`, etc. -In contrast, array elements must be of the same type, allowing the calculation of offsets to access the corresponding element positions. For example, an array containing both int and long types, with single elements occupying 4 bytes and 8 bytes respectively, cannot use the following formula to calculate offsets, as the array contains elements of two different lengths. +In contrast, array elements must be of the same type, so that the corresponding element position can be obtained by calculating the offset. For example, if an array contains both `int` and `long` types, with individual elements occupying 4 bytes and 8 bytes respectively, then the following formula cannot be used to calculate the offset, because the array contains two different "element lengths". ```shell -# Element memory address = array memory address + element length * element index +# Element Memory Address = Array Memory Address (first Element Memory address) + Element Length * Element Index ``` -**Q**: After deleting a node, is it necessary to set `P.next` to `None`? +**Q**: After deleting node `P`, do we need to set `P.next` to `None`? -Not modifying `P.next` is also acceptable. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter `P`. This means that node `P` has been effectively removed from the list, and where `P` points no longer affects the list. +It is not necessary to modify `P.next`. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter `P`. This means that node `P` has been removed from the linked list, and it doesn't matter where node `P` points to at this time—it won't affect the linked list. -From a garbage collection perspective, for languages with automatic garbage collection mechanisms like Java, Python, and Go, whether node `P` is collected depends on whether there are still references pointing to it, not on the value of `P.next`. In languages like C and C++, we need to manually free the node's memory. +From a data structures and algorithms perspective (problem-solving), not disconnecting the pointer doesn't matter as long as the program logic is correct. From the perspective of standard libraries, disconnecting is safer and the logic is clearer. If not disconnected, assuming the deleted node is not properly reclaimed, it may affect the memory reclamation of its successor nodes. -**Q**: In linked lists, the time complexity for insertion and deletion operations is `O(1)`. But searching for the element before insertion or deletion takes `O(n)` time, so why isn't the time complexity `O(n)`? +**Q**: In a linked list, the time complexity of insertion and deletion operations is $O(1)$. However, both insertion and deletion require $O(n)$ time to find the element; why isn't the time complexity $O(n)$? -If an element is searched first and then deleted, the time complexity is indeed `O(n)`. However, the `O(1)` advantage of linked lists in insertion and deletion can be realized in other applications. For example, in the implementation of double-ended queues using linked lists, we maintain pointers always pointing to the head and tail nodes, making each insertion and deletion operation `O(1)`. +If the element is first found and then deleted, the time complexity is indeed $O(n)$. However, the advantage of $O(1)$ insertion and deletion in linked lists can be demonstrated in other applications. For example, a deque is well-suited for linked list implementation, where we maintain pointer variables always pointing to the head and tail nodes, with each insertion and deletion operation being $O(1)$. -**Q**: In the figure "Linked List Definition and Storage Method", do the light blue storage nodes occupy a single memory address, or do they share half with the node value? +**Q**: In the diagram "Linked List Definition and Storage Methods", does the light blue pointer node occupy a single memory address, or does it share equally with the node value? -The figure is just a qualitative representation; quantitative analysis depends on specific situations. +This diagram is a qualitative representation; a quantitative representation requires analysis based on the specific situation. -- Different types of node values occupy different amounts of space, such as int, long, double, and object instances. -- The memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes. +- Different types of node values occupy different amounts of space, such as `int`, `long`, `double`, and instance objects, etc. +- The amount of memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes. -**Q**: Is adding elements to the end of a list always `O(1)`? +**Q**: Is appending an element at the end of a list always $O(1)$? -If adding an element exceeds the list length, the list needs to be expanded first. The system will request a new memory block and move all elements of the original list over, in which case the time complexity becomes `O(n)`. +If appending an element exceeds the list length, the list must first be expanded before adding. The system allocates a new block of memory and moves all elements from the original list to it, in which case the time complexity becomes $O(n)$. -**Q**: The statement "The emergence of lists greatly improves the practicality of arrays, but may lead to some memory space wastage" - does this refer to the memory occupied by additional variables like capacity, length, and expansion multiplier? +**Q**: "The emergence of lists has greatly improved the practicality of arrays, but may result in some wasted memory space"—does this space waste refer to the memory occupied by additional variables such as capacity, length, and expansion factor? -The space wastage here mainly refers to two aspects: on the one hand, lists are set with an initial length, which we may not always need; on the other hand, to prevent frequent expansion, expansion usually multiplies by a coefficient, such as $\times 1.5$. This results in many empty slots, which we typically cannot fully fill. +This space waste mainly has two aspects: on one hand, lists typically set an initial length, which we may not need to fully utilize; on the other hand, to prevent frequent expansion, expansion generally multiplies by a coefficient, such as $\times 1.5$. As a result, there will be many empty positions that we typically cannot completely fill. -**Q**: In Python, after initializing `n = [1, 2, 3]`, the addresses of these 3 elements are contiguous, but initializing `m = [2, 1, 3]` shows that each element's `id` is not consecutive but identical to those in `n`. If the addresses of these elements are not contiguous, is `m` still an array? +**Q**: In Python, after initializing `n = [1, 2, 3]`, the addresses of these 3 elements are contiguous, but initializing `m = [2, 1, 3]` reveals that each element's id is not continuous; rather, they are the same as those in `n`. Since the addresses of these elements are not contiguous, is `m` still an array? -If we replace list elements with linked list nodes `n = [n1, n2, n3, n4, n5]`, these 5 node objects are also typically dispersed throughout memory. However, given a list index, we can still access the node's memory address in `O(1)` time, thereby accessing the corresponding node. This is because the array stores references to the nodes, not the nodes themselves. +If we replace list elements with linked list nodes `n = [n1, n2, n3, n4, n5]`, usually these 5 node objects are also scattered throughout memory. However, given a list index, we can still obtain the node memory address in $O(1)$ time, thereby accessing the corresponding node. This is because the array stores references to nodes, not the nodes themselves. -Unlike many languages, in Python, numbers are also wrapped as objects, and lists store references to these numbers, not the numbers themselves. Therefore, we find that the same number in two arrays has the same `id`, and these numbers' memory addresses need not be contiguous. +Unlike many languages, numbers in Python are wrapped as objects, and lists store not the numbers themselves, but references to the numbers. Therefore, we find that the same numbers in two arrays have the same id, and the memory addresses of these numbers need not be contiguous. -**Q**: The `std::list` in C++ STL has already implemented a doubly linked list, but it seems that some algorithm books don't directly use it. Is there any limitation? +**Q**: C++ STL has `std::list` which has already implemented a doubly linked list, but it seems that some algorithm books don't use it directly. Is there a limitation? -On the one hand, we often prefer to use arrays to implement algorithms, only using linked lists when necessary, mainly for two reasons. +On one hand, we often prefer to use arrays for implementing algorithms and only use linked lists when necessary, mainly for two reasons. -- Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next), `std::list` usually occupies more space than `std::vector`. -- Cache unfriendly: As the data is not stored continuously, `std::list` has a lower cache utilization rate. Generally, `std::vector` performs better. +- Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next element), `std::list` typically consumes more space than `std::vector`. +- Cache unfriendliness: Since data is not stored contiguously, `std::list` has lower cache utilization. In general, `std::vector` has better performance. -On the other hand, linked lists are primarily necessary for binary trees and graphs. Stacks and queues are often implemented using the programming language's `stack` and `queue` classes, rather than linked lists. +On the other hand, cases where linked lists are necessary mainly involve binary trees and graphs. Stacks and queues usually use the `stack` and `queue` provided by the programming language, rather than linked lists. -**Q**: Does initializing a list `res = [0] * self.size()` result in each element of `res` referencing the same address? +**Q**: Does the operation `res = [[0]] * n` create a 2D list where each `[0]` is independent? -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, they are not independent. In this 2D list, all the `[0]` are actually references to the same object. If we modify one element, we will find that all corresponding elements change accordingly. -**Q**: In deleting a node, is it necessary to break the reference to its successor node? +If we want each `[0]` in the 2D list to be independent, we can use `res = [[0] for _ in range(n)]` to achieve this. The principle of this approach is to initialize $n$ independent `[0]` list objects. -From the perspective of data structures and algorithms (problem-solving), it's okay not to break the link, as long as the program's logic is correct. From the perspective of standard libraries, breaking the link is safer and more logically clear. If the link is not broken, and the deleted node is not properly recycled, it could affect the recycling of the successor node's memory. +**Q**: Does the operation `res = [0] * n` create a list where each integer 0 is independent? + +In this list, all integer 0s are references to the same object. This is because Python uses a caching mechanism for small integers (typically -5 to 256) to maximize object reuse and improve performance. + +Although they point to the same object, we can still independently modify each element in the list. This is because Python integers are "immutable objects". When we modify an element, we are actually switching to a reference of another object, rather than changing the original object itself. + +However, when list elements are "mutable objects" (such as lists, dictionaries, or class instances), modifying an element directly changes the object itself, and all elements referencing that object will have the same change. diff --git a/en/docs/chapter_backtracking/backtracking_algorithm.md b/en/docs/chapter_backtracking/backtracking_algorithm.md index d7e073462..522e66bc6 100644 --- a/en/docs/chapter_backtracking/backtracking_algorithm.md +++ b/en/docs/chapter_backtracking/backtracking_algorithm.md @@ -2,23 +2,23 @@ comments: true --- -# 13.1 Backtracking algorithms +# 13.1 Backtracking Algorithm -Backtracking algorithm is a method to solve problems by exhaustive search. Its core concept is to start from an initial state and brutally search for all possible solutions. The algorithm records the correct ones until a solution is found or all possible solutions have been tried but no solution can be found. +The backtracking algorithm is a method for solving problems through exhaustive search. Its core idea is to start from an initial state and exhaustively search all possible solutions. When a correct solution is found, it is recorded. This process continues until a solution is found or all possible choices have been tried without finding a solution. -Backtracking typically employs "depth-first search" to traverse the solution space. In the "Binary tree" chapter, we mentioned that pre-order, in-order, and post-order traversals are all depth-first searches. Next, we are going to use pre-order traversal to solve a backtracking problem. This helps us to understand how the algorithm works gradually. +The backtracking algorithm typically employs "depth-first search" to traverse the solution space. In the "Binary Tree" chapter, we mentioned that preorder, inorder, and postorder traversals all belong to depth-first search. Next, we will construct a backtracking problem using preorder traversal to progressively understand how the backtracking algorithm works. -!!! question "Example One" +!!! question "Example 1" - Given a binary tree, search and record all nodes with a value of $7$ and return them in a list. + Given a binary tree, search and record all nodes with value $7$, and return a list of these nodes. -To solve this problem, we traverse this tree in pre-order and check if the current node's value is $7$. If it is, we add the node's value to the result list `res`. The process is shown in Figure 13-1: +For this problem, we perform a preorder traversal of the tree and check whether the current node's value is $7$. If it is, we add the node to the result list `res`. The relevant implementation is shown in the following figure and code: === "Python" ```python title="preorder_traversal_i_compact.py" def pre_order(root: TreeNode): - """Pre-order traversal: Example one""" + """Preorder traversal: Example 1""" if root is None: return if root.val == 7: @@ -31,7 +31,7 @@ To solve this problem, we traverse this tree in pre-order and check if the curre === "C++" ```cpp title="preorder_traversal_i_compact.cpp" - /* Pre-order traversal: Example one */ + /* Preorder traversal: Example 1 */ void preOrder(TreeNode *root) { if (root == nullptr) { return; @@ -48,7 +48,7 @@ To solve this problem, we traverse this tree in pre-order and check if the curre === "Java" ```java title="preorder_traversal_i_compact.java" - /* Pre-order traversal: Example one */ + /* Preorder traversal: Example 1 */ void preOrder(TreeNode root) { if (root == null) { return; @@ -65,92 +65,196 @@ To solve this problem, we traverse this tree in pre-order and check if the curre === "C#" ```csharp title="preorder_traversal_i_compact.cs" - [class]{preorder_traversal_i_compact}-[func]{PreOrder} + /* Preorder traversal: Example 1 */ + void PreOrder(TreeNode? root) { + if (root == null) { + return; + } + if (root.val == 7) { + // Record solution + res.Add(root); + } + PreOrder(root.left); + PreOrder(root.right); + } ``` === "Go" ```go title="preorder_traversal_i_compact.go" - [class]{}-[func]{preOrderI} + /* Preorder traversal: Example 1 */ + func preOrderI(root *TreeNode, res *[]*TreeNode) { + if root == nil { + return + } + if (root.Val).(int) == 7 { + // Record solution + *res = append(*res, root) + } + preOrderI(root.Left, res) + preOrderI(root.Right, res) + } ``` === "Swift" ```swift title="preorder_traversal_i_compact.swift" - [class]{}-[func]{preOrder} + /* Preorder traversal: Example 1 */ + func preOrder(root: TreeNode?) { + guard let root = root else { + return + } + if root.val == 7 { + // Record solution + res.append(root) + } + preOrder(root: root.left) + preOrder(root: root.right) + } ``` === "JS" ```javascript title="preorder_traversal_i_compact.js" - [class]{}-[func]{preOrder} + /* Preorder traversal: Example 1 */ + function preOrder(root, res) { + if (root === null) { + return; + } + if (root.val === 7) { + // Record solution + res.push(root); + } + preOrder(root.left, res); + preOrder(root.right, res); + } ``` === "TS" ```typescript title="preorder_traversal_i_compact.ts" - [class]{}-[func]{preOrder} + /* Preorder traversal: Example 1 */ + function preOrder(root: TreeNode | null, res: TreeNode[]): void { + if (root === null) { + return; + } + if (root.val === 7) { + // Record solution + res.push(root); + } + preOrder(root.left, res); + preOrder(root.right, res); + } ``` === "Dart" ```dart title="preorder_traversal_i_compact.dart" - [class]{}-[func]{preOrder} + /* Preorder traversal: Example 1 */ + void preOrder(TreeNode? root, ListFigure 13-1 Search for nodes in preorder traversal
-{ class="animation-figure" } +## 13.1.1 Attempt and Backtrack -Figure 13-1 Searching nodes in pre-order traversal
+**The reason it is called a backtracking algorithm is that it employs "attempt" and "backtrack" strategies when searching the solution space**. When the algorithm encounters a state where it cannot continue forward or cannot find a solution that satisfies the constraints, it will undo the previous choice, return to a previous state, and try other possible choices. -## 13.1.1 Trial and retreat +For Example 1, visiting each node represents an "attempt", while skipping over a leaf node or a function `return` from the parent node represents a "backtrack". -**It is called a backtracking algorithm because it uses a "trial" and "retreat" strategy when searching the solution space**. During the search, whenever it encounters a state where it can no longer proceed to obtain a satisfying solution, it undoes the previous choice and reverts to the previous state so that other possible choices can be chosen for the next attempt. +It is worth noting that **backtracking is not limited to function returns alone**. To illustrate this, let's extend Example 1 slightly. -In Example One, visiting each node starts a "trial". And passing a leaf node or the `return` statement to going back to the parent node suggests "retreat". +!!! question "Example 2" -It's worth noting that **retreat is not merely about function returns**. We'll expand slightly on Example One question to explain what it means. + In a binary tree, search all nodes with value $7$, **and return the paths from the root node to these nodes**. -!!! question "Example Two" - - In a binary tree, search for all nodes with a value of $7$ and for all matching nodes, **please return the paths from the root node to that node**. - -Based on the code from Example One, we need to use a list called `path` to record the visited node paths. When a node with a value of $7$ is reached, we copy `path` and add it to the result list `res`. After the traversal, `res` holds all the solutions. The code is as shown: +Based on the code from Example 1, we need to use a list `path` to record the visited node path. When we reach a node with value $7$, we copy `path` and add it to the result list `res`. After traversal is complete, `res` contains all the solutions. The code is as follows: === "Python" ```python title="preorder_traversal_ii_compact.py" def pre_order(root: TreeNode): - """Pre-order traversal: Example two""" + """Preorder traversal: Example 2""" if root is None: return # Attempt @@ -160,14 +264,14 @@ Based on the code from Example One, we need to use a list called `path` to recor res.append(list(path)) pre_order(root.left) pre_order(root.right) - # Retract + # Backtrack path.pop() ``` === "C++" ```cpp title="preorder_traversal_ii_compact.cpp" - /* Pre-order traversal: Example two */ + /* Preorder traversal: Example 2 */ void preOrder(TreeNode *root) { if (root == nullptr) { return; @@ -180,7 +284,7 @@ Based on the code from Example One, we need to use a list called `path` to recor } preOrder(root->left); preOrder(root->right); - // Retract + // Backtrack path.pop_back(); } ``` @@ -188,7 +292,7 @@ Based on the code from Example One, we need to use a list called `path` to recor === "Java" ```java title="preorder_traversal_ii_compact.java" - /* Pre-order traversal: Example two */ + /* Preorder traversal: Example 2 */ void preOrder(TreeNode root) { if (root == null) { return; @@ -201,7 +305,7 @@ Based on the code from Example One, we need to use a list called `path` to recor } preOrder(root.left); preOrder(root.right); - // Retract + // Backtrack path.remove(path.size() - 1); } ``` @@ -209,75 +313,237 @@ Based on the code from Example One, we need to use a list called `path` to recor === "C#" ```csharp title="preorder_traversal_ii_compact.cs" - [class]{preorder_traversal_ii_compact}-[func]{PreOrder} + /* Preorder traversal: Example 2 */ + void PreOrder(TreeNode? root) { + if (root == null) { + return; + } + // Attempt + path.Add(root); + if (root.val == 7) { + // Record solution + res.Add(new ListFigure 13-2 Trying and retreating
+Figure 13-2 Attempt and backtrack
-## 13.1.2 Prune +## 13.1.2 Pruning -Complex backtracking problems usually involve one or more constraints, **which are often used for "pruning"**. +Complex backtracking problems usually contain one or more constraints. **Constraints can typically be used for "pruning"**. -!!! question "Example Three" +!!! question "Example 3" - In a binary tree, search for all nodes with a value of $7$ and return the paths from the root to these nodes, **with restriction that the paths do not contain nodes with a value of $3$**. + In a binary tree, search all nodes with value $7$ and return the paths from the root node to these nodes, **but require that the paths do not contain nodes with value $3$**. -To meet the above constraints, **we need to add a pruning operation**: during the search process, if a node with a value of $3$ is encountered, it aborts further searching down through the path immediately. The code is as shown: +To satisfy the above constraints, **we need to add pruning operations**: during the search process, if we encounter a node with value $3$, we return early and do not continue searching. The code is as follows: === "Python" ```python title="preorder_traversal_iii_compact.py" def pre_order(root: TreeNode): - """Pre-order traversal: Example three""" + """Preorder traversal: Example 3""" # Pruning if root is None or root.val == 3: return @@ -336,14 +602,14 @@ To meet the above constraints, **we need to add a pruning operation**: during th res.append(list(path)) pre_order(root.left) pre_order(root.right) - # Retract + # Backtrack path.pop() ``` === "C++" ```cpp title="preorder_traversal_iii_compact.cpp" - /* Pre-order traversal: Example three */ + /* Preorder traversal: Example 3 */ void preOrder(TreeNode *root) { // Pruning if (root == nullptr || root->val == 3) { @@ -357,7 +623,7 @@ To meet the above constraints, **we need to add a pruning operation**: during th } preOrder(root->left); preOrder(root->right); - // Retract + // Backtrack path.pop_back(); } ``` @@ -365,7 +631,7 @@ To meet the above constraints, **we need to add a pruning operation**: during th === "Java" ```java title="preorder_traversal_iii_compact.java" - /* Pre-order traversal: Example three */ + /* Preorder traversal: Example 3 */ void preOrder(TreeNode root) { // Pruning if (root == null || root.val == 3) { @@ -379,7 +645,7 @@ To meet the above constraints, **we need to add a pruning operation**: during th } preOrder(root.left); preOrder(root.right); - // Retract + // Backtrack path.remove(path.size() - 1); } ``` @@ -387,100 +653,271 @@ To meet the above constraints, **we need to add a pruning operation**: during th === "C#" ```csharp title="preorder_traversal_iii_compact.cs" - [class]{preorder_traversal_iii_compact}-[func]{PreOrder} + /* Preorder traversal: Example 3 */ + void PreOrder(TreeNode? root) { + // Pruning + if (root == null || root.val == 3) { + return; + } + // Attempt + path.Add(root); + if (root.val == 7) { + // Record solution + res.Add(new ListFigure 13-3 Pruning according to constraints
-{ class="animation-figure" } +## 13.1.3 Framework Code -Figure 13-3 Pruning based on constraints
+Next, we attempt to extract the main framework of backtracking's "attempt, backtrack, and pruning", to improve code generality. -## 13.1.3 Framework code - -Now, let's try to distill the main framework of "trial, retreat, and prune" from backtracking to enhance the code's universality. - -In the following framework code, `state` represents the current state of the problem, `choices` represents the choices available under the current state: +In the following framework code, `state` represents the current state of the problem, and `choices` represents the choices available in the current state: === "Python" ```python title="" def backtrack(state: State, choices: list[choice], res: list[state]): """Backtracking algorithm framework""" - # Check if it's a solution + # Check if it is a solution if is_solution(state): # Record the solution record_solution(state, res) # Stop searching return - # Iterate through all choices + # Traverse all choices for choice in choices: - # Prune: check if the choice is valid + # Pruning: check if the choice is valid if is_valid(state, choice): - # Trial: make a choice, update the state + # Attempt: make a choice and update the state make_choice(state, choice) backtrack(state, choices, res) - # Retreat: undo the choice, revert to the previous state + # Backtrack: undo the choice and restore to the previous state undo_choice(state, choice) ``` @@ -489,21 +926,21 @@ In the following framework code, `state` represents the current state of the pro ```cpp title="" /* Backtracking algorithm framework */ void backtrack(State *state, vectorFigure 13-4 Comparison of search process with and without return statement
- [class]{}-[func]{isValid} +Compared to code based on preorder traversal, code based on the backtracking algorithm framework appears more verbose, but has better generality. In fact, **many backtracking problems can be solved within this framework**. We only need to define `state` and `choices` for the specific problem and implement each method in the framework. - [class]{}-[func]{makeChoice} +## 13.1.4 Common Terminology - [class]{}-[func]{undoChoice} +To analyze algorithmic problems more clearly, we summarize the meanings of common terminology used in backtracking algorithms and provide corresponding examples from Example 3, as shown in the following table. - [class]{}-[func]{backtrack} - ``` - -As per the requirements, after finding a node with a value of $7$, the search should continue. **As a result, the `return` statement after recording the solution should be removed**. Figure 13-4 compares the search processes with and without retaining the `return` statement. - -{ class="animation-figure" } - -Figure 13-4 Comparison of retaining and removing the return in the search process
- -Compared to the implementation based on pre-order traversal, the code using the backtracking algorithm framework seems verbose. However, it has better universality. In fact, **many backtracking problems can be solved within this framework**. We just need to define `state` and `choices` according to the specific problem and implement the methods in the framework. - -## 13.1.4 Common terminology - -To analyze algorithmic problems more clearly, we summarize the meanings of commonly used terminology in backtracking algorithms and provide corresponding examples from Example Three as shown in Table 13-1. - -Table 13-1 Common backtracking algorithm terminology
+Table 13-1 Common Backtracking Algorithm Terminology
Figure 13-15 Solution to the 4 queens problem
+Figure 13-15 Solution to the 4-queens problem
-Figure 13-16 shows the three constraints of this problem: **multiple queens cannot occupy the same row, column, or diagonal**. It is important to note that diagonals are divided into the main diagonal `\` and the secondary diagonal `/`. +Figure 13-16 illustrates the three constraints of this problem: **multiple queens cannot be in the same row, the same column, or on the same diagonal**. It is worth noting that diagonals are divided into two types: the main diagonal `\` and the anti-diagonal `/`. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 13-16 Constraints of the n queens problem
+Figure 13-16 Constraints of the n-queens problem
-### 1. Row-by-row placing strategy +### 1. Row-By-Row Placement Strategy -As the number of queens equals the number of rows on the chessboard, both being $n$, it is easy to conclude that **each row on the chessboard allows and only allows one queen to be placed**. +Since both the number of queens and the number of rows on the chessboard are $n$, we can easily derive a conclusion: **each row of the chessboard allows and only allows exactly one queen to be placed**. -This means that we can adopt a row-by-row placing strategy: starting from the first row, place one queen per row until the last row is reached. +This means we can adopt a row-by-row placement strategy: starting from the first row, place one queen in each row until the last row is completed. -Figure 13-17 shows the row-by-row placing process for the 4 queens problem. Due to space limitations, the figure only expands one search branch of the first row, and prunes any placements that do not meet the column and diagonal constraints. +Figure 13-17 shows the row-by-row placement process for the 4-queens problem. Due to space limitations, the figure only expands one search branch of the first row, and all schemes that do not satisfy the column constraint and diagonal constraints are pruned. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 13-17 Row-by-row placing strategy
+Figure 13-17 Row-by-row placement strategy
-Essentially, **the row-by-row placing strategy serves as a pruning function**, eliminating all search branches that would place multiple queens in the same row. +Essentially, **the row-by-row placement strategy serves a pruning function**, as it avoids all search branches where multiple queens appear in the same row. -### 2. Column and diagonal pruning +### 2. Column and Diagonal Pruning -To satisfy column constraints, we can use a boolean array `cols` of length $n$ to track whether a queen occupies each column. Before each placement decision, `cols` is used to prune the columns that already have queens, and it is dynamically updated during backtracking. +To satisfy the column constraint, we can use a boolean array `cols` of length $n$ to record whether each column has a queen. Before each placement decision, we use `cols` to prune columns that already have queens, and dynamically update the state of `cols` during backtracking. !!! tip - Note that the origin of the matrix is located in the upper left corner, where the row index increases from top to bottom, and the column index increases from left to right. + Please note that the origin of the matrix is located in the upper-left corner, where the row index increases from top to bottom, and the column index increases from left to right. -How about the diagonal constraints? Let the row and column indices of a certain cell on the chessboard be $(row, col)$. By selecting a specific main diagonal, we notice that the difference $row - col$ is the same for all cells on that diagonal, **meaning that $row - col$ is a constant value on the main diagonal**. +So how do we handle diagonal constraints? Consider a square on the chessboard with row and column indices $(row, col)$. If we select a specific main diagonal in the matrix, we find that all squares on that diagonal have the same difference between their row and column indices, **meaning that $row - col$ is a constant value for all squares on the main diagonal**. -In other words, if two cells satisfy $row_1 - col_1 = row_2 - col_2$, they are definitely on the same main diagonal. Using this pattern, we can utilize the array `diags1` shown in Figure 13-18 to track whether a queen is on any main diagonal. +In other words, if two squares satisfy $row_1 - col_1 = row_2 - col_2$, they must be on the same main diagonal. Using this pattern, we can use the array `diags1` shown in Figure 13-18 to record whether there is a queen on each main diagonal. -Similarly, **the sum of $row + col$ is a constant value for all cells on the secondary diagonal**. We can also use the array `diags2` to handle secondary diagonal constraints. +Similarly, **for all squares on an anti-diagonal, the sum $row + col$ is a constant value**. We can likewise use the array `diags2` to handle anti-diagonal constraints. { class="animation-figure" }Figure 13-18 Handling column and diagonal constraints
-### 3. Code implementation +### 3. Code Implementation -Please note, in an $n$-dimensional square matrix, the range of $row - col$ is $[-n + 1, n - 1]$, and the range of $row + col$ is $[0, 2n - 2]$. Consequently, the number of both main and secondary diagonals is $2n - 1$, meaning the length of the arrays `diags1` and `diags2` is $2n - 1$. +Please note that in an $n$-dimensional square matrix, the range of $row - col$ is $[-n + 1, n - 1]$, and the range of $row + col$ is $[0, 2n - 2]$. Therefore, the number of both main diagonals and anti-diagonals is $2n - 1$, meaning the length of both arrays `diags1` and `diags2` is $2n - 1$. === "Python" @@ -68,34 +68,34 @@ Please note, in an $n$-dimensional square matrix, the range of $row - col$ is $[ diags1: list[bool], diags2: list[bool], ): - """Backtracking algorithm: n queens""" + """Backtracking algorithm: N queens""" # When all rows are placed, record the solution if row == n: res.append([list(row) for row in state]) return # Traverse all columns for col in range(n): - # Calculate the main and minor diagonals corresponding to the cell + # Calculate the main diagonal and anti-diagonal corresponding to this cell diag1 = row - col + n - 1 diag2 = row + col - # Pruning: do not allow queens on the column, main diagonal, or minor diagonal of the cell + # Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell if not cols[col] and not diags1[diag1] and not diags2[diag2]: - # Attempt: place the queen in the cell + # Attempt: place the queen in this cell state[row][col] = "Q" cols[col] = diags1[diag1] = diags2[diag2] = True # Place the next row backtrack(row + 1, n, state, res, cols, diags1, diags2) - # Retract: restore the cell to an empty spot + # Backtrack: restore this cell to an empty cell state[row][col] = "#" cols[col] = diags1[diag1] = diags2[diag2] = False def n_queens(n: int) -> list[list[list[str]]]: - """Solve n queens""" - # Initialize an n*n size chessboard, where 'Q' represents the queen and '#' represents an empty spot + """Solve N queens""" + # Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell state = [["#" for _ in range(n)] for _ in range(n)] - cols = [False] * n # Record columns with queens - diags1 = [False] * (2 * n - 1) # Record main diagonals with queens - diags2 = [False] * (2 * n - 1) # Record minor diagonals with queens + cols = [False] * n # Record whether there is a queen in the column + diags1 = [False] * (2 * n - 1) # Record whether there is a queen on the main diagonal + diags2 = [False] * (2 * n - 1) # Record whether there is a queen on the anti-diagonal res = [] backtrack(0, n, state, res, cols, diags1, diags2) @@ -105,7 +105,7 @@ Please note, in an $n$-dimensional square matrix, the range of $row - col$ is $[ === "C++" ```cpp title="n_queens.cpp" - /* Backtracking algorithm: n queens */ + /* Backtracking algorithm: N queens */ void backtrack(int row, int n, vectorTable 13-2 Permutation examples
+Table 13-2 Permutations Examples
Figure 13-5 Permutation recursive tree
+Figure 13-5 Recursion tree of permutations
-### 1. Repeated-choice pruning +### 1. Pruning Duplicate Choices -To ensure each element is selected only once, we introduce a boolean array `selected`, where `selected[i]` indicates whether `choices[i]` has been chosen. We then base our pruning steps on this array: +To ensure that each element is chosen only once, we consider introducing a boolean array `selected`, where `selected[i]` indicates whether `choices[i]` has been chosen. We implement the following pruning operation based on it. -- After choosing `choice[i]`, set `selected[i]` to $\text{True}$ to mark it as chosen. -- While iterating through `choices`, skip all elements marked as chosen (i.e., prune those branches). +- After making a choice `choice[i]`, we set `selected[i]` to $\text{True}$, indicating that it has been chosen. +- When traversing the candidate list `choices`, we skip all nodes that have been chosen, which is pruning. -As shown in Figure 13-6, suppose we choose 1 in the first round, then 3 in the second round, and finally 2 in the third round. We need to prune the branch for element 1 in the second round and the branches for elements 1 and 3 in the third round. +As shown in Figure 13-6, suppose we choose $1$ in the first round, $3$ in the second round, and $2$ in the third round. Then we need to prune the branch of element $1$ in the second round and prune the branches of elements $1$ and $3$ in the third round. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 13-6 Permutation pruning example
+Figure 13-6 Pruning example of permutations
-From the figure, we can see that this pruning process reduces the search space from $O(n^n)$ to $O(n!)$. +Observing the above figure, we find that this pruning operation reduces the search space size from $O(n^n)$ to $O(n!)$. -### 2. Code implementation +### 2. Code Implementation -With this understanding, we can "fill in the blanks" of our framework code. To keep the overall code concise, we won’t implement each part of the framework separately but instead expand everything in the `backtrack()` function: +After understanding the above information, we can fill in the blanks in the template code. To shorten the overall code, we do not implement each function in the template separately, but instead unfold them in the `backtrack()` function: === "Python" @@ -61,7 +61,7 @@ With this understanding, we can "fill in the blanks" of our framework code. To k def backtrack( state: list[int], choices: list[int], selected: list[bool], res: list[list[int]] ): - """Backtracking algorithm: Permutation I""" + """Backtracking algorithm: Permutations I""" # When the state length equals the number of elements, record the solution if len(state) == len(choices): res.append(list(state)) @@ -70,17 +70,17 @@ With this understanding, we can "fill in the blanks" of our framework code. To k for i, choice in enumerate(choices): # Pruning: do not allow repeated selection of elements if not selected[i]: - # Attempt: make a choice, update the state + # Attempt: make choice, update state selected[i] = True state.append(choice) # Proceed to the next round of selection backtrack(state, choices, selected, res) - # Retract: undo the choice, restore to the previous state + # Backtrack: undo choice, restore to previous state selected[i] = False state.pop() def permutations_i(nums: list[int]) -> list[list[int]]: - """Permutation I""" + """Permutations I""" res = [] backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res) return res @@ -89,7 +89,7 @@ With this understanding, we can "fill in the blanks" of our framework code. To k === "C++" ```cpp title="permutations_i.cpp" - /* Backtracking algorithm: Permutation I */ + /* Backtracking algorithm: Permutations I */ void backtrack(vectorFigure 13-7 Duplicate permutations
-So how can we eliminate these duplicate permutations? One direct approach is to use a hash set to remove duplicates after generating all permutations. However, this is less elegant **because branches that produce duplicates are inherently unnecessary and should be pruned in advance,** thus improving the algorithm’s efficiency. +So how do we remove duplicate permutations? The most direct approach is to use a hash set to directly deduplicate the permutation results. However, this is not elegant because **the search branches that generate duplicate permutations are unnecessary and should be identified and pruned early**, which can further improve algorithm efficiency. -### 1. Equal-element pruning +### 1. Pruning Duplicate Elements -Looking at Figure 13-8, in the first round, choosing $1$ or $\hat{1}$ leads to the same permutations, so we prune $\hat{1}$. +Observe Figure 13-8. In the first round, choosing $1$ or choosing $\hat{1}$ is equivalent. All permutations generated under these two choices are duplicates. Therefore, we should prune $\hat{1}$. -Similarly, after choosing $2$ in the first round, choosing $1$ or $\hat{1}$ in the second round also leads to duplicate branches, so we prune $\hat{1}$ then as well. +Similarly, after choosing $2$ in the first round, the $1$ and $\hat{1}$ in the second round also produce duplicate branches, so the second round's $\hat{1}$ should also be pruned. -Essentially, **our goal is to ensure that multiple identical elements are only selected once per round of choices.** +Essentially, **our goal is to ensure that multiple equal elements are chosen only once in a certain round of choices**. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 13-8 Duplicate permutations pruning
+Figure 13-8 Pruning duplicate permutations
-### 2. Code implementation +### 2. Code Implementation -Based on the code from the previous problem, we introduce a hash set `duplicated` in each round. This set keeps track of elements we have already attempted, so we can prune duplicates: +Building on the code from the previous problem, we consider opening a hash set `duplicated` in each round of choices to record which elements have been tried in this round, and prune duplicate elements: === "Python" @@ -284,7 +576,7 @@ Based on the code from the previous problem, we introduce a hash set `duplicated def backtrack( state: list[int], choices: list[int], selected: list[bool], res: list[list[int]] ): - """Backtracking algorithm: Permutation II""" + """Backtracking algorithm: Permutations II""" # When the state length equals the number of elements, record the solution if len(state) == len(choices): res.append(list(state)) @@ -294,18 +586,18 @@ Based on the code from the previous problem, we introduce a hash set `duplicated for i, choice in enumerate(choices): # Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements if not selected[i] and choice not in duplicated: - # Attempt: make a choice, update the state - duplicated.add(choice) # Record selected element values + # Attempt: make choice, update state + duplicated.add(choice) # Record the selected element value selected[i] = True state.append(choice) # Proceed to the next round of selection backtrack(state, choices, selected, res) - # Retract: undo the choice, restore to the previous state + # Backtrack: undo choice, restore to previous state selected[i] = False state.pop() def permutations_ii(nums: list[int]) -> list[list[int]]: - """Permutation II""" + """Permutations II""" res = [] backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res) return res @@ -314,7 +606,7 @@ Based on the code from the previous problem, we introduce a hash set `duplicated === "C++" ```cpp title="permutations_ii.cpp" - /* Backtracking algorithm: Permutation II */ + /* Backtracking algorithm: Permutations II */ void backtrack(vector