Merge pull request #1513 from cezarbbb/master

添加 0746 0062 0063 0017 0077 0151 0216 0203 0344 0376 0541 剑指Offer05 Rust版本

problems/0017.电话号码的字母组合.md

@@ -454,6 +454,49 @@ function letterCombinations(digits: string): string[] {
 };
 ```
 
+## Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<String>, s: &mut String, map: &[&str; 10], digits: &String, index: usize)  {
+        let len = digits.len();
+        if len == index {
+            result.push(s.to_string());
+            return;
+        }
+        // 在保证不会越界的情况下使用unwrap()将Some()中的值提取出来
+        let digit= digits.chars().nth(index).unwrap().to_digit(10).unwrap() as usize;
+        let letters = map[digit];
+        for i in letters.chars() {
+            s.push(i);
+            Self::backtracking(result, s, &map, &digits, index+1);
+            s.pop();
+        }
+    }
+    pub fn letter_combinations(digits: String) -> Vec<String> {
+        if digits.len() == 0 {
+            return vec![];
+        }
+        const MAP: [&str; 10] = [
+        "",
+        "",
+        "abc",
+        "def",
+        "ghi",
+        "jkl",
+        "mno",
+        "pqrs",
+        "tuv",
+        "wxyz"
+        ];
+        let mut result: Vec<String> = Vec::new();
+        let mut s: String = String::new();
+        Self::backtracking(&mut result, &mut s, &MAP, &digits, 0);
+        result
+    }
+}
+```
+
 ## C
 
 ```c

problems/0062.不同路径.md

@@ -374,6 +374,30 @@ function uniquePaths(m: number, n: number): number {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    pub fn unique_paths(m: i32, n: i32) -> i32 {
+            let m = m as usize;
+            let n = n as usize;
+            let mut dp = vec![vec![0; n]; m];
+            for i in 0..m {
+                dp[i][0] = 1;
+            }
+            for j in 0..n {
+                dp[0][j] = 1;
+            }
+            for i in 1..m {
+                for j in 1..n {
+                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                }
+            }
+        dp[m-1][n-1]
+    }
+}
+```
+
 ### C
 
 ```c

problems/0063.不同路径II.md

@@ -384,6 +384,42 @@ function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
+        let m: usize = obstacle_grid.len();
+        let n: usize = obstacle_grid[0].len();
+        if obstacle_grid[0][0] == 1 || obstacle_grid[m-1][n-1] == 1 {
+            return 0;
+        }
+        let mut dp = vec![vec![0; n]; m];
+        for i in 0..m {
+            if obstacle_grid[i][0] == 1 {
+                break;
+            }
+            else { dp[i][0] = 1; }
+        }
+        for j in 0..n {
+            if obstacle_grid[0][j] == 1 {
+                break;
+            }
+            else { dp[0][j] = 1; }
+        }
+        for i in 1..m {
+            for j in 1..n {
+                if obstacle_grid[i][j] == 1 {
+                    continue;
+                }
+                dp[i][j] = dp[i-1][j] + dp[i][j-1];
+            }
+        }
+        dp[m-1][n-1]
+    }
+}
+```
+
 ### C
 
 ```c

problems/0077.组合.md

@@ -535,6 +535,56 @@ func backtrack(n,k,start int,track []int){
 }
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, n: i32, k: i32, startIndex: i32) {
+        let len= path.len() as i32;
+        if len == k{
+            result.push(path.to_vec());
+            return;
+        }
+        for i in startIndex..= n {
+            path.push(i);
+            Self::backtracking(result, path, n, k, i+1);
+            path.pop();
+        }
+    }
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        Self::backtracking(&mut result, &mut path, n, k, 1);
+        result
+    }
+}
+```
+
+剪枝
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, n: i32, k: i32, startIndex: i32) {
+        let len= path.len() as i32;
+        if len == k{
+            result.push(path.to_vec());
+            return;
+        }
+	// 此处剪枝
+        for i in startIndex..= n - (k - len) + 1 {
+            path.push(i);
+            Self::backtracking(result, path, n, k, i+1);
+            path.pop();
+        }
+    }
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        Self::backtracking(&mut result, &mut path, n, k, 1);
+        result
+    }
+}
+```
+
 ### C
 ```c
 int* path;

problems/0077.组合优化.md

@@ -261,6 +261,32 @@ function combine(n: number, k: number): number[][] {
 };
 ```
 
+Rust:
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, n: i32, k: i32, startIndex: i32) {
+        let len= path.len() as i32;
+        if len == k{
+            result.push(path.to_vec());
+            return;
+        }
+	// 此处剪枝
+        for i in startIndex..= n - (k - len) + 1 {
+            path.push(i);
+            Self::backtracking(result, path, n, k, i+1);
+            path.pop();
+        }
+    }
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        Self::backtracking(&mut result, &mut path, n, k, 1);
+        result
+    }
+}
+```
+
 C:
 
 ```c

problems/0151.翻转字符串里的单词.md

@@ -864,7 +864,58 @@ function reverseString(&$s, $start, $end) {
     return ;
 }
 ```
+Rust:
 
+```Rust
+// 根据C++版本二思路进行实现
+// 函数名根据Rust编译器建议由驼峰命名法改为蛇形命名法
+impl Solution {
+    pub fn reverse(s: &mut Vec<char>, mut begin: usize, mut end: usize){
+        while begin < end {
+            let temp = s[begin];
+            s[begin] = s[end];
+            s[end] = temp;
+            begin += 1;
+            end -= 1;
+        }
+}
+pub fn remove_extra_spaces(s: &mut Vec<char>) {
+        let mut slow: usize = 0;
+        let len = s.len();
+        // 注意这里不能用for循环，不然在里面那个while循环中对i的递增会失效
+        let mut i: usize = 0;
+        while i < len {
+            if !s[i].is_ascii_whitespace() {
+                if slow != 0 {
+                    s[slow] = ' ';
+                    slow += 1;
+                }
+                while i < len && !s[i].is_ascii_whitespace() {
+                    s[slow] = s[i];
+                    slow += 1;
+                    i += 1;
+                }
+            }
+            i += 1;
+        }
+        s.resize(slow, ' ');
+    }
+    pub fn reverse_words(s: String) -> String {
+        let mut s = s.chars().collect::<Vec<char>>();
+        Self::remove_extra_spaces(&mut s);
+        let len = s.len();
+        Self::reverse(&mut s, 0, len - 1);
+        let mut start = 0;
+        for i in 0..=len {
+            if i == len || s[i].is_ascii_whitespace() {
+                Self::reverse(&mut s, start, i - 1);
+                start = i + 1;
+            }
+        }
+        s.iter().collect::<String>()
+    }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0203.移除链表元素.md

@@ -487,17 +487,19 @@ RUST:
 // }
 impl Solution {
     pub fn remove_elements(head: Option<Box<ListNode>>, val: i32) -> Option<Box<ListNode>> {
-        let mut head = head;
+        let mut dummyHead = Box::new(ListNode::new(0));
-        let mut dummy_head = ListNode::new(0);
+        dummyHead.next = head;
-        let mut cur = &mut dummy_head;
+        let mut cur = dummyHead.as_mut();
-        while let Some(mut node) = head {
+	// 使用take()替换std::men::replace(&mut node.next, None)达到相同的效果，并且更普遍易读
-            head = std::mem::replace(&mut node.next, None);
+        while let Some(nxt) = cur.next.take() {
-            if node.val != val {
+            if nxt.val == val {
-                cur.next = Some(node);
+                cur.next = nxt.next;
+            } else {
+                cur.next = Some(nxt);
                 cur = cur.next.as_mut().unwrap();
             }
         }
-        dummy_head.next
+        dummyHead.next
     }
 }
 ```

problems/0216.组合总和III.md

@@ -411,6 +411,35 @@ function combinationSum3(k: number, n: number): number[][] {
 };
 ```
 
+## Rust
+
+```Rust
+impl Solution {
+    fn backtracking(result: &mut Vec<Vec<i32>>, path:&mut Vec<i32>, targetSum:i32, k: i32, mut sum: i32, startIndex: i32) {
+        let len = path.len() as i32;
+        if len == k {
+            if sum == targetSum {
+                result.push(path.to_vec());
+            }
+            return;
+        }
+        for i in startIndex..=9 {
+            sum += i;
+            path.push(i);
+            Self::backtracking(result, path, targetSum, k, sum, i+1);
+            sum -= i;
+            path.pop();
+        }
+    }
+    pub fn combination_sum3(k: i32, n: i32) -> Vec<Vec<i32>> {
+        let mut result: Vec<Vec<i32>> = Vec::new();
+        let mut path: Vec<i32> = Vec::new();
+        Self::backtracking(&mut result, &mut path, n, k, 0, 1);
+        result
+    }
+}
+```
+
 ## C
 
 ```c

problems/0344.反转字符串.md

@@ -238,6 +238,22 @@ func reverseString(_ s: inout [Character]) {
 
 ```
 
+Rust:
+```Rust
+impl Solution {
+    pub fn reverse_string(s: &mut Vec<char>) {
+        let (mut left, mut right) = (0, s.len()-1);
+        while left < right {
+            let temp = s[left];
+            s[left] = s[right];
+            s[right] = temp;
+            left += 1;
+            right -= 1;
+        }
+    }
+}
+```
+
 C:
 ```c
 void reverseString(char* s, int sSize){

problems/0376.摆动序列.md

@@ -298,6 +298,29 @@ var wiggleMaxLength = function(nums) {
 };
 ```
 
+### Rust
+**贪心**
+```Rust
+impl Solution {
+    pub fn wiggle_max_length(nums: Vec<i32>) -> i32 {
+        let len = nums.len() as usize;
+        if len <= 1 {
+            return len as i32;
+        }
+        let mut preDiff = 0;
+        let mut curDiff = 0;
+        let mut result = 1;
+        for i in 0..len-1 {
+            curDiff = nums[i+1] - nums[i];
+            if (preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0) {
+                result += 1;
+                preDiff = curDiff;
+            }
+        }
+        result
+    }
+}
+```
 
 ### C
 **贪心**

problems/0541.反转字符串II.md

@@ -389,5 +389,36 @@ object Solution {
   }
 }
 ```
+
+Rust:
+
+```Rust
+impl Solution {
+    pub fn reverse(s: &mut Vec<char>, mut begin: usize, mut end: usize){
+        while begin < end {
+            let temp = s[begin];
+            s[begin] = s[end];
+            s[end] = temp;
+            begin += 1;
+            end -= 1;
+        }
+    }
+    pub fn reverse_str(s: String, k: i32) -> String {
+        let len = s.len();
+        let k = k as usize;
+        let mut s = s.chars().collect::<Vec<_>>();
+        for i in (0..len).step_by(2 * k) {
+            if i + k < len {
+                Self::reverse(&mut s, i, i + k - 1);
+            }
+            else {
+                Self::reverse(&mut s, i, len - 1);
+            }
+        }
+        s.iter().collect::<String>()
+    }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0746.使用最小花费爬楼梯.md

@@ -288,6 +288,24 @@ function minCostClimbingStairs(cost: number[]): number {
 };
 ```
 
+### Rust
+
+```Rust
+use std::cmp::min;
+impl Solution {
+    pub fn min_cost_climbing_stairs(cost: Vec<i32>) -> i32 {
+        let len = cost.len();
+        let mut dp = vec![0; len];
+        dp[0] = cost[0];
+        dp[1] = cost[1];
+        for i in 2..len {
+            dp[i] = min(dp[i-1], dp[i-2]) + cost[i];
+        }
+        min(dp[len-1], dp[len-2])
+    }
+}
+```
+
 ### C
 
 ```c

problems/剑指Offer05.替换空格.md

@@ -506,6 +506,37 @@ function spaceLen($s){
 }
 ```
 
+Rust
+
+```Rust
+impl Solution {
+    pub fn replace_space(s: String) -> String {
+        let mut len: usize = s.len();
+        let mut s = s.chars().collect::<Vec<char>>();
+        let mut count = 0;
+        for i in &s {
+            if i.is_ascii_whitespace() {
+                count += 1;
+            }
+        }
+        let mut new_len = len + count * 2;
+        s.resize(new_len, ' ');
+        while len < new_len {
+            len -= 1;
+            new_len -= 1;
+            if s[len].is_ascii_whitespace() {
+                s[new_len] = '0';
+                s[new_len - 1] = '2';
+                s[new_len - 2] = '%';
+                new_len -= 2;
+            }
+            else { s[new_len] = s[len] }
+        }
+        s.iter().collect::<String>()
+    }
+}
+```
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>