diff --git a/codes/rust/chapter_array_and_linkedlist/array.rs b/codes/rust/chapter_array_and_linkedlist/array.rs
index ce0fa806f..090566514 100644
--- a/codes/rust/chapter_array_and_linkedlist/array.rs
+++ b/codes/rust/chapter_array_and_linkedlist/array.rs
@@ -79,7 +79,7 @@ fn main() {
     // 在 Rust 中，指定长度时（[i32; 5]）为数组
     // 由于 Rust 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
     // 为了方便实现扩容 extend() 方法，以下将(Vec) 看作数组（Array）也是rust一般情况下使用动态数组的类型
-    let nums = vec![ 1, 3, 2, 5, 4 ];
+    let nums = vec![1, 3, 2, 5, 4];
     print!("\n数组 nums = ");
     print_util::print_array(&nums);
 
diff --git a/codes/rust/chapter_array_and_linkedlist/linked_list.rs b/codes/rust/chapter_array_and_linkedlist/linked_list.rs
index 48e70ab76..bdb96ec3f 100644
--- a/codes/rust/chapter_array_and_linkedlist/linked_list.rs
+++ b/codes/rust/chapter_array_and_linkedlist/linked_list.rs
@@ -6,14 +6,14 @@
 
 include!("../include/include.rs");
 
-use std::rc::Rc;
-use std::cell::RefCell;
 use list_node::ListNode;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /* 在链表的节点 n0 之后插入节点 P */
 #[allow(non_snake_case)]
 pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
-    let n1 =  n0.borrow_mut().next.take();
+    let n1 = n0.borrow_mut().next.take();
     P.borrow_mut().next = n1;
     n0.borrow_mut().next = Some(P);
 }
@@ -21,7 +21,9 @@ pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
 /* 删除链表的节点 n0 之后的首个节点 */
 #[allow(non_snake_case)]
 pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
-    if n0.borrow().next.is_none() {return};
+    if n0.borrow().next.is_none() {
+        return;
+    };
     // n0 -> P -> n1
     let P = n0.borrow_mut().next.take();
     if let Some(node) = P {
@@ -32,7 +34,9 @@ pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
 
 /* 访问链表中索引为 index 的节点 */
 pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
-    if index <= 0 {return head};
+    if index <= 0 {
+        return head;
+    };
     if let Some(node) = &head.borrow_mut().next {
         return access(node.clone(), index - 1);
     }
@@ -41,7 +45,9 @@ pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListN
 
 /* 在链表中查找值为 target 的首个节点 */
 pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
-    if head.borrow().val == target {return index};
+    if head.borrow().val == target {
+        return index;
+    };
     if let Some(node) = &head.borrow_mut().next {
         return find(node.clone(), target, index + 1);
     }
@@ -51,7 +57,7 @@ pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32)
 /* Driver Code */
 fn main() {
     /* 初始化链表 */
-    // 初始化各个节点 
+    // 初始化各个节点
     let n0 = ListNode::new(1);
     let n1 = ListNode::new(3);
     let n2 = ListNode::new(2);
diff --git a/codes/rust/chapter_array_and_linkedlist/list.rs b/codes/rust/chapter_array_and_linkedlist/list.rs
index 951927105..b723489d5 100644
--- a/codes/rust/chapter_array_and_linkedlist/list.rs
+++ b/codes/rust/chapter_array_and_linkedlist/list.rs
@@ -9,7 +9,7 @@ include!("../include/include.rs");
 /* Driver Code */
 fn main() {
     // 初始化列表
-    let mut nums: Vec<i32> = vec![ 1, 3, 2, 5, 4 ];
+    let mut nums: Vec<i32> = vec![1, 3, 2, 5, 4];
     print!("列表 nums = ");
     print_util::print_array(&nums);
 
@@ -58,9 +58,10 @@ fn main() {
     }
 
     // 拼接两个列表
-    let mut nums1 = vec![ 6, 8, 7, 10, 9 ];
-    nums.append(&mut nums1);  // append（移动） 之后 nums1 为空！
-    // nums.extend(&nums1);   // extend（借用） nums1 能继续使用 
+    let mut nums1 = vec![6, 8, 7, 10, 9];
+    nums.append(&mut nums1); // append（移动） 之后 nums1 为空！
+
+    // nums.extend(&nums1);   // extend（借用） nums1 能继续使用
     print!("\n将列表 nums1 拼接到 nums 之后，得到 nums = ");
     print_util::print_array(&nums);
 
diff --git a/codes/rust/chapter_array_and_linkedlist/my_list.rs b/codes/rust/chapter_array_and_linkedlist/my_list.rs
index 21abd6358..bc9375f34 100644
--- a/codes/rust/chapter_array_and_linkedlist/my_list.rs
+++ b/codes/rust/chapter_array_and_linkedlist/my_list.rs
@@ -10,16 +10,16 @@ include!("../include/include.rs");
 #[allow(dead_code)]
 struct MyList {
     arr: Vec<i32>,       // 数组（存储列表元素）
-    capacity: usize,      // 列表容量
-    size: usize,          // 列表长度（当前元素数量）
-    extend_ratio: usize,  // 每次列表扩容的倍数
+    capacity: usize,     // 列表容量
+    size: usize,         // 列表长度（当前元素数量）
+    extend_ratio: usize, // 每次列表扩容的倍数
 }
 
-#[allow(unused,unused_comparisons)]
+#[allow(unused, unused_comparisons)]
 impl MyList {
     /* 构造方法 */
     pub fn new(capacity: usize) -> Self {
-        let mut vec = Vec::new(); 
+        let mut vec = Vec::new();
         vec.resize(capacity, 0);
         Self {
             arr: vec,
@@ -42,13 +42,17 @@ impl MyList {
     /* 访问元素 */
     pub fn get(&self, index: usize) -> i32 {
         // 索引如果越界，则抛出异常，下同
-        if index >= self.size {panic!("索引越界")};
+        if index >= self.size {
+            panic!("索引越界")
+        };
         return self.arr[index];
     }
 
     /* 更新元素 */
     pub fn set(&mut self, index: usize, num: i32) {
-        if index >= self.size {panic!("索引越界")};
+        if index >= self.size {
+            panic!("索引越界")
+        };
         self.arr[index] = num;
     }
 
@@ -65,7 +69,9 @@ impl MyList {
 
     /* 在中间插入元素 */
     pub fn insert(&mut self, index: usize, num: i32) {
-        if index >= self.size() {panic!("索引越界")};
+        if index >= self.size() {
+            panic!("索引越界")
+        };
         // 元素数量超出容量时，触发扩容机制
         if self.size == self.capacity() {
             self.extend_capacity();
@@ -81,7 +87,9 @@ impl MyList {
 
     /* 删除元素 */
     pub fn remove(&mut self, index: usize) -> i32 {
-        if index >= self.size() {panic!("索引越界")};
+        if index >= self.size() {
+            panic!("索引越界")
+        };
         let num = self.arr[index];
         // 将将索引 index 之后的元素都向前移动一位
         for j in (index..self.size - 1) {
diff --git a/codes/rust/chapter_backtracking/n_queens.rs b/codes/rust/chapter_backtracking/n_queens.rs
index 7e058acc4..6676f2d12 100644
--- a/codes/rust/chapter_backtracking/n_queens.rs
+++ b/codes/rust/chapter_backtracking/n_queens.rs
@@ -5,8 +5,15 @@
  */
 
 /* 回溯算法：n 皇后 */
-fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<Vec<Vec<String>>>,
-    cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool]) {
+fn backtrack(
+    row: usize,
+    n: usize,
+    state: &mut Vec<Vec<String>>,
+    res: &mut Vec<Vec<Vec<String>>>,
+    cols: &mut [bool],
+    diags1: &mut [bool],
+    diags2: &mut [bool],
+) {
     // 当放置完所有行时，记录解
     if row == n {
         let mut copy_state: Vec<Vec<String>> = Vec::new();
@@ -51,7 +58,15 @@ fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
     let mut diags2 = vec![false; 2 * n - 1]; // 记录次对角线上是否有皇后
     let mut res: Vec<Vec<Vec<String>>> = Vec::new();
 
-    backtrack(0, n, &mut state, &mut res, &mut cols, &mut diags1, &mut diags2);
+    backtrack(
+        0,
+        n,
+        &mut state,
+        &mut res,
+        &mut cols,
+        &mut diags1,
+        &mut diags2,
+    );
 
     res
 }
diff --git a/codes/rust/chapter_backtracking/permutations_i.rs b/codes/rust/chapter_backtracking/permutations_i.rs
index 3a1f2d67c..dae411014 100644
--- a/codes/rust/chapter_backtracking/permutations_i.rs
+++ b/codes/rust/chapter_backtracking/permutations_i.rs
@@ -37,7 +37,7 @@ fn permutations_i(nums: &mut [i32]) -> Vec<Vec<i32>> {
 
 /* Driver Code */
 pub fn main() {
-    let mut nums = [ 1, 2, 3 ];
+    let mut nums = [1, 2, 3];
 
     let res = permutations_i(&mut nums);
 
diff --git a/codes/rust/chapter_backtracking/permutations_ii.rs b/codes/rust/chapter_backtracking/permutations_ii.rs
index c44c6fd79..9c422b6e0 100644
--- a/codes/rust/chapter_backtracking/permutations_ii.rs
+++ b/codes/rust/chapter_backtracking/permutations_ii.rs
@@ -41,7 +41,7 @@ fn permutations_ii(nums: &mut [i32]) -> Vec<Vec<i32>> {
 
 /* Driver Code */
 pub fn main() {
-    let mut nums = [ 1, 2, 2 ];
+    let mut nums = [1, 2, 2];
 
     let res = permutations_ii(&mut nums);
 
diff --git a/codes/rust/chapter_backtracking/preorder_traversal_ii_compact.rs b/codes/rust/chapter_backtracking/preorder_traversal_ii_compact.rs
index d3b3803e2..fa0672bd2 100644
--- a/codes/rust/chapter_backtracking/preorder_traversal_ii_compact.rs
+++ b/codes/rust/chapter_backtracking/preorder_traversal_ii_compact.rs
@@ -1,50 +1,54 @@
-/*
- * File: preorder_traversal_ii_compact.rs
- * Created Time: 2023-07-15
- * Author: codingonion (coderonion@gmail.com)
- */
-
-include!("../include/include.rs");
-
-use std::{cell::RefCell, rc::Rc};
-use tree_node::{vec_to_tree, TreeNode};
-
-/* 前序遍历：例题二 */
-fn pre_order(res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>, path: &mut Vec<Rc<RefCell<TreeNode>>>, root: Option<Rc<RefCell<TreeNode>>>) {
-    if root.is_none() {
-        return;
-    }
-    if let Some(node) = root {
-        // 尝试
-        path.push(node.clone());
-        if node.borrow().val == 7 {
-            // 记录解
-            res.push(path.clone());
-        }
-        pre_order(res, path, node.borrow().left.clone());
-        pre_order(res, path, node.borrow().right.clone());
-        // 回退
-        path.remove(path.len() -  1);
-    }
-}
-
-/* Driver Code */
-pub fn main() {
-    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
-    println!("初始化二叉树");
-    print_util::print_tree(root.as_ref().unwrap());
-
-    // 前序遍历
-    let mut path = Vec::new();
-    let mut res = Vec::new();
-    pre_order(&mut res, &mut path, root);
-
-    println!("\n输出所有根节点到节点 7 的路径");
-    for path in res {
-        let mut vals = Vec::new();
-        for node in path {
-            vals.push(node.borrow().val)
-        }
-        println!("{:?}", vals);
-    }
-}
+/*
+ * File: preorder_traversal_ii_compact.rs
+ * Created Time: 2023-07-15
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::{cell::RefCell, rc::Rc};
+use tree_node::{vec_to_tree, TreeNode};
+
+/* 前序遍历：例题二 */
+fn pre_order(
+    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
+    path: &mut Vec<Rc<RefCell<TreeNode>>>,
+    root: Option<Rc<RefCell<TreeNode>>>,
+) {
+    if root.is_none() {
+        return;
+    }
+    if let Some(node) = root {
+        // 尝试
+        path.push(node.clone());
+        if node.borrow().val == 7 {
+            // 记录解
+            res.push(path.clone());
+        }
+        pre_order(res, path, node.borrow().left.clone());
+        pre_order(res, path, node.borrow().right.clone());
+        // 回退
+        path.remove(path.len() - 1);
+    }
+}
+
+/* Driver Code */
+pub fn main() {
+    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
+    println!("初始化二叉树");
+    print_util::print_tree(root.as_ref().unwrap());
+
+    // 前序遍历
+    let mut path = Vec::new();
+    let mut res = Vec::new();
+    pre_order(&mut res, &mut path, root);
+
+    println!("\n输出所有根节点到节点 7 的路径");
+    for path in res {
+        let mut vals = Vec::new();
+        for node in path {
+            vals.push(node.borrow().val)
+        }
+        println!("{:?}", vals);
+    }
+}
diff --git a/codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs b/codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs
index 14e10e6f6..1c834fe64 100644
--- a/codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs
+++ b/codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs
@@ -1,51 +1,55 @@
-/*
- * File: preorder_traversal_iii_compact.rs
- * Created Time: 2023-07-15
- * Author: codingonion (coderonion@gmail.com)
- */
-
-include!("../include/include.rs");
-
-use std::{cell::RefCell, rc::Rc};
-use tree_node::{vec_to_tree, TreeNode};
-
-/* 前序遍历：例题三 */
-fn pre_order(res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>, path: &mut Vec<Rc<RefCell<TreeNode>>>, root: Option<Rc<RefCell<TreeNode>>>) {
-    // 剪枝
-    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {
-        return;
-    }
-    if let Some(node) = root {
-        // 尝试
-        path.push(node.clone());
-        if node.borrow().val == 7 {
-            // 记录解
-            res.push(path.clone());
-        }
-        pre_order(res, path, node.borrow().left.clone());
-        pre_order(res, path, node.borrow().right.clone());
-        // 回退
-        path.remove(path.len() -  1);
-    }
-}
-
-/* Driver Code */
-pub fn main() {
-    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
-    println!("初始化二叉树");
-    print_util::print_tree(root.as_ref().unwrap());
-
-    // 前序遍历
-    let mut path = Vec::new();
-    let mut res = Vec::new();
-    pre_order(&mut res, &mut path, root);
-
-    println!("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点");
-    for path in res {
-        let mut vals = Vec::new();
-        for node in path {
-            vals.push(node.borrow().val)
-        }
-        println!("{:?}", vals);
-    }
-}
+/*
+ * File: preorder_traversal_iii_compact.rs
+ * Created Time: 2023-07-15
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::{cell::RefCell, rc::Rc};
+use tree_node::{vec_to_tree, TreeNode};
+
+/* 前序遍历：例题三 */
+fn pre_order(
+    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
+    path: &mut Vec<Rc<RefCell<TreeNode>>>,
+    root: Option<Rc<RefCell<TreeNode>>>,
+) {
+    // 剪枝
+    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {
+        return;
+    }
+    if let Some(node) = root {
+        // 尝试
+        path.push(node.clone());
+        if node.borrow().val == 7 {
+            // 记录解
+            res.push(path.clone());
+        }
+        pre_order(res, path, node.borrow().left.clone());
+        pre_order(res, path, node.borrow().right.clone());
+        // 回退
+        path.remove(path.len() - 1);
+    }
+}
+
+/* Driver Code */
+pub fn main() {
+    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
+    println!("初始化二叉树");
+    print_util::print_tree(root.as_ref().unwrap());
+
+    // 前序遍历
+    let mut path = Vec::new();
+    let mut res = Vec::new();
+    pre_order(&mut res, &mut path, root);
+
+    println!("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点");
+    for path in res {
+        let mut vals = Vec::new();
+        for node in path {
+            vals.push(node.borrow().val)
+        }
+        println!("{:?}", vals);
+    }
+}
diff --git a/codes/rust/chapter_backtracking/preorder_traversal_iii_template.rs b/codes/rust/chapter_backtracking/preorder_traversal_iii_template.rs
index ee4471ea5..f100f23cc 100644
--- a/codes/rust/chapter_backtracking/preorder_traversal_iii_template.rs
+++ b/codes/rust/chapter_backtracking/preorder_traversal_iii_template.rs
@@ -1,76 +1,90 @@
-/*
- * File: preorder_traversal_iii_template.rs
- * Created Time: 2023-07-15
- * Author: codingonion (coderonion@gmail.com)
- */
-
-include!("../include/include.rs");
-
-use std::{cell::RefCell, rc::Rc};
-use tree_node::{vec_to_tree, TreeNode};
-
-/* 判断当前状态是否为解 */
-fn is_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>) -> bool {
-    return !state.is_empty() && state.get(state.len() - 1).unwrap().borrow().val == 7;
-}
-
-/* 记录解 */
-fn record_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>, res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>) {
-    res.push(state.clone());
-}
-
-/* 判断在当前状态下，该选择是否合法 */
-fn is_valid(_: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) -> bool {
-    return choice.borrow().val != 3;
-}
-
-/* 更新状态 */
-fn make_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) {
-    state.push(choice);
-}
-
-/* 恢复状态 */
-fn undo_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, _: Rc<RefCell<TreeNode>>) {
-    state.remove(state.len() - 1);
-}
-
-/* 回溯算法：例题三 */
-fn backtrack(state: &mut Vec<Rc<RefCell<TreeNode>>>, choices: &mut Vec<Rc<RefCell<TreeNode>>>, res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>) {
-    // 检查是否为解
-    if is_solution(state) {
-        // 记录解
-        record_solution(state, res);
-    }
-    // 遍历所有选择
-    for choice in choices {
-        // 剪枝：检查选择是否合法
-        if is_valid(state, choice.clone()) {
-            // 尝试：做出选择，更新状态
-            make_choice(state, choice.clone());
-            // 进行下一轮选择
-            backtrack(state, &mut vec![choice.borrow().left.clone().unwrap(), choice.borrow().right.clone().unwrap()], res);
-            // 回退：撤销选择，恢复到之前的状态
-            undo_choice(state, choice.clone());
-        }
-    }
-}
-
-/* Driver Code */
-pub fn main() {
-    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
-    println!("初始化二叉树");
-    print_util::print_tree(root.as_ref().unwrap());
-
-    // 回溯算法
-    let mut res = Vec::new();
-    backtrack(&mut Vec::new(), &mut vec![root.unwrap()], &mut res);
-
-    println!("\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点");
-    for path in res {
-        let mut vals = Vec::new();
-        for node in path {
-            vals.push(node.borrow().val)
-        }
-        println!("{:?}", vals);
-    }
-}
+/*
+ * File: preorder_traversal_iii_template.rs
+ * Created Time: 2023-07-15
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+include!("../include/include.rs");
+
+use std::{cell::RefCell, rc::Rc};
+use tree_node::{vec_to_tree, TreeNode};
+
+/* 判断当前状态是否为解 */
+fn is_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>) -> bool {
+    return !state.is_empty() && state.get(state.len() - 1).unwrap().borrow().val == 7;
+}
+
+/* 记录解 */
+fn record_solution(
+    state: &mut Vec<Rc<RefCell<TreeNode>>>,
+    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
+) {
+    res.push(state.clone());
+}
+
+/* 判断在当前状态下，该选择是否合法 */
+fn is_valid(_: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) -> bool {
+    return choice.borrow().val != 3;
+}
+
+/* 更新状态 */
+fn make_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) {
+    state.push(choice);
+}
+
+/* 恢复状态 */
+fn undo_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, _: Rc<RefCell<TreeNode>>) {
+    state.remove(state.len() - 1);
+}
+
+/* 回溯算法：例题三 */
+fn backtrack(
+    state: &mut Vec<Rc<RefCell<TreeNode>>>,
+    choices: &mut Vec<Rc<RefCell<TreeNode>>>,
+    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
+) {
+    // 检查是否为解
+    if is_solution(state) {
+        // 记录解
+        record_solution(state, res);
+    }
+    // 遍历所有选择
+    for choice in choices {
+        // 剪枝：检查选择是否合法
+        if is_valid(state, choice.clone()) {
+            // 尝试：做出选择，更新状态
+            make_choice(state, choice.clone());
+            // 进行下一轮选择
+            backtrack(
+                state,
+                &mut vec![
+                    choice.borrow().left.clone().unwrap(),
+                    choice.borrow().right.clone().unwrap(),
+                ],
+                res,
+            );
+            // 回退：撤销选择，恢复到之前的状态
+            undo_choice(state, choice.clone());
+        }
+    }
+}
+
+/* Driver Code */
+pub fn main() {
+    let root = vec_to_tree([1, 7, 3, 4, 5, 6, 7].map(|x| Some(x)).to_vec());
+    println!("初始化二叉树");
+    print_util::print_tree(root.as_ref().unwrap());
+
+    // 回溯算法
+    let mut res = Vec::new();
+    backtrack(&mut Vec::new(), &mut vec![root.unwrap()], &mut res);
+
+    println!("\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点");
+    for path in res {
+        let mut vals = Vec::new();
+        for node in path {
+            vals.push(node.borrow().val)
+        }
+        println!("{:?}", vals);
+    }
+}
diff --git a/codes/rust/chapter_backtracking/subset_sum_i.rs b/codes/rust/chapter_backtracking/subset_sum_i.rs
index 83c32d11a..e2a5d0198 100644
--- a/codes/rust/chapter_backtracking/subset_sum_i.rs
+++ b/codes/rust/chapter_backtracking/subset_sum_i.rs
@@ -1,50 +1,56 @@
-/*
- * File: subset_sum_i.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 回溯算法：子集和 I */
-fn backtrack(mut state: Vec<i32>, target: i32, choices: &[i32], start: usize, res: &mut Vec<Vec<i32>>) {
-    // 子集和等于 target 时，记录解
-    if target == 0 {
-        res.push(state);
-        return;
-    }
-    // 遍历所有选择
-    // 剪枝二：从 start 开始遍历，避免生成重复子集
-    for i in start..choices.len() {
-        // 剪枝一：若子集和超过 target ，则直接结束循环
-        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
-        if target - choices[i] < 0 {
-            break;
-        }
-        // 尝试：做出选择，更新 target, start
-        state.push(choices[i]);
-        // 进行下一轮选择
-        backtrack(state.clone(), target - choices[i], choices, i, res);
-        // 回退：撤销选择，恢复到之前的状态
-        state.pop();
-    }
-}
-
-/* 求解子集和 I */
-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(); // 结果列表（子集列表）
-    backtrack(state, target, nums, start, &mut res);
-    res
-}
-
-/* Driver Code */
-pub fn main() {
-    let mut nums = [ 3, 4, 5 ];
-    let target = 9;
-
-    let res = subset_sum_i(&mut nums, target);
-    
-    println!("输入数组 nums = {:?}, target = {}", &nums, target);
-    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
-}
\ No newline at end of file
+/*
+ * File: subset_sum_i.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 回溯算法：子集和 I */
+fn backtrack(
+    mut state: Vec<i32>,
+    target: i32,
+    choices: &[i32],
+    start: usize,
+    res: &mut Vec<Vec<i32>>,
+) {
+    // 子集和等于 target 时，记录解
+    if target == 0 {
+        res.push(state);
+        return;
+    }
+    // 遍历所有选择
+    // 剪枝二：从 start 开始遍历，避免生成重复子集
+    for i in start..choices.len() {
+        // 剪枝一：若子集和超过 target ，则直接结束循环
+        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
+        if target - choices[i] < 0 {
+            break;
+        }
+        // 尝试：做出选择，更新 target, start
+        state.push(choices[i]);
+        // 进行下一轮选择
+        backtrack(state.clone(), target - choices[i], choices, i, res);
+        // 回退：撤销选择，恢复到之前的状态
+        state.pop();
+    }
+}
+
+/* 求解子集和 I */
+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(); // 结果列表（子集列表）
+    backtrack(state, target, nums, start, &mut res);
+    res
+}
+
+/* Driver Code */
+pub fn main() {
+    let mut nums = [3, 4, 5];
+    let target = 9;
+
+    let res = subset_sum_i(&mut nums, target);
+
+    println!("输入数组 nums = {:?}, target = {}", &nums, target);
+    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
+}
diff --git a/codes/rust/chapter_backtracking/subset_sum_i_naive.rs b/codes/rust/chapter_backtracking/subset_sum_i_naive.rs
index b5379c082..b2dae54ea 100644
--- a/codes/rust/chapter_backtracking/subset_sum_i_naive.rs
+++ b/codes/rust/chapter_backtracking/subset_sum_i_naive.rs
@@ -1,48 +1,54 @@
-/*
- * File: subset_sum_i_naive.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 回溯算法：子集和 I */
-fn backtrack(mut state: Vec<i32>, target: i32, total: i32, choices: &[i32], res: &mut Vec<Vec<i32>>) {
-    // 子集和等于 target 时，记录解
-    if total == target {
-        res.push(state);
-        return;
-    }
-    // 遍历所有选择
-    for i in 0..choices.len() {
-        // 剪枝：若子集和超过 target ，则跳过该选择
-        if total + choices[i] > target {
-            continue;
-        }
-        // 尝试：做出选择，更新元素和 total
-        state.push(choices[i]);
-        // 进行下一轮选择
-        backtrack(state.clone(), target, total + choices[i], choices, res);
-        // 回退：撤销选择，恢复到之前的状态
-        state.pop();
-    }
-}
-
-/* 求解子集和 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(); // 结果列表（子集列表）
-    backtrack(state, target, total, nums, &mut res);
-    res
-}
-
-/* Driver Code */
-pub fn main() {
-    let nums = [ 3, 4, 5 ];
-    let target = 9;
-
-    let res = subset_sum_i_naive(&nums, target);
-    
-    println!("输入数组 nums = {:?}, target = {}", &nums, target);
-    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
-    println!("请注意，该方法输出的结果包含重复集合");
-}
\ No newline at end of file
+/*
+ * File: subset_sum_i_naive.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 回溯算法：子集和 I */
+fn backtrack(
+    mut state: Vec<i32>,
+    target: i32,
+    total: i32,
+    choices: &[i32],
+    res: &mut Vec<Vec<i32>>,
+) {
+    // 子集和等于 target 时，记录解
+    if total == target {
+        res.push(state);
+        return;
+    }
+    // 遍历所有选择
+    for i in 0..choices.len() {
+        // 剪枝：若子集和超过 target ，则跳过该选择
+        if total + choices[i] > target {
+            continue;
+        }
+        // 尝试：做出选择，更新元素和 total
+        state.push(choices[i]);
+        // 进行下一轮选择
+        backtrack(state.clone(), target, total + choices[i], choices, res);
+        // 回退：撤销选择，恢复到之前的状态
+        state.pop();
+    }
+}
+
+/* 求解子集和 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(); // 结果列表（子集列表）
+    backtrack(state, target, total, nums, &mut res);
+    res
+}
+
+/* Driver Code */
+pub fn main() {
+    let nums = [3, 4, 5];
+    let target = 9;
+
+    let res = subset_sum_i_naive(&nums, target);
+
+    println!("输入数组 nums = {:?}, target = {}", &nums, target);
+    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
+    println!("请注意，该方法输出的结果包含重复集合");
+}
diff --git a/codes/rust/chapter_backtracking/subset_sum_ii.rs b/codes/rust/chapter_backtracking/subset_sum_ii.rs
index 2aded76c4..cd7677db5 100644
--- a/codes/rust/chapter_backtracking/subset_sum_ii.rs
+++ b/codes/rust/chapter_backtracking/subset_sum_ii.rs
@@ -1,55 +1,61 @@
-/*
- * File: subset_sum_ii.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 回溯算法：子集和 II */
-fn backtrack(mut state: Vec<i32>, target: i32, choices: &[i32], start: usize, res: &mut Vec<Vec<i32>>) {
-    // 子集和等于 target 时，记录解
-    if target == 0 {
-        res.push(state);
-        return;
-    }
-    // 遍历所有选择
-    // 剪枝二：从 start 开始遍历，避免生成重复子集
-    // 剪枝三：从 start 开始遍历，避免重复选择同一元素
-    for i in start..choices.len() {
-        // 剪枝一：若子集和超过 target ，则直接结束循环
-        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
-        if target - choices[i] < 0 {
-            break;
-        }
-        // 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
-        if i > start && choices[i] == choices[i - 1] {
-            continue;
-        }
-        // 尝试：做出选择，更新 target, start
-        state.push(choices[i]);
-        // 进行下一轮选择
-        backtrack(state.clone(), target - choices[i], choices, i, res);
-        // 回退：撤销选择，恢复到之前的状态
-        state.pop();
-    }
-}
-
-/* 求解子集和 II */
-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(); // 结果列表（子集列表）
-    backtrack(state, target, nums, start, &mut res);
-    res
-}
-
-/* Driver Code */
-pub fn main() {
-    let mut nums = [ 4, 4, 5 ];
-    let target = 9;
-
-    let res = subset_sum_ii(&mut nums, target);
-    
-    println!("输入数组 nums = {:?}, target = {}", &nums, target);
-    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
-}
+/*
+ * File: subset_sum_ii.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 回溯算法：子集和 II */
+fn backtrack(
+    mut state: Vec<i32>,
+    target: i32,
+    choices: &[i32],
+    start: usize,
+    res: &mut Vec<Vec<i32>>,
+) {
+    // 子集和等于 target 时，记录解
+    if target == 0 {
+        res.push(state);
+        return;
+    }
+    // 遍历所有选择
+    // 剪枝二：从 start 开始遍历，避免生成重复子集
+    // 剪枝三：从 start 开始遍历，避免重复选择同一元素
+    for i in start..choices.len() {
+        // 剪枝一：若子集和超过 target ，则直接结束循环
+        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
+        if target - choices[i] < 0 {
+            break;
+        }
+        // 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
+        if i > start && choices[i] == choices[i - 1] {
+            continue;
+        }
+        // 尝试：做出选择，更新 target, start
+        state.push(choices[i]);
+        // 进行下一轮选择
+        backtrack(state.clone(), target - choices[i], choices, i, res);
+        // 回退：撤销选择，恢复到之前的状态
+        state.pop();
+    }
+}
+
+/* 求解子集和 II */
+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(); // 结果列表（子集列表）
+    backtrack(state, target, nums, start, &mut res);
+    res
+}
+
+/* Driver Code */
+pub fn main() {
+    let mut nums = [4, 4, 5];
+    let target = 9;
+
+    let res = subset_sum_ii(&mut nums, target);
+
+    println!("输入数组 nums = {:?}, target = {}", &nums, target);
+    println!("所有和等于 {} 的子集 res = {:?}", target, &res);
+}
diff --git a/codes/rust/chapter_computational_complexity/iteration.rs b/codes/rust/chapter_computational_complexity/iteration.rs
index 8f2a175b1..311741941 100644
--- a/codes/rust/chapter_computational_complexity/iteration.rs
+++ b/codes/rust/chapter_computational_complexity/iteration.rs
@@ -4,7 +4,6 @@
  * Author: night-cruise (2586447362@qq.com)
  */
 
- 
 /* for 循环 */
 fn for_loop(n: i32) -> i32 {
     let mut res = 0;
@@ -13,12 +12,13 @@ fn for_loop(n: i32) -> i32 {
         res += i;
     }
     res
-} 
+}
 
 /* while 循环 */
 fn while_loop(n: i32) -> i32 {
     let mut res = 0;
     let mut i = 1; // 初始化条件变量
+
     // 循环求和 1, 2, ..., n-1, n
     while i <= n {
         res += i;
@@ -31,6 +31,7 @@ fn while_loop(n: i32) -> i32 {
 fn while_loop_ii(n: i32) -> i32 {
     let mut res = 0;
     let mut i = 1; // 初始化条件变量
+
     // 循环求和 1, 4, 10, ...
     while i <= n {
         res += i;
@@ -53,7 +54,7 @@ fn nested_for_loop(n: i32) -> String {
     }
     res.join("")
 }
- 
+
 /* Driver Code */
 fn main() {
     let n = 5;
@@ -70,4 +71,4 @@ fn main() {
 
     let res = nested_for_loop(n);
     println!("\n双层 for 循环的遍历结果 {res}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_computational_complexity/recursion.rs b/codes/rust/chapter_computational_complexity/recursion.rs
index 9f4826bcd..6035c0362 100644
--- a/codes/rust/chapter_computational_complexity/recursion.rs
+++ b/codes/rust/chapter_computational_complexity/recursion.rs
@@ -4,7 +4,6 @@
  * Author: night-cruise (2586447362@qq.com)
  */
 
-
 /* 递归 */
 fn recur(n: i32) -> i32 {
     // 终止条件
@@ -71,7 +70,7 @@ fn main() {
 
     res = tail_recur(n, 0);
     println!("\n尾递归函数的求和结果 res = {res}");
-    
+
     res = fib(n);
     println!("\n斐波那契数列的第 {n} 项为 {res}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_computational_complexity/space_complexity.rs b/codes/rust/chapter_computational_complexity/space_complexity.rs
index 15f4b82c7..cd41b2b13 100644
--- a/codes/rust/chapter_computational_complexity/space_complexity.rs
+++ b/codes/rust/chapter_computational_complexity/space_complexity.rs
@@ -6,14 +6,14 @@
 
 include!("../include/include.rs");
 
+use list_node::ListNode;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
-use std::cell::RefCell;
-use list_node::ListNode;
 use tree_node::TreeNode;
 
 /* 函数 */
-fn function() ->i32 {
+fn function() -> i32 {
     // 执行某些操作
     return 0;
 }
@@ -56,7 +56,9 @@ fn linear(n: i32) {
 /* 线性阶（递归实现） */
 fn linear_recur(n: i32) {
     println!("递归 n = {}", n);
-    if n == 1 {return};
+    if n == 1 {
+        return;
+    };
     linear_recur(n - 1);
 }
 
@@ -78,7 +80,9 @@ fn quadratic(n: i32) {
 
 /* 平方阶（递归实现） */
 fn quadratic_recur(n: i32) -> i32 {
-    if n <= 0 {return 0};
+    if n <= 0 {
+        return 0;
+    };
     // 数组 nums 长度为 n, n-1, ..., 2, 1
     let nums = vec![0; n as usize];
     println!("递归 n = {} 中的 nums 长度 = {}", n, nums.len());
@@ -87,7 +91,9 @@ fn quadratic_recur(n: i32) -> i32 {
 
 /* 指数阶（建立满二叉树） */
 fn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {
-    if n == 0 {return None};
+    if n == 0 {
+        return None;
+    };
     let root = TreeNode::new(0);
     root.borrow_mut().left = build_tree(n - 1);
     root.borrow_mut().right = build_tree(n - 1);
@@ -107,5 +113,5 @@ fn main() {
     quadratic_recur(n);
     // 指数阶
     let root = build_tree(n);
-    print_util::print_tree(&root.unwrap());   
-}
\ No newline at end of file
+    print_util::print_tree(&root.unwrap());
+}
diff --git a/codes/rust/chapter_computational_complexity/time_complexity.rs b/codes/rust/chapter_computational_complexity/time_complexity.rs
index 78e814b54..3464b98d1 100644
--- a/codes/rust/chapter_computational_complexity/time_complexity.rs
+++ b/codes/rust/chapter_computational_complexity/time_complexity.rs
@@ -49,9 +49,10 @@ fn quadratic(n: i32) -> i32 {
 /* 平方阶（冒泡排序） */
 fn bubble_sort(nums: &mut [i32]) -> i32 {
     let mut count = 0; // 计数器
+
     // 外循环：未排序区间为 [0, i]
     for i in (1..nums.len()).rev() {
-        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
         for j in 0..i {
             if nums[j] > nums[j + 1] {
                 // 交换 nums[j] 与 nums[j + 1]
@@ -112,10 +113,10 @@ fn linear_log_recur(n: f32) -> i32 {
         return 1;
     }
     let mut count = linear_log_recur(n / 2.0) + linear_log_recur(n / 2.0);
-    for _ in 0 ..n as i32 {
+    for _ in 0..n as i32 {
         count += 1;
     }
-    return count
+    return count;
 }
 
 /* 阶乘阶（递归实现） */
diff --git a/codes/rust/chapter_computational_complexity/worst_best_time_complexity.rs b/codes/rust/chapter_computational_complexity/worst_best_time_complexity.rs
index 2ce56eb71..20d8ed33c 100644
--- a/codes/rust/chapter_computational_complexity/worst_best_time_complexity.rs
+++ b/codes/rust/chapter_computational_complexity/worst_best_time_complexity.rs
@@ -40,4 +40,4 @@ fn main() {
         print_util::print_array(&nums);
         println!("\n数字 1 的索引为 {}", index);
     }
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_divide_and_conquer/binary_search_recur.rs b/codes/rust/chapter_divide_and_conquer/binary_search_recur.rs
index b3ac46779..4130a147d 100644
--- a/codes/rust/chapter_divide_and_conquer/binary_search_recur.rs
+++ b/codes/rust/chapter_divide_and_conquer/binary_search_recur.rs
@@ -7,7 +7,9 @@
 /* 二分查找：问题 f(i, j) */
 fn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {
     // 若区间为空，代表无目标元素，则返回 -1
-    if i > j { return -1; }
+    if i > j {
+        return -1;
+    }
     let m: i32 = (i + j) / 2;
     if nums[m as usize] < target {
         // 递归子问题 f(m+1, j)
@@ -31,7 +33,7 @@ fn binary_search(nums: &[i32], target: i32) -> i32 {
 /* Driver Code */
 pub fn main() {
     let target = 6;
-    let nums = [ 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 ];
+    let nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
 
     // 二分查找（双闭区间）
     let index = binary_search(&nums, target);
diff --git a/codes/rust/chapter_divide_and_conquer/build_tree.rs b/codes/rust/chapter_divide_and_conquer/build_tree.rs
index 6da6e5511..2c1df9c60 100644
--- a/codes/rust/chapter_divide_and_conquer/build_tree.rs
+++ b/codes/rust/chapter_divide_and_conquer/build_tree.rs
@@ -1,49 +1,57 @@
-/*
- * File: build_tree.rs
- * Created Time: 2023-07-15
- * Author: codingonion (coderonion@gmail.com)
- */
-
-use std::{cell::RefCell, rc::Rc};
-use std::collections::HashMap;
-include!("../include/include.rs");
-use tree_node::TreeNode;
-
-/* 构建二叉树：分治 */
-fn dfs(preorder: &[i32], inorder_map: &HashMap<i32, i32>, i: i32, l: i32, r: i32) -> Option<Rc<RefCell<TreeNode>>> {
-    // 子树区间为空时终止
-    if r - l < 0 { return None; }
-    // 初始化根节点
-    let root = TreeNode::new(preorder[i as usize]);
-    // 查询 m ，从而划分左右子树
-    let m = inorder_map.get(&preorder[i as usize]).unwrap();
-    // 子问题：构建左子树
-    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
-    // 子问题：构建右子树
-    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
-    // 返回根节点
-    Some(root)
-}
-
-/* 构建二叉树 */
-fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
-    // 初始化哈希表，存储 inorder 元素到索引的映射
-    let mut inorder_map: HashMap<i32, i32> = HashMap::new();
-    for i in 0..inorder.len() {
-        inorder_map.insert(inorder[i], i as i32);
-    }
-    let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
-    root
-}
-
-/* Driver Code */
-fn main() {
-    let preorder = [ 3, 9, 2, 1, 7 ];
-    let inorder = [ 9, 3, 1, 2, 7 ];
-    println!("中序遍历 = {:?}", preorder);
-    println!("前序遍历 = {:?}", inorder);
-
-    let root = build_tree(&preorder, &inorder);
-    println!("构建的二叉树为：");
-    print_util::print_tree(root.as_ref().unwrap());
-}
+/*
+ * File: build_tree.rs
+ * Created Time: 2023-07-15
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use std::collections::HashMap;
+use std::{cell::RefCell, rc::Rc};
+include!("../include/include.rs");
+use tree_node::TreeNode;
+
+/* 构建二叉树：分治 */
+fn dfs(
+    preorder: &[i32],
+    inorder_map: &HashMap<i32, i32>,
+    i: i32,
+    l: i32,
+    r: i32,
+) -> Option<Rc<RefCell<TreeNode>>> {
+    // 子树区间为空时终止
+    if r - l < 0 {
+        return None;
+    }
+    // 初始化根节点
+    let root = TreeNode::new(preorder[i as usize]);
+    // 查询 m ，从而划分左右子树
+    let m = inorder_map.get(&preorder[i as usize]).unwrap();
+    // 子问题：构建左子树
+    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
+    // 子问题：构建右子树
+    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
+    // 返回根节点
+    Some(root)
+}
+
+/* 构建二叉树 */
+fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+    // 初始化哈希表，存储 inorder 元素到索引的映射
+    let mut inorder_map: HashMap<i32, i32> = HashMap::new();
+    for i in 0..inorder.len() {
+        inorder_map.insert(inorder[i], i as i32);
+    }
+    let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
+    root
+}
+
+/* Driver Code */
+fn main() {
+    let preorder = [3, 9, 2, 1, 7];
+    let inorder = [9, 3, 1, 2, 7];
+    println!("中序遍历 = {:?}", preorder);
+    println!("前序遍历 = {:?}", inorder);
+
+    let root = build_tree(&preorder, &inorder);
+    println!("构建的二叉树为：");
+    print_util::print_tree(root.as_ref().unwrap());
+}
diff --git a/codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs b/codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs
index 07bbf04cc..03211b5db 100644
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs
+++ b/codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs
@@ -1,37 +1,41 @@
-/*
- * File: climbing_stairs_backtrack.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 回溯 */
-fn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {
-    // 当爬到第 n 阶时，方案数量加 1
-    if state == n { res[0] = res[0] + 1; }
-    // 遍历所有选择
-    for &choice in choices {
-        // 剪枝：不允许越过第 n 阶
-        if state + choice > n { continue; }
-        // 尝试：做出选择，更新状态
-        backtrack(choices, state + choice, n, res);
-        // 回退
-    }
-}
-
-/* 爬楼梯：回溯 */
-fn climbing_stairs_backtrack(n: usize) -> i32 {
-    let choices = vec![ 1, 2 ]; // 可选择向上爬 1 阶或 2 阶
-    let state = 0; // 从第 0 阶开始爬
-    let mut res = Vec::new();
-    res.push(0); // 使用 res[0] 记录方案数量
-    backtrack(&choices, state, n as i32, &mut res);
-    res[0]
-}
-
-/* Driver Code */
-pub fn main() {
-    let n: usize = 9;
-
-    let res = climbing_stairs_backtrack(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-}
+/*
+ * File: climbing_stairs_backtrack.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 回溯 */
+fn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {
+    // 当爬到第 n 阶时，方案数量加 1
+    if state == n {
+        res[0] = res[0] + 1;
+    }
+    // 遍历所有选择
+    for &choice in choices {
+        // 剪枝：不允许越过第 n 阶
+        if state + choice > n {
+            continue;
+        }
+        // 尝试：做出选择，更新状态
+        backtrack(choices, state + choice, n, res);
+        // 回退
+    }
+}
+
+/* 爬楼梯：回溯 */
+fn climbing_stairs_backtrack(n: usize) -> i32 {
+    let choices = vec![1, 2]; // 可选择向上爬 1 阶或 2 阶
+    let state = 0; // 从第 0 阶开始爬
+    let mut res = Vec::new();
+    res.push(0); // 使用 res[0] 记录方案数量
+    backtrack(&choices, state, n as i32, &mut res);
+    res[0]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_backtrack(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}
diff --git a/codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs b/codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs
index bb7bcdda0..24078307b 100644
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs
+++ b/codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs
@@ -1,31 +1,33 @@
-/*
- * File: climbing_stairs_constraint_dp.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 带约束爬楼梯：动态规划 */
-fn climbing_stairs_constraint_dp(n: usize) -> i32 {
-    if n == 1 || n == 2 { return 1 };
-    // 初始化 dp 表，用于存储子问题的解
-    let mut dp = vec![vec![-1; 3]; n + 1];
-    // 初始状态：预设最小子问题的解
-    dp[1][1] = 1;
-    dp[1][2] = 0;
-    dp[2][1] = 0;
-    dp[2][2] = 1;
-    // 状态转移：从较小子问题逐步求解较大子问题
-    for i in 3..=n {
-        dp[i][1] = dp[i - 1][2];
-        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
-    }
-    dp[n][1] + dp[n][2]
-}
-
-/* Driver Code */
-pub fn main() {
-    let n: usize = 9;
-
-    let res = climbing_stairs_constraint_dp(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-}
+/*
+ * File: climbing_stairs_constraint_dp.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 带约束爬楼梯：动态规划 */
+fn climbing_stairs_constraint_dp(n: usize) -> i32 {
+    if n == 1 || n == 2 {
+        return 1;
+    };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![vec![-1; 3]; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1][1] = 1;
+    dp[1][2] = 0;
+    dp[2][1] = 0;
+    dp[2][2] = 1;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i][1] = dp[i - 1][2];
+        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+    }
+    dp[n][1] + dp[n][2]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_constraint_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}
diff --git a/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs b/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs
index c253bb700..8695f5925 100644
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs
+++ b/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs
@@ -1,27 +1,29 @@
-/*
- * File: climbing_stairs_dfs.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 搜索 */
-fn dfs(i: usize) -> i32 {
-    // 已知 dp[1] 和 dp[2] ，返回之
-    if i == 1 || i == 2 { return i as i32; }
-    // dp[i] = dp[i-1] + dp[i-2]
-    let count = dfs(i - 1) + dfs(i - 2);
-    count
-}
-
-/* 爬楼梯：搜索 */
-fn climbing_stairs_dfs(n: usize) -> i32 {
-    dfs(n) 
-}
-
-/* Driver Code */
-pub fn main() {
-    let n: usize = 9;
-
-    let res = climbing_stairs_dfs(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-}
+/*
+ * File: climbing_stairs_dfs.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 搜索 */
+fn dfs(i: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 {
+        return i as i32;
+    }
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1) + dfs(i - 2);
+    count
+}
+
+/* 爬楼梯：搜索 */
+fn climbing_stairs_dfs(n: usize) -> i32 {
+    dfs(n)
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}
diff --git a/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs b/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs
index 15fdc3eed..43d95896b 100644
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs
+++ b/codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs
@@ -1,33 +1,37 @@
-/*
- * File: climbing_stairs_dfs_mem.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 记忆化搜索 */
-fn dfs(i: usize, mem: &mut [i32]) -> i32 {
-    // 已知 dp[1] 和 dp[2] ，返回之
-    if i == 1 || i == 2 { return i as i32; }
-    // 若存在记录 dp[i] ，则直接返回之
-    if mem[i] != -1 { return mem[i]; }
-    // dp[i] = dp[i-1] + dp[i-2]
-    let count = dfs(i - 1, mem) + dfs(i - 2, mem);
-    // 记录 dp[i]
-    mem[i] = count;
-    count
-}
-
-/* 爬楼梯：记忆化搜索 */
-fn climbing_stairs_dfs_mem(n: usize) -> i32 {
-    // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
-    let mut mem = vec![-1; n + 1];
-    dfs(n, &mut mem)
-}
-
-/* Driver Code */
-pub fn main() {
-    let n: usize = 9;
-
-    let res = climbing_stairs_dfs_mem(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-}
+/*
+ * File: climbing_stairs_dfs_mem.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 记忆化搜索 */
+fn dfs(i: usize, mem: &mut [i32]) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 {
+        return i as i32;
+    }
+    // 若存在记录 dp[i] ，则直接返回之
+    if mem[i] != -1 {
+        return mem[i];
+    }
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1, mem) + dfs(i - 2, mem);
+    // 记录 dp[i]
+    mem[i] = count;
+    count
+}
+
+/* 爬楼梯：记忆化搜索 */
+fn climbing_stairs_dfs_mem(n: usize) -> i32 {
+    // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+    let mut mem = vec![-1; n + 1];
+    dfs(n, &mut mem)
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs_mem(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}
diff --git a/codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs b/codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs
index f33aee22e..ec948e7ea 100644
--- a/codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs
+++ b/codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs
@@ -1,44 +1,48 @@
-/*
- * File: climbing_stairs_dp.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-/* 爬楼梯：动态规划 */
-fn climbing_stairs_dp(n: usize) -> i32 {
-    // 已知 dp[1] 和 dp[2] ，返回之
-    if n == 1 || n == 2 { return n as i32; }
-    // 初始化 dp 表，用于存储子问题的解
-    let mut dp = vec![-1; n + 1];
-    // 初始状态：预设最小子问题的解
-    dp[1] = 1;
-    dp[2] = 2;
-    // 状态转移：从较小子问题逐步求解较大子问题
-    for i in 3..=n {
-        dp[i] = dp[i - 1] + dp[i - 2];
-    }
-    dp[n]
-}
-
-/* 爬楼梯：空间优化后的动态规划 */
-fn climbing_stairs_dp_comp(n: usize) -> i32 {
-    if n == 1 || n == 2 { return n as i32; }
-    let (mut a, mut b) = (1, 2);
-    for _ in 3..=n {
-        let tmp = b;
-        b = a + b;
-        a = tmp;
-    }
-    b
-}
-
-/* Driver Code */
-pub fn main() {
-    let n: usize = 9;
-
-    let res = climbing_stairs_dp(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-
-    let res = climbing_stairs_dp_comp(n);
-    println!("爬 {n} 阶楼梯共有 {res} 种方案");
-}
+/*
+ * File: climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+/* 爬楼梯：动态规划 */
+fn climbing_stairs_dp(n: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if n == 1 || n == 2 {
+        return n as i32;
+    }
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = 1;
+    dp[2] = 2;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    dp[n]
+}
+
+/* 爬楼梯：空间优化后的动态规划 */
+fn climbing_stairs_dp_comp(n: usize) -> i32 {
+    if n == 1 || n == 2 {
+        return n as i32;
+    }
+    let (mut a, mut b) = (1, 2);
+    for _ in 3..=n {
+        let tmp = b;
+        b = a + b;
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+
+    let res = climbing_stairs_dp_comp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}
diff --git a/codes/rust/chapter_dynamic_programming/coin_change.rs b/codes/rust/chapter_dynamic_programming/coin_change.rs
index 93fb23a5c..33922a2d5 100644
--- a/codes/rust/chapter_dynamic_programming/coin_change.rs
+++ b/codes/rust/chapter_dynamic_programming/coin_change.rs
@@ -11,7 +11,7 @@ fn coin_change_dp(coins: &[i32], amt: usize) -> i32 {
     // 初始化 dp 表
     let mut dp = vec![vec![0; amt + 1]; n + 1];
     // 状态转移：首行首列
-    for a in 1..= amt {
+    for a in 1..=amt {
         dp[0][a] = max;
     }
     // 状态转移：其余行和列
@@ -26,7 +26,11 @@ fn coin_change_dp(coins: &[i32], amt: usize) -> i32 {
             }
         }
     }
-    if dp[n][amt] != max { return dp[n][amt] as i32; } else { -1 }
+    if dp[n][amt] != max {
+        return dp[n][amt] as i32;
+    } else {
+        -1
+    }
 }
 
 /* 零钱兑换：空间优化后的动态规划 */
@@ -49,12 +53,16 @@ fn coin_change_dp_comp(coins: &[i32], amt: usize) -> i32 {
             }
         }
     }
-    if dp[amt] != max { return dp[amt] as i32; } else { -1 }
+    if dp[amt] != max {
+        return dp[amt] as i32;
+    } else {
+        -1
+    }
 }
 
 /* Driver Code */
 pub fn main() {
-    let coins = [ 1, 2, 5 ];
+    let coins = [1, 2, 5];
     let amt: usize = 4;
 
     // 动态规划
diff --git a/codes/rust/chapter_dynamic_programming/coin_change_ii.rs b/codes/rust/chapter_dynamic_programming/coin_change_ii.rs
index 8306e530d..12702bdf3 100644
--- a/codes/rust/chapter_dynamic_programming/coin_change_ii.rs
+++ b/codes/rust/chapter_dynamic_programming/coin_change_ii.rs
@@ -10,7 +10,7 @@ fn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {
     // 初始化 dp 表
     let mut dp = vec![vec![0; amt + 1]; n + 1];
     // 初始化首列
-    for i in 0..= n {
+    for i in 0..=n {
         dp[i][0] = 1;
     }
     // 状态转移
@@ -51,7 +51,7 @@ fn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {
 
 /* Driver Code */
 pub fn main() {
-    let coins = [ 1, 2, 5 ];
+    let coins = [1, 2, 5];
     let amt: usize = 5;
 
     // 动态规划
diff --git a/codes/rust/chapter_dynamic_programming/edit_distance.rs b/codes/rust/chapter_dynamic_programming/edit_distance.rs
index 5e0fb8b13..d2dcad92c 100644
--- a/codes/rust/chapter_dynamic_programming/edit_distance.rs
+++ b/codes/rust/chapter_dynamic_programming/edit_distance.rs
@@ -7,11 +7,17 @@
 /* 编辑距离：暴力搜索 */
 fn edit_distance_dfs(s: &str, t: &str, i: usize, j: usize) -> i32 {
     // 若 s 和 t 都为空，则返回 0
-    if i == 0 && j == 0 { return 0; }
+    if i == 0 && j == 0 {
+        return 0;
+    }
     // 若 s 为空，则返回 t 长度
-    if i == 0 { return j as i32; }
+    if i == 0 {
+        return j as i32;
+    }
     // 若 t 为空，则返回 s 长度
-    if j == 0 {return i as i32; }
+    if j == 0 {
+        return i as i32;
+    }
     // 若两字符相等，则直接跳过此两字符
     if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
         return edit_distance_dfs(s, t, i - 1, j - 1);
@@ -27,13 +33,21 @@ fn edit_distance_dfs(s: &str, t: &str, i: usize, j: usize) -> i32 {
 /* 编辑距离：记忆化搜索 */
 fn edit_distance_dfs_mem(s: &str, t: &str, mem: &mut Vec<Vec<i32>>, i: usize, j: usize) -> i32 {
     // 若 s 和 t 都为空，则返回 0
-    if i == 0 && j == 0 { return 0; }
+    if i == 0 && j == 0 {
+        return 0;
+    }
     // 若 s 为空，则返回 t 长度
-    if i == 0 { return j as i32; }
+    if i == 0 {
+        return j as i32;
+    }
     // 若 t 为空，则返回 s 长度
-    if j == 0 {return i as i32; }
+    if j == 0 {
+        return i as i32;
+    }
     // 若已有记录，则直接返回之
-    if mem[i][j] != -1 { return mem[i][j]; }
+    if mem[i][j] != -1 {
+        return mem[i][j];
+    }
     // 若两字符相等，则直接跳过此两字符
     if s.chars().nth(i - 1) == t.chars().nth(j - 1) {
         return edit_distance_dfs_mem(s, t, mem, i - 1, j - 1);
@@ -52,7 +66,7 @@ fn edit_distance_dp(s: &str, t: &str) -> i32 {
     let (n, m) = (s.len(), t.len());
     let mut dp = vec![vec![0; m + 1]; n + 1];
     // 状态转移：首行首列
-    for i in 1..= n {
+    for i in 1..=n {
         dp[i][0] = i as i32;
     }
     for j in 1..m {
@@ -66,7 +80,8 @@ fn edit_distance_dp(s: &str, t: &str) -> i32 {
                 dp[i][j] = dp[i - 1][j - 1];
             } else {
                 // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
-                dp[i][j] = std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                dp[i][j] =
+                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
             }
         }
     }
diff --git a/codes/rust/chapter_dynamic_programming/knapsack.rs b/codes/rust/chapter_dynamic_programming/knapsack.rs
index a141562f6..9e99b4c04 100644
--- a/codes/rust/chapter_dynamic_programming/knapsack.rs
+++ b/codes/rust/chapter_dynamic_programming/knapsack.rs
@@ -56,7 +56,10 @@ fn knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
                 dp[i][c] = dp[i - 1][c];
             } else {
                 // 不选和选物品 i 这两种方案的较大值
-                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1]);
+                dp[i][c] = std::cmp::max(
+                    dp[i - 1][c],
+                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],
+                );
             }
         }
     }
@@ -83,8 +86,8 @@ fn knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
 
 /* Driver Code */
 pub fn main() {
-    let wgt = [ 10, 20, 30, 40, 50 ];
-    let val = [ 50, 120, 150, 210, 240 ];
+    let wgt = [10, 20, 30, 40, 50];
+    let val = [50, 120, 150, 210, 240];
     let cap: usize = 50;
     let n = wgt.len();
 
diff --git a/codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs b/codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs
index 8feacf882..146068e59 100644
--- a/codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs
+++ b/codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs
@@ -1,48 +1,52 @@
-/*
- * File: min_cost_climbing_stairs_dp.rs
- * Created Time: 2023-07-09
- * Author: codingonion (coderonion@gmail.com)
- */
-
-use std::cmp;
-
-/* 爬楼梯最小代价：动态规划 */
-fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
-    let n = cost.len() - 1;
-    if n == 1 || n == 2 { return cost[n]; }
-    // 初始化 dp 表，用于存储子问题的解
-    let mut dp = vec![-1; n + 1];
-    // 初始状态：预设最小子问题的解
-    dp[1] = cost[1];
-    dp[2] = cost[2];
-    // 状态转移：从较小子问题逐步求解较大子问题
-    for i in 3..=n {
-        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
-    }
-    dp[n]
-}
-
-/* 爬楼梯最小代价：空间优化后的动态规划 */
-fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
-    let n = cost.len() - 1;
-    if n == 1 || n == 2 { return cost[n] };
-    let (mut a, mut b) = (cost[1], cost[2]);
-    for i in 3..=n {
-        let tmp = b;
-        b = cmp::min(a, tmp) + cost[i];
-        a = tmp;
-    }
-    b
-}
-
-/* Driver Code */
-pub fn main() {
-    let cost = [ 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 ];
-    println!("输入楼梯的代价列表为 {:?}", &cost);
-
-    let res = min_cost_climbing_stairs_dp(&cost);
-    println!("爬完楼梯的最低代价为 {res}");
-
-    let res = min_cost_climbing_stairs_dp_comp(&cost);
-    println!("爬完楼梯的最低代价为 {res}");
-}
+/*
+ * File: min_cost_climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: codingonion (coderonion@gmail.com)
+ */
+
+use std::cmp;
+
+/* 爬楼梯最小代价：动态规划 */
+fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 {
+        return cost[n];
+    }
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = cost[1];
+    dp[2] = cost[2];
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    dp[n]
+}
+
+/* 爬楼梯最小代价：空间优化后的动态规划 */
+fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 {
+        return cost[n];
+    };
+    let (mut a, mut b) = (cost[1], cost[2]);
+    for i in 3..=n {
+        let tmp = b;
+        b = cmp::min(a, tmp) + cost[i];
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
+    println!("输入楼梯的代价列表为 {:?}", &cost);
+
+    let res = min_cost_climbing_stairs_dp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+
+    let res = min_cost_climbing_stairs_dp_comp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+}
diff --git a/codes/rust/chapter_dynamic_programming/min_path_sum.rs b/codes/rust/chapter_dynamic_programming/min_path_sum.rs
index cd2b7397c..bb7b9c8e1 100644
--- a/codes/rust/chapter_dynamic_programming/min_path_sum.rs
+++ b/codes/rust/chapter_dynamic_programming/min_path_sum.rs
@@ -91,10 +91,11 @@ fn min_path_sum_dp_comp(grid: &Vec<Vec<i32>>) -> i32 {
 /* Driver Code */
 pub fn main() {
     let grid = vec![
-        vec![ 1, 3, 1, 5 ],
-        vec![ 2, 2, 4, 2 ],
-        vec![ 5, 3, 2, 1 ],
-        vec![ 4, 3, 5, 2 ]];
+        vec![1, 3, 1, 5],
+        vec![2, 2, 4, 2],
+        vec![5, 3, 2, 1],
+        vec![4, 3, 5, 2],
+    ];
     let (n, m) = (grid.len(), grid[0].len());
 
     // 暴力搜索
diff --git a/codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs b/codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs
index a2d39c3af..670f845af 100644
--- a/codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs
+++ b/codes/rust/chapter_dynamic_programming/unbounded_knapsack.rs
@@ -46,8 +46,8 @@ fn unbounded_knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
 
 /* Driver Code */
 pub fn main() {
-    let wgt = [ 1, 2, 3 ];
-    let val = [ 5, 11, 15 ];
+    let wgt = [1, 2, 3];
+    let val = [5, 11, 15];
     let cap: usize = 4;
 
     // 动态规划
diff --git a/codes/rust/chapter_graph/graph_bfs.rs b/codes/rust/chapter_graph/graph_bfs.rs
index 44e70df15..bfc520300 100644
--- a/codes/rust/chapter_graph/graph_bfs.rs
+++ b/codes/rust/chapter_graph/graph_bfs.rs
@@ -6,9 +6,9 @@
 
 mod graph_adjacency_list;
 
-use std::collections::{HashSet, VecDeque};
 use graph_adjacency_list::GraphAdjList;
-use graph_adjacency_list::{Vertex, vets_to_vals, vals_to_vets};
+use graph_adjacency_list::{vals_to_vets, vets_to_vals, Vertex};
+use std::collections::{HashSet, VecDeque};
 
 /* 广度优先遍历 */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
@@ -25,7 +25,8 @@ fn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
     while !que.is_empty() {
         let vet = que.pop_front().unwrap(); // 队首顶点出队
         res.push(vet); // 记录访问顶点
-                    // 遍历该顶点的所有邻接顶点
+
+        // 遍历该顶点的所有邻接顶点
         if let Some(adj_vets) = graph.adj_list.get(&vet) {
             for &adj_vet in adj_vets {
                 if visited.contains(&adj_vet) {
diff --git a/codes/rust/chapter_graph/graph_dfs.rs b/codes/rust/chapter_graph/graph_dfs.rs
index 6d76fb3c0..b126b252c 100644
--- a/codes/rust/chapter_graph/graph_dfs.rs
+++ b/codes/rust/chapter_graph/graph_dfs.rs
@@ -6,9 +6,9 @@
 
 mod graph_adjacency_list;
 
-use std::collections::HashSet;
 use graph_adjacency_list::GraphAdjList;
-use graph_adjacency_list::{Vertex, vets_to_vals, vals_to_vets};
+use graph_adjacency_list::{vals_to_vets, vets_to_vals, Vertex};
+use std::collections::HashSet;
 
 /* 深度优先遍历辅助函数 */
 fn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {
diff --git a/codes/rust/chapter_hashing/array_hash_map.rs b/codes/rust/chapter_hashing/array_hash_map.rs
index 63cd517f1..2eff4f435 100644
--- a/codes/rust/chapter_hashing/array_hash_map.rs
+++ b/codes/rust/chapter_hashing/array_hash_map.rs
@@ -12,13 +12,15 @@ pub struct Pair {
 }
 /* 基于数组实现的哈希表 */
 pub struct ArrayHashMap {
-    buckets: Vec<Option<Pair>>
+    buckets: Vec<Option<Pair>>,
 }
 
 impl ArrayHashMap {
     pub fn new() -> ArrayHashMap {
         // 初始化数组，包含 100 个桶
-        Self { buckets: vec![None; 100] }
+        Self {
+            buckets: vec![None; 100],
+        }
     }
 
     /* 哈希函数 */
@@ -50,17 +52,26 @@ impl ArrayHashMap {
 
     /* 获取所有键值对 */
     pub fn entry_set(&self) -> Vec<&Pair> {
-        self.buckets.iter().filter_map(|pair| pair.as_ref()).collect()
+        self.buckets
+            .iter()
+            .filter_map(|pair| pair.as_ref())
+            .collect()
     }
 
     /* 获取所有键 */
     pub fn key_set(&self) -> Vec<&i32> {
-        self.buckets.iter().filter_map(|pair| pair.as_ref().map(|pair| &pair.key)).collect()
+        self.buckets
+            .iter()
+            .filter_map(|pair| pair.as_ref().map(|pair| &pair.key))
+            .collect()
     }
 
     /* 获取所有值 */
     pub fn value_set(&self) -> Vec<&String> {
-        self.buckets.iter().filter_map(|pair| pair.as_ref().map(|pair| &pair.val)).collect()
+        self.buckets
+            .iter()
+            .filter_map(|pair| pair.as_ref().map(|pair| &pair.val))
+            .collect()
     }
 
     /* 打印哈希表 */
diff --git a/codes/rust/chapter_hashing/hash_map_chaining.rs b/codes/rust/chapter_hashing/hash_map_chaining.rs
index 3f43e5eb0..2a08d2f09 100644
--- a/codes/rust/chapter_hashing/hash_map_chaining.rs
+++ b/codes/rust/chapter_hashing/hash_map_chaining.rs
@@ -151,10 +151,13 @@ pub fn main() {
 
     /* 查询操作 */
     // 向哈希表中输入键 key ，得到值 value
-    println!("\n输入学号 13276,查询到姓名 {}", match map.get(13276) {
-        Some(value) => value,
-        None => "Not a valid Key"
-    });
+    println!(
+        "\n输入学号 13276,查询到姓名 {}",
+        match map.get(13276) {
+            Some(value) => value,
+            None => "Not a valid Key",
+        }
+    );
 
     /* 删除操作 */
     // 在哈希表中删除键值对 (key, value)
diff --git a/codes/rust/chapter_hashing/hash_map_open_addressing.rs b/codes/rust/chapter_hashing/hash_map_open_addressing.rs
index 61578ce1a..5ed34fc43 100644
--- a/codes/rust/chapter_hashing/hash_map_open_addressing.rs
+++ b/codes/rust/chapter_hashing/hash_map_open_addressing.rs
@@ -12,15 +12,14 @@ use array_hash_map::Pair;
 
 /* 开放寻址哈希表 */
 struct HashMapOpenAddressing {
-    size: usize,                    // 键值对数量
-    capacity: usize,                // 哈希表容量
-    load_thres: f64,                // 触发扩容的负载因子阈值
-    extend_ratio: usize,            // 扩容倍数
-    buckets: Vec<Option<Pair>>,     // 桶数组
-    TOMBSTONE: Option<Pair>,        // 删除标记
+    size: usize,                // 键值对数量
+    capacity: usize,            // 哈希表容量
+    load_thres: f64,            // 触发扩容的负载因子阈值
+    extend_ratio: usize,        // 扩容倍数
+    buckets: Vec<Option<Pair>>, // 桶数组
+    TOMBSTONE: Option<Pair>,    // 删除标记
 }
 
-
 impl HashMapOpenAddressing {
     /* 构造方法 */
     fn new() -> Self {
@@ -30,7 +29,10 @@ impl HashMapOpenAddressing {
             load_thres: 2.0 / 3.0,
             extend_ratio: 2,
             buckets: vec![None; 4],
-            TOMBSTONE: Some(Pair {key: -1, val: "-1".to_string()}),
+            TOMBSTONE: Some(Pair {
+                key: -1,
+                val: "-1".to_string(),
+            }),
         }
     }
 
@@ -56,9 +58,9 @@ impl HashMapOpenAddressing {
                 if first_tombstone != -1 {
                     self.buckets[first_tombstone as usize] = self.buckets[index].take();
                     self.buckets[index] = self.TOMBSTONE.clone();
-                    return first_tombstone as usize;    // 返回移动后的桶索引
+                    return first_tombstone as usize; // 返回移动后的桶索引
                 }
-                return index;   // 返回桶索引
+                return index; // 返回桶索引
             }
             // 记录遇到的首个删除标记
             if first_tombstone == -1 && self.buckets[index] == self.TOMBSTONE {
@@ -68,7 +70,11 @@ impl HashMapOpenAddressing {
             index = (index + 1) % self.capacity;
         }
         // 若 key 不存在，则返回添加点的索引
-        if first_tombstone == -1 { index } else { first_tombstone as usize }
+        if first_tombstone == -1 {
+            index
+        } else {
+            first_tombstone as usize
+        }
     }
 
     /* 查询操作 */
diff --git a/codes/rust/chapter_hashing/simple_hash.rs b/codes/rust/chapter_hashing/simple_hash.rs
index bb6299ca7..1106101bb 100644
--- a/codes/rust/chapter_hashing/simple_hash.rs
+++ b/codes/rust/chapter_hashing/simple_hash.rs
@@ -4,7 +4,6 @@
  * Author: night-cruise (2586447362@qq.com)
  */
 
-
 /* 加法哈希 */
 fn add_hash(key: &str) -> i32 {
     let mut hash = 0_i64;
@@ -15,7 +14,7 @@ fn add_hash(key: &str) -> i32 {
     }
 
     hash as i32
-} 
+}
 
 /* 乘法哈希 */
 fn mul_hash(key: &str) -> i32 {
@@ -68,4 +67,4 @@ fn main() {
 
     let hash = rot_hash(key);
     println!("旋转哈希值为 {hash}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_heap/my_heap.rs b/codes/rust/chapter_heap/my_heap.rs
index 0d0a9769f..67688d1a2 100644
--- a/codes/rust/chapter_heap/my_heap.rs
+++ b/codes/rust/chapter_heap/my_heap.rs
@@ -162,4 +162,4 @@ fn main() {
     /* 判断堆是否为空 */
     let is_empty = max_heap.is_empty();
     println!("\n堆是否为空 {}", is_empty);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_heap/top_k.rs b/codes/rust/chapter_heap/top_k.rs
index f731a97de..fdfdb97cd 100644
--- a/codes/rust/chapter_heap/top_k.rs
+++ b/codes/rust/chapter_heap/top_k.rs
@@ -36,4 +36,4 @@ fn main() {
     let res = top_k_heap(nums, k);
     println!("最大的 {} 个元素为", k);
     print_util::print_heap(res.into_iter().map(|item| item.0).collect());
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_searching/binary_search.rs b/codes/rust/chapter_searching/binary_search.rs
index 9aa81514f..b60742e0f 100644
--- a/codes/rust/chapter_searching/binary_search.rs
+++ b/codes/rust/chapter_searching/binary_search.rs
@@ -11,14 +11,17 @@ fn binary_search(nums: &[i32], target: i32) -> i32 {
     let mut j = nums.len() as i32 - 1;
     // 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while i <= j {
-        let m = i + (j - i) / 2;      // 计算中点索引 m
-        if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j] 中
+        let m = i + (j - i) / 2; // 计算中点索引 m
+        if nums[m as usize] < target {
+            // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
-        } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m-1] 中
+        } else if nums[m as usize] > target {
+            // 此情况说明 target 在区间 [i, m-1] 中
             j = m - 1;
-        } else {                      // 找到目标元素，返回其索引
+        } else {
+            // 找到目标元素，返回其索引
             return m;
-        }                       
+        }
     }
     // 未找到目标元素，返回 -1
     return -1;
@@ -31,14 +34,17 @@ fn binary_search_lcro(nums: &[i32], target: i32) -> i32 {
     let mut j = nums.len() as i32;
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while i < j {
-        let m = i + (j - i) / 2;      // 计算中点索引 m
-        if nums[m as usize] < target {         // 此情况说明 target 在区间 [m+1, j) 中
+        let m = i + (j - i) / 2; // 计算中点索引 m
+        if nums[m as usize] < target {
+            // 此情况说明 target 在区间 [m+1, j) 中
             i = m + 1;
-        } else if nums[m as usize] > target {  // 此情况说明 target 在区间 [i, m) 中
+        } else if nums[m as usize] > target {
+            // 此情况说明 target 在区间 [i, m) 中
             j = m;
-        } else {                      // 找到目标元素，返回其索引
+        } else {
+            // 找到目标元素，返回其索引
             return m;
-        }                       
+        }
     }
     // 未找到目标元素，返回 -1
     return -1;
@@ -47,8 +53,8 @@ fn binary_search_lcro(nums: &[i32], target: i32) -> i32 {
 /* Driver Code */
 pub fn main() {
     let target = 6;
-    let nums = [ 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 ];
-        
+    let nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
     // 二分查找（双闭区间）
     let mut index = binary_search(&nums, target);
     println!("目标元素 6 的索引 = {index}");
diff --git a/codes/rust/chapter_searching/binary_search_edge.rs b/codes/rust/chapter_searching/binary_search_edge.rs
index e5baede9f..5d8195ab3 100644
--- a/codes/rust/chapter_searching/binary_search_edge.rs
+++ b/codes/rust/chapter_searching/binary_search_edge.rs
@@ -8,7 +8,6 @@ mod binary_search_insertion;
 
 use binary_search_insertion::binary_search_insertion;
 
-
 /* 二分查找最左一个 target */
 fn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {
     // 等价于查找 target 的插入点
@@ -48,4 +47,4 @@ fn main() {
         let index = binary_search_right_edge(&nums, target);
         println!("最右一个元素 {} 的索引为 {}", target, index);
     }
-} 
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_searching/binary_search_insertion.rs b/codes/rust/chapter_searching/binary_search_insertion.rs
index 654b63f42..d0c584e3c 100644
--- a/codes/rust/chapter_searching/binary_search_insertion.rs
+++ b/codes/rust/chapter_searching/binary_search_insertion.rs
@@ -7,13 +7,13 @@
 
 /* 二分查找插入点（无重复元素） */
 fn binary_search_insertion_simple(nums: &[i32], target: i32) -> i32 {
-    let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化双闭区间 [0, n-1]
     while i <= j {
-        let m = i + (j - i) / 2;    // 计算中点索引 m
+        let m = i + (j - i) / 2; // 计算中点索引 m
         if nums[m as usize] < target {
-            i = m + 1;  // target 在区间 [m+1, j] 中
+            i = m + 1; // target 在区间 [m+1, j] 中
         } else if nums[m as usize] > target {
-            j = m - 1;  // target 在区间 [i, m-1] 中
+            j = m - 1; // target 在区间 [i, m-1] 中
         } else {
             return m;
         }
@@ -24,22 +24,21 @@ fn binary_search_insertion_simple(nums: &[i32], target: i32) -> i32 {
 
 /* 二分查找插入点（存在重复元素） */
 pub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {
-    let (mut i, mut j) = (0, nums.len() as i32 - 1);    // 初始化双闭区间 [0, n-1]
+    let (mut i, mut j) = (0, nums.len() as i32 - 1); // 初始化双闭区间 [0, n-1]
     while i <= j {
-        let m = i + (j - i) / 2;    // 计算中点索引 m
+        let m = i + (j - i) / 2; // 计算中点索引 m
         if nums[m as usize] < target {
-            i = m + 1;  // target 在区间 [m+1, j] 中
+            i = m + 1; // target 在区间 [m+1, j] 中
         } else if nums[m as usize] > target {
-            j = m - 1;  // target 在区间 [i, m-1] 中
+            j = m - 1; // target 在区间 [i, m-1] 中
         } else {
-            j = m - 1;  // 首个小于 target 的元素在区间 [i, m-1] 中
+            j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
         }
     }
     // 返回插入点 i
     i
 }
 
-
 /* Driver Code */
 fn main() {
     // 无重复元素的数组
@@ -59,4 +58,4 @@ fn main() {
         let index = binary_search_insertion(&nums, target);
         println!("元素 {} 的插入点的索引为 {}", target, index);
     }
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_searching/hashing_search.rs b/codes/rust/chapter_searching/hashing_search.rs
index e689239f0..1e41bc0b2 100644
--- a/codes/rust/chapter_searching/hashing_search.rs
+++ b/codes/rust/chapter_searching/hashing_search.rs
@@ -6,10 +6,10 @@
 
 include!("../include/include.rs");
 
+use list_node::ListNode;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
-use std::cell::RefCell;
-use list_node::ListNode;
 
 /* 哈希查找（数组） */
 fn hashing_search_array<'a>(map: &'a HashMap<i32, usize>, target: i32) -> Option<&'a usize> {
@@ -19,7 +19,10 @@ fn hashing_search_array<'a>(map: &'a HashMap<i32, usize>, target: i32) -> Option
 }
 
 /* 哈希查找（链表） */
-fn hashing_search_linked_list(map: &HashMap<i32, Rc<RefCell<ListNode<i32>>>>, target: i32) -> Option<&Rc<RefCell<ListNode<i32>>>> {
+fn hashing_search_linked_list(
+    map: &HashMap<i32, Rc<RefCell<ListNode<i32>>>>,
+    target: i32,
+) -> Option<&Rc<RefCell<ListNode<i32>>>> {
     // 哈希表的 key: 目标节点值，value: 节点对象
     // 若哈希表中无此 key ，返回 None
     map.get(&target)
@@ -30,7 +33,7 @@ pub fn main() {
     let target = 3;
 
     /* 哈希查找（数组） */
-    let nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
+    let nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
     // 初始化哈希表
     let mut map = HashMap::new();
     for (i, num) in nums.iter().enumerate() {
diff --git a/codes/rust/chapter_searching/linear_search.rs b/codes/rust/chapter_searching/linear_search.rs
index 4482d8507..5a0d131d7 100644
--- a/codes/rust/chapter_searching/linear_search.rs
+++ b/codes/rust/chapter_searching/linear_search.rs
@@ -6,9 +6,9 @@
 
 include!("../include/include.rs");
 
-use std::rc::Rc;
-use std::cell::RefCell;
 use list_node::ListNode;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /* 线性查找（数组） */
 fn linear_search_array(nums: &[i32], target: i32) -> i32 {
@@ -24,9 +24,14 @@ 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>>>> {
+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 head.borrow().val == target {
+        return Some(head);
+    };
     // 找到目标节点，返回之
     if let Some(node) = &head.borrow_mut().next {
         return linear_search_linked_list(node.clone(), target);
@@ -40,7 +45,7 @@ pub fn main() {
     let target = 3;
 
     /* 在数组中执行线性查找 */
-    let nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
+    let nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
     let index = linear_search_array(&nums, target);
     println!("目标元素 3 的索引 = {}", index);
 
diff --git a/codes/rust/chapter_searching/two_sum.rs b/codes/rust/chapter_searching/two_sum.rs
index ddbf20e7a..6766db5dc 100644
--- a/codes/rust/chapter_searching/two_sum.rs
+++ b/codes/rust/chapter_searching/two_sum.rs
@@ -30,7 +30,7 @@ pub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
     for (i, num) in nums.iter().enumerate() {
         match dic.get(&(target - num)) {
             Some(v) => return Some(vec![*v as i32, i as i32]),
-            None => dic.insert(num, i as i32)
+            None => dic.insert(num, i as i32),
         };
     }
     None
@@ -38,7 +38,7 @@ pub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
 
 fn main() {
     // ======= Test Case =======
-    let nums = vec![ 2, 7, 11, 15 ];
+    let nums = vec![2, 7, 11, 15];
     let target = 13;
 
     // ====== Driver Code ======
diff --git a/codes/rust/chapter_sorting/bubble_sort.rs b/codes/rust/chapter_sorting/bubble_sort.rs
index 8d3e7ccee..b69227dd3 100644
--- a/codes/rust/chapter_sorting/bubble_sort.rs
+++ b/codes/rust/chapter_sorting/bubble_sort.rs
@@ -10,7 +10,7 @@ include!("../include/include.rs");
 fn bubble_sort(nums: &mut [i32]) {
     // 外循环：未排序区间为 [0, i]
     for i in (1..nums.len()).rev() {
-        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
         for j in 0..i {
             if nums[j] > nums[j + 1] {
                 // 交换 nums[j] 与 nums[j + 1]
@@ -27,29 +27,32 @@ fn bubble_sort_with_flag(nums: &mut [i32]) {
     // 外循环：未排序区间为 [0, i]
     for i in (1..nums.len()).rev() {
         let mut flag = false; // 初始化标志位
-        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
+
+        // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
         for j in 0..i {
             if nums[j] > nums[j + 1] {
                 // 交换 nums[j] 与 nums[j + 1]
                 let tmp = nums[j];
                 nums[j] = nums[j + 1];
                 nums[j + 1] = tmp;
-                flag = true;  // 记录交换元素
+                flag = true; // 记录交换元素
             }
         }
-        if !flag {break};  // 此轮“冒泡”未交换任何元素，直接跳出
+        if !flag {
+            break; // 此轮“冒泡”未交换任何元素，直接跳出
+        };
     }
 }
 
 /* Driver Code */
 pub fn main() {
-    let mut nums = [ 4, 1, 3, 1, 5, 2 ];
+    let mut nums = [4, 1, 3, 1, 5, 2];
     bubble_sort(&mut nums);
     print!("冒泡排序完成后 nums = ");
     print_util::print_array(&nums);
 
-    let mut nums1 = [ 4, 1, 3, 1, 5, 2 ];
+    let mut nums1 = [4, 1, 3, 1, 5, 2];
     bubble_sort_with_flag(&mut nums1);
     print!("\n冒泡排序完成后 nums1 = ");
     print_util::print_array(&nums1);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/bucket_sort.rs b/codes/rust/chapter_sorting/bucket_sort.rs
index 8a80394fa..5bec09451 100644
--- a/codes/rust/chapter_sorting/bucket_sort.rs
+++ b/codes/rust/chapter_sorting/bucket_sort.rs
@@ -40,4 +40,4 @@ fn main() {
     bucket_sort(&mut nums);
     print!("桶排序完成后 nums = ");
     print_util::print_array(&nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/counting_sort.rs b/codes/rust/chapter_sorting/counting_sort.rs
index 56e5a1825..ca4ed0de3 100644
--- a/codes/rust/chapter_sorting/counting_sort.rs
+++ b/codes/rust/chapter_sorting/counting_sort.rs
@@ -69,4 +69,4 @@ fn main() {
     counting_sort(&mut nums1);
     print!("\n计数排序完成后 nums1 = ");
     print_util::print_array(&nums1);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/heap_sort.rs b/codes/rust/chapter_sorting/heap_sort.rs
index 6e0c93837..d01202b4c 100644
--- a/codes/rust/chapter_sorting/heap_sort.rs
+++ b/codes/rust/chapter_sorting/heap_sort.rs
@@ -55,4 +55,4 @@ fn main() {
     heap_sort(&mut nums);
     print!("堆排序完成后 nums = ");
     print_util::print_array(&nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/insertion_sort.rs b/codes/rust/chapter_sorting/insertion_sort.rs
index 833052f71..37b685aaf 100644
--- a/codes/rust/chapter_sorting/insertion_sort.rs
+++ b/codes/rust/chapter_sorting/insertion_sort.rs
@@ -10,13 +10,13 @@ include!("../include/include.rs");
 fn insertion_sort(nums: &mut [i32]) {
     // 外循环：已排序区间为 [0, i-1]
     for i in 1..nums.len() {
-        let (base, mut j) = (nums[i],  (i - 1) as i32);
+        let (base, mut j) = (nums[i], (i - 1) as i32);
         // 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置
         while j >= 0 && nums[j as usize] > base {
             nums[(j + 1) as usize] = nums[j as usize]; // 将 nums[j] 向右移动一位
             j -= 1;
         }
-        nums[(j + 1) as usize] = base;  // 将 base 赋值到正确位置
+        nums[(j + 1) as usize] = base; // 将 base 赋值到正确位置
     }
 }
 
@@ -26,4 +26,4 @@ fn main() {
     insertion_sort(&mut nums);
     print!("插入排序完成后 nums = ");
     print_util::print_array(&nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/merge_sort.rs b/codes/rust/chapter_sorting/merge_sort.rs
index fa3f348e6..698af073f 100644
--- a/codes/rust/chapter_sorting/merge_sort.rs
+++ b/codes/rust/chapter_sorting/merge_sort.rs
@@ -43,11 +43,15 @@ fn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {
 /* 归并排序 */
 fn merge_sort(nums: &mut [i32], left: usize, right: usize) {
     // 终止条件
-    if left >= right { return; }             // 当子数组长度为 1 时终止递归
+    if left >= right {
+        return; // 当子数组长度为 1 时终止递归
+    }
+
     // 划分阶段
-    let mid = (left + right) / 2;     // 计算中点
-    merge_sort(nums, left, mid);      // 递归左子数组
-    merge_sort(nums, mid + 1, right);  // 递归右子数组
+    let mid = (left + right) / 2; // 计算中点
+    merge_sort(nums, left, mid); // 递归左子数组
+    merge_sort(nums, mid + 1, right); // 递归右子数组
+
     // 合并阶段
     merge(nums, left, mid, right);
 }
@@ -59,4 +63,4 @@ fn main() {
     let right = nums.len() - 1;
     merge_sort(&mut nums, 0, right);
     println!("归并排序完成后 nums = {:?}", nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/quick_sort.rs b/codes/rust/chapter_sorting/quick_sort.rs
index cd44248e2..c155e6322 100644
--- a/codes/rust/chapter_sorting/quick_sort.rs
+++ b/codes/rust/chapter_sorting/quick_sort.rs
@@ -4,7 +4,6 @@
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
-
 /* 快速排序 */
 struct QuickSort;
 
@@ -15,15 +14,15 @@ impl QuickSort {
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
-                j -= 1;      // 从右向左找首个小于基准数的元素
+                j -= 1; // 从右向左找首个小于基准数的元素
             }
             while i < j && nums[i] <= nums[left] {
-                i += 1;      // 从左向右找首个大于基准数的元素
+                i += 1; // 从左向右找首个大于基准数的元素
             }
             nums.swap(i, j); // 交换这两个元素
         }
-        nums.swap(i, left);  // 将基准数交换至两子数组的分界线
-        i                    // 返回基准数的索引
+        nums.swap(i, left); // 将基准数交换至两子数组的分界线
+        i // 返回基准数的索引
     }
 
     /* 快速排序 */
@@ -66,15 +65,15 @@ impl QuickSortMedian {
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
-                j -= 1;      // 从右向左找首个小于基准数的元素
+                j -= 1; // 从右向左找首个小于基准数的元素
             }
             while i < j && nums[i] <= nums[left] {
-                i += 1;      // 从左向右找首个大于基准数的元素
+                i += 1; // 从左向右找首个大于基准数的元素
             }
             nums.swap(i, j); // 交换这两个元素
         }
-        nums.swap(i, left);  // 将基准数交换至两子数组的分界线
-        i                    // 返回基准数的索引
+        nums.swap(i, left); // 将基准数交换至两子数组的分界线
+        i // 返回基准数的索引
     }
 
     /* 快速排序 */
@@ -101,15 +100,15 @@ impl QuickSortTailCall {
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
-                j -= 1;      // 从右向左找首个小于基准数的元素
+                j -= 1; // 从右向左找首个小于基准数的元素
             }
             while i < j && nums[i] <= nums[left] {
-                i += 1;      // 从左向右找首个大于基准数的元素
+                i += 1; // 从左向右找首个大于基准数的元素
             }
             nums.swap(i, j); // 交换这两个元素
         }
-        nums.swap(i, left);  // 将基准数交换至两子数组的分界线
-        i                    // 返回基准数的索引
+        nums.swap(i, left); // 将基准数交换至两子数组的分界线
+        i // 返回基准数的索引
     }
 
     /* 快速排序（尾递归优化） */
@@ -119,9 +118,9 @@ impl QuickSortTailCall {
             // 哨兵划分操作
             let pivot = Self::partition(nums, left as usize, right as usize) as i32;
             // 对两个子数组中较短的那个执行快速排序
-            if  pivot - left < right - pivot {
-                Self::quick_sort(left, pivot - 1, nums);  // 递归排序左子数组
-                left = pivot + 1;  // 剩余未排序区间为 [pivot + 1, right]
+            if pivot - left < right - pivot {
+                Self::quick_sort(left, pivot - 1, nums); // 递归排序左子数组
+                left = pivot + 1; // 剩余未排序区间为 [pivot + 1, right]
             } else {
                 Self::quick_sort(pivot + 1, right, nums); // 递归排序右子数组
                 right = pivot - 1; // 剩余未排序区间为 [left, pivot - 1]
diff --git a/codes/rust/chapter_sorting/radix_sort.rs b/codes/rust/chapter_sorting/radix_sort.rs
index f350e5d62..d9c151be3 100644
--- a/codes/rust/chapter_sorting/radix_sort.rs
+++ b/codes/rust/chapter_sorting/radix_sort.rs
@@ -62,4 +62,4 @@ fn main() {
     radix_sort(&mut nums);
     print!("基数排序完成后 nums = ");
     print_util::print_array(&nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_sorting/selection_sort.rs b/codes/rust/chapter_sorting/selection_sort.rs
index 54265b0a4..9b21d9bc1 100644
--- a/codes/rust/chapter_sorting/selection_sort.rs
+++ b/codes/rust/chapter_sorting/selection_sort.rs
@@ -13,10 +13,10 @@ fn selection_sort(nums: &mut [i32]) {
     }
     let n = nums.len();
     // 外循环：未排序区间为 [i, n-1]
-    for i in 0..n-1 {
+    for i in 0..n - 1 {
         // 内循环：找到未排序区间内的最小元素
         let mut k = i;
-        for j in i+1..n {
+        for j in i + 1..n {
             if nums[j] < nums[k] {
                 k = j; // 记录最小元素的索引
             }
@@ -32,4 +32,4 @@ pub fn main() {
     selection_sort(&mut nums);
     print!("\n选择排序完成后 nums = ");
     print_util::print_array(&nums);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/array_deque.rs b/codes/rust/chapter_stack_and_queue/array_deque.rs
index 48d44874e..8ad4e487d 100644
--- a/codes/rust/chapter_stack_and_queue/array_deque.rs
+++ b/codes/rust/chapter_stack_and_queue/array_deque.rs
@@ -8,9 +8,9 @@ include!("../include/include.rs");
 
 /* 基于环形数组实现的双向队列 */
 struct ArrayDeque {
-    nums: Vec<i32>,     // 用于存储双向队列元素的数组
-    front: usize,       // 队首指针，指向队首元素
-    que_size: usize,    // 双向队列长度
+    nums: Vec<i32>,  // 用于存储双向队列元素的数组
+    front: usize,    // 队首指针，指向队首元素
+    que_size: usize, // 双向队列长度
 }
 
 impl ArrayDeque {
@@ -50,7 +50,7 @@ impl ArrayDeque {
     pub fn push_first(&mut self, num: i32) {
         if self.que_size == self.capacity() {
             println!("双向队列已满");
-            return
+            return;
         }
         // 队首指针向左移动一位
         // 通过取余操作实现 front 越过数组头部后回到尾部
@@ -64,7 +64,7 @@ impl ArrayDeque {
     pub fn push_last(&mut self, num: i32) {
         if self.que_size == self.capacity() {
             println!("双向队列已满");
-            return
+            return;
         }
         // 计算队尾指针，指向队尾索引 + 1
         let rear = self.index(self.front as i32 + self.que_size as i32);
@@ -91,18 +91,22 @@ impl ArrayDeque {
 
     /* 访问队首元素 */
     fn peek_first(&self) -> i32 {
-        if self.is_empty() { panic!("双向队列为空") };
+        if self.is_empty() {
+            panic!("双向队列为空")
+        };
         self.nums[self.front]
     }
 
     /* 访问队尾元素 */
     fn peek_last(&self) -> i32 {
-        if self.is_empty() { panic!("双向队列为空") };
+        if self.is_empty() {
+            panic!("双向队列为空")
+        };
         // 计算尾元素索引
         let last = self.index(self.front as i32 + self.que_size as i32 - 1);
         self.nums[last]
     }
-    
+
     /* 返回数组用于打印 */
     fn to_array(&self) -> Vec<i32> {
         // 仅转换有效长度范围内的列表元素
@@ -146,7 +150,7 @@ fn main() {
     print_util::print_array(&deque.to_array());
     let pop_first = deque.pop_first();
     print!("\n队首出队元素 = {}，队首出队后 deque = ", pop_first);
-    print_util::print_array(&deque.to_array());   
+    print_util::print_array(&deque.to_array());
 
     /* 获取双向队列的长度 */
     let size = deque.size();
diff --git a/codes/rust/chapter_stack_and_queue/array_queue.rs b/codes/rust/chapter_stack_and_queue/array_queue.rs
index 374ec7c97..6f2af5731 100644
--- a/codes/rust/chapter_stack_and_queue/array_queue.rs
+++ b/codes/rust/chapter_stack_and_queue/array_queue.rs
@@ -6,10 +6,10 @@
 
 /* 基于环形数组实现的队列 */
 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 {
diff --git a/codes/rust/chapter_stack_and_queue/array_stack.rs b/codes/rust/chapter_stack_and_queue/array_stack.rs
index f100c8123..ca136c563 100644
--- a/codes/rust/chapter_stack_and_queue/array_stack.rs
+++ b/codes/rust/chapter_stack_and_queue/array_stack.rs
@@ -14,7 +14,9 @@ struct ArrayStack<T> {
 impl<T> ArrayStack<T> {
     /* 初始化栈 */
     fn new() -> ArrayStack<T> {
-        ArrayStack::<T> { stack: Vec::<T>::new() }
+        ArrayStack::<T> {
+            stack: Vec::<T>::new(),
+        }
     }
 
     /* 获取栈的长度 */
@@ -42,7 +44,9 @@ impl<T> ArrayStack<T> {
 
     /* 访问栈顶元素 */
     fn peek(&self) -> Option<&T> {
-        if self.is_empty() { panic!("栈为空") };
+        if self.is_empty() {
+            panic!("栈为空")
+        };
         self.stack.last()
     }
 
@@ -82,4 +86,4 @@ fn main() {
     // 判断是否为空
     let is_empty = stack.is_empty();
     print!("\n栈是否为空 = {is_empty}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/deque.rs b/codes/rust/chapter_stack_and_queue/deque.rs
index 5bed8ecf6..486975033 100644
--- a/codes/rust/chapter_stack_and_queue/deque.rs
+++ b/codes/rust/chapter_stack_and_queue/deque.rs
@@ -12,16 +12,16 @@ use std::collections::VecDeque;
 pub fn main() {
     // 初始化双向队列
     let mut deque: VecDeque<i32> = VecDeque::new();
-    deque.push_back(3);     
+    deque.push_back(3);
     deque.push_back(2);
     deque.push_back(5);
     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}");
 
     /* 元素入队 */
@@ -47,4 +47,4 @@ pub fn main() {
     // 判断双向队列是否为空
     let is_empty = deque.is_empty();
     print!("\n双向队列是否为空 = {is_empty}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs b/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs
index 809211d68..b181f8ffd 100644
--- a/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs
+++ b/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs
@@ -6,8 +6,8 @@
 
 include!("../include/include.rs");
 
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 
 /* 双向链表节点 */
 pub struct ListNode<T> {
@@ -29,9 +29,9 @@ impl<T> ListNode<T> {
 /* 基于双向链表实现的双向队列 */
 #[allow(dead_code)]
 pub struct LinkedListDeque<T> {
-    front: Option<Rc<RefCell<ListNode<T>>>>,    // 头节点 front
-    rear: Option<Rc<RefCell<ListNode<T>>>>,     // 尾节点 rear 
-    que_size: usize,                            // 双向队列的长度
+    front: Option<Rc<RefCell<ListNode<T>>>>, // 头节点 front
+    rear: Option<Rc<RefCell<ListNode<T>>>>,  // 尾节点 rear
+    que_size: usize,                         // 双向队列的长度
 }
 
 impl<T: Copy> LinkedListDeque<T> {
@@ -39,7 +39,7 @@ impl<T: Copy> LinkedListDeque<T> {
         Self {
             front: None,
             rear: None,
-            que_size: 0, 
+            que_size: 0,
         }
     }
 
@@ -71,7 +71,7 @@ impl<T: Copy> LinkedListDeque<T> {
                     self.front = Some(node); // 更新头节点
                 }
             }
-        } 
+        }
         // 队尾入队操作
         else {
             match self.rear.take() {
@@ -104,8 +104,8 @@ impl<T: Copy> LinkedListDeque<T> {
     /* 出队操作 */
     pub fn pop(&mut self, is_front: bool) -> Option<T> {
         // 若队列为空，直接返回 None
-        if self.is_empty() { 
-            return None 
+        if self.is_empty() {
+            return None;
         };
         // 队首出队操作
         if is_front {
@@ -113,7 +113,7 @@ impl<T: Copy> LinkedListDeque<T> {
                 match old_front.borrow_mut().next.take() {
                     Some(new_front) => {
                         new_front.borrow_mut().prev.take();
-                        self.front = Some(new_front);   // 更新头节点
+                        self.front = Some(new_front); // 更新头节点
                     }
                     None => {
                         self.rear.take();
@@ -122,15 +122,14 @@ impl<T: Copy> LinkedListDeque<T> {
                 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);     // 更新尾节点
+                        self.rear = Some(new_rear); // 更新尾节点
                     }
                     None => {
                         self.front.take();
@@ -203,7 +202,7 @@ fn main() {
     print_util::print_array(&deque.to_array(deque.peek_first()));
     let pop_first = deque.pop_first().unwrap();
     print!("\n队首出队元素 = {}，队首出队后 deque = ", pop_first);
-    print_util::print_array(&deque.to_array(deque.peek_first()));   
+    print_util::print_array(&deque.to_array(deque.peek_first()));
 
     /* 获取双向队列的长度 */
     let size = deque.size();
diff --git a/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs b/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs
index 67f31e6da..1b940a032 100644
--- a/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs
+++ b/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs
@@ -6,16 +6,16 @@
 
 include!("../include/include.rs");
 
-use std::rc::Rc;
-use std::cell::RefCell;
 use list_node::ListNode;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /* 基于链表实现的队列 */
 #[allow(dead_code)]
 pub struct LinkedListQueue<T> {
-    front: Option<Rc<RefCell<ListNode<T>>>>,    // 头节点 front
-    rear: Option<Rc<RefCell<ListNode<T>>>>,     // 尾节点 rear 
-    que_size: usize,                            // 队列的长度
+    front: Option<Rc<RefCell<ListNode<T>>>>, // 头节点 front
+    rear: Option<Rc<RefCell<ListNode<T>>>>,  // 尾节点 rear
+    que_size: usize,                         // 队列的长度
 }
 
 impl<T: Copy> LinkedListQueue<T> {
@@ -23,7 +23,7 @@ impl<T: Copy> LinkedListQueue<T> {
         Self {
             front: None,
             rear: None,
-            que_size: 0, 
+            que_size: 0,
         }
     }
 
@@ -118,4 +118,4 @@ fn main() {
     /* 判断队列是否为空 */
     let is_empty = queue.is_empty();
     print!("\n队列是否为空 = {}", is_empty);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs b/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs
index 8b50fff8f..f2d479ae2 100644
--- a/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs
+++ b/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs
@@ -6,15 +6,15 @@
 
 include!("../include/include.rs");
 
-use std::rc::Rc;
-use std::cell::RefCell;
 use list_node::ListNode;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /* 基于链表实现的栈 */
 #[allow(dead_code)]
 pub struct LinkedListStack<T> {
-    stack_peek: Option<Rc<RefCell<ListNode<T>>>>,   // 将头节点作为栈顶
-    stk_size: usize,                                // 栈的长度
+    stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // 将头节点作为栈顶
+    stk_size: usize,                              // 栈的长度
 }
 
 impl<T: Copy> LinkedListStack<T> {
@@ -105,4 +105,4 @@ fn main() {
     /* 判断是否为空 */
     let is_empty = stack.is_empty();
     print!("\n栈是否为空 = {}", is_empty);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/queue.rs b/codes/rust/chapter_stack_and_queue/queue.rs
index 77f592e3b..56144666a 100644
--- a/codes/rust/chapter_stack_and_queue/queue.rs
+++ b/codes/rust/chapter_stack_and_queue/queue.rs
@@ -38,4 +38,4 @@ pub fn main() {
     // 判断队列是否为空
     let is_empty = queue.is_empty();
     print!("\n队列是否为空 = {is_empty}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_stack_and_queue/stack.rs b/codes/rust/chapter_stack_and_queue/stack.rs
index 4d96690be..64e214245 100644
--- a/codes/rust/chapter_stack_and_queue/stack.rs
+++ b/codes/rust/chapter_stack_and_queue/stack.rs
@@ -37,4 +37,4 @@ pub fn main() {
     // 判断栈是否为空
     let is_empty = stack.is_empty();
     print!("\n栈是否为空 = {is_empty}");
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_tree/array_binary_tree.rs b/codes/rust/chapter_tree/array_binary_tree.rs
index 8e3576d58..1ce7e9048 100644
--- a/codes/rust/chapter_tree/array_binary_tree.rs
+++ b/codes/rust/chapter_tree/array_binary_tree.rs
@@ -196,4 +196,4 @@ fn main() {
     println!("中序遍历为：{:?}", res);
     res = abt.post_order();
     println!("后序遍历为：{:?}", res);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_tree/avl_tree.rs b/codes/rust/chapter_tree/avl_tree.rs
index a342350dd..a48ec813f 100644
--- a/codes/rust/chapter_tree/avl_tree.rs
+++ b/codes/rust/chapter_tree/avl_tree.rs
@@ -6,10 +6,10 @@
 
 include!("../include/include.rs");
 
-use tree_node::TreeNode;
-use std::rc::Rc;
-use std::cmp::Ordering;
 use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::rc::Rc;
+use tree_node::TreeNode;
 
 type OptionTreeNodeRc = Option<Rc<RefCell<TreeNode>>>;
 
@@ -157,6 +157,7 @@ impl AVLTree {
                     }
                 }
                 Self::update_height(Some(node.clone())); // 更新节点高度
+
                 /* 2. 执行旋转操作，使该子树重新恢复平衡 */
                 node = Self::rotate(Some(node)).unwrap();
                 // 返回子树的根节点
@@ -211,6 +212,7 @@ impl AVLTree {
                     node.borrow_mut().val = temp.borrow().val;
                 }
                 Self::update_height(Some(node.clone())); // 更新节点高度
+
                 /* 2. 执行旋转操作，使该子树重新恢复平衡 */
                 node = Self::rotate(Some(node)).unwrap();
                 // 返回子树的根节点
diff --git a/codes/rust/chapter_tree/binary_search_tree.rs b/codes/rust/chapter_tree/binary_search_tree.rs
index fa4498ad5..aca3f4334 100644
--- a/codes/rust/chapter_tree/binary_search_tree.rs
+++ b/codes/rust/chapter_tree/binary_search_tree.rs
@@ -7,8 +7,8 @@
 include!("../include/include.rs");
 
 use std::cell::RefCell;
-use std::rc::Rc;
 use std::cmp::Ordering;
+use std::rc::Rc;
 
 use tree_node::TreeNode;
 
@@ -89,8 +89,8 @@ impl BinarySearchTree {
     /* 删除节点 */
     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;
@@ -171,7 +171,11 @@ fn main() {
 
     /* 查找结点 */
     let node = bst.search(7);
-    println!("\n查找到的节点对象为 {:?}，节点值 = {}", node.clone().unwrap(), node.clone().unwrap().borrow().val);
+    println!(
+        "\n查找到的节点对象为 {:?}，节点值 = {}",
+        node.clone().unwrap(),
+        node.clone().unwrap().borrow().val
+    );
 
     /* 插入节点 */
     bst.insert(16);
diff --git a/codes/rust/chapter_tree/binary_tree.rs b/codes/rust/chapter_tree/binary_tree.rs
index c1e4ba903..823088617 100644
--- a/codes/rust/chapter_tree/binary_tree.rs
+++ b/codes/rust/chapter_tree/binary_tree.rs
@@ -3,7 +3,6 @@
  * Created Time: 2023-02-27
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
-
 use std::rc::Rc;
 include!("../include/include.rs");
 use tree_node::TreeNode;
@@ -37,4 +36,4 @@ fn main() {
     n1.borrow_mut().left = Some(Rc::clone(&n2));
     println!("\n删除节点 P 后\n");
     print_util::print_tree(&n1);
-}
\ No newline at end of file
+}
diff --git a/codes/rust/chapter_tree/binary_tree_bfs.rs b/codes/rust/chapter_tree/binary_tree_bfs.rs
index 4a5829a72..da2ddbcf9 100644
--- a/codes/rust/chapter_tree/binary_tree_bfs.rs
+++ b/codes/rust/chapter_tree/binary_tree_bfs.rs
@@ -18,13 +18,14 @@ 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
diff --git a/codes/rust/chapter_tree/binary_tree_dfs.rs b/codes/rust/chapter_tree/binary_tree_dfs.rs
index ec4f27f81..3652393bb 100644
--- a/codes/rust/chapter_tree/binary_tree_dfs.rs
+++ b/codes/rust/chapter_tree/binary_tree_dfs.rs
@@ -68,4 +68,4 @@ fn main() {
     /* 后序遍历 */
     let vec = post_order(root.as_ref());
     print!("\n后序遍历的节点打印序列 = {:?}", vec);
-}
\ No newline at end of file
+}