cargo fmt rust code (#1131)

* cargo fmt code

* Add empty line to seperate unrelated comments

* Fix review

* Update bubble_sort.rs

* Update merge_sort.rs

---------

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

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

codes/rust/chapter_sorting/bucket_sort.rs

@@ -40,4 +40,4 @@ fn main() {
     bucket_sort(&mut nums);
     print!("桶排序完成后 nums = ");
     print_util::print_array(&nums);
-}
+}

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

codes/rust/chapter_sorting/heap_sort.rs

@@ -55,4 +55,4 @@ fn main() {
     heap_sort(&mut nums);
     print!("堆排序完成后 nums = ");
     print_util::print_array(&nums);
-}
+}

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

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

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]

codes/rust/chapter_sorting/radix_sort.rs

@@ -62,4 +62,4 @@ fn main() {
     radix_sort(&mut nums);
     print!("基数排序完成后 nums = ");
     print_util::print_array(&nums);
-}
+}

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