Release Rust code to documents. (#656)

codes/rust/chapter_array_and_linkedlist/linked_list.rs

@@ -13,9 +13,9 @@ use list_node::ListNode;
 /* 在链表的节点 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();
-   P.borrow_mut().next = n1;
-   n0.borrow_mut().next = Some(P);
+    let n1 =  n0.borrow_mut().next.take();
+    P.borrow_mut().next = n1;
+    n0.borrow_mut().next = Some(P);
 }
 
 /* 删除链表的节点 n0 之后的首个节点 */
@@ -28,7 +28,7 @@ pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
         let n1 = node.borrow_mut().next.take();
         n0.borrow_mut().next = n1;
     }
- }
+}
 
 /* 访问链表中索引为 index 的节点 */
 pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
@@ -37,7 +37,7 @@ pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListN
         return access(node.clone(), index - 1);
     }
     return head;
- }
+}
 
 /* 在链表中查找值为 target 的首个节点 */
 pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
@@ -46,7 +46,7 @@ pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32)
         return find(node.clone(), target, index + 1);
     }
     return -1;
- }
+}
 
 /* Driver Code */
 fn main() {
@@ -74,7 +74,7 @@ fn main() {
     remove(&n0);
     print!("删除节点后的链表为 ");
     print_util::print_linked_list(&n0);
-   
+
     /* 访问节点 */
     let node = access(n0.clone(), 3);
     println!("链表中索引 3 处的节点的值 = {}", node.borrow().val);

codes/rust/chapter_array_and_linkedlist/list.rs

@@ -4,72 +4,72 @@
  * Author: xBLACICEx (xBLACKICEx@outlook.com), sjinzh (sjinzh@gmail.com)
  */
 
- include!("../include/include.rs");
+include!("../include/include.rs");
 
 /* Driver Code */
- fn main() {
-    //  初始化列表
-    let mut list: Vec<i32> = vec![ 1, 3, 2, 5, 4 ];
-    print!("列表 list = ");
-    print_util::print_array(&list);
- 
-    //  访问元素
-    let num = list[1];
-    println!("\n访问索引 1 处的元素，得到 num = {num}");
- 
-    //  更新元素
-    list[1] = 0;
-    print!("将索引 1 处的元素更新为 0 ，得到 list = ");
-    print_util::print_array(&list);
- 
-    //  清空列表
-    list.clear();
-    print!("\n清空列表后 list = ");
-    print_util::print_array(&list);
- 
-    //  尾部添加元素
-    list.push(1);
-    list.push(3);
-    list.push(2);
-    list.push(5);
-    list.push(4);
-    print!("\n添加元素后 list = ");
-    print_util::print_array(&list);
- 
-    //  中间插入元素
-    list.insert(3, 6);
-    print!("\n在索引 3 处插入数字 6 ，得到 list = ");
-    print_util::print_array(&list);
- 
-    //  删除元素
-    list.remove(3);
-    print!("\n删除索引 3 处的元素，得到 list = ");
-    print_util::print_array(&list);
- 
-    //  通过索引遍历列表
-    let mut _count = 0;
-    for _ in 0..list.len() {
-    _count += 1;
-    }
- 
-    // 直接遍历列表元素
-    _count = 0;
-    for _n in &list {
-    _count += 1;
-    } 
-    // 或者
-    // list.iter().for_each(|_| _count += 1);
-    // let _count = list.iter().fold(0, |_count, _| _count + 1);
- 
-    //  拼接两个列表
-    let mut list1 = vec![ 6, 8, 7, 10, 9 ];
-    list.append(&mut list1);   // append（移动） 之后 list1 为空！
-    // list.extend(&list1);    // extend（借用） list1 能继续使用 
-    print!("\n将列表 list1 拼接到 list 之后，得到 list = ");
-    print_util::print_array(&list);
- 
-    //  排序列表
-    list.sort();
-    print!("\n排序列表后 list = ");
-    print_util::print_array(&list);
- }
+fn main() {
+   //  初始化列表
+   let mut list: Vec<i32> = vec![ 1, 3, 2, 5, 4 ];
+   print!("列表 list = ");
+   print_util::print_array(&list);
+
+   //  访问元素
+   let num = list[1];
+   println!("\n访问索引 1 处的元素，得到 num = {num}");
+
+   //  更新元素
+   list[1] = 0;
+   print!("将索引 1 处的元素更新为 0 ，得到 list = ");
+   print_util::print_array(&list);
+
+   //  清空列表
+   list.clear();
+   print!("\n清空列表后 list = ");
+   print_util::print_array(&list);
+
+   //  尾部添加元素
+   list.push(1);
+   list.push(3);
+   list.push(2);
+   list.push(5);
+   list.push(4);
+   print!("\n添加元素后 list = ");
+   print_util::print_array(&list);
+
+   //  中间插入元素
+   list.insert(3, 6);
+   print!("\n在索引 3 处插入数字 6 ，得到 list = ");
+   print_util::print_array(&list);
+
+   //  删除元素
+   list.remove(3);
+   print!("\n删除索引 3 处的元素，得到 list = ");
+   print_util::print_array(&list);
+
+   //  通过索引遍历列表
+   let mut _count = 0;
+   for _ in 0..list.len() {
+   _count += 1;
+   }
+
+   // 直接遍历列表元素
+   _count = 0;
+   for _n in &list {
+   _count += 1;
+   } 
+   // 或者
+   // list.iter().for_each(|_| _count += 1);
+   // let _count = list.iter().fold(0, |_count, _| _count + 1);
+
+   //  拼接两个列表
+   let mut list1 = vec![ 6, 8, 7, 10, 9 ];
+   list.append(&mut list1);   // append（移动） 之后 list1 为空！
+   // list.extend(&list1);    // extend（借用） list1 能继续使用 
+   print!("\n将列表 list1 拼接到 list 之后，得到 list = ");
+   print_util::print_array(&list);
+
+   //  排序列表
+   list.sort();
+   print!("\n排序列表后 list = ");
+   print_util::print_array(&list);
+}

codes/rust/chapter_array_and_linkedlist/my_list.rs

@@ -6,8 +6,8 @@
 
 include!("../include/include.rs");
 
-#[allow(dead_code)]
 /* 列表类简易实现 */
+#[allow(dead_code)]
 struct MyList {
     nums: Vec<i32>,       // 数组（存储列表元素）
     capacity: usize,      // 列表容量
@@ -154,4 +154,4 @@ fn main() {
     print!("\n扩容后的列表 list = ");
     print_util::print_array(&list.to_array());
     print!(" ，容量 = {} ，长度 = {}", list.capacity(), list.size());
-}
+}

codes/rust/chapter_computational_complexity/worst_best_time_complexity.rs

@@ -4,40 +4,40 @@
  * Author: xBLACICEx (xBLACKICEx@outlook.com), sjinzh (sjinzh@gmail.com)
  */
 
- include!("../include/include.rs");
+include!("../include/include.rs");
 
- use rand::seq::SliceRandom;
- use rand::thread_rng;
- 
- /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
- fn random_numbers(n: i32) -> Vec<i32> {
-     // 生成数组 nums = { 1, 2, 3, ..., n }
-     let mut nums = (1..=n).collect::<Vec<i32>>();
-     // 随机打乱数组元素
-     nums.shuffle(&mut thread_rng());
-     nums
- }
- 
- /* 查找数组 nums 中数字 1 所在索引 */
- fn find_one(nums: &[i32]) -> Option<usize> {
-     for i in 0..nums.len() {
-         // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-         // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-         if nums[i] == 1 {
-             return Some(i);
-         }
-     }
-     None
- }
- 
- /* Driver Code */
- fn main() {
-     for _ in 0..10 {
-         let n = 100;
-         let nums = random_numbers(n);
-         let index = find_one(&nums).unwrap();
-         print!("\n数组 [ 1, 2, ..., n ] 被打乱后 = ");
-         print_util::print_array(&nums);
-         println!("\n数字 1 的索引为 {}", index);
-     }
- }
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+fn random_numbers(n: i32) -> Vec<i32> {
+    // 生成数组 nums = { 1, 2, 3, ..., n }
+    let mut nums = (1..=n).collect::<Vec<i32>>();
+    // 随机打乱数组元素
+    nums.shuffle(&mut thread_rng());
+    nums
+}
+
+/* 查找数组 nums 中数字 1 所在索引 */
+fn find_one(nums: &[i32]) -> Option<usize> {
+    for i in 0..nums.len() {
+        // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
+        // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
+        if nums[i] == 1 {
+            return Some(i);
+        }
+    }
+    None
+}
+
+/* Driver Code */
+fn main() {
+    for _ in 0..10 {
+        let n = 100;
+        let nums = random_numbers(n);
+        let index = find_one(&nums).unwrap();
+        print!("\n数组 [ 1, 2, ..., n ] 被打乱后 = ");
+        print_util::print_array(&nums);
+        println!("\n数字 1 的索引为 {}", index);
+    }
+}

codes/rust/chapter_dynamic_programming/coin_change_ii.rs

@@ -29,7 +29,7 @@ fn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {
 }
 
 /* 零钱兑换 II：状态压缩后的动态规划 */
-fn coin_change_dp_ii_comp(coins: &[i32], amt: usize) -> i32 {
+fn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {
     let n = coins.len();
     // 初始化 dp 表
     let mut dp = vec![0; amt + 1];

codes/rust/chapter_sorting/bubble_sort.rs

@@ -26,7 +26,7 @@ fn bubble_sort(nums: &mut [i32]) {
 fn bubble_sort_with_flag(nums: &mut [i32]) {
     // 外循环：未排序区间为 [0, i]
     for i in (1..nums.len()).rev() {
-        let mut flag = false;   // 初始化标志位
+        let mut flag = false; // 初始化标志位
         // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 
         for j in 0..i {
             if nums[j] > nums[j + 1] {
@@ -34,10 +34,10 @@ fn bubble_sort_with_flag(nums: &mut [i32]) {
                 let tmp = nums[j];
                 nums[j] = nums[j + 1];
                 nums[j + 1] = tmp;
-                flag = true;        // 记录交换元素
+                flag = true;  // 记录交换元素
             }
         }
-        if !flag {break};           // 此轮冒泡未交换任何元素，直接跳出
+        if !flag {break};  // 此轮冒泡未交换任何元素，直接跳出
     }
 }
 

codes/rust/chapter_sorting/insertion_sort.rs

@@ -6,7 +6,7 @@
 
 include!("../include/include.rs");
 
-/*插入排序 */
+/* 插入排序 */
 fn insertion_sort(nums: &mut [i32]) {
     // 外循环：已排序元素数量为 1, 2, ..., n
     for i in 1..nums.len() {

codes/rust/chapter_sorting/quick_sort.rs

@@ -4,14 +4,10 @@
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
-// 快速排序
-struct QuickSort;
-// 快速排序（中位基准数优化）
-struct QuickSortMedian;
-// 快速排序（尾递归优化）
-struct QuickSortTailCall;
 
 /* 快速排序 */
+struct QuickSort;
+
 impl QuickSort {
     /* 哨兵划分 */
     fn partition(nums: &mut [i32], left: usize, right: usize) -> usize {
@@ -19,15 +15,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                    // 返回基准数的索引
     }
 
     /* 快速排序 */
@@ -45,6 +41,8 @@ impl QuickSort {
 }
 
 /* 快速排序（中位基准数优化） */
+struct QuickSortMedian;
+
 impl QuickSortMedian {
     /* 选取三个元素的中位数 */
     fn median_three(nums: &mut [i32], left: usize, mid: usize, right: usize) -> usize {
@@ -66,17 +64,17 @@ impl QuickSortMedian {
         nums.swap(left, med);
         // 以 nums[left] 作为基准数
         let (mut i, mut j) = (left, right);
-         while i < j {
-             while i < j && nums[j] >= nums[left] {
-                 j -= 1;           // 从右向左找首个小于基准数的元素
-             }
-             while i < j && nums[i] <= nums[left] {
-                 i += 1;           // 从左向右找首个大于基准数的元素
-             }
-             nums.swap(i, j); // 交换这两个元素
-         }
-         nums.swap(i, left); // 将基准数交换至两子数组的分界线
-         i                        // 返回基准数的索引
+        while i < j {
+            while i < j && nums[j] >= nums[left] {
+                j -= 1;      // 从右向左找首个小于基准数的元素
+            }
+            while i < j && nums[i] <= nums[left] {
+                i += 1;      // 从左向右找首个大于基准数的元素
+            }
+            nums.swap(i, j); // 交换这两个元素
+        }
+         nums.swap(i, left);  // 将基准数交换至两子数组的分界线
+         i                    // 返回基准数的索引
     }
 
     /* 快速排序 */
@@ -94,23 +92,24 @@ impl QuickSortMedian {
 }
 
 /* 快速排序（尾递归优化） */
+struct QuickSortTailCall;
+
 impl QuickSortTailCall {
     /* 哨兵划分 */
     fn partition(nums: &mut [i32], left: usize, right: usize) -> usize {
         // 以 nums[left] 作为基准数
         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                    // 返回基准数的索引
     }
 
     /* 快速排序（尾递归优化） */
@@ -131,6 +130,7 @@ impl QuickSortTailCall {
     }
 }
 
+/* Driver Code */
 fn main() {
     /* 快速排序 */
     let mut nums = [2, 4, 1, 0, 3, 5];
@@ -146,4 +146,4 @@ fn main() {
     let mut nums = [2, 4, 1, 0, 3, 5];
     QuickSortTailCall::quick_sort(0, (nums.len() - 1) as i32, &mut nums);
     println!("快速排序（尾递归优化）完成后 nums = {:?}", nums);
-}
+}

codes/rust/chapter_stack_and_queue/linkedlist_deque.rs

@@ -212,4 +212,4 @@ fn main() {
     /* 判断双向队列是否为空 */
     let is_empty = deque.is_empty();
     print!("\n双向队列是否为空 = {}", is_empty);
-}
+}