code: update zig 0.14.1 for the chapter of array_and_linkedlist and computational_complexity (#1787)

* update zig array list chapter

* update not need change codes.

* fix some pr issues and update time space chapter

Author: CreatorMetaSky

codes/zig/.gitignore

@@ -1,2 +1,4 @@
-zig-out/
-zig-cache/
+zig-out
+zig-cache
+.zig-cache
+!/.vscode/

codes/zig/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug",
+            "type": "lldb",
+            "request": "launch",
+            "program": "${workspaceFolder}/zig-out/bin/${fileBasenameNoExtension}",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            "preLaunchTask": "build"
+        }
+    ]
+}

codes/zig/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "zig.testArgs": ["build", "test", "-Dtest-filter=${filter}"]
+}

codes/zig/.vscode/tasks.json

@@ -0,0 +1,10 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "type": "shell",
+            "command": "zig build",
+        }
+    ]
+}

codes/zig/build.zig

@@ -1,26 +1,28 @@
 // File: array.zig
 // Created Time: 2023-01-07
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
 
 // 随机访问元素
-pub fn randomAccess(nums: []i32) i32 {
+pub fn randomAccess(nums: []const i32) i32 {
     // 在区间 [0, nums.len) 中随机抽取一个整数
-    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
+    const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
     // 获取并返回随机元素
-    var randomNum = nums[randomIndex];
+    const randomNum = nums[random_index];
     return randomNum;
 }
 
 // 扩展数组长度
-pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
+pub fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
     // 初始化一个扩展长度后的数组
-    var res = try mem_allocator.alloc(i32, nums.len + enlarge);
+    const res = try allocator.alloc(i32, nums.len + enlarge);
     @memset(res, 0);
+
     // 将原数组中的所有元素复制到新数组
-    std.mem.copy(i32, res, nums);
+    std.mem.copyForwards(i32, res, nums);
+
     // 返回扩展后的新数组
     return res;
 }
@@ -46,18 +48,26 @@ pub fn remove(nums: []i32, index: usize) void {
 }
 
 // 遍历数组
-pub fn traverse(nums: []i32) void {
+pub fn traverse(nums: []const i32) void {
     var count: i32 = 0;
+
     // 通过索引遍历数组
-    var i: i32 = 0;
+    var i: usize = 0;
     while (i < nums.len) : (i += 1) {
         count += nums[i];
     }
-    count = 0;
+
     // 直接遍历数组元素
+    count = 0;
     for (nums) |num| {
         count += num;
     }
+
+    // 同时遍历数据索引和元素
+    for (nums, 0..) |num, index| {
+        count += nums[index];
+        count += num;
+    }
 }
 
 // 在数组中查找指定元素
@@ -69,49 +79,53 @@ pub fn find(nums: []i32, target: i32) i32 {
 }
 
 // Driver Code
-pub fn main() !void {
-    // 初始化内存分配器
-    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer mem_arena.deinit();
-    const mem_allocator = mem_arena.allocator();
-
+pub fn run() !void {
     // 初始化数组
-    var arr = [_]i32{0} ** 5;
-    std.debug.print("数组 arr = ", .{});
-    inc.PrintUtil.printArray(i32, &arr);
+    const arr = [_]i32{0} ** 5;
+    std.debug.print("数组 arr = {}\n", .{utils.fmt.slice(&arr)});
 
+    // 数组切片
     var array = [_]i32{ 1, 3, 2, 5, 4 };
     var known_at_runtime_zero: usize = 0;
-    var nums = array[known_at_runtime_zero..];
-    std.debug.print("\n数组 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    _ = &known_at_runtime_zero;
+    var nums = array[known_at_runtime_zero..array.len]; // 通过 known_at_runtime_zero 运行时变量将指针变切片
+    std.debug.print("数组 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 随机访问
-    var randomNum = randomAccess(nums);
-    std.debug.print("\n在 nums 中获取随机元素 {}", .{randomNum});
+    const randomNum = randomAccess(nums);
+    std.debug.print("在 nums 中获取随机元素 {}\n", .{randomNum});
+
+    // 初始化内存分配器
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
 
     // 长度扩展
-    nums = try extend(mem_allocator, nums, 3);
-    std.debug.print("\n将数组长度扩展至 8 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    nums = try extend(allocator, nums, 3);
+    std.debug.print("将数组长度扩展至 8 ，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 插入元素
     insert(nums, 6, 3);
-    std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    std.debug.print("在索引 3 处插入数字 6 ，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 删除元素
     remove(nums, 2);
-    std.debug.print("\n删除索引 2 处的元素，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    std.debug.print("删除索引 2 处的元素，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 遍历数组
     traverse(nums);
 
     // 查找元素
-    var index = find(nums, 3);
-    std.debug.print("\n在 nums 中查找元素 3 ，得到索引 = {}\n", .{index});
+    const index = find(nums, 3);
+    std.debug.print("在 nums 中查找元素 3 ，得到索引 = {}\n", .{index});
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
 }
 
+pub fn main() !void {
+    try run();
+}
+
+test "array" {
+    try run();
+}

codes/zig/chapter_array_and_linkedlist/array.zig

@@ -1,84 +1,106 @@
 // File: linked_list.zig
 // Created Time: 2023-01-07
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
+const ListNode = utils.ListNode;
 
 // 在链表的节点 n0 之后插入节点 P
-pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
-    var n1 = n0.?.next;
-    P.?.next = n1;
-    n0.?.next = P;
+pub fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
+    const n1 = n0.next;
+    P.next = n1;
+    n0.next = P;
 }
 
 // 删除链表的节点 n0 之后的首个节点
-pub fn remove(n0: ?*inc.ListNode(i32)) void {
-    if (n0.?.next == null) return;
-    // n0 -> P -> n1
-    var P = n0.?.next;
-    var n1 = P.?.next;
-    n0.?.next = n1;
+pub fn remove(comptime T: type, n0: *ListNode(T)) void {
+    // n0 -> P -> n1 => n0 -> n1
+    const P = n0.next;
+    const n1 = P.?.next;
+    n0.next = n1;
 }
 
 // 访问链表中索引为 index 的节点
-pub fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
-    var head = node;
+pub fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
+    var head: ?*ListNode(T) = node;
     var i: i32 = 0;
     while (i < index) : (i += 1) {
-        head = head.?.next;
-        if (head == null) return null;
+        if (head) |cur| {
+            head = cur.next;
+        } else {
+            return null;
+        }
     }
     return head;
 }
 
 // 在链表中查找值为 target 的首个节点
-pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
-    var head = node;
+pub fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
+    var head: ?*ListNode(T) = node;
     var index: i32 = 0;
-    while (head != null) {
-        if (head.?.val == target) return index;
-        head = head.?.next;
+    while (head) |cur| {
+        if (cur.val == target) return index;
+        head = cur.next;
         index += 1;
     }
     return -1;
 }
 
 // Driver Code
-pub fn main() !void {
-    // 初始化链表
-    // 初始化各个节点 
-    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};
+pub fn run() void {
+    // 初始化各个节点
+    var n0 = ListNode(i32){ .val = 1 };
+    var n1 = ListNode(i32){ .val = 3 };
+    var n2 = ListNode(i32){ .val = 2 };
+    var n3 = ListNode(i32){ .val = 5 };
+    var n4 = ListNode(i32){ .val = 4 };
     // 构建节点之间的引用
     n0.next = &n1;
     n1.next = &n2;
     n2.next = &n3;
     n3.next = &n4;
-    std.debug.print("初始化的链表为", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    std.debug.print(
+        "初始化的链表为 {}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 插入节点
-    var tmp = inc.ListNode(i32){.val = 0};
-    insert(&n0, &tmp);
-    std.debug.print("插入节点后的链表为", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    var tmp = ListNode(i32){ .val = 0 };
+    insert(i32, &n0, &tmp);
+    std.debug.print(
+        "插入节点后的链表为 {}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 删除节点
-    remove(&n0);
-    std.debug.print("删除节点后的链表为", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    remove(i32, &n0);
+    std.debug.print(
+        "删除节点后的链表为{}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 访问节点
-    var node = access(&n0, 3);
-    std.debug.print("链表中索引 3 处的节点的值 = {}\n", .{node.?.val});
+    const node = access(i32, &n0, 3);
+    std.debug.print(
+        "链表中索引 3 处的节点的值 = {}\n",
+        .{node.?.val},
+    );
 
     // 查找节点
-    var index = find(&n0, 2);
-    std.debug.print("链表中值为 2 的节点的索引 = {}\n", .{index});
+    const index = find(i32, &n0, 2);
+    std.debug.print(
+        "链表中值为 2 的节点的索引 = {}\n",
+        .{index},
+    );
 
-    _ = try std.io.getStdIn().reader().readByte();
-}
+    std.debug.print("\n", .{});
+}
+
+pub fn main() void {
+    run();
+}
+
+test "linked_list" {
+    run();
+}