update

coderonion · coderonion · commit 9c1df91e22f7 · 2023-02-01T23:00:43.000+08:00
diff --git a/zig/chapter_array_and_linkedlist/my_list.zig b/zig/chapter_array_and_linkedlist/my_list.zig
@@ -11,12 +11,12 @@ pub fn MyList(comptime T: type) type {
     return struct {
         const Self = @This();
         
-        nums: []T = undefined,                          // 数组（存储列表元素）
-        numsCapacity: usize = 10,                       // 列表容量
-        numSize: usize = 0,                             // 列表长度（即当前元素数量）
-        extendRatio: usize = 2,                         // 每次列表扩容的倍数
+        nums: []T = undefined,                        // 数组（存储列表元素）
+        numsCapacity: usize = 10,                     // 列表容量
+        numSize: usize = 0,                           // 列表长度（即当前元素数量）
+        extendRatio: usize = 2,                       // 每次列表扩容的倍数
         mem_arena: ?std.heap.ArenaAllocator = null,
-        mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
+        mem_allocator: std.mem.Allocator = undefined, // 内存分配器
 
         // 构造函数（分配内存+初始化列表）
         pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
@@ -47,14 +47,14 @@ pub fn MyList(comptime T: type) type {
         // 访问元素
         pub fn get(self: *Self, index: usize) T {
             // 索引如果越界则抛出异常，下同
-            if (index >= self.size()) @panic("索引越界");
+            if (index < 0 or index >= self.size()) @panic("索引越界");
             return self.nums[index];
         }  
 
         // 更新元素
         pub fn set(self: *Self, index: usize, num: T) void {
             // 索引如果越界则抛出异常，下同
-            if (index >= self.size()) @panic("索引越界");
+            if (index < 0 or index >= self.size()) @panic("索引越界");
             self.nums[index] = num;
         }  
 
@@ -69,7 +69,7 @@ pub fn MyList(comptime T: type) type {
 
         // 中间插入元素
         pub fn insert(self: *Self, index: usize, num: T) !void {
-            if (index >= self.size()) @panic("索引越界");
+            if (index < 0 or index >= self.size()) @panic("索引越界");
             // 元素数量超出容量时，触发扩容机制
             if (self.size() == self.capacity()) try self.extendCapacity();
             // 索引 i 以及之后的元素都向后移动一位
@@ -84,7 +84,7 @@ pub fn MyList(comptime T: type) type {
 
         // 删除元素
         pub fn remove(self: *Self, index: usize) T {
-            if (index >= self.size()) @panic("索引越界");
+            if (index < 0 or index >= self.size()) @panic("索引越界");
             var num = self.nums[index];
             // 索引 i 之后的元素都向前移动一位
             var j = index;
@@ -125,10 +125,6 @@ pub fn MyList(comptime T: type) type {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     // 初始化列表
     var list = MyList(i32){};
     try list.init(std.heap.page_allocator);
@@ -176,5 +172,4 @@ pub fn main() !void {
     std.debug.print(" ，容量 = {} ，长度 = {}\n", .{list.capacity(), list.size()});
 
     _ = try std.io.getStdIn().reader().readByte();
-}
-
+}
diff --git a/zig/chapter_stack_and_queue/array_queue.zig b/zig/chapter_stack_and_queue/array_queue.zig
@@ -12,8 +12,8 @@ pub fn ArrayQueue(comptime T: type) type {
 
         nums: []T = undefined,                          // 用于存储队列元素的数组     
         cap: usize = 0,                                 // 队列容量
-        front: usize = 0,                               // 头指针，指向队首
-        rear: usize = 0,                                // 尾指针，指向队尾 + 1
+        front: usize = 0,                               // 队首指针，指向队首元素
+        queSize: usize = 0,                             // 尾指针，指向队尾 + 1
         mem_arena: ?std.heap.ArenaAllocator = null,
         mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
 
@@ -41,13 +41,12 @@ pub fn ArrayQueue(comptime T: type) type {
 
         // 获取队列的长度
         pub fn size(self: *Self) usize {
-            // 由于将数组看作为环形，可能 rear < front ，因此需要取余数
-            return (self.capacity() + self.rear - self.front) % self.capacity();
+            return self.queSize;
         }
 
         // 判断队列是否为空
         pub fn isEmpty(self: *Self) bool {
-            return self.rear == self.front;
+            return self.queSize == 0;
         }
 
         // 入队
@@ -56,17 +55,20 @@ pub fn ArrayQueue(comptime T: type) type {
                 std.debug.print("队列已满\n", .{});
                 return;
             }
+            // 计算尾指针，指向队尾索引 + 1
+            // 通过取余操作，实现 rear 越过数组尾部后回到头部
+            var rear = (self.front + self.queSize) % self.capacity();
             // 尾结点后添加 num
-            self.nums[self.rear] = num;
-            // 尾指针向后移动一位，越过尾部后返回到数组头部
-            self.rear = (self.rear + 1) % self.capacity();
+            self.nums[rear] = num;
+            self.queSize += 1;
         } 
 
         // 出队
         pub fn poll(self: *Self) T {
             var num = self.peek();
-            // 队头指针向后移动一位，若越过尾部则返回到数组头部
+            // 队首指针向后移动一位，若越过尾部则返回到数组头部
             self.front = (self.front + 1) % self.capacity();
+            self.queSize -= 1;
             return num;
         } 
 
@@ -93,10 +95,6 @@ pub fn ArrayQueue(comptime T: type) type {
 
 // Driver Code
 pub fn main() !void {
-    // 查看本地CPU架构和操作系统信息
-    var native_target_info = try std.zig.system.NativeTargetInfo.detect(std.zig.CrossTarget{});
-    std.debug.print("Native Info: CPU Arch = {}, OS = {}\n", .{native_target_info.target.cpu.arch, native_target_info.target.os.tag});
-
     // 初始化队列
     var capacity: usize = 10;
     var queue = ArrayQueue(i32){};
@@ -139,4 +137,4 @@ pub fn main() !void {
     }
 
     _ = try std.io.getStdIn().reader().readByte();
-}
+}
