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

codes/zig/chapter_array_and_linkedlist/array.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/linked_list.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();
+}

codes/zig/chapter_array_and_linkedlist/list.zig

@@ -1,33 +1,30 @@
 // File: 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");
 
 // Driver Code
-pub fn main() !void {
+pub fn run() !void {
     // 初始化列表
     var nums = std.ArrayList(i32).init(std.heap.page_allocator);
-    // 延迟释放内存
-    defer nums.deinit();
+    defer nums.deinit(); // 延迟释放内存
+
     try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
-    std.debug.print("列表 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("列表 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 访问元素
-    var num = nums.items[1];
-    std.debug.print("\n访问索引 1 处的元素，得到 num = {}", .{num});
+    const num = nums.items[1];
+    std.debug.print("访问索引 1 处的元素，得到 num = {}\n", .{num});
 
     // 更新元素
     nums.items[1] = 0;
-    std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("将索引 1 处的元素更新为 0 ，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 清空列表
     nums.clearRetainingCapacity();
-    std.debug.print("\n清空列表后 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("清空列表后 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 在尾部添加元素
     try nums.append(1);
@@ -35,25 +32,23 @@ pub fn main() !void {
     try nums.append(2);
     try nums.append(5);
     try nums.append(4);
-    std.debug.print("\n添加元素后 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("添加元素后 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 在中间插入元素
     try nums.insert(3, 6);
-    std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("在索引 3 处插入数字 6 ，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 删除元素
     _ = nums.orderedRemove(3);
-    std.debug.print("\n删除索引 3 处的元素，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("删除索引 3 处的元素，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 通过索引遍历列表
     var count: i32 = 0;
-    var i: i32 = 0;
+    var i: usize = 0;
     while (i < nums.items.len) : (i += 1) {
-        count += nums[i];
+        count += nums.items[i];
     }
+
     // 直接遍历列表元素
     count = 0;
     for (nums.items) |x| {
@@ -65,14 +60,19 @@ pub fn main() !void {
     defer nums1.deinit();
     try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
     try nums.insertSlice(nums.items.len, nums1.items);
-    std.debug.print("\n将列表 nums1 拼接到 nums 之后，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("将列表 nums1 拼接到 nums 之后，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 排序列表
     std.mem.sort(i32, nums.items, {}, comptime std.sort.asc(i32));
-    std.debug.print("\n排序列表后 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("排序列表后 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
 }
 
+pub fn main() !void {
+    try run();
+}
+
+test "list" {
+    try run();
+}

codes/zig/chapter_array_and_linkedlist/my_list.zig

@@ -1,132 +1,171 @@
 // File: my_list.zig
 // Created Time: 2023-01-08
-// 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 MyList(comptime T: type) type {
-    return struct {
-        const Self = @This();
-        
-        arr: []T = undefined,                        // 数组（存储列表元素）
-        arrCapacity: usize = 10,                     // 列表容量
-        numSize: usize = 0,                           // 列表长度（当前元素数量）
-        extendRatio: usize = 2,                       // 每次列表扩容的倍数
-        mem_arena: ?std.heap.ArenaAllocator = null,
-        mem_allocator: std.mem.Allocator = undefined, // 内存分配器
+const MyList = struct {
+    const Self = @This();
 
-        // 构造函数（分配内存+初始化列表）
-        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
-            if (self.mem_arena == null) {
-                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
-                self.mem_allocator = self.mem_arena.?.allocator();
-            }
-            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
-            @memset(self.arr, @as(T, 0));
-        }
+    items: []i32, // 数组（存储列表元素）
+    capacity: usize, // 列表容量
+    allocator: std.mem.Allocator, // 内存分配器
 
-        // 析构函数（释放内存）
-        pub fn deinit(self: *Self) void {
-            if (self.mem_arena == null) return;
-            self.mem_arena.?.deinit();
-        }
+    extend_ratio: usize = 2, // 每次列表扩容的倍数
 
-        // 获取列表长度（当前元素数量）
-        pub fn size(self: *Self) usize {
-            return self.numSize;
-        }
+    // 构造函数（分配内存+初始化列表）
+    pub fn init(allocator: std.mem.Allocator) Self {
+        return Self{
+            .items = &[_]i32{},
+            .capacity = 0,
+            .allocator = allocator,
+        };
+    }
 
-        // 获取列表容量
-        pub fn capacity(self: *Self) usize {
-            return self.arrCapacity;
-        }
+    // 析构函数（释放内存）
+    pub fn deinit(self: Self) void {
+        self.allocator.free(self.allocatedSlice());
+    }
 
-        // 访问元素
-        pub fn get(self: *Self, index: usize) T {
-            // 索引如果越界，则抛出异常，下同
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            return self.arr[index];
-        }  
+    // 在尾部添加元素
+    pub fn add(self: *Self, item: i32) !void {
+        // 元素数量超出容量时，触发扩容机制
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
 
         // 更新元素
-        pub fn set(self: *Self, index: usize, num: T) void {
-            // 索引如果越界，则抛出异常，下同
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            self.arr[index] = num;
-        }  
+        self.items.len += 1;
+        const new_item_ptr = &self.items[self.items.len - 1];
+        new_item_ptr.* = item;
+    }
 
-        // 在尾部添加元素
-        pub fn add(self: *Self, num: T) !void {
-            // 元素数量超出容量时，触发扩容机制
-            if (self.size() == self.capacity()) try self.extendCapacity();
-            self.arr[self.size()] = num;
-            // 更新元素数量
-            self.numSize += 1;
-        }  
+    // 获取列表长度（当前元素数量）
+    pub fn getSize(self: *Self) usize {
+        return self.items.len;
+    }
 
-        // 在中间插入元素
-        pub fn insert(self: *Self, index: usize, num: T) !void {
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            // 元素数量超出容量时，触发扩容机制
-            if (self.size() == self.capacity()) try self.extendCapacity();
-            // 将索引 index 以及之后的元素都向后移动一位
-            var j = self.size() - 1;
-            while (j >= index) : (j -= 1) {
-                self.arr[j + 1] = self.arr[j];
+    // 获取列表容量
+    pub fn getCapacity(self: *Self) usize {
+        return self.capacity;
+    }
+
+    // 访问元素
+    pub fn get(self: *Self, index: usize) i32 {
+        // 索引如果越界，则抛出异常，下同
+        if (index < 0 or index >= self.items.len) {
+            @panic("索引越界");
+        }
+        return self.items[index];
+    }
+
+    // 更新元素
+    pub fn set(self: *Self, index: usize, num: i32) void {
+        // 索引如果越界，则抛出异常，下同
+        if (index < 0 or index >= self.items.len) {
+            @panic("索引越界");
+        }
+        self.items[index] = num;
+    }
+
+    // 在中间插入元素
+    pub fn insert(self: *Self, index: usize, item: i32) !void {
+        if (index < 0 or index >= self.items.len) {
+            @panic("索引越界");
+        }
+
+        // 元素数量超出容量时，触发扩容机制
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
+
+        // 将索引 index 以及之后的元素都向后移动一位
+        self.items.len += 1;
+        var i = self.items.len - 1;
+        while (i >= index) : (i -= 1) {
+            self.items[i] = self.items[i - 1];
+        }
+        self.items[index] = item;
+    }
+
+    // 删除元素
+    pub fn remove(self: *Self, index: usize) i32 {
+        if (index < 0 or index >= self.getSize()) {
+            @panic("索引越界");
+        }
+        // 将索引 index 之后的元素都向前移动一位
+        const item = self.items[index];
+        var i = index;
+        while (i < self.items.len - 1) : (i += 1) {
+            self.items[i] = self.items[i + 1];
+        }
+        self.items.len -= 1;
+        // 返回被删除的元素
+        return item;
+    }
+
+    // 将列表转换为数组
+    pub fn toArraySlice(self: *Self) ![]i32 {
+        return self.toOwnedSlice(false);
+    }
+
+    // 返回新的切片并设置是否要重置或清空列表容器
+    pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
+        const allocator = self.allocator;
+        const old_memory = self.allocatedSlice();
+        if (allocator.remap(old_memory, self.items.len)) |new_items| {
+            if (clear) {
+                self.* = init(allocator);
             }
-            self.arr[index] = num;
-            // 更新元素数量
-            self.numSize += 1;
+            return new_items;
         }
 
-        // 删除元素
-        pub fn remove(self: *Self, index: usize) T {
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            var num = self.arr[index];
-            // 将索引 index 之后的元素都向前移动一位
-            var j = index;
-            while (j < self.size() - 1) : (j += 1) {
-                self.arr[j] = self.arr[j + 1];
-            }
-            // 更新元素数量
-            self.numSize -= 1;
-            // 返回被删除的元素
-            return num;
+        const new_memory = try allocator.alloc(i32, self.items.len);
+        @memcpy(new_memory, self.items);
+        if (clear) {
+            self.clearAndFree();
         }
+        return new_memory;
+    }
 
-        // 列表扩容
-        pub fn extendCapacity(self: *Self) !void {
-            // 新建一个长度为 size * extendRatio 的数组，并将原数组复制到新数组
-            var newCapacity = self.capacity() * self.extendRatio;
-            var extend = try self.mem_allocator.alloc(T, newCapacity);
-            @memset(extend, @as(T, 0));
-            // 将原数组中的所有元素复制到新数组
-            std.mem.copy(T, extend, self.arr);
-            self.arr = extend;
-            // 更新列表容量
-            self.arrCapacity = newCapacity;
-        }
+    // 列表扩容
+    fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+        if (self.capacity >= new_capacity) return;
+        const capcacity = if (self.capacity == 0) 10 else self.capacity;
+        const better_capacity = capcacity * self.extend_ratio;
 
-        // 将列表转换为数组
-        pub fn toArray(self: *Self) ![]T {
-            // 仅转换有效长度范围内的列表元素
-            var arr = try self.mem_allocator.alloc(T, self.size());
-           @memset(arr, @as(T, 0));
-            for (arr, 0..) |*num, i| {
-                num.* = self.get(i);
-            }
-            return arr;
+        const old_memory = self.allocatedSlice();
+        if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
+        } else {
+            const new_memory = try self.allocator.alloc(i32, better_capacity);
+            @memcpy(new_memory[0..self.items.len], self.items);
+            self.allocator.free(old_memory);
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
         }
-    };
-}
+    }
+
+    fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
+        allocator.free(self.allocatedSlice());
+        self.items.len = 0;
+        self.capacity = 0;
+    }
+
+    fn allocatedSlice(self: Self) []i32 {
+        return self.items.ptr[0..self.capacity];
+    }
+};
 
 // Driver Code
-pub fn main() !void {
+pub fn run() !void {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
     // 初始化列表
-    var nums = MyList(i32){};
-    try nums.init(std.heap.page_allocator);
+    var nums = MyList.init(allocator);
     // 延迟释放内存
     defer nums.deinit();
 
@@ -136,28 +175,36 @@ pub fn main() !void {
     try nums.add(2);
     try nums.add(5);
     try nums.add(4);
-    std.debug.print("列表 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
-    std.debug.print(" ，容量 = {} ，长度 = {}", .{nums.capacity(), nums.size()});
+    std.debug.print("列表 nums = {} ，容量 = {} ，长度 = {}\n", .{
+        utils.fmt.slice(nums.items),
+        nums.getCapacity(),
+        nums.getSize(),
+    });
 
     // 在中间插入元素
     try nums.insert(3, 6);
-    std.debug.print("\n在索引 3 处插入数字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "在索引 3 处插入数字 6 ，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 删除元素
     _ = nums.remove(3);
-    std.debug.print("\n删除索引 3 处的元素，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "删除索引 3 处的元素，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 访问元素
-    var num = nums.get(1);
-    std.debug.print("\n访问索引 1 处的元素，得到 num = {}", .{num});
+    const num = nums.get(1);
+    std.debug.print("访问索引 1 处的元素，得到 num = {}\n", .{num});
 
     // 更新元素
     nums.set(1, 0);
-    std.debug.print("\n将索引 1 处的元素更新为 0 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "将索引 1 处的元素更新为 0 ，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 测试扩容机制
     var i: i32 = 0;
@@ -165,9 +212,22 @@ pub fn main() !void {
         // 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
         try nums.add(i);
     }
-    std.debug.print("\n扩容后的列表 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
-    std.debug.print(" ，容量 = {} ，长度 = {}\n", .{nums.capacity(), nums.size()});
+    std.debug.print(
+        "扩容后的列表 nums = {} ，容量 = {} ，长度 = {}\n",
+        .{
+            utils.fmt.slice(nums.items),
+            nums.getCapacity(),
+            nums.getSize(),
+        },
+    );
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "my_list" {
+    try run();
 }