🚀feat: add rust codes for linkedlist_stack, linkedlist_queue and linkedlist_deque (#410)

* feat: add rust codes for space_complexity

* feat: add rust codes for linkedlist_stack

* update

* feat: add rust codes for linkedlist_queue

* feat: add rust codes for linkedlist_deque

* update

codes/rust/Cargo.toml

@@ -49,16 +49,31 @@ path = "chapter_array_and_linkedlist/my_list.rs"
 name = "stack"
 path = "chapter_stack_and_queue/stack.rs"
 
+# Run Command: cargo run --bin linkedlist_stack
+[[bin]]
+name = "linkedlist_stack"
+path = "chapter_stack_and_queue/linkedlist_stack.rs"
+
 # Run Command: cargo run --bin queue
 [[bin]]
 name = "queue"
 path = "chapter_stack_and_queue/queue.rs"
 
+# Run Command: cargo run --bin linkedlist_queue
+[[bin]]
+name = "linkedlist_queue"
+path = "chapter_stack_and_queue/linkedlist_queue.rs"
+
 # Run Command: cargo run --bin deque
 [[bin]]
 name = "deque"
 path = "chapter_stack_and_queue/deque.rs"
 
+# Run Command: cargo run --bin linkedlist_deque
+[[bin]]
+name = "linkedlist_deque"
+path = "chapter_stack_and_queue/linkedlist_deque.rs"
+
 # Run Command: cargo run --bin hash_map
 [[bin]]
 name = "hash_map"

codes/rust/chapter_array_and_linkedlist/linked_list.rs

@@ -5,8 +5,10 @@
  */
 
 include!("../include/include.rs");
+
 use std::rc::Rc;
 use std::cell::RefCell;
+use list_node::ListNode;
 
 /* 在链表的结点 n0 之后插入结点 P */
 #[allow(non_snake_case)]

codes/rust/chapter_computational_complexity/space_complexity.rs

@@ -9,6 +9,8 @@ include!("../include/include.rs");
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::cell::RefCell;
+use list_node::ListNode;
+use tree_node::TreeNode;
 
 /* 函数 */
 fn function() ->i32 {

codes/rust/chapter_stack_and_queue/linkedlist_deque.rs

@@ -0,0 +1,207 @@
+/*
+ * File: linkedlist_deque.rs
+ * Created Time: 2023-03-11
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::rc::Rc;
+use std::cell::RefCell;
+
+/* 双向链表结点 */
+pub struct ListNode<T> {
+    pub val: T,                                 // 结点值
+    pub next: Option<Rc<RefCell<ListNode<T>>>>, // 后继结点引用（指针）
+    pub prev: Option<Rc<RefCell<ListNode<T>>>>, // 前驱结点引用（指针）
+}
+
+impl<T> ListNode<T> {
+    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {
+        Rc::new(RefCell::new(ListNode {
+            val,
+            next: None,
+            prev: None,
+        }))
+    }
+}
+
+/* 基于双向链表实现的双向队列 */
+#[allow(dead_code)]
+pub struct LinkedListDeque<T> {
+    front: Option<Rc<RefCell<ListNode<T>>>>,    // 头结点 front
+    rear: Option<Rc<RefCell<ListNode<T>>>>,     // 尾结点 rear 
+    que_size: usize,                            // 双向队列的长度
+}
+
+impl<T: Copy> LinkedListDeque<T> {
+    pub fn new() -> Self {
+        Self {
+            front: None,
+            rear: None,
+            que_size: 0, 
+        }
+    }
+
+    /* 获取双向队列的长度 */
+    pub fn size(&self) -> usize {
+        return self.que_size;
+    }
+
+    /* 判断双向队列是否为空 */
+    pub fn is_empty(&self) -> bool {
+        return self.size() == 0;
+    }
+
+    /* 入队操作 */
+    pub fn push(&mut self, num: T, is_front: bool) {
+        let node = ListNode::new(num);
+        // 队首入队操作
+        if is_front {
+            // 将 node 添加至链表头部
+            match self.front.take() {
+                Some(old_front) => {
+                    old_front.borrow_mut().prev = Some(node.clone());
+                    node.borrow_mut().next = Some(old_front);
+                    self.front = Some(node); // 更新头结点
+                }
+                None => {
+                    self.rear = Some(node.clone());
+                    self.front = Some(node);
+                }
+            }
+        // 队尾入队操作
+        } else {
+            // 将 node 添加至链表尾部
+            match self.rear.take() {
+                Some(old_rear) => {
+                    old_rear.borrow_mut().next = Some(node.clone());
+                    node.borrow_mut().prev = Some(old_rear);
+                    self.rear = Some(node); // 更新尾结点
+                }
+                None => {
+                    self.front = Some(node.clone());
+                    self.rear = Some(node);
+                }
+            }
+        }
+        self.que_size += 1;
+    }
+
+    /* 队首入队 */
+    pub fn push_first(&mut self, num: T) {
+        self.push(num, true);
+    }
+
+    /* 队尾入队 */
+    pub fn push_last(&mut self, num: T) {
+        self.push(num, false);
+    }
+
+    /* 出队操作 */
+    pub fn poll(&mut self, is_front: bool) -> Option<T> {
+        if self.is_empty() {return None};
+        // 队首出队操作
+        if is_front {
+            self.front.take().map(|old_front| {
+                match old_front.borrow_mut().next.take() {
+                    Some(new_front) => {
+                        new_front.borrow_mut().prev.take();
+                        self.front = Some(new_front);   // 更新头结点
+                    }
+                    None => {
+                        self.rear.take();
+                    }
+                }
+                self.que_size -= 1;
+                Rc::try_unwrap(old_front).ok().unwrap().into_inner().val
+            })
+        // 队尾出队操作
+        } else {
+            self.rear.take().map(|old_rear| {
+                match old_rear.borrow_mut().prev.take() {
+                    Some(new_rear) => {
+                        new_rear.borrow_mut().next.take();
+                        self.rear = Some(new_rear);     // 更新尾结点
+                    }
+                    None => {
+                        self.front.take();
+                    }
+                }
+                self.que_size -= 1;
+                Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val
+            })
+        }
+    }
+
+    /* 队首出队 */
+    pub fn poll_first(&mut self) -> Option<T> {
+        return self.poll(true);
+    }
+
+    /* 队尾出队 */
+    pub fn poll_last(&mut self) -> Option<T> {
+        return self.poll(false);
+    }
+
+    /* 访问队首元素 */
+    pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
+        self.front.as_ref()
+    }
+
+    /* 访问队尾元素 */
+    pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
+        self.rear.as_ref()
+    }
+
+    /* 返回数组用于打印 */
+    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
+        if let Some(node) = head {
+            let mut nums = self.to_array(node.borrow().next.as_ref());
+            nums.insert(0, node.borrow().val);
+            return nums;
+        }
+        return Vec::new();
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化双向队列 */
+    let mut deque = LinkedListDeque::new();
+    deque.push_last(3);
+    deque.push_last(2);
+    deque.push_last(5);
+    print!("双向队列 deque = ");
+    print_util::print_array(&deque.to_array(deque.peek_first()));
+
+    /* 访问元素 */
+    let peek_first = deque.peek_first().unwrap().borrow().val;
+    print!("\n队首元素 peek_first = {}", peek_first);
+    let peek_last = deque.peek_last().unwrap().borrow().val;
+    print!("\n队尾元素 peek_last = {}", peek_last);
+
+    /* 元素入队 */
+    deque.push_last(4);
+    print!("\n元素 4 队尾入队后 deque = ");
+    print_util::print_array(&deque.to_array(deque.peek_first()));
+    deque.push_first(1);
+    print!("\n元素 1 队首入队后 deque = ");
+    print_util::print_array(&deque.to_array(deque.peek_first()));
+
+    /* 元素出队 */
+    let poll_last = deque.poll_last().unwrap();
+    print!("\n队尾出队元素 = {}，队尾出队后 deque = ", poll_last);
+    print_util::print_array(&deque.to_array(deque.peek_first()));
+    let poll_first = deque.poll_first().unwrap();
+    print!("\n队首出队元素 = {}，队首出队后 deque = ", poll_first);
+    print_util::print_array(&deque.to_array(deque.peek_first()));   
+
+    /* 获取双向队列的长度 */
+    let size = deque.size();
+    print!("\n双向队列长度 size = {}", size);
+
+    /* 判断双向队列是否为空 */
+    let is_empty = deque.is_empty();
+    print!("\n双向队列是否为空 = {}", is_empty);
+}

codes/rust/chapter_stack_and_queue/linkedlist_queue.rs

@@ -0,0 +1,121 @@
+/*
+ * File: linkedlist_queue.rs
+ * Created Time: 2023-03-11
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::rc::Rc;
+use std::cell::RefCell;
+use list_node::ListNode;
+
+/* 基于链表实现的队列 */
+#[allow(dead_code)]
+pub struct LinkedListQueue<T> {
+    front: Option<Rc<RefCell<ListNode<T>>>>,    // 头结点 front
+    rear: Option<Rc<RefCell<ListNode<T>>>>,     // 尾结点 rear 
+    que_size: usize,                            // 队列的长度
+}
+
+impl<T: Copy> LinkedListQueue<T> {
+    pub fn new() -> Self {
+        Self {
+            front: None,
+            rear: None,
+            que_size: 0, 
+        }
+    }
+
+    /* 获取队列的长度 */
+    pub fn size(&self) -> usize {
+        return self.que_size;
+    }
+
+    /* 判断队列是否为空 */
+    pub fn is_empty(&self) -> bool {
+        return self.size() == 0;
+    }
+
+    /* 入队 */
+    pub fn push(&mut self, num: T) {
+        // 尾结点后添加 num
+        let new_rear = ListNode::new(num);
+        match self.rear.take() {
+            // 如果队列不为空，则将该结点添加到尾结点后
+            Some(old_rear) => {
+                old_rear.borrow_mut().next = Some(new_rear.clone());
+                self.rear = Some(new_rear);
+            }
+            // 如果队列为空，则令头、尾结点都指向该结点
+            None => {
+                self.front = Some(new_rear.clone());
+                self.rear = Some(new_rear);
+            }
+        }
+        self.que_size += 1;
+    }
+
+    /* 出队 */
+    pub fn poll(&mut self) -> Option<T> {
+        self.front.take().map(|old_front| {
+            match old_front.borrow_mut().next.take() {
+                Some(new_front) => {
+                    self.front = Some(new_front);
+                }
+                None => {
+                    self.rear.take();
+                }
+            }
+            self.que_size -= 1;
+            Rc::try_unwrap(old_front).ok().unwrap().into_inner().val
+        })
+    }
+
+    /* 访问队首元素 */
+    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
+        self.front.as_ref()
+    }
+
+    /* 将链表转化为 Array 并返回 */
+    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
+        if let Some(node) = head {
+            let mut nums = self.to_array(node.borrow().next.as_ref());
+            nums.insert(0, node.borrow().val);
+            return nums;
+        }
+        return Vec::new();
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化队列 */
+    let mut queue = LinkedListQueue::new();
+
+    /* 元素入队 */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+    print!("队列 queue = ");
+    print_util::print_array(&queue.to_array(queue.peek()));
+
+    /* 访问队首元素 */
+    let peek = queue.peek().unwrap().borrow().val;
+    print!("\n队首元素 peek = {}", peek);
+
+    /* 元素出队 */
+    let poll = queue.poll().unwrap();
+    print!("\n出队元素 poll = {}，出队后 queue = ", poll);
+    print_util::print_array(&queue.to_array(queue.peek()));
+
+    /* 获取队列的长度 */
+    let size = queue.size();
+    print!("\n队列长度 size = {}", size);
+
+    /* 判断队列是否为空 */
+    let is_empty = queue.is_empty();
+    print!("\n队列是否为空 = {}", is_empty);
+}

codes/rust/chapter_stack_and_queue/linkedlist_stack.rs

@@ -0,0 +1,108 @@
+/*
+ * File: linkedlist_stack.rs
+ * Created Time: 2023-03-11
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::rc::Rc;
+use std::cell::RefCell;
+use list_node::ListNode;
+
+/* 基于链表实现的栈 */
+#[allow(dead_code)]
+pub struct LinkedListStack<T> {
+    stack_peek: Option<Rc<RefCell<ListNode<T>>>>,   // 将头结点作为栈顶
+    stk_size: usize,                                // 栈的长度
+}
+
+impl<T: Copy> LinkedListStack<T> {
+    pub fn new() -> Self {
+        Self {
+            stack_peek: None,
+            stk_size: 0,
+        }
+    }
+
+    /* 获取栈的长度 */
+    pub fn size(&self) -> usize {
+        return self.stk_size;
+    }
+
+    /* 判断栈是否为空 */
+    pub fn is_empty(&self) -> bool {
+        return self.size() == 0;
+    }
+
+    /* 入栈 */
+    pub fn push(&mut self, num: T) {
+        let node = ListNode::new(num);
+        node.borrow_mut().next = self.stack_peek.take();
+        self.stack_peek = Some(node);
+        self.stk_size += 1;
+    }
+
+    /* 出栈 */
+    pub fn pop(&mut self) -> Option<T> {
+        self.stack_peek.take().map(|old_head| {
+            match old_head.borrow_mut().next.take() {
+                Some(new_head) => {
+                    self.stack_peek = Some(new_head);
+                }
+                None => {
+                    self.stack_peek = None;
+                }
+            }
+            self.stk_size -= 1;
+            Rc::try_unwrap(old_head).ok().unwrap().into_inner().val
+        })
+    }
+
+    /* 访问栈顶元素 */
+    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
+        self.stack_peek.as_ref()
+    }
+
+    /* 将 List 转化为 Array 并返回 */
+    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
+        if let Some(node) = head {
+            let mut nums = self.to_array(node.borrow().next.as_ref());
+            nums.push(node.borrow().val);
+            return nums;
+        }
+        return Vec::new();
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 初始化栈 */
+    let mut stack = LinkedListStack::new();
+
+    /* 元素入栈 */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+    print!("栈 stack = ");
+    print_util::print_array(&stack.to_array(stack.peek()));
+
+    /* 访问栈顶元素 */
+    let peek = stack.peek().unwrap().borrow().val;
+    print!("\n栈顶元素 peek = {}", peek);
+
+    /* 元素出栈 */
+    let pop = stack.pop().unwrap();
+    print!("\n出栈元素 pop = {}，出栈后 stack = ", pop);
+    print_util::print_array(&stack.to_array(stack.peek()));
+
+    /* 获取栈的长度 */
+    let size = stack.size();
+    print!("\n栈的长度 size = {}", size);
+
+    /* 判断是否为空 */
+    let is_empty = stack.is_empty();
+    print!("\n栈是否为空 = {}", is_empty);
+}

codes/rust/include/include.rs

@@ -6,6 +6,4 @@
 
 pub mod print_util;
 pub mod list_node;
-pub use list_node::ListNode;
+pub mod tree_node;
-pub mod tree_node;
-pub use tree_node::TreeNode;

codes/zig/chapter_stack_and_queue/linkedlist_deque.zig

@@ -30,7 +30,7 @@ pub fn LinkedListDeque(comptime T: type) type {
 
         front: ?*ListNode(T) = null,                    // 头结点 front
         rear: ?*ListNode(T) = null,                     // 尾结点 rear
-        deqSize: usize = 0,                             // 双向队列的长度
+        que_size: usize = 0,                             // 双向队列的长度
         mem_arena: ?std.heap.ArenaAllocator = null,
         mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
 
@@ -42,7 +42,7 @@ pub fn LinkedListDeque(comptime T: type) type {
             }
             self.front = null;
             self.rear = null;
-            self.deqSize = 0;
+            self.que_size = 0;
         }
 
         // 析构方法（释放内存）
@@ -53,7 +53,7 @@ pub fn LinkedListDeque(comptime T: type) type {
 
         // 获取双向队列的长度
         pub fn size(self: *Self) usize {
-            return self.deqSize;
+            return self.que_size;
         }
 
         // 判断双向队列是否为空
@@ -62,7 +62,7 @@ pub fn LinkedListDeque(comptime T: type) type {
         }
 
         // 入队操作
-        pub fn push(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
@@ -70,7 +70,7 @@ pub fn LinkedListDeque(comptime T: type) type {
                 self.front = node;
                 self.rear = node;
             // 队首入队操作
-            } else if (isFront) {
+            } else if (is_front) {
                 // 将 node 添加至链表头部
                 self.front.?.prev = node;
                 node.next = self.front;
@@ -82,7 +82,7 @@ pub fn LinkedListDeque(comptime T: type) type {
                 node.prev = self.rear;
                 self.rear = node;   // 更新尾结点
             }
-            self.deqSize += 1;      // 更新队列长度
+            self.que_size += 1;      // 更新队列长度
         } 
 
         // 队首入队
@@ -96,11 +96,11 @@ pub fn LinkedListDeque(comptime T: type) type {
         } 
         
         // 出队操作
-        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;
@@ -120,7 +120,7 @@ pub fn LinkedListDeque(comptime T: type) type {
                 }
                 self.rear = rPrev;          // 更新尾结点
             }
-            self.deqSize -= 1;              // 更新队列长度
+            self.que_size -= 1;              // 更新队列长度
             return val;
         } 
 
@@ -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("]", .{});
-            }
-        }
     };
 }
 
@@ -180,46 +167,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.pushLast(3);
-    try deque.print();
+    try deque.pushLast(2);
+    try deque.pushLast(5);
+    std.debug.print("双向队列 deque = ", .{});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
 
-    var nums = [_]i32{ 1, 2, 3};    // 测试数据
+    // 访问元素
+    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});
 
-    // 队尾入队
+    // 元素入队
-    for (nums) |num| {
+    try deque.pushLast(4);
-        try deque.pushLast(num);
+    std.debug.print("\n元素 4 队尾入队后 deque = ", .{});
-        std.debug.print("\n元素 {} 队尾入队后，队列为\n", .{num});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
-        try deque.print();
+    try deque.pushFirst(1);
-    }
+    std.debug.print("\n元素 1 队首入队后 deque = ", .{});
-    // 获取队尾元素
+    inc.PrintUtil.printArray(i32, try deque.toArray());
-    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| {
+    var poll_last = deque.pollLast();
-        try deque.pushFirst(num);
+    std.debug.print("\n队尾出队元素 = {}，队尾出队后 deque = ", .{poll_last});
-        std.debug.print("\n元素 {} 队首入队后，队列为\n", .{num});
+    inc.PrintUtil.printArray(i32, try deque.toArray());
-        try deque.print();
+    var poll_first = deque.pollFirst();
-    }
+    std.debug.print("\n队首出队元素 = {}，队首出队后 deque = ", .{poll_first});
-    // 获取队首元素
+    inc.PrintUtil.printArray(i32, try deque.toArray());
-    var first = deque.peekFirst();
-    std.debug.print("\n队首元素为 {}", .{first});
-    // 队首出队
-    while (!deque.isEmpty()) {
-        first = deque.pollFirst();
-        std.debug.print("\n队首出队元素为 {} ，队列为\n", .{first});
-        try deque.print();
-    }
 
-    // 获取队列的长度
+    // 获取双向队列的长度
     var size = deque.size();
-    std.debug.print("\n队列长度 size = {}", .{size});
+    std.debug.print("\n双向队列长度 size = {}", .{size});
 
     // 判断双向队列是否为空
     var is_empty = deque.isEmpty();

codes/zig/chapter_stack_and_queue/linkedlist_queue.zig

@@ -12,7 +12,7 @@ pub fn LinkedListQueue(comptime T: type) type {
 
         front: ?*inc.ListNode(T) = null,                // 头结点 front
         rear: ?*inc.ListNode(T) = null,                 // 尾结点 rear
-        queSize: usize = 0,                             // 队列的长度
+        que_size: usize = 0,                             // 队列的长度
         mem_arena: ?std.heap.ArenaAllocator = null,
         mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
 
@@ -24,7 +24,7 @@ pub fn LinkedListQueue(comptime T: type) type {
             }
             self.front = null;
             self.rear = null;
-            self.queSize = 0;
+            self.que_size = 0;
         }
 
         // 析构方法（释放内存）
@@ -35,7 +35,7 @@ pub fn LinkedListQueue(comptime T: type) type {
 
         // 获取队列的长度
         pub fn size(self: *Self) usize {
-            return self.queSize;
+            return self.que_size;
         }
 
         // 判断队列是否为空
@@ -63,7 +63,7 @@ pub fn LinkedListQueue(comptime T: type) type {
                 self.rear.?.next = node;
                 self.rear = node;
             }
-            self.queSize += 1;
+            self.que_size += 1;
         } 
 
         // 出队
@@ -71,7 +71,7 @@ pub fn LinkedListQueue(comptime T: type) type {
             var num = self.peek();
             // 删除头结点
             self.front = self.front.?.next;
-            self.queSize -= 1;
+            self.que_size -= 1;
             return num;
         } 
 

codes/zig/chapter_stack_and_queue/linkedlist_stack.zig

@@ -10,8 +10,8 @@ pub fn LinkedListStack(comptime T: type) type {
     return struct {
         const Self = @This();
 
-        stackTop: ?*inc.ListNode(T) = null,             // 将头结点作为栈顶
+        stack_top: ?*inc.ListNode(T) = null,             // 将头结点作为栈顶
-        stkSize: usize = 0,                             // 栈的长度
+        stk_size: usize = 0,                             // 栈的长度
         mem_arena: ?std.heap.ArenaAllocator = null,
         mem_allocator: std.mem.Allocator = undefined,   // 内存分配器
 
@@ -21,8 +21,8 @@ pub fn LinkedListStack(comptime T: type) type {
                 self.mem_arena = std.heap.ArenaAllocator.init(allocator);
                 self.mem_allocator = self.mem_arena.?.allocator();
             }
-            self.stackTop = null;
+            self.stack_top = null;
-            self.stkSize = 0;
+            self.stk_size = 0;
         }
 
         // 析构方法（释放内存）
@@ -33,7 +33,7 @@ pub fn LinkedListStack(comptime T: type) type {
 
         // 获取栈的长度
         pub fn size(self: *Self) usize {
-            return self.stkSize;
+            return self.stk_size;
         }
 
         // 判断栈是否为空
@@ -42,31 +42,31 @@ pub fn LinkedListStack(comptime T: type) type {
         }
 
         // 访问栈顶元素
-        pub fn top(self: *Self) T {
+        pub fn peek(self: *Self) T {
             if (self.size() == 0) @panic("栈为空");
-            return self.stackTop.?.val;
+            return self.stack_top.?.val;
         }  
 
         // 入栈
         pub fn push(self: *Self, num: T) !void {
             var node = try self.mem_allocator.create(inc.ListNode(T));
             node.init(num);
-            node.next = self.stackTop;
+            node.next = self.stack_top;
-            self.stackTop = node;
+            self.stack_top = node;
-            self.stkSize += 1;
+            self.stk_size += 1;
         } 
 
         // 出栈
         pub fn pop(self: *Self) T {
-            var num = self.top();
+            var num = self.peek();
-            self.stackTop = self.stackTop.?.next;
+            self.stack_top = self.stack_top.?.next;
-            self.stkSize -= 1;
+            self.stk_size -= 1;
             return num;
         } 
 
         // 将栈转换为数组
         pub fn toArray(self: *Self) ![]T {
-            var node = self.stackTop;
+            var node = self.stack_top;
             var res = try self.mem_allocator.alloc(T, self.size());
             std.mem.set(T, res, @as(T, 0));
             var i: usize = 0;
@@ -97,12 +97,12 @@ pub fn main() !void {
     inc.PrintUtil.printArray(i32, try stack.toArray());
 
     // 访问栈顶元素
-    var top = stack.top();
+    var peek = stack.peek();
-    std.debug.print("\n栈顶元素 top = {}", .{top});
+    std.debug.print("\n栈顶元素 top = {}", .{peek});
 
     // 元素出栈
-    top = stack.pop();
+    var pop = stack.pop();
-    std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{top});
+    std.debug.print("\n出栈元素 pop = {}，出栈后 stack = ", .{pop});
     inc.PrintUtil.printArray(i32, try stack.toArray());
 
     // 获取栈的长度