diff --git a/problems/0096.不同的二叉搜索树.md b/problems/0096.不同的二叉搜索树.md
index 9adc0457..51de1e23 100644
--- a/problems/0096.不同的二叉搜索树.md
+++ b/problems/0096.不同的二叉搜索树.md
@@ -252,6 +252,24 @@ function numTrees(n: number): number {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    pub fn num_trees(n: i32) -> i32 {
+        let n = n as usize;
+        let mut dp = vec![0; n + 1];
+        dp[0] = 1;
+        for i in 1..=n {
+            for j in 1..=i {
+                dp[i] += dp[j - 1] * dp[i - j];
+            }
+        }
+        dp[n]
+    }
+}
+```
+
 ### C
 
 ```c
diff --git a/problems/0343.整数拆分.md b/problems/0343.整数拆分.md
index a4d532fd..0a568b57 100644
--- a/problems/0343.整数拆分.md
+++ b/problems/0343.整数拆分.md
@@ -192,7 +192,7 @@ public:
 ## 其他语言版本
 
 
-### Java 
+### Java
 ```Java
 class Solution {
     public int integerBreak(int n) {
@@ -259,6 +259,21 @@ func max(a,b int) int{
 }
 ```
 
+### Rust
+```rust
+pub fn integer_break(n: i32) -> i32 {
+    let n = n as usize;
+    let mut dp = vec![0; n + 1];
+    dp[2] = 1;
+    for i in 3..=n {
+        for j in 1..i-1 {
+            dp[i] = dp[i].max((i - j) * j).max(dp[i - j] * j);
+        }
+    }
+    dp[n] as i32
+}
+```
+
 ### Javascript
 ```Javascript
 var integerBreak = function(n) {
@@ -299,6 +314,27 @@ function integerBreak(n: number): number {
 };
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    fn max(a: i32, b: i32) -> i32{
+        if a > b { a } else { b }
+    }
+    pub fn integer_break(n: i32) -> i32 {
+        let n = n as usize;
+        let mut dp = vec![0; n + 1];
+        dp[2] = 1;
+        for i in 3..=n {
+            for j in 1..i - 1 {
+                dp[i] = Self::max(dp[i], Self::max(((i - j) * j) as i32, dp[i - j] * j as i32));
+            }
+        }
+        dp[n]
+    }
+}
+```
+
 ### C
 
 ```c
diff --git a/problems/0376.摆动序列.md b/problems/0376.摆动序列.md
index a41a0f0a..d15ed2d0 100644
--- a/problems/0376.摆动序列.md
+++ b/problems/0376.摆动序列.md
@@ -266,22 +266,58 @@ class Solution:
 
 ### Go 
 
+**贪心**
 ```golang
 func wiggleMaxLength(nums []int) int {
-    var count,preDiff,curDiff  int
-    count=1
-    if len(nums)<2{
-        return count
-    }
-    for i:=0;i<len(nums)-1;i++{
-        curDiff=nums[i+1]-nums[i]
-        //如果有正有负则更新下标值||或者只有前一个元素为0（针对两个不等元素的序列也视作摆动序列，且摆动长度为2）
-        if (curDiff > 0 && preDiff <= 0) || (preDiff >= 0 && curDiff < 0){
-            preDiff=curDiff
-            count++
-        }
-    }
-    return count
+	var count, preDiff, curDiff int //初始化默认为0
+	count = 1                       // 初始化为1，因为最小的序列是1个数
+	if len(nums) < 2 {
+		return count
+	}
+	for i := 0; i < len(nums)-1; i++ {
+		curDiff = nums[i+1] - nums[i]
+		if (curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0) {
+			count++
+		}
+	}
+	return count
+}
+```
+
+**动态规划**
+```golang
+func wiggleMaxLength(nums []int) int {
+	n := len(nums)
+	if n <= 1 {
+		return n
+	}
+	dp := make([][2]int, n)
+	//  i 0 作为波峰的最大长度
+	//  i 1 作为波谷的最大长度
+	dp[0][0] = 1
+	dp[0][1] = 1
+	for i := 0; i < n; i++ {
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[i] { //nums[i]为波谷
+				dp[i][1] = max(dp[i][1], dp[j][0]+1)
+			}
+			if nums[j] < nums[i] { //nums[i]为波峰 或者相等
+				dp[i][0] = max(dp[i][0], dp[j][1]+1)
+			}
+			if nums[j] == nums[i] { //添加一种情况，nums[i]为相等
+				dp[i][0] = max(dp[i][0], dp[j][0]) //波峰
+				dp[i][1] = max(dp[i][1], dp[j][1]) //波谷
+			}
+		}
+	}
+	return max(dp[n-1][0], dp[n-1][1])
+}
+func max(a, b int) int {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
 }
 ```
 
diff --git a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
index 6e4a86eb..c573f00d 100644
--- a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
+++ b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
@@ -221,8 +221,46 @@ function maxProfit(prices: number[], fee: number): number {
 };
 ```
 
+Rust:
+**贪心**
+```Rust
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>, fee: i32) -> i32 {
+        let mut result = 0;
+        let mut min_price = prices[0];
+        for i in 1..prices.len() {
+            if prices[i] < min_price { min_price = prices[i]; }
 
+            // if prices[i] >= min_price && prices[i] <= min_price + fee { continue; }
 
+            if prices[i] > min_price + fee {
+                result += prices[i] - min_price - fee;
+                min_price = prices[i] - fee;
+            }
+        }
+        result
+    }
+}
+```
+
+**动态规划**
+```Rust
+impl Solution {
+    fn max(a: i32, b: i32) -> i32 {
+        if a > b { a } else { b }
+    }
+    pub fn max_profit(prices: Vec<i32>, fee: i32) -> i32 {
+        let n = prices.len();
+        let mut dp = vec![vec![0; 2]; n];
+        dp[0][0] -= prices[0];
+        for i in 1..n {
+            dp[i][0] = Self::max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+            dp[i][1] = Self::max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
+        }
+        Self::max(dp[n - 1][0], dp[n - 1][1])
+    }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
diff --git a/problems/0738.单调递增的数字.md b/problems/0738.单调递增的数字.md
index 6b7381f3..b452d02d 100644
--- a/problems/0738.单调递增的数字.md
+++ b/problems/0738.单调递增的数字.md
@@ -278,5 +278,26 @@ object Solution {
 }
 ```
 
+### Rust
+
+```Rust
+impl Solution {
+    pub fn monotone_increasing_digits(n: i32) -> i32 {
+        let mut str_num = n.to_string().chars().map(|x| x.to_digit(10).unwrap() as i32).collect::<Vec<i32>>();
+        let mut flag = str_num.len();
+        for i in (1..str_num.len()).rev() {
+            if str_num[i - 1] > str_num[i] {
+                flag = i;
+                str_num[i - 1] -= 1;
+            }
+        }
+        for i in flag..str_num.len() {
+            str_num[i] = 9;
+        }
+        str_num.iter().fold(0, |acc, x| acc * 10 + x)
+    }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
diff --git a/problems/0922.按奇偶排序数组II.md b/problems/0922.按奇偶排序数组II.md
index 49547a15..4e281a3c 100644
--- a/problems/0922.按奇偶排序数组II.md
+++ b/problems/0922.按奇偶排序数组II.md
@@ -147,6 +147,59 @@ class Solution {
 }
 ```
 
+### java
+
+```java
+//方法一：采用额外的数组空间
+class Solution {
+    public int[] sortArrayByParityII(int[] nums) {
+        //定义结果数组 result
+        int[] result = new int[nums.length];
+        int even = 0, odd = 1;
+        for(int i = 0; i < nums.length; i++){
+            //如果为偶数
+            if(nums[i] % 2 == 0){
+                result[even] = nums[i];
+                even += 2;
+            }else{
+                result[odd] = nums[i];
+                odd += 2;
+            }
+        }
+        return result;
+    }
+}
+```
+```java
+//方法二：不采用额外的数组空间
+class Solution922 {
+    public int[] sortArrayByParityII(int[] nums) {
+        //定义双指针
+        int oddPoint = 1, evenPoint = 0;
+        //开始移动并交换，最后一层必然为相互交换后再移动或者相同直接移动
+        while(oddPoint < nums.length && evenPoint < nums.length){
+            //进行判断
+            if(nums[oddPoint] % 2 == 0 && nums[evenPoint] % 2 == 1){    //如果均不满足
+                int temp = 0;
+                temp = nums[oddPoint];
+                nums[oddPoint] = nums[evenPoint];
+                nums[evenPoint] = temp;
+                oddPoint += 2;
+                evenPoint += 2;
+            }else if(nums[oddPoint] % 2 == 0 && nums[evenPoint] % 2 == 0){  //偶数满足
+                evenPoint += 2;
+            }else if(nums[oddPoint] % 2 == 1 && nums[evenPoint] % 2 == 1){  //奇数满足
+                oddPoint += 2;
+            }else{
+                oddPoint += 2;
+                evenPoint += 2;
+            }
+        }
+        return nums;
+    }
+}
+```
+
 ### Python3
 
 ```python