feat: add sorting algorithm in rust

Author: maolonglong

basic/sorting/BubbleSort/BubbleSort.rs

@@ -0,0 +1,18 @@
+fn bubble_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in 0..n - 1 {
+        for j in i..n {
+            if nums[i] > nums[j] {
+                let temp = nums[i];
+                nums[i] = nums[j];
+                nums[j] = temp;
+            }
+        }
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 2, 7, 9, 5, 8];
+    bubble_sort(&mut nums);
+    println!("{:?}", nums);
+}

basic/sorting/BubbleSort/README.md

@@ -162,6 +162,29 @@ int main(void)
 }
 ```
 
+### **Rust**
+
+```rust
+fn bubble_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in 0..n - 1 {
+        for j in i..n {
+            if nums[i] > nums[j] {
+                let temp = nums[i];
+                nums[i] = nums[j];
+                nums[j] = temp;
+            }
+        }
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 2, 7, 9, 5, 8];
+    bubble_sort(&mut nums);
+    println!("{:?}", nums);
+}
+```
+
 <!-- tabs:end -->
 
 ## 算法分析

basic/sorting/HeapSort/Main.rs

@@ -0,0 +1,40 @@
+fn heap_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    // 自底向上的下沉
+    for i in (0..n / 2).rev() {
+        sink(nums, i, n);
+    }
+    for i in (1..n).rev() {
+        let temp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = temp;
+        sink(nums, 0, i);
+    }
+}
+
+fn sink(nums: &mut Vec<i32>, mut i: usize, n: usize) {
+    loop {
+        let left = i * 2 + 1;
+        let right = left + 1;
+        let mut largest = i;
+        if left < n && nums[left] > nums[largest] {
+            largest = left;
+        }
+        if right < n && nums[right] > nums[largest] {
+            largest = right;
+        }
+        if largest == i {
+            break;
+        }
+        let temp = nums[i];
+        nums[i] = nums[largest];
+        nums[largest] = temp;
+        i = largest;
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 2, 7, 9, 5, 8];
+    heap_sort(&mut nums);
+    println!("{:?}", nums);
+}

basic/sorting/HeapSort/README.md

@@ -165,4 +165,63 @@ public class Main {
 }
 ```
 
+### **Rust**
+
+```rust
+use std::io;
+
+fn heap_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in (0..n / 2).rev() {
+        sink(nums, i, n);
+    }
+    for i in (1..n).rev() {
+        let temp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = temp;
+        sink(nums, 0, i);
+    }
+}
+
+fn sink(nums: &mut Vec<i32>, mut i: usize, n: usize) {
+    loop {
+        let left = i * 2 + 1;
+        let right = left + 1;
+        let mut largest = i;
+        if left < n && nums[left] > nums[largest] {
+            largest = left;
+        }
+        if right < n && nums[right] > nums[largest] {
+            largest = right;
+        }
+        if largest == i {
+            break;
+        }
+        let temp = nums[i];
+        nums[i] = nums[largest];
+        nums[largest] = temp;
+        i = largest;
+    }
+}
+
+fn main() -> io::Result<()> {
+    let mut s = String::new();
+    io::stdin().read_line(&mut s)?;
+    let s: Vec<usize> = s.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+    // let n = s[0];
+    let m = s[1];
+
+    let mut nums = String::new();
+    io::stdin().read_line(&mut nums)?;
+    let mut nums: Vec<i32> = nums.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+
+    heap_sort(&mut nums);
+    for num in nums.iter().take(m) {
+        print!("{} ", num);
+    }
+
+    Ok(())
+}
+```
+
 <!-- tabs:end -->

basic/sorting/InsertionSort/InsertionSort.rs

@@ -0,0 +1,18 @@
+fn insertion_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in 1..n {
+        let mut j = i - 1;
+        let temp = nums[i];
+        while j >= 0 as usize && nums[j] > temp {
+            nums[j + 1] = nums[j];
+            j -= 1;
+        }
+        nums[j + 1] = temp;
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 2, 7, 9, 5, 8];
+    insertion_sort(&mut nums);
+    println!("{:?}", nums);
+}

basic/sorting/InsertionSort/README.md

@@ -132,6 +132,29 @@ int main()
 }
 ```
 
+### **Rust**
+
+```rust
+fn insertion_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in 1..n {
+        let mut j = i - 1;
+        let temp = nums[i];
+        while j >= 0 as usize && nums[j] > temp {
+            nums[j + 1] = nums[j];
+            j -= 1;
+        }
+        nums[j + 1] = temp;
+    }
+}
+
+fn main() {
+    let mut nums = vec![1, 2, 7, 9, 5, 8];
+    insertion_sort(&mut nums);
+    println!("{:?}", nums);
+}
+```
+
 <!-- tabs:end -->
 
 ## 算法分析

basic/sorting/MergeSort/Main.rs

@@ -0,0 +1,54 @@
+use std::io;
+
+fn merge_sort(nums: &mut Vec<i32>, left: usize, right: usize) {
+    if left >= right {
+        return;
+    }
+
+    let mid = left + (right - left) / 2;
+    merge_sort(nums, left, mid);
+    merge_sort(nums, mid + 1, right);
+
+    let mut temp = Vec::new();
+    let mut i = left;
+    let mut j = mid + 1;
+
+    while i <= mid && j <= right {
+        if nums[i] < nums[j] {
+            temp.push(nums[i]);
+            i += 1;
+        } else {
+            temp.push(nums[j]);
+            j += 1;
+        }
+    }
+    while i <= mid {
+        temp.push(nums[i]);
+        i += 1;
+    }
+    while j <= right {
+        temp.push(nums[j]);
+        j += 1;
+    }
+
+    for i in left..=right {
+        nums[i] = temp[i - left];
+    }
+}
+
+fn main() -> io::Result<()> {
+    let mut n = String::new();
+    io::stdin().read_line(&mut n)?;
+    let n = n.trim().parse::<usize>().unwrap();
+
+    let mut nums = String::new();
+    io::stdin().read_line(&mut nums)?;
+    let mut nums: Vec<i32> = nums.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+
+    merge_sort(&mut nums, 0, n - 1);
+    for num in nums.iter() {
+        print!("{} ", num);
+    }
+
+    Ok(())
+}

basic/sorting/MergeSort/README.md

@@ -351,4 +351,63 @@ int main( void )
 }
 ```
 
+### **Rust**
+
+```rust
+use std::io;
+
+fn merge_sort(nums: &mut Vec<i32>, left: usize, right: usize) {
+    if left >= right {
+        return;
+    }
+
+    let mid = left + (right - left) / 2;
+    merge_sort(nums, left, mid);
+    merge_sort(nums, mid + 1, right);
+
+    let mut temp = Vec::new();
+    let mut i = left;
+    let mut j = mid + 1;
+
+    while i <= mid && j <= right {
+        if nums[i] < nums[j] {
+            temp.push(nums[i]);
+            i += 1;
+        } else {
+            temp.push(nums[j]);
+            j += 1;
+        }
+    }
+    while i <= mid {
+        temp.push(nums[i]);
+        i += 1;
+    }
+    while j <= right {
+        temp.push(nums[j]);
+        j += 1;
+    }
+
+    for i in left..=right {
+        nums[i] = temp[i - left];
+    }
+}
+
+fn main() -> io::Result<()> {
+    let mut n = String::new();
+    io::stdin().read_line(&mut n)?;
+    let n = n.trim().parse::<usize>().unwrap();
+
+    let mut nums = String::new();
+    io::stdin().read_line(&mut nums)?;
+    let mut nums: Vec<i32> = nums.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+
+    merge_sort(&mut nums, 0, n - 1);
+    for num in nums.iter() {
+        print!("{} ", num);
+    }
+
+    Ok(())
+}
+```
+
 <!-- tabs:end -->

basic/sorting/QuickSort/Main.rs

@@ -0,0 +1,54 @@
+use std::io;
+
+fn heap_sort(nums: &mut Vec<i32>) {
+    let n = nums.len();
+    for i in (0..n / 2).rev() {
+        sink(nums, i, n);
+    }
+    for i in (1..n).rev() {
+        let temp = nums[0];
+        nums[0] = nums[i];
+        nums[i] = temp;
+        sink(nums, 0, i);
+    }
+}
+
+fn sink(nums: &mut Vec<i32>, mut i: usize, n: usize) {
+    loop {
+        let left = i * 2 + 1;
+        let right = left + 1;
+        let mut largest = i;
+        if left < n && nums[left] > nums[largest] {
+            largest = left;
+        }
+        if right < n && nums[right] > nums[largest] {
+            largest = right;
+        }
+        if largest == i {
+            break;
+        }
+        let temp = nums[i];
+        nums[i] = nums[largest];
+        nums[largest] = temp;
+        i = largest;
+    }
+}
+
+fn main() -> io::Result<()> {
+    let mut s = String::new();
+    io::stdin().read_line(&mut s)?;
+    let s: Vec<usize> = s.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+    // let n = s[0];
+    let m = s[1];
+
+    let mut nums = String::new();
+    io::stdin().read_line(&mut nums)?;
+    let mut nums: Vec<i32> = nums.split(' ').map(|s| s.trim().parse().unwrap()).collect();
+
+    heap_sort(&mut nums);
+    for num in nums.iter().take(m) {
+        print!("{} ", num);
+    }
+
+    Ok(())
+}