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_array_and_linkedlist/array.rs

@@ -72,6 +72,7 @@ fn find(nums: &[i32], target: i32) -> Option<usize> {
 
 /* Driver Code */
 fn main() {
+    /* 初始化数组 */
     let arr = [0; 5];
     print!("数组 arr = ");
     print_util::print_array(&arr);

codes/rust/chapter_array_and_linkedlist/list.rs

@@ -52,11 +52,12 @@
     _count += 1;
     }
  
-    //  直接遍历列表元素
+    // 直接遍历列表元素
     _count = 0;
-    for _ in &list {
+    for _n in &list {
     _count += 1;
-    } // 或者
+    } 
+    // 或者
     // list.iter().for_each(|_| _count += 1);
     // let _count = list.iter().fold(0, |_count, _| _count + 1);
  

codes/rust/chapter_array_and_linkedlist/my_list.rs

@@ -8,10 +8,10 @@ include!("../include/include.rs");
 
 #[allow(dead_code)]
 struct MyList {
-    nums: Vec<i32>,
-    capacity: usize,
-    size: usize,
-    extend_ratio: usize,
+    nums: Vec<i32>,       // 数组（存储列表元素）
+    capacity: usize,      // 列表容量
+    size: usize,          // 列表长度（即当前元素数量）
+    extend_ratio: usize,  // 每次列表扩容的倍数
 }
 
 #[allow(unused,unused_comparisons)]
@@ -94,6 +94,7 @@ impl MyList {
 
     /* 列表扩容 */
     pub fn extend_capacity(&mut self) {
+        // 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组拷贝到新数组
         let new_capacity = self.capacity * self.extend_ratio;
         self.nums.resize(new_capacity, 0);
         // 更新列表容量
@@ -102,6 +103,7 @@ impl MyList {
 
     /* 将列表转换为数组 */
     pub fn to_array(&mut self) -> Vec<i32> {
+        // 仅转换有效长度范围内的列表元素
         let mut nums = Vec::new();
         for i in 0..self.size {
             nums.push(self.get(i));

codes/rust/chapter_backtracking/subset_sum_i.rs

@@ -33,7 +33,7 @@ fn subset_sum_i(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
     let state = Vec::new(); // 状态（子集）
     nums.sort(); // 对 nums 进行排序
     let start = 0; // 遍历起始点
-    let mut res = Vec::new();
+    let mut res = Vec::new(); // 结果列表（子集列表）
     backtrack(state, target, nums, start, &mut res);
     res
 }

codes/rust/chapter_backtracking/subset_sum_i_naive.rs

@@ -29,8 +29,8 @@ fn backtrack(mut state: Vec<i32>, target: i32, total: i32, choices: &[i32], res:
 /* 求解子集和 I（包含重复子集） */
 fn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec<Vec<i32>> {
     let state = Vec::new(); // 状态（子集）
-    let total = 0;
-    let mut res = Vec::new();
+    let total = 0; // 子集和
+    let mut res = Vec::new(); // 结果列表（子集列表）
     backtrack(state, target, total, nums, &mut res);
     res
 }

codes/rust/chapter_backtracking/subset_sum_ii.rs

@@ -38,7 +38,7 @@ fn subset_sum_ii(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {
     let state = Vec::new(); // 状态（子集）
     nums.sort(); // 对 nums 进行排序
     let start = 0; // 遍历起始点
-    let mut res = Vec::new();
+    let mut res = Vec::new(); // 结果列表（子集列表）
     backtrack(state, target, nums, start, &mut res);
     res
 }

codes/rust/chapter_divide_and_conquer/hanota.rs

@@ -4,6 +4,8 @@
  * Author: sjinzh (sjinzh@gmail.com)
  */
 
+#![allow(non_snake_case)]
+
 /* 移动一个圆盘 */
 fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
     // 从 src 顶部拿出一个圆盘

codes/rust/chapter_hashing/array_hash_map.rs

@@ -43,6 +43,7 @@ impl ArrayHashMap {
     /* 删除操作 */
     pub fn remove(&mut self, key: i32) {
         let index = self.hash_func(key);
+        // 置为 None ，代表删除
         self.buckets[index] = None;
     }
 

codes/rust/chapter_searching/hashing_search.rs

@@ -34,7 +34,7 @@ pub fn main() {
     // 初始化哈希表
     let mut map = HashMap::new();
     for (i, num) in nums.iter().enumerate() {
-        map.insert(*num, i);
+        map.insert(*num, i); // key: 元素，value: 索引
     }
     let index = hashing_search_array(&map, target);
     println!("目标元素 3 的索引 = {}", index.unwrap());

codes/rust/chapter_searching/linear_search.rs

@@ -14,6 +14,7 @@
 fn linear_search_array(nums: &[i32], target: i32) -> i32 {
     // 遍历数组
     for (i, num) in nums.iter().enumerate() {
+        // 找到目标元素，返回其索引
         if num == &target {
             return i as i32;
         }
@@ -26,6 +27,7 @@ fn linear_search_array(nums: &[i32], target: i32) -> i32 {
 fn linear_search_linked_list(head: Rc<RefCell<ListNode<i32>>>, target: i32) -> Option<Rc<RefCell<ListNode<i32>>>> {
     // 找到目标节点，返回之
     if head.borrow().val == target {return Some(head)};
+    // 找到目标节点，返回之
     if let Some(node) = &head.borrow_mut().next {
         return linear_search_linked_list(node.clone(), target);
     }

codes/rust/chapter_sorting/quick_sort.rs

@@ -30,6 +30,7 @@ impl QuickSort {
         i                        // 返回基准数的索引
     }
 
+    /* 快速排序 */
     pub fn quick_sort(left: i32, right: i32, nums: &mut [i32]) {
         // 子数组长度为 1 时终止递归
         if left >= right {
@@ -78,6 +79,7 @@ impl QuickSortMedian {
          i                        // 返回基准数的索引
     }
 
+    /* 快速排序 */
     pub fn quick_sort(left: i32, right: i32, nums: &mut [i32]) {
         // 子数组长度为 1 时终止递归
         if left >= right {
@@ -111,6 +113,7 @@ impl QuickSortTailCall {
         i                        // 返回基准数的索引
     }
 
+    /* 快速排序（尾递归优化） */
     pub fn quick_sort(mut left: i32, mut right: i32, nums: &mut [i32]) {
         // 子数组长度为 1 时终止
         while left < right {

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
             })
         }

codes/rust/chapter_tree/binary_search_tree.rs

@@ -1,12 +1,14 @@
-/**
+/*
  * File: binary_search_tree.rs
  * Created Time: 2023-04-20
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
+include!("../include/include.rs");
+
 use std::{cell::RefCell, rc::Rc};
 use tree_node::TreeNode;
-include!("../include/include.rs");
+
 type TreeNodeRc = Rc<RefCell<TreeNode>>;
 
 /* 二叉搜索树 */
@@ -15,16 +17,15 @@ pub struct BinarySearchTree {
 }
 
 impl BinarySearchTree {
+    /* 构造方法 */
     pub fn new(mut nums: Vec<i32>) -> Self {
         // 排序数组
         nums.sort();
+        // 构建二叉搜索树
         if nums.is_empty() {
             Self { root: None }
-        } else {
-            // 构建二叉搜索树
-            Self {
-                root: Some(Self::build_tree(&nums)),
-            }
+        } else {  
+            Self { root: Some(Self::build_tree(&nums)) }
         }
     }
 
@@ -72,10 +73,10 @@ impl BinarySearchTree {
     }
 
     /* 插入节点 */
-    pub fn insert(&mut self, num: i32) -> Option<TreeNodeRc> {
+    pub fn insert(&mut self, num: i32) {
         // 若树为空，直接提前返回
         if self.root.is_none() {
-            return None;
+            return;
         }
         let mut cur = self.root.clone();
         let mut pre = None;
@@ -83,7 +84,7 @@ impl BinarySearchTree {
         while let Some(node) = cur.clone() {
             // 找到重复节点，直接返回
             if node.borrow().val == num {
-                return None;
+                return;
             }
             // 插入位置在 cur 的右子树中
             pre = cur.clone();
@@ -103,13 +104,14 @@ impl BinarySearchTree {
         } else {
             pre.borrow_mut().left = Some(Rc::clone(&node));
         }
-        Some(node)
     }
 
     /* 删除节点 */
-    pub fn remove(&self, num: i32) {
+    pub fn remove(&mut self, num: i32) {
         // 若树为空，直接提前返回
-        if self.root.is_none() { return }
+        if self.root.is_none() { 
+            return; 
+        }
         let mut cur = self.root.clone();
         let mut pre = None;
         // 循环查找，越过叶节点后跳出
@@ -129,50 +131,57 @@ impl BinarySearchTree {
             }
         }
         // 若无待删除节点，则直接返回
-        if let Some(cur) = cur.clone() {
-            // 子节点数量 = 0 or 1
-            if cur.borrow().left.is_none() || cur.borrow().right.is_none() {
-                // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
-                let child = cur.borrow().left.clone()
-                .or_else(|| cur.borrow().right.clone()).clone();
-                let pre = pre.unwrap();
-                let left = pre.borrow().left.clone().unwrap();
+        if cur.is_none() {
+            return;
+        }
+        let cur = cur.unwrap();
+        // 子节点数量 = 0 or 1
+        if cur.borrow().left.is_none() || cur.borrow().right.is_none() {
+            // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
+            let child = cur.borrow().left.clone().or_else(|| cur.borrow().right.clone());
+            let pre = pre.unwrap();
+            let left = pre.borrow().left.clone().unwrap();
+            // 删除节点 cur
+            if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {
                 if Rc::ptr_eq(&left, &cur) {
                     pre.borrow_mut().left = child;
                 } else {
                     pre.borrow_mut().right = child;
                 }
+            } else {
+                // 若删除节点为根节点，则重新指定根节点
+                self.root = child;
             }
-            // 子节点数量 = 2
-            else {
-                // 获取中序遍历中 cur 的下一个节点
-                let mut tmp = cur.borrow().right.clone();
-                while let Some(node) = tmp.clone() {
-                    if node.borrow().left.is_some() {
-                        tmp = node.borrow().left.clone();
-                    } else {
-                        break;
-                    }
+        }
+        // 子节点数量 = 2
+        else {
+            // 获取中序遍历中 cur 的下一个节点
+            let mut tmp = cur.borrow().right.clone();
+            while let Some(node) = tmp.clone() {
+                if node.borrow().left.is_some() {
+                    tmp = node.borrow().left.clone();
+                } else {
+                    break;
                 }
-                let tmpval = tmp.unwrap().borrow().val;
-                // 递归删除节点 tmp
-                self.remove(tmpval);
-                // 将 tmp 的值复制给 cur
-                cur.borrow_mut().val = tmpval;
             }
+            let tmpval = tmp.unwrap().borrow().val;
+            // 递归删除节点 tmp
+            self.remove(tmpval);
+            // 用 tmp 覆盖 cur
+            cur.borrow_mut().val = tmpval;
         }
     }
 }
 
 /* Driver Code */
 fn main() {
-    // 初始化二叉搜索树
+    /* 初始化二叉搜索树 */
     let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
     let mut bst = BinarySearchTree::new(nums);
     println!("初始化的二叉树为\n");
     print_util::print_tree(&bst.get_root().unwrap());
 
-    // 查找节点
+    /* 查找节点 */
     let node = bst.search(7).unwrap();
     println!(
         "\n查找到的节点对象为: {:p} 节点值 = {}\n",
@@ -180,12 +189,12 @@ fn main() {
         node.borrow().val
     );
 
-    // 插入节点
-    let node = bst.insert(16).unwrap();
-    println!("插入节点 {} 后，二叉树为\n", node.borrow().val);
+    /* 插入节点 */
+    bst.insert(16);
+    println!("插入节点 16 后，二叉树为\n");
     print_util::print_tree(&bst.get_root().unwrap());
 
-    // 删除节点
+    /* 删除节点 */
     bst.remove(1);
     println!("\n删除节点 1 后，二叉树为\n");
     print_util::print_tree(&bst.get_root().unwrap());

codes/rust/chapter_tree/binary_tree.rs

@@ -10,7 +10,8 @@ use tree_node::TreeNode;
 
 /* Driver Code */
 fn main() {
-    // 初始化二叉树
+    /* 初始化二叉树 */
+    // 初始化节点
     let n1 = TreeNode::new(1);
     let n2 = TreeNode::new(2);
     let n3 = TreeNode::new(3);

codes/rust/chapter_tree/binary_tree_bfs.rs

@@ -1,14 +1,16 @@
-/**
+/*
  * File: binary_tree_bfs.rs
  * Created Time: 2023-04-07
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
+include!("../include/include.rs");
+
 use std::collections::VecDeque;
 use std::{cell::RefCell, rc::Rc};
 use tree_node::{vec_to_tree, TreeNode};
-include!("../include/include.rs");
 
+/* 层序遍历 */
 fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
     // 初始化队列，加入根结点
     let mut que = VecDeque::new();
@@ -16,13 +18,13 @@ fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
     // 初始化一个列表，用于保存遍历序列
     let mut vec = Vec::new();
 
-    while let Some(node) = que.pop_front() {                // 队列出队
-        vec.push(node.borrow().val);                        // 保存结点值
+    while let Some(node) = que.pop_front() {                 // 队列出队
+        vec.push(node.borrow().val);                         // 保存结点值
         if let Some(left) = node.borrow().left.as_ref() {
-            que.push_back(Rc::clone(left));                 // 左子结点入队
+            que.push_back(Rc::clone(left));                  // 左子结点入队
         }
         if let Some(right) = node.borrow().right.as_ref() {
-            que.push_back(Rc::clone(right));                // 右子结点入队
+            que.push_back(Rc::clone(right));                 // 右子结点入队
         };
     }
     vec
@@ -39,4 +41,4 @@ fn main() {
     /* 层序遍历 */
     let vec = level_order(&root);
     print!("\n层序遍历的结点打印序列 = {:?}", vec);
-}
+}

codes/rust/chapter_tree/binary_tree_dfs.rs

@@ -1,13 +1,14 @@
-/**
+/*
  * File: binary_tree_dfs.rs
  * Created Time: 2023-04-06
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
+include!("../include/include.rs");
+
 use std::cell::RefCell;
 use std::rc::Rc;
 use tree_node::{vec_to_tree, TreeNode};
-include!("../include/include.rs");
 
 /* 前序遍历 */
 fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {