fix: check the rust codes and fix them (#653)

* fix: check the rust codes and fix it

* Update binary_tree_bfs.rs

---------

Co-authored-by: Yudong Jin <krahets@163.com>

codes/rust/chapter_stack_and_queue/array_queue.rs

@@ -4,15 +4,16 @@
  * Author: WSL0809 (wslzzy@outlook.com)
  */
 
-
+/* 基于环形数组实现的队列 */
 struct ArrayQueue {
-    nums: Vec<i32>,
-    front: i32,
-    que_size: i32,
-    que_capacity: i32,
+    nums: Vec<i32>,     // 用于存储队列元素的数组
+    front: i32,         // 队首指针，指向队首元素
+    que_size: i32,      // 队列长度
+    que_capacity: i32,  // 队列容量
 }
 
 impl ArrayQueue {
+    /* 构造方法 */
     fn new(capacity: i32) -> ArrayQueue {
         ArrayQueue {
             nums: vec![0; capacity as usize],
@@ -22,31 +23,53 @@ impl ArrayQueue {
         }
     }
 
+    /* 获取队列的容量 */
+    fn capacity(&self) -> i32 {
+        self.que_capacity
+    }
+
+    /* 获取队列的长度 */
     fn size(&self) -> i32 {
         self.que_size
     }
 
+    /* 判断队列是否为空 */
+    fn is_empty(&self) -> bool {
+        self.que_size == 0
+    }
+
+    /* 入队 */
     fn push(&mut self, num: i32) {
-        if self.que_size == self.que_capacity {
+        if self.que_size == self.capacity() {
+            println!("队列已满");
             return;
         }
+        // 计算尾指针，指向队尾索引 + 1
+        // 通过取余操作，实现 rear 越过数组尾部后回到头部
         let rear = (self.front + self.que_size) % self.que_capacity;
-        // self.nums.insert(rear as usize, num);
+        // 将 num 添加至队尾
         self.nums[rear as usize] = num;
         self.que_size += 1;
     }
 
+    /* 出队 */
     fn pop(&mut self) -> i32 {
         let num = self.peek();
+        // 队首指针向后移动一位，若越过尾部则返回到数组头部
         self.front = (self.front + 1) % self.que_capacity;
         self.que_size -= 1;
         num
     }
 
+    /* 访问队首元素 */
     fn peek(&self) -> i32 {
+        if self.is_empty() {
+            panic!("index out of bounds");
+        }
         self.nums[self.front as usize]
     }
 
+    /* 返回数组 */
     fn to_vector(&self) -> Vec<i32> {
         let cap = self.que_capacity;
         let mut j = self.front;
@@ -57,16 +80,14 @@ impl ArrayQueue {
         }
         arr
     }
-
-    fn is_empty(&self) -> bool {
-        self.size() == 0
-    }
 }
 
 fn main() {
+    /* 初始化队列 */
     let capacity = 10;
     let mut queue = ArrayQueue::new(capacity);
 
+    /* 元素入队 */
     queue.push(1);
     queue.push(3);
     queue.push(2);
@@ -74,9 +95,11 @@ fn main() {
     queue.push(4);
     println!("队列 queue = {:?}", queue.to_vector());
 
+    /* 访问队首元素 */
     let peek = queue.peek();
     println!("队首元素 peek = {}", peek);
 
+    /* 元素出队 */
     let pop = queue.pop();
     println!(
         "出队元素 pop = {:?},出队后 queue = {:?}",
@@ -84,12 +107,15 @@ fn main() {
         queue.to_vector()
     );
 
+    /* 获取队列的长度 */
     let size = queue.size();
     println!("队列长度 size = {}", size);
 
+    /* 判断队列是否为空 */
     let is_empty = queue.is_empty();
     println!("队列是否为空 = {}", is_empty);
 
+    /* 测试环形数组 */
     for i in 0..10 {
         queue.push(i);
         queue.pop();

codes/rust/chapter_stack_and_queue/deque.rs

@@ -12,26 +12,32 @@ use std::collections::VecDeque;
 pub fn main() {
     // 初始化双向队列
     let mut deque: VecDeque<i32> = VecDeque::new();
-    deque.push_back(2);     // 添加至队尾
+    deque.push_back(3);     
+    deque.push_back(2);
     deque.push_back(5);
-    deque.push_back(4);
-    deque.push_front(3);    // 添加至队首
-    deque.push_front(1);
     print!("双向队列 deque = ");
     print_util::print_queue(&deque);
 
     // 访问元素
-    let peek_first = deque.front().unwrap();    // 队首元素
+    let peek_first = deque.front().unwrap();   
     print!("\n队首元素 peekFirst = {peek_first}");
-    let peek_last = deque.back().unwrap();      // 队尾元素
+    let peek_last = deque.back().unwrap();     
     print!("\n队尾元素 peekLast = {peek_last}");
 
-    // 元素出队
-    let pop_first = deque.pop_front().unwrap();    // 队首元素出队
-    print!("\n队首出队元素 popFirst = {pop_first}，队首出队后 deque = ");
+    /* 元素入队 */
+    deque.push_back(4);
+    print!("\n元素 4 队尾入队后 deque = ");
     print_util::print_queue(&deque);
-    let pop_last = deque.pop_back().unwrap();      // 队尾元素出队     
-    print!("\n队尾出队元素 popLast = {pop_last}，队尾出队后 deque = ");
+    deque.push_front(1);
+    print!("\n元素 1 队首入队后 deque = ");
+    print_util::print_queue(&deque);
+
+    // 元素出队
+    let pop_last = deque.pop_back().unwrap();
+    print!("\n队尾出队元素 = {pop_last}，队尾出队后 deque = ");
+    print_util::print_queue(&deque);
+    let pop_first = deque.pop_front().unwrap();
+    print!("\n队首出队元素 = {pop_first}，队首出队后 deque = ");
     print_util::print_queue(&deque);
 
     // 获取双向队列的长度

codes/rust/chapter_stack_and_queue/linkedlist_deque.rs

@@ -58,34 +58,37 @@ impl<T: Copy> LinkedListDeque<T> {
         let node = ListNode::new(num);
         // 队首入队操作
         if is_front {
-            // 将 node 添加至链表头部
             match self.front.take() {
+                // 若链表为空，则令 front, rear 都指向 node
+                None => {
+                    self.rear = Some(node.clone());
+                    self.front = Some(node);
+                }
+                // 将 node 添加至链表头部
                 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 添加至链表尾部
+        else {
             match self.rear.take() {
+                // 若链表为空，则令 front, rear 都指向 node
+                None => {
+                    self.front = Some(node.clone());
+                    self.rear = Some(node);
+                }
+                // 将 node 添加至链表尾部
                 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;
+        self.que_size += 1; // 更新队列长度
     }
 
     /* 队首入队 */
@@ -100,7 +103,10 @@ impl<T: Copy> LinkedListDeque<T> {
 
     /* 出队操作 */
     pub fn pop(&mut self, is_front: bool) -> Option<T> {
-        if self.is_empty() {return None};
+        // 若队列为空，直接返回 None
+        if self.is_empty() { 
+            return None 
+        };
         // 队首出队操作
         if is_front {
             self.front.take().map(|old_front| {
@@ -113,11 +119,13 @@ impl<T: Copy> LinkedListDeque<T> {
                         self.rear.take();
                     }
                 }
-                self.que_size -= 1;
+                self.que_size -= 1; // 更新队列长度
                 Rc::try_unwrap(old_front).ok().unwrap().into_inner().val
             })
+        
+        } 
         // 队尾出队操作
-        } else {
+        else {
             self.rear.take().map(|old_rear| {
                 match old_rear.borrow_mut().prev.take() {
                     Some(new_rear) => {
@@ -128,7 +136,7 @@ impl<T: Copy> LinkedListDeque<T> {
                         self.front.take();
                     }
                 }
-                self.que_size -= 1;
+                self.que_size -= 1; // 更新队列长度
                 Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val
             })
         }