update

coderonion · coderonion · commit 0e7d93cdcce3 · 2023-03-12T23:00:02.000+08:00
diff --git a/rust/chapter_computational_complexity/space_complexity.rs b/rust/chapter_computational_complexity/space_complexity.rs
@@ -10,6 +10,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 use std::cell::RefCell;
 use list_node::ListNode;
+use tree_node::TreeNode;
 
 /* 函数 */
 fn function() ->i32 {
diff --git a/zig/chapter_stack_and_queue/linkedlist_deque.zig b/zig/chapter_stack_and_queue/linkedlist_deque.zig
@@ -62,15 +62,15 @@ pub fn LinkedListDeque(comptime T: type) type {
         }
 
         // 入队操作
-        pub fn offer(self: *Self, num: T, isFront: bool) !void {
+        pub fn push(self: *Self, num: T, is_front: bool) !void {
             var node = try self.mem_allocator.create(ListNode(T));
             node.init(num);
             // 若链表为空，则令 front, rear 都指向 node
             if (self.isEmpty()) {
                 self.front = node;
                 self.rear = node;
             // 队首入队操作
-            } else if (isFront) {
+            } else if (is_front) {
                 // 将 node 添加至链表头部
                 self.front.?.prev = node;
                 node.next = self.front;
@@ -86,21 +86,21 @@ pub fn LinkedListDeque(comptime T: type) type {
         } 
 
         // 队首入队
-        pub fn offerFirst(self: *Self, num: T) !void {
-            try self.offer(num, true);
+        pub fn pushFirst(self: *Self, num: T) !void {
+            try self.push(num, true);
         } 
 
         // 队尾入队
-        pub fn offerLast(self: *Self, num: T) !void {
-            try self.offer(num, false);
+        pub fn pushLast(self: *Self, num: T) !void {
+            try self.push(num, false);
         } 
         
         // 出队操作
-        pub fn poll(self: *Self, isFront: bool) T {
+        pub fn poll(self: *Self, is_front: bool) T {
             if (self.isEmpty()) @panic("双向队列为空");
             var val: T = undefined;
             // 队首出队操作
-            if (isFront) {
+            if (is_front) {
                 val = self.front.?.val;     // 暂存头结点值
                 // 删除头结点
                 var fNext = self.front.?.next;
@@ -146,7 +146,7 @@ pub fn LinkedListDeque(comptime T: type) type {
             return self.rear.?.val;
         }
 
-        // 将链表转换为数组
+        // 返回数组用于打印
         pub fn toArray(self: *Self) ![]T {
             var node = self.front;
             var res = try self.mem_allocator.alloc(T, self.size());
@@ -158,19 +158,6 @@ pub fn LinkedListDeque(comptime T: type) type {
             }
             return res;
         }
-
-        // 打印双向队列
-        pub fn print(self: *Self) !void {
-            var nums = try self.toArray();
-            std.debug.print("[", .{});
-            if (nums.len > 0) {
-                for (nums) |num, j| {
-                    std.debug.print("{}{s}", .{num, if (j == nums.len - 1) "]" else " <-> " });
-                }
-            } else {
-                std.debug.print("]", .{});
-            }
-        }
     };
 }
 
@@ -184,46 +171,37 @@ pub fn main() !void {
     var deque = LinkedListDeque(i32){};
     try deque.init(std.heap.page_allocator);
     defer deque.deinit();
-    std.debug.print("初始化空队列\n", .{});
-    try deque.print();
-
-    var nums = [_]i32{ 1, 2, 3};    // 测试数据
-
-    // 队尾入队
-    for (nums) |num| {
-        try deque.offerLast(num);
-        std.debug.print("\n元素 {} 队尾入队后，队列为\n", .{num});
-        try deque.print();
-    }
-    // 获取队尾元素
-    var last = deque.peekLast();
-    std.debug.print("\n队尾元素为 {}", .{last});
-    // 队尾出队
-    while (!deque.isEmpty()) {
-        last = deque.pollLast();
-        std.debug.print("\n队尾出队元素为 {} ，队列为\n", .{last});
-        try deque.print();
-    }
-
-    // 队首入队
-    for (nums) |num| {
-        try deque.offerFirst(num);
-        std.debug.print("\n元素 {} 队首入队后，队列为\n", .{num});
-        try deque.print();
-    }
-    // 获取队首元素
-    var first = deque.peekFirst();
-    std.debug.print("\n队首元素为 {}", .{first});
-    // 队首出队
-    while (!deque.isEmpty()) {
-        first = deque.pollFirst();
-        std.debug.print("\n队首出队元素为 {} ，队列为\n", .{first});
-        try deque.print();
-    }
-
-    // 获取队列的长度
+    try deque.pushLast(3);
+    try deque.pushLast(2);
+    try deque.pushLast(5);
+    std.debug.print("双向队列 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 访问元素
+    var peek_first = deque.peekFirst();
+    std.debug.print("\n队首元素 peek_first = {}", .{peek_first});
+    var peek_last = deque.peekLast();
+    std.debug.print("\n队尾元素 peek_last = {}", .{peek_last});
+
+    // 元素入队
+    try deque.pushLast(4);
+    std.debug.print("\n元素 4 队尾入队后 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+    try deque.pushFirst(1);
+    std.debug.print("\n元素 1 队首入队后 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 元素出队
+    var poll_last = deque.pollLast();
+    std.debug.print("\n队尾出队元素 = {}，队尾出队后 deque = ", .{poll_last});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+    var poll_first = deque.pollFirst();
+    std.debug.print("\n队首出队元素 = {}，队首出队后 deque = ", .{poll_first});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
+
+    // 获取双向队列的长度
     var size = deque.size();
-    std.debug.print("\n队列长度 size = {}", .{size});
+    std.debug.print("\n双向队列长度 size = {}", .{size});
 
     // 判断双向队列是否为空
     var is_empty = deque.isEmpty();
