From 36f630b109a93685bb241884e5584b327028d5f5 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Tue, 3 May 2022 12:34:20 +0800
Subject: [PATCH 01/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=88=E8=83=8C?=
=?UTF-8?q?=E5=8C=85=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=8001=E8=83=8C?=
=?UTF-8?q?=E5=8C=85-2.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-2.md | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index dabdfb2d..bb5e3a03 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -315,6 +315,30 @@ function test () {
test();
```
+### TypeScript
+
+```typescript
+function testWeightBagProblem(
+ weight: number[],
+ value: number[],
+ size: number
+): number {
+ const goodsNum: number = weight.length;
+ const dp: number[] = new Array(size + 1).fill(0);
+ for (let i = 0; i < goodsNum; i++) {
+ for (let j = size; j >= weight[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
+ }
+ }
+ return dp[size];
+}
+const weight = [1, 3, 4];
+const value = [15, 20, 30];
+const size = 4;
+console.log(testWeightBagProblem(weight, value, size));
+
+```
+
-----------------------
From d692ffe034aa1d7af9a4e5d76999ee6a506c23b9 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Tue, 3 May 2022 21:51:21 +0800
Subject: [PATCH 02/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880416.=E5=88=86?=
=?UTF-8?q?=E5=89=B2=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md=EF=BC=89?=
=?UTF-8?q?=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0416.分割等和子集.md | 55 +++++++++++++++++++++++++++++
1 file changed, 55 insertions(+)
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index b24fb365..20b7782d 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -416,6 +416,61 @@ var canPartition = function(nums) {
};
```
+TypeScript:
+
+> 一维数组，简洁
+
+```typescript
+function canPartition(nums: number[]): boolean {
+ const sum: number = nums.reduce((pre, cur) => pre + cur);
+ if (sum % 2 === 1) return false;
+ const bagSize: number = sum / 2;
+ const goodsNum: number = nums.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ for (let i = 0; i < goodsNum; i++) {
+ for (let j = bagSize; j >= nums[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
+ }
+ }
+ return dp[bagSize] === bagSize;
+};
+```
+
+> 二维数组，易懂
+
+```typescript
+function canPartition(nums: number[]): boolean {
+ /**
+ weightArr = nums;
+ valueArr = nums;
+ bagSize = sum / 2; (sum为nums各元素总和);
+ 按照0-1背包处理
+ */
+ const sum: number = nums.reduce((pre, cur) => pre + cur);
+ if (sum % 2 === 1) return false;
+ const bagSize: number = sum / 2;
+ const weightArr: number[] = nums;
+ const valueArr: number[] = nums;
+ const goodsNum: number = weightArr.length;
+ const dp: number[][] = new Array(goodsNum)
+ .fill(0)
+ .map(_ => new Array(bagSize + 1).fill(0));
+ for (let i = weightArr[0]; i <= bagSize; i++) {
+ dp[0][i] = valueArr[0];
+ }
+ for (let i = 1; i < goodsNum; i++) {
+ for (let j = 0; j <= bagSize; j++) {
+ if (j < weightArr[i]) {
+ dp[i][j] = dp[i - 1][j];
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weightArr[i]] + valueArr[i]);
+ }
+ }
+ }
+ return dp[goodsNum - 1][bagSize] === bagSize;
+};
+```
+
From 65cde78559bf18cced2e91b57fba8f92a66437a4 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 4 May 2022 12:57:05 +0800
Subject: [PATCH 03/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=881049.=E6=9C=80?=
=?UTF-8?q?=E5=90=8E=E4=B8=80=E5=9D=97=E7=9F=B3=E5=A4=B4=E7=9A=84=E9=87=8D?=
=?UTF-8?q?=E9=87=8FII.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../1049.最后一块石头的重量II.md | 21 +++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md
index ee0ddef2..3d256c3d 100644
--- a/problems/1049.最后一块石头的重量II.md
+++ b/problems/1049.最后一块石头的重量II.md
@@ -277,5 +277,26 @@ var lastStoneWeightII = function (stones) {
};
```
+TypeScript：
+
+```typescript
+function lastStoneWeightII(stones: number[]): number {
+ const sum: number = stones.reduce((pre, cur) => pre + cur);
+ const bagSize: number = Math.floor(sum / 2);
+ const weightArr: number[] = stones;
+ const valueArr: number[] = stones;
+ const goodsNum: number = weightArr.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ for (let i = 0; i < goodsNum; i++) {
+ for (let j = bagSize; j >= weightArr[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - weightArr[i]] + valueArr[i]);
+ }
+ }
+ return sum - dp[bagSize] * 2;
+};
+```
+
+
+
-----------------------
From b82984e24b23940aa95da2a0283ae4cf3c706f7a Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 5 May 2022 18:11:41 +0800
Subject: [PATCH 07/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880518.=E9=9B=B6?=
=?UTF-8?q?=E9=92=B1=E5=85=91=E6=8D=A2II.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0518.零钱兑换II.md | 15 +++++++++++++++
1 file changed, 15 insertions(+)
diff --git a/problems/0518.零钱兑换II.md b/problems/0518.零钱兑换II.md
index e72c5f85..8faf6698 100644
--- a/problems/0518.零钱兑换II.md
+++ b/problems/0518.零钱兑换II.md
@@ -258,6 +258,21 @@ const change = (amount, coins) => {
}
```
+TypeScript：
+
+```typescript
+function change(amount: number, coins: number[]): number {
+ const dp: number[] = new Array(amount + 1).fill(0);
+ dp[0] = 1;
+ for (let i = 0, length = coins.length; i < length; i++) {
+ for (let j = coins[i]; j <= amount; j++) {
+ dp[j] += dp[j - coins[i]];
+ }
+ }
+ return dp[amount];
+};
+```
+
-----------------------
From cb7bf67a4e3a277ecf53ce37d0556c8e2e65f9f3 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 6 May 2022 11:08:47 +0800
Subject: [PATCH 08/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880377.=E7=BB=84?=
=?UTF-8?q?=E5=90=88=E6=80=BB=E5=92=8C=E2=85=A3.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0377.组合总和Ⅳ.md | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/problems/0377.组合总和Ⅳ.md b/problems/0377.组合总和Ⅳ.md
index aaf27e61..1d808a3a 100644
--- a/problems/0377.组合总和Ⅳ.md
+++ b/problems/0377.组合总和Ⅳ.md
@@ -221,7 +221,27 @@ const combinationSum4 = (nums, target) => {
};
```
+TypeScript：
+
+```typescript
+function combinationSum4(nums: number[], target: number): number {
+ const dp: number[] = new Array(target + 1).fill(0);
+ dp[0] = 1;
+ // 遍历背包
+ for (let i = 1; i <= target; i++) {
+ // 遍历物品
+ for (let j = 0, length = nums.length; j < length; j++) {
+ if (i >= nums[j]) {
+ dp[i] += dp[i - nums[j]];
+ }
+ }
+ }
+ return dp[target];
+};
+```
+
Rust
+
```Rust
impl Solution {
pub fn combination_sum4(nums: Vec, target: i32) -> i32 {
From 100a4e2b46abf913dacc62637da7faf27bfe060e Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 6 May 2022 11:56:19 +0800
Subject: [PATCH 09/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880070.=E7=88=AC?=
=?UTF-8?q?=E6=A5=BC=E6=A2=AF=E5=AE=8C=E5=85=A8=E8=83=8C=E5=8C=85=E7=89=88?=
=?UTF-8?q?=E6=9C=AC.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0070.爬楼梯完全背包版本.md | 22 ++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/problems/0070.爬楼梯完全背包版本.md b/problems/0070.爬楼梯完全背包版本.md
index 2286de2d..0f482bb7 100644
--- a/problems/0070.爬楼梯完全背包版本.md
+++ b/problems/0070.爬楼梯完全背包版本.md
@@ -199,6 +199,28 @@ var climbStairs = function(n) {
};
```
+TypeScript：
+
+```typescript
+function climbStairs(n: number): number {
+ const m: number = 2; // 本题m为2
+ const dp: number[] = new Array(n + 1).fill(0);
+ dp[0] = 1;
+ // 遍历背包
+ for (let i = 1; i <= n; i++) {
+ // 遍历物品
+ for (let j = 1; j <= m; j++) {
+ if (j <= i) {
+ dp[i] += dp[i - j];
+ }
+ }
+ }
+ return dp[n];
+};
+```
+
+
+
-----------------------
From cb6f015186ae9d6af13cddf9b929f7bbdfe9bc29 Mon Sep 17 00:00:00 2001
From: cy948 <67412196+cy948@users.noreply.github.com>
Date: Fri, 6 May 2022 14:43:58 +0800
Subject: [PATCH 10/99] =?UTF-8?q?Update=200112.=E8=B7=AF=E5=BE=84=E6=80=BB?=
=?UTF-8?q?=E5=92=8C.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
修复了 0113.路径总和-ii 中Java递归解法中的类名大小写问题。
---
problems/0112.路径总和.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 41463ec1..2fdd7741 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -377,22 +377,22 @@ class solution {
```java
class solution {
- public list> pathsum(treenode root, int targetsum) {
- list> res = new arraylist<>();
+ public List> pathsum(TreeNode root, int targetsum) {
+ List> res = new ArrayList<>();
if (root == null) return res; // 非空判断
-
- list path = new linkedlist<>();
+
+ List path = new LinkedList<>();
preorderdfs(root, targetsum, res, path);
return res;
}
- public void preorderdfs(treenode root, int targetsum, list> res, list path) {
+ public void preorderdfs(TreeNode root, int targetsum, List> res, List path) {
path.add(root.val);
// 遇到了叶子节点
if (root.left == null && root.right == null) {
// 找到了和为 targetsum 的路径
if (targetsum - root.val == 0) {
- res.add(new arraylist<>(path));
+ res.add(new ArrayList<>(path));
}
return; // 如果和不为 targetsum，返回
}
From 82a58bc20249bb248dbbb0d90771db0ea60bf017 Mon Sep 17 00:00:00 2001
From: Jamcy123 <1219502823@qq.com>
Date: Fri, 6 May 2022 15:49:43 +0800
Subject: [PATCH 11/99] =?UTF-8?q?1005.K=E6=AC=A1=E5=8F=96=E5=8F=8D?=
=?UTF-8?q?=E5=90=8E=E6=9C=80=E5=A4=A7=E5=8C=96=E7=9A=84=E6=95=B0=E7=BB=84?=
=?UTF-8?q?=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../1005.K次取反后最大化的数组和.md | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 79767deb..202534da 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -209,6 +209,22 @@ var largestSumAfterKNegations = function(nums, k) {
return a + b
})
};
+
+// 版本二 (优化: 一次遍历)
+var largestSumAfterKNegations = function(nums, k) {
+ nums.sort((a, b) => Math.abs(b) - Math.abs(a)); // 排序
+ let sum = 0;
+ for(let i = 0; i < nums.length; i++) {
+ if(nums[i] < 0 && k-- > 0) { // 负数取反（k 数量足够时）
+ nums[i] = -nums[i];
+ }
+ sum += nums[i]; // 求和
+ }
+ if(k % 2 > 0) { // k 有多余的（k若消耗完则应为 -1）
+ sum -= 2 * nums[nums.length - 1]; // 减去两倍的最小值（因为之前加过一次）
+ }
+ return sum;
+};
```
From da464016574f14c43fe1e9f7c0d808ed7ea304fb Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Sun, 8 May 2022 10:29:33 +0800
Subject: [PATCH 12/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880322.=E9=9B=B6?=
=?UTF-8?q?=E9=92=B1=E5=85=91=E6=8D=A2.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0322.零钱兑换.md | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/problems/0322.零钱兑换.md b/problems/0322.零钱兑换.md
index 3a8d0662..1df8d613 100644
--- a/problems/0322.零钱兑换.md
+++ b/problems/0322.零钱兑换.md
@@ -322,7 +322,21 @@ const coinChange = (coins, amount) => {
}
```
+TypeScript：
+```typescript
+function coinChange(coins: number[], amount: number): number {
+ const dp: number[] = new Array(amount + 1).fill(Infinity);
+ dp[0] = 0;
+ for (let i = 0; i < coins.length; i++) {
+ for (let j = coins[i]; j <= amount; j++) {
+ if (dp[j - coins[i]] === Infinity) continue;
+ dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
+ }
+ }
+ return dp[amount] === Infinity ? -1 : dp[amount];
+};
+```
-----------------------
From 2722fe7b5eceec7d746f94a63683430205839469 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Sun, 8 May 2022 11:07:39 +0800
Subject: [PATCH 13/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880279.=E5=AE=8C?=
=?UTF-8?q?=E5=85=A8=E5=B9=B3=E6=96=B9=E6=95=B0.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0279.完全平方数.md | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/problems/0279.完全平方数.md b/problems/0279.完全平方数.md
index 9bad2085..5b15639c 100644
--- a/problems/0279.完全平方数.md
+++ b/problems/0279.完全平方数.md
@@ -355,5 +355,24 @@ var numSquares2 = function(n) {
};
```
+TypeScript：
+
+```typescript
+function numSquares(n: number): number {
+ const goodsNum: number = Math.floor(Math.sqrt(n));
+ const dp: number[] = new Array(n + 1).fill(Infinity);
+ dp[0] = 0;
+ for (let i = 1; i <= goodsNum; i++) {
+ const tempVal: number = i * i;
+ for (let j = tempVal; j <= n; j++) {
+ dp[j] = Math.min(dp[j], dp[j - tempVal] + 1);
+ }
+ }
+ return dp[n];
+};
+```
+
+
+
-----------------------
From 9b6a447674f3290541e46088962e1e3aa764d827 Mon Sep 17 00:00:00 2001
From: Hayden-Chang <62008508+Hayden-Chang@users.noreply.github.com>
Date: Sun, 8 May 2022 14:20:09 +0800
Subject: [PATCH 14/99] explain the reason for reverse traversal
---
problems/背包理论基础01背包-2.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index dabdfb2d..ea7c53ad 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -136,6 +136,7 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
不可以！
因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。
+倒叙遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
（这里如果读不懂，就在回想一下dp[j]的定义，或者就把两个for循环顺序颠倒一下试试！）
From 80167289e4895c4116b61a5c2a4fa22e9e2e88b5 Mon Sep 17 00:00:00 2001
From: Hayden-Chang <62008508+Hayden-Chang@users.noreply.github.com>
Date: Sun, 8 May 2022 14:24:09 +0800
Subject: [PATCH 15/99] =?UTF-8?q?Update=20=E8=83=8C=E5=8C=85=E7=90=86?=
=?UTF-8?q?=E8=AE=BA=E5=9F=BA=E7=A1=8001=E8=83=8C=E5=8C=85-2.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-2.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index ea7c53ad..eae01158 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -136,7 +136,8 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
不可以！
因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。
-倒叙遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
+
+倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
（这里如果读不懂，就在回想一下dp[j]的定义，或者就把两个for循环顺序颠倒一下试试！）
From 2fb34b30b38ee73624d65d183955cef3a80caced Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Sun, 8 May 2022 18:28:32 +0800
Subject: [PATCH 16/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880139.=E5=8D=95?=
=?UTF-8?q?=E8=AF=8D=E6=8B=86=E5=88=86.md=EF=BC=89:=E5=A2=9E=E5=8A=A0types?=
=?UTF-8?q?cript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0139.单词拆分.md | 42 +++++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index ac834f04..5b4e92b9 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -345,6 +345,48 @@ const wordBreak = (s, wordDict) => {
}
```
+TypeScript：
+
+> 动态规划
+
+```typescript
+function wordBreak(s: string, wordDict: string[]): boolean {
+ const dp: boolean[] = new Array(s.length + 1).fill(false);
+ dp[0] = true;
+ for (let i = 1; i <= s.length; i++) {
+ for (let j = 0; j < i; j++) {
+ const tempStr: string = s.slice(j, i);
+ if (wordDict.includes(tempStr) && dp[j] === true) {
+ dp[i] = true;
+ break;
+ }
+ }
+ }
+ return dp[s.length];
+};
+```
+
+> 记忆化回溯
+
+```typescript
+function wordBreak(s: string, wordDict: string[]): boolean {
+ // 只需要记忆结果为false的情况
+ const memory: boolean[] = [];
+ return backTracking(s, wordDict, 0, memory);
+ function backTracking(s: string, wordDict: string[], startIndex: number, memory: boolean[]): boolean {
+ if (startIndex >= s.length) return true;
+ if (memory[startIndex] === false) return false;
+ for (let i = startIndex + 1, length = s.length; i <= length; i++) {
+ const str: string = s.slice(startIndex, i);
+ if (wordDict.includes(str) && backTracking(s, wordDict, i, memory))
+ return true;
+ }
+ memory[startIndex] = false;
+ return false;
+ }
+};
+```
+
-----------------------
From 21475ad21864ce33fb5a6a113581f2c346be78b6 Mon Sep 17 00:00:00 2001
From: languagege
Date: Mon, 9 May 2022 18:51:39 +0800
Subject: [PATCH 17/99] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E4=BA=86=E5=85=B6?=
=?UTF-8?q?=E4=B8=AD=E4=B8=80=E4=B8=AA=E9=94=99=E5=88=AB=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0027.移除元素.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..3a93ac88 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -81,7 +81,7 @@ public:
**双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。**
-后序都会一一介绍到，本题代码如下：
+后续都会一一介绍到，本题代码如下：
```CPP
// 时间复杂度：O(n)
From 75198263f91484020c4a4dde421d9ecd989422dd Mon Sep 17 00:00:00 2001
From: changjunkui <506678275@qq.com>
Date: Tue, 10 May 2022 08:16:53 +0800
Subject: [PATCH 18/99] =?UTF-8?q?Update=200019.=E5=88=A0=E9=99=A4=E9=93=BE?=
=?UTF-8?q?=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=ACN=E4=B8=AA?=
=?UTF-8?q?=E8=8A=82=E7=82=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
方面改为方便
---
problems/0019.删除链表的倒数第N个节点.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 813e9b02..b3030a81 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -39,7 +39,7 @@
分为如下几步：
-* 首先这里我推荐大家使用虚拟头结点，这样方面处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
+* 首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
* 定义fast指针和slow指针，初始值为虚拟头结点，如图：
From c62d518e149295783d219ec1871da84af8e5546e Mon Sep 17 00:00:00 2001
From: FizzerYu <36132150+FizzerYu@users.noreply.github.com>
Date: Wed, 11 May 2022 01:17:08 +0800
Subject: [PATCH 19/99] fix bug
---
problems/0701.二叉搜索树中的插入操作.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md
index df6a3954..50e39ade 100644
--- a/problems/0701.二叉搜索树中的插入操作.md
+++ b/problems/0701.二叉搜索树中的插入操作.md
@@ -279,7 +279,7 @@ class Solution:
root.right = self.insertIntoBST(root.right, val)
# 返回更新后的以当前root为根节点的新树
- return roo
+ return root
```
**递归法** - 无返回值
From d92aa2c52f0589cca9dbf1a7624f9312395b63fe Mon Sep 17 00:00:00 2001
From: unknown
Date: Wed, 11 May 2022 00:39:59 +0100
Subject: [PATCH 20/99] =?UTF-8?q?Add=200112.=E8=B7=AF=E5=BE=84=E6=80=BB?=
=?UTF-8?q?=E5=92=8C.md=20C=E8=AF=AD=E8=A8=80=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0112.路径总和.md | 57 +++++++++++++++++++++++++++++++++++
1 file changed, 57 insertions(+)
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 41463ec1..6433996c 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -1006,6 +1006,63 @@ func traversal(_ cur: TreeNode?, count: Int) {
}
```
+## C
+0112.路径总和
+递归法：
+```c
+bool hasPathSum(struct TreeNode* root, int targetSum){
+ // 递归结束条件：若当前节点不存在，返回false
+ if(!root)
+ return false;
+ // 若当前节点为叶子节点，且targetSum-root的值为0。（当前路径上的节点值的和满足条件）返回true
+ if(!root->right && !root->left && targetSum == root->val)
+ return true;
+
+ // 查看左子树和右子树的所有节点是否满足条件
+ return hasPathSum(root->right, targetSum - root->val) || hasPathSum(root->left, targetSum - root->val);
+}
+```
+
+迭代法:
+```c
+// 存储一个节点以及当前的和
+struct Pair {
+ struct TreeNode* node;
+ int sum;
+};
+
+bool hasPathSum(struct TreeNode* root, int targetSum){
+ struct Pair stack[1000];
+ int stackTop = 0;
+
+ // 若root存在，则将节点和值封装成一个pair入栈
+ if(root) {
+ struct Pair newPair = {root, root->val};
+ stack[stackTop++] = newPair;
+ }
+
+ // 当栈不为空时
+ while(stackTop) {
+ // 出栈栈顶元素
+ struct Pair topPair = stack[--stackTop];
+ // 若栈顶元素为叶子节点，且和为targetSum时，返回true
+ if(!topPair.node->left && !topPair.node->right && topPair.sum == targetSum)
+ return true;
+
+ // 若当前栈顶节点有左右孩子，计算和并入栈
+ if(topPair.node->left) {
+ struct Pair newPair = {topPair.node->left, topPair.sum + topPair.node->left->val};
+ stack[stackTop++] = newPair;
+ }
+ if(topPair.node->right) {
+ struct Pair newPair = {topPair.node->right, topPair.sum + topPair.node->right->val};
+ stack[stackTop++] = newPair;
+ }
+ }
+ return false;
+}
+```
+
-----------------------
From cc2c2adb0987a5e2e82eed75a93be068da6388a4 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 16:03:22 +0800
Subject: [PATCH 21/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200977.=E6=9C=89?=
=?UTF-8?q?=E5=BA=8F=E6=95=B0=E7=BB=84=E7=9A=84=E5=B9=B3=E6=96=B9.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0977.有序数组的平方.md | 34 ++++++++++++++++++++++++++
1 file changed, 34 insertions(+)
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 24276bcf..0e79a3d6 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -358,7 +358,41 @@ class Solution {
}
}
```
+Scala:
+双指针:
+```scala
+object Solution {
+ def sortedSquares(nums: Array[Int]): Array[Int] = {
+ val res: Array[Int] = new Array[Int](nums.length)
+ var top = nums.length - 1
+ var i = 0
+ var j = nums.length - 1
+ while (i <= j) {
+ if (nums(i) * nums(i) <= nums(j) * nums(j)) {
+ // 当左侧平方小于等于右侧，res数组顶部放右侧的平方，并且top下移，j左移
+ res(top) = nums(j) * nums(j)
+ top -= 1
+ j -= 1
+ } else {
+ // 当左侧平方大于右侧，res数组顶部放左侧的平方，并且top下移，i右移
+ res(top) = nums(i) * nums(i)
+ top -= 1
+ i += 1
+ }
+ }
+ res
+ }
+}
+```
+骚操作(暴力思路):
+```scala
+object Solution {
+ def sortedSquares(nums: Array[Int]): Array[Int] = {
+ nums.map(x=>{x*x}).sortWith(_ < _)
+ }
+}
+```
-----------------------
From 842c04208b163c4782fb7070d949f5feb0c01bee Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 16:35:58 +0800
Subject: [PATCH 22/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=88=E8=83=8C?=
=?UTF-8?q?=E5=8C=85=E9=97=AE=E9=A2=98=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80?=
=?UTF-8?q?=E5=A4=9A=E9=87=8D=E8=83=8C=E5=8C=85.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../背包问题理论基础多重背包.md | 58 +++++++++++++++++++
1 file changed, 58 insertions(+)
diff --git a/problems/背包问题理论基础多重背包.md b/problems/背包问题理论基础多重背包.md
index a988db2c..712380f4 100644
--- a/problems/背包问题理论基础多重背包.md
+++ b/problems/背包问题理论基础多重背包.md
@@ -334,6 +334,64 @@ func Test_multiplePack(t *testing.T) {
PASS
```
+TypeScript：
+
+> 版本一（改变数据源）：
+
+```typescript
+function testMultiPack() {
+ const bagSize: number = 10;
+ const weightArr: number[] = [1, 3, 4],
+ valueArr: number[] = [15, 20, 30],
+ amountArr: number[] = [2, 3, 2];
+ for (let i = 0, length = amountArr.length; i < length; i++) {
+ while (amountArr[i] > 1) {
+ weightArr.push(weightArr[i]);
+ valueArr.push(valueArr[i]);
+ amountArr[i]--;
+ }
+ }
+ const goodsNum: number = weightArr.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ // 遍历物品
+ for (let i = 0; i < goodsNum; i++) {
+ // 遍历背包容量
+ for (let j = bagSize; j >= weightArr[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - weightArr[i]] + valueArr[i]);
+ }
+ }
+ console.log(dp);
+}
+testMultiPack();
+```
+
+> 版本二（改变遍历方式）：
+
+```typescript
+function testMultiPack() {
+ const bagSize: number = 10;
+ const weightArr: number[] = [1, 3, 4],
+ valueArr: number[] = [15, 20, 30],
+ amountArr: number[] = [2, 3, 2];
+ const goodsNum: number = weightArr.length;
+ const dp: number[] = new Array(bagSize + 1).fill(0);
+ // 遍历物品
+ for (let i = 0; i < goodsNum; i++) {
+ // 遍历物品个数
+ for (let j = 0; j < amountArr[i]; j++) {
+ // 遍历背包容量
+ for (let k = bagSize; k >= weightArr[i]; k--) {
+ dp[k] = Math.max(dp[k], dp[k - weightArr[i]] + valueArr[i]);
+ }
+ }
+ }
+ console.log(dp);
+}
+testMultiPack();
+```
+
+
+
-----------------------
From 871d96a2f9202504f2f5c754da7404f602a9f073 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 16:48:59 +0800
Subject: [PATCH 23/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200209.=E9=95=BF?=
=?UTF-8?q?=E5=BA=A6=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0209.长度最小的子数组.md | 48 +++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index fd72cf1b..78b8156c 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -400,6 +400,54 @@ class Solution {
}
}
```
+Scala:
+
+滑动窗口:
+```scala
+object Solution {
+ def minSubArrayLen(target: Int, nums: Array[Int]): Int = {
+ var result = Int.MaxValue // 返回结果，默认最大值
+ var left = 0 // 慢指针，当sum>=target，向右移动
+ var sum = 0 // 窗口值的总和
+ for (right <- 0 until nums.length) {
+ sum += nums(right)
+ while (sum >= target) {
+ result = math.min(result, right - left + 1) // 产生新结果
+ sum -= nums(left) // 左指针移动，窗口总和减去左指针的值
+ left += 1 // 左指针向右移动
+ }
+ }
+ // 相当于三元运算符，return关键字可以省略
+ if (result == Int.MaxValue) 0 else result
+ }
+}
+```
+
+暴力解法:
+```scala
+object Solution {
+ def minSubArrayLen(target: Int, nums: Array[Int]): Int = {
+ import scala.util.control.Breaks
+ var res = Int.MaxValue
+ var subLength = 0
+ for (i <- 0 until nums.length) {
+ var sum = 0
+ Breaks.breakable(
+ for (j <- i until nums.length) {
+ sum += nums(j)
+ if (sum >= target) {
+ subLength = j - i + 1
+ res = math.min(subLength, res)
+ Breaks.break()
+ }
+ }
+ )
+ }
+ // 相当于三元运算符
+ if (res == Int.MaxValue) 0 else res
+ }
+}
+```
-----------------------
From cb2fea63e7f5e616f697a715b9d523b6ba877308 Mon Sep 17 00:00:00 2001
From: unknown
Date: Wed, 11 May 2022 09:50:47 +0100
Subject: [PATCH 24/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200113.=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8CII=20C=E8=AF=AD=E8=A8=80=E8=A7=A3?=
=?UTF-8?q?=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0112.路径总和.md | 65 ++++++++++++++++++++++++++++++++++-
1 file changed, 64 insertions(+), 1 deletion(-)
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 6433996c..de155b45 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -1007,7 +1007,7 @@ func traversal(_ cur: TreeNode?, count: Int) {
```
## C
-0112.路径总和
+> 0112.路径总和
递归法：
```c
bool hasPathSum(struct TreeNode* root, int targetSum){
@@ -1062,6 +1062,69 @@ bool hasPathSum(struct TreeNode* root, int targetSum){
return false;
}
```
+> 0113.路径总和 II
+```c
+int** ret;
+int* path;
+int* colSize;
+int retTop;
+int pathTop;
+
+void traversal(const struct TreeNode* const node, int count) {
+ // 若当前节点为叶子节点
+ if(!node->right && !node->left) {
+ // 若当前path上的节点值总和等于targetSum。
+ if(count == 0) {
+ // 复制当前path
+ int *curPath = (int*)malloc(sizeof(int) * pathTop);
+ memcpy(curPath, path, sizeof(int) * pathTop);
+ // 记录当前path的长度为pathTop
+ colSize[retTop] = pathTop;
+ // 将当前path加入到ret数组中
+ ret[retTop++] = curPath;
+ }
+ return;
+ }
+
+ // 若节点有左/右孩子
+ if(node->left) {
+ // 将左孩子的值加入path中
+ path[pathTop++] = node->left->val;
+ traversal(node->left, count - node->left->val);
+ // 回溯
+ pathTop--;
+ }
+ if(node->right) {
+ // 将右孩子的值加入path中
+ path[pathTop++] = node->right->val;
+ traversal(node->right, count - node->right->val);
+ // 回溯
+ --pathTop;
+ }
+}
+
+int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes){
+ // 初始化数组
+ ret = (int**)malloc(sizeof(int*) * 1000);
+ path = (int*)malloc(sizeof(int*) * 1000);
+ colSize = (int*)malloc(sizeof(int) * 1000);
+ retTop = pathTop = 0;
+ *returnSize = 0;
+
+ // 若根节点不存在，返回空的ret
+ if(!root)
+ return ret;
+ // 将根节点加入到path中
+ path[pathTop++] = root->val;
+ traversal(root, targetSum - root->val);
+
+ // 设置返回ret数组大小，以及其中每个一维数组元素的长度
+ *returnSize = retTop;
+ *returnColumnSizes = colSize;
+
+ return ret;
+}
+```
From c363e9da86973e5dafaa5e765c9c6318b5eb9723 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 16:59:05 +0800
Subject: [PATCH 25/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880198.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8D.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0198.打家劫舍.md | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
index dfe1f3a0..a828b9a9 100644
--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@@ -189,6 +189,29 @@ const rob = nums => {
};
```
+TypeScript：
+
+```typescript
+function rob(nums: number[]): number {
+ /**
+ dp[i]: 前i个房屋能偷到的最大金额
+ dp[0]: nums[0];
+ dp[1]: max(nums[0], nums[1]);
+ ...
+ dp[i]: max(dp[i-1], dp[i-2]+nums[i]);
+ */
+ const length: number = nums.length;
+ if (length === 1) return nums[0];
+ const dp: number[] = [];
+ dp[0] = nums[0];
+ dp[1] = Math.max(nums[0], nums[1]);
+ for (let i = 2; i < length; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ return dp[length - 1];
+};
+```
+
From a8cfc460e7143e6b6d8486ad9e8d88e1c9759211 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 17:37:12 +0800
Subject: [PATCH 26/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200059.=E8=9E=BA?=
=?UTF-8?q?=E6=97=8B=E7=9F=A9=E9=98=B5II.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0059.螺旋矩阵II.md | 51 +++++++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index a7b19a34..f3b8e1ce 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -564,6 +564,57 @@ int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
return ans;
}
```
+Scala:
+```scala
+object Solution {
+ def generateMatrix(n: Int): Array[Array[Int]] = {
+ var res = Array.ofDim[Int](n, n) // 定义一个n*n的二维矩阵
+ var num = 1 // 标志当前到了哪个数字
+ var i = 0 // 横坐标
+ var j = 0 // 竖坐标
+ while (num <= n * n) {
+ // 向右：当j不越界，并且下一个要填的数字是空白时
+ while (j < n && res(i)(j) == 0) {
+ res(i)(j) = num // 当前坐标等于num
+ num += 1 // num++
+ j += 1 // 竖坐标+1
+ }
+ i += 1 // 下移一行
+ j -= 1 // 左移一列
+
+ // 剩下的都同上
+
+ // 向下
+ while (i < n && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ i += 1
+ }
+ i -= 1
+ j -= 1
+
+ // 向左
+ while (j >= 0 && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ j -= 1
+ }
+ i -= 1
+ j += 1
+
+ // 向上
+ while (i >= 0 && res(i)(j) == 0) {
+ res(i)(j) = num
+ num += 1
+ i -= 1
+ }
+ i += 1
+ j += 1
+ }
+ res
+ }
+}
+```
-----------------------
From 296485551542d296e27486e985406d7944f3aa9a Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Wed, 11 May 2022 18:35:43 +0800
Subject: [PATCH 27/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880213.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8DII.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0213.打家劫舍II.md | 23 +++++++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index 8e569e46..9e698d01 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -165,7 +165,30 @@ const robRange = (nums, start, end) => {
return dp[end]
}
```
+TypeScript：
+
+```typescript
+function rob(nums: number[]): number {
+ const length: number = nums.length;
+ if (length === 0) return 0;
+ if (length === 1) return nums[0];
+ return Math.max(robRange(nums, 0, length - 2),
+ robRange(nums, 1, length - 1));
+};
+function robRange(nums: number[], start: number, end: number): number {
+ if (start === end) return nums[start];
+ const dp: number[] = [];
+ dp[start] = nums[start];
+ dp[start + 1] = Math.max(nums[start], nums[start + 1]);
+ for (let i = start + 2; i <= end; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ return dp[end];
+}
+```
+
Go：
+
```go
// 打家劫舍Ⅱ 动态规划
// 时间复杂度O(n) 空间复杂度O(n)
From 558dc3343150b1a91a1f307c0bb1fcb881abcd20 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 19:11:53 +0800
Subject: [PATCH 28/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E9=93=BE=E8=A1=A8?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/链表理论基础.md | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/problems/链表理论基础.md b/problems/链表理论基础.md
index 095282f5..9dddf1e2 100644
--- a/problems/链表理论基础.md
+++ b/problems/链表理论基础.md
@@ -210,6 +210,13 @@ type ListNode struct {
}
```
+Scala:
+```scala
+class ListNode(_x: Int = 0, _next: ListNode = null) {
+ var next: ListNode = _next
+ var x: Int = _x
+}
+```
-----------------------
From 8a562b7a2511b44705a6d9e28388738d6a452848 Mon Sep 17 00:00:00 2001
From: UndeadSheep
Date: Wed, 11 May 2022 19:44:09 +0800
Subject: [PATCH 29/99] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20=E5=93=88=E5=B8=8C?=
=?UTF-8?q?=E8=A1=A8=E9=83=A8=E5=88=86=E7=9A=84=20C#=E7=89=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0001.两数之和.md | 18 +++++++++++++++
problems/0202.快乐数.md | 23 +++++++++++++++++++
problems/0242.有效的字母异位词.md | 19 ++++++++++++++++
problems/0349.两个数组的交集.md | 18 +++++++++++++++
problems/0383.赎金信.md | 17 ++++++++++++++
problems/0454.四数相加II.md | 27 +++++++++++++++++++++++
6 files changed, 122 insertions(+)
diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index 9571a773..459a66ad 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -274,6 +274,24 @@ class Solution {
}
}
```
+C#:
+```csharp
+public class Solution {
+ public int[] TwoSum(int[] nums, int target) {
+ Dictionary dic= new Dictionary();
+ for(int i=0;i
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 741a735a..51a79aff 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -385,5 +385,28 @@ bool isHappy(int n){
return bHappy;
}
```
+
+C#：
+```csharp
+public class Solution {
+ private int getSum(int n) {
+ int sum = 0;
+ //每位数的换算
+ while (n > 0) {
+ sum += (n % 10) * (n % 10);
+ n /= 10;
+ }
+ return sum;
+ }
+ public bool IsHappy(int n) {
+ HashSet set = new HashSet();
+ while(n != 1 && !set.Contains(n)) { //判断避免循环
+ set.Add(n);
+ n = getSum(n);
+ }
+ return n == 1;
+ }
+}
+```
-----------------------
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 080166fd..878b2466 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -307,6 +307,25 @@ impl Solution {
}
}
```
+
+C#：
+```csharp
+ public bool IsAnagram(string s, string t) {
+ int sl=s.Length,tl=t.Length;
+ if(sl!=tl) return false;
+ int[] a = new int[26];
+ for(int i = 0; i < sl; i++){
+ a[s[i] - 'a']++;
+ a[t[i] - 'a']--;
+ }
+ foreach (int i in a)
+ {
+ if (i != 0)
+ return false;
+ }
+ return true;
+ }
+```
## 相关题目
* 383.赎金信
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 45f19b6e..7f8958d2 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -313,6 +313,24 @@ int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* re
}
```
+C#:
+```csharp
+ public int[] Intersection(int[] nums1, int[] nums2) {
+ if(nums1==null||nums1.Length==0||nums2==null||nums1.Length==0)
+ return new int[0]; //注意数组条件
+ HashSet one = Insert(nums1);
+ HashSet two = Insert(nums2);
+ one.IntersectWith(two);
+ return one.ToArray();
+ }
+ public HashSet Insert(int[] nums){
+ HashSet one = new HashSet();
+ foreach(int num in nums){
+ one.Add(num);
+ }
+ return one;
+ }
+```
## 相关题目
* 350.两个数组的交集 II
diff --git a/problems/0383.赎金信.md b/problems/0383.赎金信.md
index 5d9e8295..6d6efc55 100644
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@@ -361,5 +361,22 @@ impl Solution {
}
```
+C#：
+```csharp
+public bool CanConstruct(string ransomNote, string magazine) {
+ if(ransomNote.Length > magazine.Length) return false;
+ int[] letters = new int[26];
+ foreach(char c in magazine){
+ letters[c-'a']++;
+ }
+ foreach(char c in ransomNote){
+ letters[c-'a']--;
+ if(letters[c-'a']<0){
+ return false;
+ }
+ }
+ return true;
+ }
+```
-----------------------
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index a6cd413b..962fe7a5 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -318,5 +318,32 @@ impl Solution {
}
```
+C#：
+```csharp
+public int FourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
+ Dictionary dic = new Dictionary();
+ foreach(var i in nums1){
+ foreach(var j in nums2){
+ int sum = i + j;
+ if(dic.ContainsKey(sum)){
+ dic[sum]++;
+ }else{
+ dic.Add(sum, 1);
+ }
+
+ }
+ }
+ int res = 0;
+ foreach(var a in nums3){
+ foreach(var b in nums4){
+ int sum = a+b;
+ if(dic.TryGetValue(-sum, out var result)){
+ res += result;
+ }
+ }
+ }
+ return res;
+ }
+```
-----------------------
From ef8564a5930805ace91776c5648fa7110800c2d7 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 19:51:07 +0800
Subject: [PATCH 30/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200203.=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E5=85=83=E7=B4=A0.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0203.移除链表元素.md | 32 ++++++++++++++++++++++++++++-
1 file changed, 31 insertions(+), 1 deletion(-)
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index c34831b7..53230c0b 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -446,6 +446,36 @@ impl Solution {
}
}
```
-
+Scala:
+```scala
+/**
+ * Definition for singly-linked list.
+ * class ListNode(_x: Int = 0, _next: ListNode = null) {
+ * var next: ListNode = _next
+ * var x: Int = _x
+ * }
+ */
+object Solution {
+ def removeElements(head: ListNode, `val`: Int): ListNode = {
+ if (head == null) return head
+ var dummy = new ListNode(-1, head) // 定义虚拟头节点
+ var cur = head // cur 表示当前节点
+ var pre = dummy // pre 表示cur前一个节点
+ while (cur != null) {
+ if (cur.x == `val`) {
+ // 相等，就删除那么cur的前一个节点pre执行cur的下一个
+ pre.next = cur.next
+ } else {
+ // 不相等，pre就等于当前cur节点
+ pre = cur
+ }
+ // 向下迭代
+ cur = cur.next
+ }
+ // 最终返回dummy的下一个，就是链表的头
+ dummy.next
+ }
+}
+```
-----------------------
From 898016b8a98aa7eeb2445681e66f0302a79c28ae Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 21:13:42 +0800
Subject: [PATCH 31/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200707.=E8=AE=BE?=
=?UTF-8?q?=E8=AE=A1=E9=93=BE=E8=A1=A8.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0707.设计链表.md | 68 +++++++++++++++++++++++++++++++++++
1 file changed, 68 insertions(+)
diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index 37ce15ad..dcdb53f4 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -1154,7 +1154,75 @@ class MyLinkedList {
}
```
+Scala:
+```scala
+class ListNode(_x: Int = 0, _next: ListNode = null) {
+ var next: ListNode = _next
+ var x: Int = _x
+}
+class MyLinkedList() {
+
+ var size = 0 // 链表尺寸
+ var dummy: ListNode = new ListNode(0) // 虚拟头节点
+
+ // 获取第index个节点的值
+ def get(index: Int): Int = {
+ if (index < 0 || index >= size) {
+ return -1;
+ }
+ var cur = dummy
+ for (i <- 0 to index) {
+ cur = cur.next
+ }
+ cur.x // 返回cur的值
+ }
+
+ // 在链表最前面插入一个节点
+ def addAtHead(`val`: Int) {
+ addAtIndex(0, `val`)
+ }
+
+ // 在链表最后面插入一个节点
+ def addAtTail(`val`: Int) {
+ addAtIndex(size, `val`)
+ }
+
+ // 在第index个节点之前插入一个新节点
+ // 如果index等于链表长度，则说明新插入的节点是尾巴
+ // 如果index等于0，则说明新插入的节点是头
+ // 如果index>链表长度，则说明为空
+ def addAtIndex(index: Int, `val`: Int) {
+ if (index > size) {
+ return
+ }
+ var loc = index // 因为参数index是val不可变类型，所以需要赋值给一个可变类型
+ if (index < 0) {
+ loc = 0
+ }
+ size += 1 //链表尺寸+1
+ var pre = dummy
+ for (i <- 0 until loc) {
+ pre = pre.next
+ }
+ val node: ListNode = new ListNode(`val`, pre.next)
+ pre.next = node
+ }
+ // 删除第index个节点
+ def deleteAtIndex(index: Int) {
+ if (index < 0 || index >= size) {
+ return
+ }
+ size -= 1
+ var pre = dummy
+ for (i <- 0 until index) {
+ pre = pre.next
+ }
+ pre.next = pre.next.next
+ }
+
+}
+```
-----------------------
From 923ce563f1461876fbed667f8a79194ccb060096 Mon Sep 17 00:00:00 2001
From: yangtzech
Date: Wed, 11 May 2022 21:30:43 +0800
Subject: [PATCH 32/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=EF=BC=880102.?=
=?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D?=
=?UTF-8?q?=E5=8E=86.md=EF=BC=89=EF=BC=9A102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
=?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86=20=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0=20c++=20=E9=80=92=E5=BD=92=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..5f69f53d 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -82,6 +82,26 @@ public:
}
};
```
+```CPP
+# 递归法
+class Solution {
+public:
+ void order(TreeNode* cur, vector>& result, int depth)
+ {
+ if (cur == nullptr) return;
+ if (result.size() == depth) result.push_back(vector());
+ result[depth].push_back(cur->val);
+ order(cur->left, result, depth + 1);
+ order(cur->right, result, depth + 1);
+ }
+ vector> levelOrder(TreeNode* root) {
+ vector> result;
+ int depth = 0;
+ order(root, result, depth);
+ return result;
+ }
+};
+```
python3代码：
From 3606a624237334eddee98308e39daedbb2d250b0 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 11 May 2022 23:03:42 +0800
Subject: [PATCH 33/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200206.=E7=BF=BB?=
=?UTF-8?q?=E8=BD=AC=E9=93=BE=E8=A1=A8.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0206.翻转链表.md | 34 ++++++++++++++++++++++++++++++++++
1 file changed, 34 insertions(+)
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index 941928ba..25b16907 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -496,6 +496,40 @@ struct ListNode* reverseList(struct ListNode* head){
return reverse(NULL, head);
}
```
+Scala:
+双指针法：
+```scala
+object Solution {
+ def reverseList(head: ListNode): ListNode = {
+ var pre: ListNode = null
+ var cur = head
+ while (cur != null) {
+ var tmp = cur.next
+ cur.next = pre
+ pre = cur
+ cur = tmp
+ }
+ pre
+ }
+}
+```
+递归法：
+```scala
+object Solution {
+ def reverseList(head: ListNode): ListNode = {
+ reverse(null, head)
+ }
+
+ def reverse(pre: ListNode, cur: ListNode): ListNode = {
+ if (cur == null) {
+ return pre // 如果当前cur为空，则返回pre
+ }
+ val tmp: ListNode = cur.next
+ cur.next = pre
+ reverse(cur, tmp) // 此时cur成为前一个节点，tmp是当前节点
+ }
+}
+```
-----------------------
From 83086c903d77496e6fa34e7e4b0069e27ad1210c Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 10:13:00 +0800
Subject: [PATCH 34/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200024.=E4=B8=A4?=
=?UTF-8?q?=E4=B8=A4=E4=BA=A4=E6=8D=A2=E9=93=BE=E8=A1=A8=E4=B8=AD=E7=9A=84?=
=?UTF-8?q?=E8=8A=82=E7=82=B9.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0024.两两交换链表中的节点.md | 24 ++++++++++++++++++-
1 file changed, 23 insertions(+), 1 deletion(-)
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index ce75e0d7..2289c229 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -311,7 +311,29 @@ func swapPairs(_ head: ListNode?) -> ListNode? {
return dummyHead.next
}
```
-
+Scala:
+```scala
+// 虚拟头节点
+object Solution {
+ def swapPairs(head: ListNode): ListNode = {
+ var dummy = new ListNode(0, head) // 虚拟头节点
+ var pre = dummy
+ var cur = head
+ // 当pre的下一个和下下个都不为空，才进行两两转换
+ while (pre.next != null && pre.next.next != null) {
+ var tmp: ListNode = cur.next.next // 缓存下一次要进行转换的第一个节点
+ pre.next = cur.next // 步骤一
+ cur.next.next = cur // 步骤二
+ cur.next = tmp // 步骤三
+ // 下面是准备下一轮的交换
+ pre = cur
+ cur = tmp
+ }
+ // 最终返回dummy虚拟头节点的下一个，return可以省略
+ dummy.next
+ }
+}
+```
-----------------------
From 5fd85215ea9c30c73e5ab84f41dbc9cf170e8617 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 10:53:20 +0800
Subject: [PATCH 35/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200019.=E5=88=A0?=
=?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=AC?=
=?UTF-8?q?N=E4=B8=AA=E8=8A=82=E7=82=B9.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...0019.删除链表的倒数第N个节点.md | 24 ++++++++++++++++++-
1 file changed, 23 insertions(+), 1 deletion(-)
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index 813e9b02..8df65627 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -289,6 +289,28 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
return dummyHead.next
}
```
-
+Scala:
+```scala
+object Solution {
+ def removeNthFromEnd(head: ListNode, n: Int): ListNode = {
+ val dummy = new ListNode(-1, head) // 定义虚拟头节点
+ var fast = head // 快指针从头开始走
+ var slow = dummy // 慢指针从虚拟头开始头
+ // 因为参数 n 是不可变量，所以不能使用 while(n>0){n-=1}的方式
+ for (i <- 0 until n) {
+ fast = fast.next
+ }
+ // 快指针和满指针一起走，直到fast走到null
+ while (fast != null) {
+ slow = slow.next
+ fast = fast.next
+ }
+ // 删除slow的下一个节点
+ slow.next = slow.next.next
+ // 返回虚拟头节点的下一个
+ dummy.next
+ }
+}
+```
-----------------------
From 6992735d8de6d1875d0565413faed410e81c822e Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 12:46:47 +0800
Subject: [PATCH 36/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E9=9D=A2=E8=AF=95?=
=?UTF-8?q?=E9=A2=9802.07.=E9=93=BE=E8=A1=A8=E7=9B=B8=E4=BA=A4.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/面试题02.07.链表相交.md | 50 ++++++++++++++++++++++++-
1 file changed, 49 insertions(+), 1 deletion(-)
diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index 2e7226de..0a38cc33 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -317,7 +317,55 @@ ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
}
```
-
+Scala:
+```scala
+object Solution {
+ def getIntersectionNode(headA: ListNode, headB: ListNode): ListNode = {
+ var lenA = 0 // headA链表的长度
+ var lenB = 0 // headB链表的长度
+ var tmp = headA // 临时变量
+ // 统计headA的长度
+ while (tmp != null) {
+ lenA += 1;
+ tmp = tmp.next
+ }
+ // 统计headB的长度
+ tmp = headB // 临时变量赋值给headB
+ while (tmp != null) {
+ lenB += 1
+ tmp = tmp.next
+ }
+ // 因为传递过来的参数是不可变量，所以需要重新定义
+ var listA = headA
+ var listB = headB
+ // 两个链表的长度差
+ // 如果gap>0，lenA>lenB，headA(listA)链表往前移动gap步
+ // 如果gap<0，lenA 0) {
+ // 因为不可以i-=1，所以可以使用for
+ for (i <- 0 until gap) {
+ listA = listA.next // 链表headA(listA) 移动
+ }
+ } else {
+ gap = math.abs(gap) // 此刻gap为负值，取绝对值
+ for (i <- 0 until gap) {
+ listB = listB.next
+ }
+ }
+ // 现在两个链表同时往前走，如果相等则返回
+ while (listA != null && listB != null) {
+ if (listA == listB) {
+ return listA
+ }
+ listA = listA.next
+ listB = listB.next
+ }
+ // 如果链表没有相交则返回null，return可以省略
+ null
+ }
+}
+```
-----------------------
From 2ce58ac6756775f8ec5139b36a23e8f3de232d30 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 12:55:14 +0800
Subject: [PATCH 37/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880337.=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8DIII.md=EF=BC=89=EF=BC=9A=E5=A2=9E?=
=?UTF-8?q?=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0337.打家劫舍III.md | 43 ++++++++++++++++++++++++++++++++
1 file changed, 43 insertions(+)
diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
index a4d8f6b2..6f50723d 100644
--- a/problems/0337.打家劫舍III.md
+++ b/problems/0337.打家劫舍III.md
@@ -429,7 +429,50 @@ const rob = root => {
};
```
+### TypeScript
+
+> 记忆化后序遍历
+
+```typescript
+const memory: Map = new Map();
+function rob(root: TreeNode | null): number {
+ if (root === null) return 0;
+ if (memory.has(root)) return memory.get(root);
+ // 不取当前节点
+ const res1: number = rob(root.left) + rob(root.right);
+ // 取当前节点
+ let res2: number = root.val;
+ if (root.left !== null) res2 += rob(root.left.left) + rob(root.left.right);
+ if (root.right !== null) res2 += rob(root.right.left) + rob(root.right.right);
+ const res: number = Math.max(res1, res2);
+ memory.set(root, res);
+ return res;
+};
+```
+
+> 状态标记化后序遍历
+
+```typescript
+function rob(root: TreeNode | null): number {
+ return Math.max(...robNode(root));
+};
+// [0]-不偷当前节点能获得的最大金额; [1]-偷~~
+type MaxValueArr = [number, number];
+function robNode(node: TreeNode | null): MaxValueArr {
+ if (node === null) return [0, 0];
+ const leftArr: MaxValueArr = robNode(node.left);
+ const rightArr: MaxValueArr = robNode(node.right);
+ // 不偷
+ const val1: number = Math.max(leftArr[0], leftArr[1]) +
+ Math.max(rightArr[0], rightArr[1]);
+ // 偷
+ const val2: number = leftArr[0] + rightArr[0] + node.val;
+ return [val1, val2];
+}
+```
+
### Go
+
```go
// 打家劫舍Ⅲ 动态规划
// 时间复杂度O(n) 空间复杂度O(logn)
From 5627d4ba8605f35b8d63cf4af363c64d721f69a3 Mon Sep 17 00:00:00 2001
From: Jamcy123 <1219502823@qq.com>
Date: Thu, 12 May 2022 16:04:42 +0800
Subject: [PATCH 38/99] =?UTF-8?q?=E8=83=8C=E5=8C=85=E7=90=86=E8=AE=BA?=
=?UTF-8?q?=E5=9F=BA=E7=A1=8001=E8=83=8C=E5=8C=85-1=20js=20=E7=89=88?=
=?UTF-8?q?=E6=9C=AC=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-1.md | 51 +++++++++---------------
1 file changed, 19 insertions(+), 32 deletions(-)
diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md
index fe940b4c..e833ea80 100644
--- a/problems/背包理论基础01背包-1.md
+++ b/problems/背包理论基础01背包-1.md
@@ -380,44 +380,31 @@ func main() {
### javascript
```js
-function testweightbagproblem (wight, value, size) {
- const len = wight.length,
- dp = array.from({length: len + 1}).map(
- () => array(size + 1).fill(0)
- );
-
- for(let i = 1; i <= len; i++) {
- for(let j = 0; j <= size; j++) {
- if(wight[i - 1] <= j) {
- dp[i][j] = math.max(
- dp[i - 1][j],
- value[i - 1] + dp[i - 1][j - wight[i - 1]]
- )
- } else {
- dp[i][j] = dp[i - 1][j];
- }
+function testWeightBagProblem (weight, value, size) {
+ // 定义 dp 数组
+ const len = weight.length,
+ dp = Array(len).fill().map(() => Array(size + 1).fill(0));
+
+ // 初始化
+ for(let j = weight[0]; j <= size; j++) {
+ dp[0][j] = value[0];
}
- }
-// console.table(dp);
-
- return dp[len][size];
-}
-
-function testWeightBagProblem2 (wight, value, size) {
- const len = wight.length,
- dp = Array(size + 1).fill(0);
- for(let i = 1; i <= len; i++) {
- for(let j = size; j >= wight[i - 1]; j--) {
- dp[j] = Math.max(dp[j], value[i - 1] + dp[j - wight[i - 1]]);
+ // weight 数组的长度len 就是物品个数
+ for(let i = 1; i < len; i++) { // 遍历物品
+ for(let j = 0; j <= size; j++) { // 遍历背包容量
+ if(j < weight[i]) dp[i][j] = dp[i - 1][j];
+ else dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
+ }
}
- }
- return dp[size];
-}
+ console.table(dp)
+
+ return dp[len - 1][size];
+}
function test () {
- console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
+ console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
}
test();
From 40457f0f44d3981dc071fd56871f66d7e5946af1 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 16:16:48 +0800
Subject: [PATCH 39/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880121.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0121.买卖股票的最佳时机.md | 40 ++++++++++++++++++++
1 file changed, 40 insertions(+)
diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
index f0bc3b97..a2498bb6 100644
--- a/problems/0121.买卖股票的最佳时机.md
+++ b/problems/0121.买卖股票的最佳时机.md
@@ -426,6 +426,46 @@ var maxProfit = function(prices) {
};
```
+TypeScript：
+
+> 贪心法
+
+```typescript
+function maxProfit(prices: number[]): number {
+ if (prices.length === 0) return 0;
+ let buy: number = prices[0];
+ let profitMax: number = 0;
+ for (let i = 1, length = prices.length; i < length; i++) {
+ profitMax = Math.max(profitMax, prices[i] - buy);
+ buy = Math.min(prices[i], buy);
+ }
+ return profitMax;
+};
+```
+
+> 动态规划
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 第i天持有股票的最大现金
+ dp[i][1]: 第i天不持有股票的最大现金
+ */
+ const length = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = [];
+ dp[0] = [-prices[0], 0];
+ for (let i = 1; i < length; i++) {
+ dp[i] = [];
+ dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
+ }
+ return dp[length - 1][1];
+};
+```
+
+
+
-----------------------
From 8ba775d04acd100e6cdac8ebd913aaead67fae15 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 16:40:54 +0800
Subject: [PATCH 40/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880122.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAII=E5=8A=A8=E6=80=81=E8=A7=84=E5=88=92.md=EF=BC=89?=
=?UTF-8?q?=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...票的最佳时机II（动态规划）.md | 36 +++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
index 5a165a14..12b21fde 100644
--- a/problems/0122.买卖股票的最佳时机II（动态规划）.md
+++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -295,6 +295,42 @@ const maxProfit = (prices) => {
}
```
+TypeScript：
+
+> 动态规划
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 第i天持有股票
+ dp[i][1]: 第i天不持有股票
+ */
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0] = [-prices[0], 0];
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
+ }
+ return dp[length - 1][1];
+};
+```
+
+> 贪心法
+
+```typescript
+function maxProfit(prices: number[]): number {
+ let resProfit: number = 0;
+ for (let i = 1, length = prices.length; i < length; i++) {
+ if (prices[i] > prices[i - 1]) {
+ resProfit += prices[i] - prices[i - 1];
+ }
+ }
+ return resProfit;
+};
+```
+
-----------------------
From 0a58ef986de4c20c5d69a4b490b478f44b7f3f5c Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 17:35:30 +0800
Subject: [PATCH 41/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200142.=E7=8E=AF?=
=?UTF-8?q?=E5=BD=A2=E9=93=BE=E8=A1=A8II.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0142.环形链表II.md | 26 +++++++++++++++++++++++++-
1 file changed, 25 insertions(+), 1 deletion(-)
diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index e8ca950d..f8e62d45 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -370,7 +370,31 @@ ListNode *detectCycle(ListNode *head) {
}
```
-
+Scala:
+```scala
+object Solution {
+ def detectCycle(head: ListNode): ListNode = {
+ var fast = head // 快指针
+ var slow = head // 慢指针
+ while (fast != null && fast.next != null) {
+ fast = fast.next.next // 快指针一次走两步
+ slow = slow.next // 慢指针一次走一步
+ // 如果相遇，fast快指针回到头
+ if (fast == slow) {
+ fast = head
+ // 两个指针一步一步的走，第一次相遇的节点必是入环节点
+ while (fast != slow) {
+ fast = fast.next
+ slow = slow.next
+ }
+ return fast
+ }
+ }
+ // 如果fast指向空值，必然无环返回null
+ null
+ }
+}
+```
-----------------------
From a25409d7ec351aaf2e6e513e3e091fc97cd17d60 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 19:16:20 +0800
Subject: [PATCH 42/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200242.=E6=9C=89?=
=?UTF-8?q?=E6=95=88=E7=9A=84=E5=AD=97=E6=AF=8D=E5=BC=82=E4=BD=8D=E8=AF=8D?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0242.有效的字母异位词.md | 25 +++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0242.有效的字母异位词.md b/problems/0242.有效的字母异位词.md
index 080166fd..4f0d143e 100644
--- a/problems/0242.有效的字母异位词.md
+++ b/problems/0242.有效的字母异位词.md
@@ -307,6 +307,31 @@ impl Solution {
}
}
```
+
+Scala:
+```scala
+object Solution {
+ def isAnagram(s: String, t: String): Boolean = {
+ // 如果两个字符串的长度不等，直接返回false
+ if (s.length != t.length) return false
+ val record = new Array[Int](26) // 记录每个单词出现了多少次
+ // 遍历字符串，对于s字符串单词对应的记录+=1，t字符串对应的记录-=1
+ for (i <- 0 until s.length) {
+ record(s(i) - 97) += 1
+ record(t(i) - 97) -= 1
+ }
+ // 如果不等于则直接返回false
+ for (i <- 0 until 26) {
+ if (record(i) != 0) {
+ return false
+ }
+ }
+ // 如果前面不返回false，说明匹配成功，返回true，return可以省略
+ true
+ }
+}
+```
+
## 相关题目
* 383.赎金信
From 74b76bfd120446653495d96135e697b5797bae35 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 12 May 2022 22:21:29 +0800
Subject: [PATCH 43/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=201002.=E6=9F=A5?=
=?UTF-8?q?=E6=89=BE=E5=B8=B8=E7=94=A8=E5=AD=97=E7=AC=A6.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/1002.查找常用字符.md | 34 ++++++++++++++++++++++++++++-
1 file changed, 33 insertions(+), 1 deletion(-)
diff --git a/problems/1002.查找常用字符.md b/problems/1002.查找常用字符.md
index 36937b0b..075b5ef1 100644
--- a/problems/1002.查找常用字符.md
+++ b/problems/1002.查找常用字符.md
@@ -418,6 +418,38 @@ char ** commonChars(char ** words, int wordsSize, int* returnSize){
return ret;
}
```
-
+Scala:
+```scala
+object Solution {
+ def commonChars(words: Array[String]): List[String] = {
+ // 声明返回结果的不可变List集合，因为res要重新赋值，所以声明为var
+ var res = List[String]()
+ var hash = new Array[Int](26) // 统计字符出现的最小频率
+ // 统计第一个字符串中字符出现的次数
+ for (i <- 0 until words(0).length) {
+ hash(words(0)(i) - 'a') += 1
+ }
+ // 统计其他字符串出现的频率
+ for (i <- 1 until words.length) {
+ // 统计其他字符出现的频率
+ var hashOtherStr = new Array[Int](26)
+ for (j <- 0 until words(i).length) {
+ hashOtherStr(words(i)(j) - 'a') += 1
+ }
+ // 更新hash，取26个字母最小出现的频率
+ for (k <- 0 until 26) {
+ hash(k) = math.min(hash(k), hashOtherStr(k))
+ }
+ }
+ // 根据hash的结果转换输出的形式
+ for (i <- 0 until 26) {
+ for (j <- 0 until hash(i)) {
+ res = res :+ (i + 'a').toChar.toString
+ }
+ }
+ res
+ }
+}
+```
-----------------------
From a71f7d2127bae83cc42dffd20b4c460865006d15 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 12 May 2022 23:23:59 +0800
Subject: [PATCH 44/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880123.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAIII.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0123.买卖股票的最佳时机III.md | 30 +++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md
index 56ade343..67c99497 100644
--- a/problems/0123.买卖股票的最佳时机III.md
+++ b/problems/0123.买卖股票的最佳时机III.md
@@ -352,6 +352,36 @@ const maxProfit = prices => {
};
```
+TypeScript：
+
+> 版本一
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 无操作;
+ dp[i][1]: 第一次买入；
+ dp[i][2]: 第一次卖出；
+ dp[i][3]: 第二次买入；
+ dp[i][4]: 第二次卖出；
+ */
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0)
+ .map(_ => new Array(5).fill(0));
+ dp[0][1] = -prices[0];
+ dp[0][3] = -prices[0];
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = dp[i - 1][0];
+ dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
+ dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
+ dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
+ dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
+ }
+ return Math.max(dp[length - 1][2], dp[length - 1][4]);
+};
+```
+
Go:
> 版本一：
From 78c6602ff20c309132007795956f332d66ff7130 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 10:05:27 +0800
Subject: [PATCH 45/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200349.=E4=B8=A4?=
=?UTF-8?q?=E4=B8=AA=E6=95=B0=E7=BB=84=E7=9A=84=E4=BA=A4=E9=9B=86.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0349.两个数组的交集.md | 42 ++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 45f19b6e..49cf4112 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -312,7 +312,49 @@ int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* re
return result;
}
```
+Scala:
+正常解法:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // 导入mutable
+ import scala.collection.mutable
+ // 临时Set，用于记录数组1出现的每个元素
+ val tmpSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ // 结果Set，存储最终结果
+ val resSet: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ // 遍历nums1，把每个元素添加到tmpSet
+ nums1.foreach(tmpSet.add(_))
+ // 遍历nums2，如果在tmpSet存在就添加到resSet
+ nums2.foreach(elem => {
+ if (tmpSet.contains(elem)) {
+ resSet.add(elem)
+ }
+ })
+ // 将结果转换为Array返回，return可以省略
+ resSet.toArray
+ }
+}
+```
+骚操作1:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // 先转为Set，然后取交集，最后转换为Array
+ (nums1.toSet).intersect(nums2.toSet).toArray
+ }
+}
+```
+骚操作2:
+```scala
+object Solution {
+ def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
+ // distinct去重，然后取交集
+ (nums1.distinct).intersect(nums2.distinct)
+ }
+}
+```
## 相关题目
* 350.两个数组的交集 II
From 9f720470e8e2360047052897885261545d0e1ac7 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 10:29:17 +0800
Subject: [PATCH 46/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200202.=E5=BF=AB?=
=?UTF-8?q?=E4=B9=90=E6=95=B0.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0202.快乐数.md | 33 +++++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 741a735a..2d0f7d27 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -385,5 +385,38 @@ bool isHappy(int n){
return bHappy;
}
```
+Scala:
+```scala
+object Solution {
+ // 引入mutable
+ import scala.collection.mutable
+ def isHappy(n: Int): Boolean = {
+ // 存放每次计算后的结果
+ val set: mutable.HashSet[Int] = new mutable.HashSet[Int]()
+ var tmp = n // 因为形参是不可变量，所以需要找到一个临时变量
+ // 开始进入循环
+ while (true) {
+ val sum = getSum(tmp) // 获取这个数每个值的平方和
+ if (sum == 1) return true // 如果最终等于 1，则返回true
+ // 如果set里面已经有这个值了，说明进入无限循环，可以返回false，否则添加这个值到set
+ if (set.contains(sum)) return false
+ else set.add(sum)
+ tmp = sum
+ }
+ // 最终需要返回值，直接返回个false
+ false
+ }
+
+ def getSum(n: Int): Int = {
+ var sum = 0
+ var tmp = n
+ while (tmp != 0) {
+ sum += (tmp % 10) * (tmp % 10)
+ tmp = tmp / 10
+ }
+ sum
+ }
+}
+```
-----------------------
From be5cc136c56cb194af8ce1d794871ca7af4b1e1d Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:00:11 +0800
Subject: [PATCH 47/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200035.=E6=90=9C?=
=?UTF-8?q?=E7=B4=A2=E6=8F=92=E5=85=A5=E4=BD=8D=E7=BD=AE.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0035.搜索插入位置.md | 21 ++++++++++++++++++++-
1 file changed, 20 insertions(+), 1 deletion(-)
diff --git a/problems/0035.搜索插入位置.md b/problems/0035.搜索插入位置.md
index 9a770703..3e8cf5c8 100644
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@@ -316,7 +316,26 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
return right + 1
}
```
-
+### Scala
+```scala
+object Solution {
+ def searchInsert(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (target == nums(mid)) {
+ return mid
+ } else if (target > nums(mid)) {
+ left = mid + 1
+ } else {
+ right = mid - 1
+ }
+ }
+ right + 1
+ }
+}
+```
From 95593634b341a951850fae3b5aa739ba7c5d3864 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:01:04 +0800
Subject: [PATCH 48/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200704.=E4=BA=8C?=
=?UTF-8?q?=E5=88=86=E6=9F=A5=E6=89=BE.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0704.二分查找.md | 41 +++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 55625130..1e474f9a 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -610,7 +610,48 @@ public class Solution{
}
}
```
+**Scala:**
+（版本一）左闭右闭区间
+```scala
+object Solution {
+ def search(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + ((right - left) / 2)
+ if (target == nums(mid)) {
+ return mid
+ } else if (target < nums(mid)) {
+ right = mid - 1
+ } else {
+ left = mid + 1
+ }
+ }
+ -1
+ }
+}
+```
+（版本二）左闭右开区间
+```scala
+object Solution {
+ def search(nums: Array[Int], target: Int): Int = {
+ var left = 0
+ var right = nums.length
+ while (left < right) {
+ val mid = left + (right - left) / 2
+ if (target == nums(mid)) {
+ return mid
+ } else if (target < nums(mid)) {
+ right = mid
+ } else {
+ left = mid + 1
+ }
+ }
+ -1
+ }
+}
+```
-----------------------
From 9fc232aba413b43fd479ad5b4fd1a186ff90a359 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:01:45 +0800
Subject: [PATCH 49/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200034.=E5=9C=A8?=
=?UTF-8?q?=E6=8E=92=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD=E6=9F=A5=E6=89=BE?=
=?UTF-8?q?=E5=85=83=E7=B4=A0=E7=9A=84=E7=AC=AC=E4=B8=80=E4=B8=AA=E5=92=8C?=
=?UTF-8?q?=E6=9C=80=E5=90=8E=E4=B8=80=E4=B8=AA=E4=BD=8D=E7=BD=AE.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...元素的第一个和最后一个位置.md | 45 +++++++++++++++++++
1 file changed, 45 insertions(+)
diff --git a/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md b/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
index dfd90b82..260462c2 100644
--- a/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
+++ b/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
@@ -480,7 +480,52 @@ var searchRange = function(nums, target) {
return [-1, -1];
};
```
+### Scala
+```scala
+object Solution {
+ def searchRange(nums: Array[Int], target: Int): Array[Int] = {
+ var left = getLeftBorder(nums, target)
+ var right = getRightBorder(nums, target)
+ if (left == -2 || right == -2) return Array(-1, -1)
+ if (right - left > 1) return Array(left + 1, right - 1)
+ Array(-1, -1)
+ }
+ // 寻找左边界
+ def getLeftBorder(nums: Array[Int], target: Int): Int = {
+ var leftBorder = -2
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (nums(mid) >= target) {
+ right = mid - 1
+ leftBorder = right
+ } else {
+ left = mid + 1
+ }
+ }
+ leftBorder
+ }
+
+ // 寻找右边界
+ def getRightBorder(nums: Array[Int], target: Int): Int = {
+ var rightBorder = -2
+ var left = 0
+ var right = nums.length - 1
+ while (left <= right) {
+ var mid = left + (right - left) / 2
+ if (nums(mid) <= target) {
+ left = mid + 1
+ rightBorder = left
+ } else {
+ right = mid - 1
+ }
+ }
+ rightBorder
+ }
+}
+```
-----------------------
From f131f27744693b91f40df4ea0fb7c1578bd6647b Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 11:02:19 +0800
Subject: [PATCH 50/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200027.=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E5=85=83=E7=B4=A0.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0027.移除元素.md | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..5ff327fb 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -328,6 +328,20 @@ int removeElement(int* nums, int numsSize, int val){
return slow;
}
```
-
+Scala:
+```scala
+object Solution {
+ def removeElement(nums: Array[Int], `val`: Int): Int = {
+ var slow = 0
+ for (fast <- 0 until nums.length) {
+ if (`val` != nums(fast)) {
+ nums(slow) = nums(fast)
+ slow += 1
+ }
+ }
+ slow
+ }
+}
+```
-----------------------
From 495998e509527b53a8b84cc0527dfcff4fc1e1af Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 13 May 2022 12:07:52 +0800
Subject: [PATCH 51/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880188.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BAIV.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0188.买卖股票的最佳时机IV.md | 22 +++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md
index 61c558a1..27eb38c3 100644
--- a/problems/0188.买卖股票的最佳时机IV.md
+++ b/problems/0188.买卖股票的最佳时机IV.md
@@ -409,5 +409,27 @@ var maxProfit = function(k, prices) {
};
```
+TypeScript：
+
+```typescript
+function maxProfit(k: number, prices: number[]): number {
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0)
+ .map(_ => new Array(k * 2 + 1).fill(0));
+ for (let i = 1; i <= k; i++) {
+ dp[0][i * 2 - 1] = -prices[0];
+ }
+ for (let i = 1; i < length; i++) {
+ for (let j = 1; j < 2 * k + 1; j++) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] + Math.pow(-1, j) * prices[i]);
+ }
+ }
+ return dp[length - 1][2 * k];
+};
+```
+
+
+
-----------------------
From 127986e03a0b4acdedf80a6b38d3ded7d61514f3 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 13 May 2022 16:19:59 +0800
Subject: [PATCH 52/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880309.=E6=9C=80?=
=?UTF-8?q?=E4=BD=B3=E4=B9=B0=E5=8D=96=E8=82=A1=E7=A5=A8=E6=97=B6=E6=9C=BA?=
=?UTF-8?q?=E5=90=AB=E5=86=B7=E5=86=BB=E6=9C=9F.md=EF=BC=89=EF=BC=9A?=
=?UTF-8?q?=E5=A2=9E=E5=8A=A0typescript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...09.最佳买卖股票时机含冷冻期.md | 60 +++++++++++++++++++
1 file changed, 60 insertions(+)
diff --git a/problems/0309.最佳买卖股票时机含冷冻期.md b/problems/0309.最佳买卖股票时机含冷冻期.md
index f3e7541b..f037fe85 100644
--- a/problems/0309.最佳买卖股票时机含冷冻期.md
+++ b/problems/0309.最佳买卖股票时机含冷冻期.md
@@ -325,6 +325,66 @@ const maxProfit = (prices) => {
};
```
+TypeScript：
+
+> 版本一，与本文思路一致
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 持股状态；
+ dp[i][1]: 无股状态，当天为非冷冻期；
+ dp[i][2]: 无股状态，当天卖出；
+ dp[i][3]: 无股状态，当天为冷冻期；
+ */
+ const length: number = prices.length;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0][0] = -prices[0];
+ dp[0][1] = dp[0][2] = dp[0][3] = 0;
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = Math.max(
+ dp[i - 1][0],
+ Math.max(dp[i - 1][1], dp[i - 1][3]) - prices[i]
+ );
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][3]);
+ dp[i][2] = dp[i - 1][0] + prices[i];
+ dp[i][3] = dp[i - 1][2];
+ }
+ const lastEl: number[] = dp[length - 1];
+ return Math.max(lastEl[1], lastEl[2], lastEl[3]);
+};
+```
+
+> 版本二，状态定义略有不同，可以帮助理解
+
+```typescript
+function maxProfit(prices: number[]): number {
+ /**
+ dp[i][0]: 持股状态，当天买入；
+ dp[i][1]: 持股状态，当天未买入；
+ dp[i][2]: 无股状态，当天卖出；
+ dp[i][3]: 无股状态，当天未卖出；
+
+ 买入有冷冻期限制，其实就是状态[0]只能由前一天的状态[3]得到；
+ 如果卖出有冷冻期限制，其实就是[2]由[1]得到。
+ */
+ const length: number = prices.length;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0][0] = -prices[0];
+ dp[0][1] = -Infinity;
+ dp[0][2] = dp[0][3] = 0;
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = dp[i - 1][3] - prices[i];
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0]);
+ dp[i][2] = Math.max(dp[i - 1][0], dp[i - 1][1]) + prices[i];
+ dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2]);
+ }
+ return Math.max(dp[length - 1][2], dp[length - 1][3]);
+};
+```
+
+
+
-----------------------
From abe00238f44718c49b9442c26e7f7b01f84be3e4 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 16:37:39 +0800
Subject: [PATCH 53/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200001.=E4=B8=A4?=
=?UTF-8?q?=E6=95=B0=E4=B9=8B=E5=92=8C.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0001.两数之和.md | 23 ++++++++++++++++++++++-
1 file changed, 22 insertions(+), 1 deletion(-)
diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index 9571a773..141e66f3 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -274,6 +274,27 @@ class Solution {
}
}
```
-
+Scala:
+```scala
+object Solution {
+ // 导入包
+ import scala.collection.mutable
+ def twoSum(nums: Array[Int], target: Int): Array[Int] = {
+ // key存储值，value存储下标
+ val map = new mutable.HashMap[Int, Int]()
+ for (i <- nums.indices) {
+ val tmp = target - nums(i) // 计算差值
+ // 如果这个差值存在于map，则说明找到了结果
+ if (map.contains(tmp)) {
+ return Array(map.get(tmp).get, i)
+ }
+ // 如果不包含把当前值与其下标放到map
+ map.put(nums(i), i)
+ }
+ // 如果没有找到直接返回一个空的数组，return关键字可以省略
+ new Array[Int](2)
+ }
+}
+```
-----------------------
From 53379c023fe935398801f41aad3dd0399b2d7d73 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 17:28:14 +0800
Subject: [PATCH 54/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200454.=E5=9B=9B?=
=?UTF-8?q?=E6=95=B0=E7=9B=B8=E5=8A=A0II.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0454.四数相加II.md | 36 +++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index a6cd413b..d4aba8fa 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -318,5 +318,41 @@ impl Solution {
}
```
+Scala:
+```scala
+object Solution {
+ // 导包
+ import scala.collection.mutable
+ def fourSumCount(nums1: Array[Int], nums2: Array[Int], nums3: Array[Int], nums4: Array[Int]): Int = {
+ // 定义一个HashMap，key存储值，value存储该值出现的次数
+ val map = new mutable.HashMap[Int, Int]()
+ // 遍历前两个数组，把他们所有可能的情况都记录到map
+ for (i <- nums1.indices) {
+ for (j <- nums2.indices) {
+ val tmp = nums1(i) + nums2(j)
+ // 如果包含该值，则对他的key加1，不包含则添加进去
+ if (map.contains(tmp)) {
+ map.put(tmp, map.get(tmp).get + 1)
+ } else {
+ map.put(tmp, 1)
+ }
+ }
+ }
+ var res = 0 // 结果变量
+ // 遍历后两个数组
+ for (i <- nums3.indices) {
+ for (j <- nums4.indices) {
+ val tmp = -(nums3(i) + nums4(j))
+ // 如果map中存在该值，结果就+=value
+ if (map.contains(tmp)) {
+ res += map.get(tmp).get
+ }
+ }
+ }
+ // 返回最终结果，可以省略关键字return
+ res
+ }
+}
+```
-----------------------
From 6c0d4365c6ed1e9a47c5f31e14d59912648f4afa Mon Sep 17 00:00:00 2001
From: lizhendong128
Date: Fri, 13 May 2022 17:26:03 +0800
Subject: [PATCH 55/99] =?UTF-8?q?=E4=BF=AE=E6=94=B90059=E8=9E=BA=E6=97=8B?=
=?UTF-8?q?=E7=9F=A9=E9=98=B5II=20Java=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
精简Java代码中不必要的变量，调整结构，减少代码量，使代码更加易读
---
problems/0059.螺旋矩阵II.md | 44 +++++++++------------------------
1 file changed, 12 insertions(+), 32 deletions(-)
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index 93735895..7afc1575 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -130,57 +130,37 @@ Java：
```Java
class Solution {
public int[][] generateMatrix(int n) {
+ int loop = 0; // 控制循环次数
int[][] res = new int[n][n];
+ int start = 0; // 每次循环的开始点(start, start)
+ int count = 1; // 定义填充数字
+ int i, j;
- // 循环次数
- int loop = n / 2;
-
- // 定义每次循环起始位置
- int startX = 0;
- int startY = 0;
-
- // 定义偏移量
- int offset = 1;
-
- // 定义填充数字
- int count = 1;
-
- // 定义中间位置
- int mid = n / 2;
- while (loop > 0) {
- int i = startX;
- int j = startY;
-
+ while (loop++ < n / 2) { // 判断边界后，loop从1开始
// 模拟上侧从左到右
- for (; j startY; j--) {
+ for (; j >= loop; j--) {
res[i][j] = count++;
}
// 模拟左侧从下到上
- for (; i > startX; i--) {
+ for (; i >= loop; i--) {
res[i][j] = count++;
}
-
- loop--;
-
- startX += 1;
- startY += 1;
-
- offset += 2;
+ start++;
}
if (n % 2 == 1) {
- res[mid][mid] = count;
+ res[start][start] = count;
}
return res;
From 16c6abff54ec4b85d0891ed12914f538da7b8332 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 21:02:07 +0800
Subject: [PATCH 56/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200383.=E8=B5=8E?=
=?UTF-8?q?=E9=87=91=E4=BF=A1.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0383.赎金信.md | 62 ++++++++++++++++++++++++++++++++++++++
1 file changed, 62 insertions(+)
diff --git a/problems/0383.赎金信.md b/problems/0383.赎金信.md
index 5d9e8295..8e4cbbf8 100644
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@@ -360,6 +360,68 @@ impl Solution {
}
}
```
+Scala:
+版本一: 使用数组作为哈希表
+```scala
+object Solution {
+ def canConstruct(ransomNote: String, magazine: String): Boolean = {
+ // 如果magazine的长度小于ransomNote的长度，必然是false
+ if (magazine.length < ransomNote.length) {
+ return false
+ }
+ // 定义一个数组，存储magazine字符出现的次数
+ val map: Array[Int] = new Array[Int](26)
+ // 遍历magazine字符串，对应的字符+=1
+ for (i <- magazine.indices) {
+ map(magazine(i) - 'a') += 1
+ }
+ // 遍历ransomNote
+ for (i <- ransomNote.indices) {
+ if (map(ransomNote(i) - 'a') > 0)
+ map(ransomNote(i) - 'a') -= 1
+ else return false
+ }
+ // 如果上面没有返回false，直接返回true，关键字return可以省略
+ true
+ }
+}
+```
+版本二: 使用HashMap
+```scala
+object Solution {
+ import scala.collection.mutable
+ def canConstruct(ransomNote: String, magazine: String): Boolean = {
+ // 如果magazine的长度小于ransomNote的长度，必然是false
+ if (magazine.length < ransomNote.length) {
+ return false
+ }
+ // 定义map，key是字符，value是字符出现的次数
+ val map = new mutable.HashMap[Char, Int]()
+ // 遍历magazine，把所有的字符都记录到map里面
+ for (i <- magazine.indices) {
+ val tmpChar = magazine(i)
+ // 如果map包含该字符，那么对应的value++，否则添加该字符
+ if (map.contains(tmpChar)) {
+ map.put(tmpChar, map.get(tmpChar).get + 1)
+ } else {
+ map.put(tmpChar, 1)
+ }
+ }
+ // 遍历ransomNote
+ for (i <- ransomNote.indices) {
+ val tmpChar = ransomNote(i)
+ // 如果map包含并且该字符的value大于0，则匹配成功，map对应的--，否则直接返回false
+ if (map.contains(tmpChar) && map.get(tmpChar).get > 0) {
+ map.put(tmpChar, map.get(tmpChar).get - 1)
+ } else {
+ return false
+ }
+ }
+ // 如果上面没有返回false，直接返回true，关键字return可以省略
+ true
+ }
+}
+```
-----------------------
From ca2711164dfd39b51f1e6d96207673ffba29d3f1 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 13 May 2022 21:11:48 +0800
Subject: [PATCH 57/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880714.=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA=E5=90=AB=E6=89=8B=E7=BB=AD=E8=B4=B9=E5=8A=A8=E6=80=81?=
=?UTF-8?q?=E8=A7=84=E5=88=92.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typesc?=
=?UTF-8?q?ript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...佳时机含手续费（动态规划）.md | 23 +++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
index 4ab63e79..5625604b 100644
--- a/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
+++ b/problems/0714.买卖股票的最佳时机含手续费（动态规划）.md
@@ -200,6 +200,29 @@ const maxProfit = (prices,fee) => {
}
```
+TypeScript：
+
+```typescript
+function maxProfit(prices: number[], fee: number): number {
+ /**
+ dp[i][0]：持有股票
+ dp[i][1]: 不持有
+ */
+ const length: number = prices.length;
+ if (length === 0) return 0;
+ const dp: number[][] = new Array(length).fill(0).map(_ => []);
+ dp[0][0] = -prices[0];
+ dp[0][1] = 0;
+ for (let i = 1; i < length; i++) {
+ dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
+ }
+ return dp[length - 1][1];
+};
+```
+
+
+
-----------------------
From a53da7b4e205468bb7f870b5b46093c42923d429 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sat, 14 May 2022 14:41:14 +0800
Subject: [PATCH 58/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200015.=E4=B8=89?=
=?UTF-8?q?=E6=95=B0=E4=B9=8B=E5=92=8C.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0015.三数之和.md | 43 +++++++++++++++++++++++++++++++++++
1 file changed, 43 insertions(+)
diff --git a/problems/0015.三数之和.md b/problems/0015.三数之和.md
index cc184c87..1764d244 100644
--- a/problems/0015.三数之和.md
+++ b/problems/0015.三数之和.md
@@ -616,6 +616,49 @@ public class Solution
}
}
```
+Scala:
+```scala
+object Solution {
+ // 导包
+ import scala.collection.mutable.ListBuffer
+ import scala.util.control.Breaks.{break, breakable}
+ def threeSum(nums: Array[Int]): List[List[Int]] = {
+ // 定义结果集，最后需要转换为List
+ val res = ListBuffer[List[Int]]()
+ val nums_tmp = nums.sorted // 对nums进行排序
+ for (i <- nums_tmp.indices) {
+ // 如果要排的第一个数字大于0，直接返回结果
+ if (nums_tmp(i) > 0) {
+ return res.toList
+ }
+ // 如果i大于0并且和前一个数字重复，则跳过本次循环，相当于continue
+ breakable {
+ if (i > 0 && nums_tmp(i) == nums_tmp(i - 1)) {
+ break
+ } else {
+ var left = i + 1
+ var right = nums_tmp.length - 1
+ while (left < right) {
+ var sum = nums_tmp(i) + nums_tmp(left) + nums_tmp(right) // 求三数之和
+ if (sum < 0) left += 1
+ else if (sum > 0) right -= 1
+ else {
+ res += List(nums_tmp(i), nums_tmp(left), nums_tmp(right)) // 如果等于0 添加进结果集
+ // 为了避免重复，对left和right进行移动
+ while (left < right && nums_tmp(left) == nums_tmp(left + 1)) left += 1
+ while (left < right && nums_tmp(right) == nums_tmp(right - 1)) right -= 1
+ left += 1
+ right -= 1
+ }
+ }
+ }
+ }
+ }
+ // 最终返回需要转换为List，return关键字可以省略
+ res.toList
+ }
+}
+```
-----------------------
From 68eed4af5b1f43e7ac65093dd00c7497f88885cc Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sat, 14 May 2022 15:26:29 +0800
Subject: [PATCH 59/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200018.=E5=9B=9B?=
=?UTF-8?q?=E6=95=B0=E4=B9=8B=E5=92=8C.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0018.四数之和.md | 45 ++++++++++++++++++++++++++++++++++-
1 file changed, 44 insertions(+), 1 deletion(-)
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
index ee70cb69..6cbd40c2 100644
--- a/problems/0018.四数之和.md
+++ b/problems/0018.四数之和.md
@@ -522,6 +522,49 @@ public class Solution
}
}
```
-
+Scala:
+```scala
+object Solution {
+ // 导包
+ import scala.collection.mutable.ListBuffer
+ import scala.util.control.Breaks.{break, breakable}
+ def fourSum(nums: Array[Int], target: Int): List[List[Int]] = {
+ val res = ListBuffer[List[Int]]()
+ val nums_tmp = nums.sorted // 先排序
+ for (i <- nums_tmp.indices) {
+ breakable {
+ if (i > 0 && nums_tmp(i) == nums_tmp(i - 1)) {
+ break // 如果该值和上次的值相同，跳过本次循环，相当于continue
+ } else {
+ for (j <- i + 1 until nums_tmp.length) {
+ breakable {
+ if (j > i + 1 && nums_tmp(j) == nums_tmp(j - 1)) {
+ break // 同上
+ } else {
+ // 双指针
+ var (left, right) = (j + 1, nums_tmp.length - 1)
+ while (left < right) {
+ var sum = nums_tmp(i) + nums_tmp(j) + nums_tmp(left) + nums_tmp(right)
+ if (sum == target) {
+ // 满足要求，直接加入到集合里面去
+ res += List(nums_tmp(i), nums_tmp(j), nums_tmp(left), nums_tmp(right))
+ while (left < right && nums_tmp(left) == nums_tmp(left + 1)) left += 1
+ while (left < right && nums_tmp(right) == nums_tmp(right - 1)) right -= 1
+ left += 1
+ right -= 1
+ } else if (sum < target) left += 1
+ else right -= 1
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ // 最终返回的res要转换为List，return关键字可以省略
+ res.toList
+ }
+}
+```
-----------------------
From e4da60add91e39177250f6808c3846c9b563612a Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sat, 14 May 2022 15:44:42 +0800
Subject: [PATCH 60/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200344.=E5=8F=8D?=
=?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0344.反转字符串.md | 16 +++++++++++++++-
1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/problems/0344.反转字符串.md b/problems/0344.反转字符串.md
index 58bada05..e1f27bd7 100644
--- a/problems/0344.反转字符串.md
+++ b/problems/0344.反转字符串.md
@@ -266,6 +266,20 @@ public class Solution
}
}
```
-
+Scala:
+```scala
+object Solution {
+ def reverseString(s: Array[Char]): Unit = {
+ var (left, right) = (0, s.length - 1)
+ while (left < right) {
+ var tmp = s(left)
+ s(left) = s(right)
+ s(right) = tmp
+ left += 1
+ right -= 1
+ }
+ }
+}
+```
-----------------------
From f2dcdbe94757d3ef88278e4f8c80281ce7baf5c9 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sat, 14 May 2022 16:32:23 +0800
Subject: [PATCH 61/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200541.=E5=8F=8D?=
=?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2II.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0541.反转字符串II.md | 41 ++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/problems/0541.反转字符串II.md b/problems/0541.反转字符串II.md
index 8c13a390..99d6ebe0 100644
--- a/problems/0541.反转字符串II.md
+++ b/problems/0541.反转字符串II.md
@@ -347,6 +347,47 @@ public class Solution
}
}
```
+Scala:
+版本一: (正常解法)
+```scala
+object Solution {
+ def reverseStr(s: String, k: Int): String = {
+ val res = s.toCharArray // 转换为Array好处理
+ for (i <- s.indices by 2 * k) {
+ // 如果i+k大于了res的长度，则需要全部翻转
+ if (i + k > res.length) {
+ reverse(res, i, s.length - 1)
+ } else {
+ reverse(res, i, i + k - 1)
+ }
+ }
+ new String(res)
+ }
+ // 翻转字符串，从start到end
+ def reverse(s: Array[Char], start: Int, end: Int): Unit = {
+ var (left, right) = (start, end)
+ while (left < right) {
+ var tmp = s(left)
+ s(left) = s(right)
+ s(right) = tmp
+ left += 1
+ right -= 1
+ }
+ }
+}
+```
+版本二: 首先利用sliding每隔k个进行分割，随后转换为数组，再使用zipWithIndex添加每个数组的索引，紧接着利用map做变换，如果索引%2==0则说明需要翻转，否则原封不动，最后再转换为String
+```scala
+object Solution {
+ def reverseStr(s: String, k: Int): String = {
+ s.sliding(k, k)
+ .toArray
+ .zipWithIndex
+ .map(v => if (v._2 % 2 == 0) v._1.reverse else v._1)
+ .mkString
+ }
+}
+```
-----------------------
From 037bebbe90eb7bd607314d5d3d5d63e506f5aeeb Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sat, 14 May 2022 17:04:40 +0800
Subject: [PATCH 62/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E5=89=91=E6=8C=87Of?=
=?UTF-8?q?fer05.=E6=9B=BF=E6=8D=A2=E7=A9=BA=E6=A0=BC.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/剑指Offer05.替换空格.md | 56 +++++++++++++++++++++++++-
1 file changed, 55 insertions(+), 1 deletion(-)
diff --git a/problems/剑指Offer05.替换空格.md b/problems/剑指Offer05.替换空格.md
index 037bd427..eecd7f0c 100644
--- a/problems/剑指Offer05.替换空格.md
+++ b/problems/剑指Offer05.替换空格.md
@@ -413,8 +413,62 @@ func replaceSpace(_ s: String) -> String {
}
```
+Scala:
-
+方式一: 双指针
+```scala
+object Solution {
+ def replaceSpace(s: String): String = {
+ var count = 0
+ s.foreach(c => if (c == ' ') count += 1) // 统计空格的数量
+ val sOldSize = s.length // 旧数组字符串长度
+ val sNewSize = s.length + count * 2 // 新数组字符串长度
+ val res = new Array[Char](sNewSize) // 新数组
+ var index = sNewSize - 1 // 新数组索引
+ // 逆序遍历
+ for (i <- (0 until sOldSize).reverse) {
+ if (s(i) == ' ') {
+ res(index) = '0'
+ index -= 1
+ res(index) = '2'
+ index -= 1
+ res(index) = '%'
+ } else {
+ res(index) = s(i)
+ }
+ index -= 1
+ }
+ res.mkString
+ }
+}
+```
+方式二: 使用一个集合，遇到空格就添加%20
+```scala
+object Solution {
+ import scala.collection.mutable.ListBuffer
+ def replaceSpace(s: String): String = {
+ val res: ListBuffer[Char] = ListBuffer[Char]()
+ for (i <- s.indices) {
+ if (s(i) == ' ') {
+ res += '%'
+ res += '2'
+ res += '0'
+ }else{
+ res += s(i)
+ }
+ }
+ res.mkString
+ }
+}
+```
+方式三: 使用map
+```scala
+object Solution {
+ def replaceSpace(s: String): String = {
+ s.map(c => if(c == ' ') "%20" else c).mkString
+ }
+}
+```
-----------------------
From 1c369bb83631f4449af7e646bc26bc86aacc5442 Mon Sep 17 00:00:00 2001
From: 3Xpl0it3r
Date: Sat, 14 May 2022 23:24:57 +0800
Subject: [PATCH 63/99] 102 in rust
---
problems/0102.二叉树的层序遍历.md | 59 +++++++++++++++++++++++
1 file changed, 59 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..13267819 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -299,6 +299,36 @@ func levelOrder(_ root: TreeNode?) -> [[Int]] {
}
```
+Rust:
+
+```rust
+pub fn level_order(root: Option>>) -> Vec> {
+ let mut ans = Vec::new();
+ let mut stack = Vec::new();
+ if root.is_none(){
+ return ans;
+ }
+ stack.push(root.unwrap());
+ while stack.is_empty()!= true{
+ let num = stack.len();
+ let mut level = Vec::new();
+ for _i in 0..num{
+ let tmp = stack.remove(0);
+ level.push(tmp.borrow_mut().val);
+ if tmp.borrow_mut().left.is_some(){
+ stack.push(tmp.borrow_mut().left.take().unwrap());
+ }
+ if tmp.borrow_mut().right.is_some(){
+ stack.push(tmp.borrow_mut().right.take().unwrap());
+ }
+ }
+ ans.push(level);
+ }
+ ans
+}
+```
+
+
**此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒！**
@@ -528,6 +558,35 @@ func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
}
```
+Rust:
+
+```rust
+pub fn level_order(root: Option>>) -> Vec> {
+ let mut ans = Vec::new();
+ let mut stack = Vec::new();
+ if root.is_none(){
+ return ans;
+ }
+ stack.push(root.unwrap());
+ while stack.is_empty()!= true{
+ let num = stack.len();
+ let mut level = Vec::new();
+ for _i in 0..num{
+ let tmp = stack.remove(0);
+ level.push(tmp.borrow_mut().val);
+ if tmp.borrow_mut().left.is_some(){
+ stack.push(tmp.borrow_mut().left.take().unwrap());
+ }
+ if tmp.borrow_mut().right.is_some(){
+ stack.push(tmp.borrow_mut().right.take().unwrap());
+ }
+ }
+ ans.push(level);
+ }
+ ans
+}
+```
+
# 199.二叉树的右视图
[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-right-side-view/)
From 5da6c06ef9fd308e9ab77b8393e81377eec75821 Mon Sep 17 00:00:00 2001
From: unknown
Date: Sat, 14 May 2022 16:27:47 +0100
Subject: [PATCH 64/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E8=83=8C=E5=8C=85?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E8=82=8C=E9=86=8701=E8=83=8C=E5=8C=85=20C?=
=?UTF-8?q?=E8=AF=AD=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-1.md | 46 ++++++++++++++++++++++++
1 file changed, 46 insertions(+)
diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md
index fe940b4c..43ad26be 100644
--- a/problems/背包理论基础01背包-1.md
+++ b/problems/背包理论基础01背包-1.md
@@ -423,5 +423,51 @@ function test () {
test();
```
+### C
+```c
+#include
+#include
+#include
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define ARR_SIZE(a) (sizeof((a)) / sizeof((a)[0]))
+#define BAG_WEIGHT 4
+
+void backPack(int* weights, int weightSize, int* costs, int costSize, int bagWeight) {
+ // 开辟dp数组
+ int dp[weightSize][bagWeight + 1];
+ memset(dp, 0, sizeof(int) * weightSize * (bagWeight + 1));
+
+ int i, j;
+ // 当背包容量大于物品0的重量时，将物品0放入到背包中
+ for(j = weights[0]; j <= bagWeight; ++j) {
+ dp[0][j] = costs[0];
+ }
+
+ // 先遍历物品，再遍历重量
+ for(j = 1; j <= bagWeight; ++j) {
+ for(i = 1; i < weightSize; ++i) {
+ // 如果当前背包容量小于物品重量
+ if(j < weights[i])
+ // 背包物品的价值等于背包不放置当前物品时的价值
+ dp[i][j] = dp[i-1][j];
+ // 若背包当前重量可以放置物品
+ else
+ // 背包的价值等于放置该物品或不放置该物品的最大值
+ dp[i][j] = MAX(dp[i - 1][j], dp[i - 1][j - weights[i]] + costs[i]);
+ }
+ }
+
+ printf("%d\n", dp[weightSize - 1][bagWeight]);
+}
+
+int main(int argc, char* argv[]) {
+ int weights[] = {1, 3, 4};
+ int costs[] = {15, 20, 30};
+ backPack(weights, ARR_SIZE(weights), costs, ARR_SIZE(costs), BAG_WEIGHT);
+ return 0;
+}
+```
+
-----------------------
From ab4d42cf0c41ce9089838dee087e961aac1b6357 Mon Sep 17 00:00:00 2001
From: n4feng
Date: Sat, 14 May 2022 12:52:11 -0400
Subject: [PATCH 65/99] =?UTF-8?q?Update=200739.=E6=AF=8F=E6=97=A5=E6=B8=A9?=
=?UTF-8?q?=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
少了一个关键词“高”
---
problems/0739.每日温度.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md
index 5f53e412..367e521a 100644
--- a/problems/0739.每日温度.md
+++ b/problems/0739.每日温度.md
@@ -34,7 +34,7 @@
那么单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？
-单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素的元素，优点是只需要遍历一次。
+单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是只需要遍历一次。
在使用单调栈的时候首先要明确如下几点：
From 78b367e5c5ee493a96cfe4ebcb440059909db285 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sun, 15 May 2022 12:57:39 +0800
Subject: [PATCH 66/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200151.=E7=BF=BB?=
=?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2=E9=87=8C=E7=9A=84=E5=8D=95?=
=?UTF-8?q?=E8=AF=8D.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0151.翻转字符串里的单词.md | 56 ++++++++++++++++++++
1 file changed, 56 insertions(+)
diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
index d03de421..0e25fc4d 100644
--- a/problems/0151.翻转字符串里的单词.md
+++ b/problems/0151.翻转字符串里的单词.md
@@ -758,7 +758,63 @@ func reverseWord(_ s: inout [Character]) {
}
```
+Scala:
+```scala
+object Solution {
+ def reverseWords(s: String): String = {
+ var sb = removeSpace(s) // 移除多余的空格
+ reverseString(sb, 0, sb.length - 1) // 翻转字符串
+ reverseEachWord(sb)
+ sb.mkString
+ }
+
+ // 移除多余的空格
+ def removeSpace(s: String): Array[Char] = {
+ var start = 0
+ var end = s.length - 1
+ // 移除字符串前面的空格
+ while (start < s.length && s(start) == ' ') start += 1
+ // 移除字符串后面的空格
+ while (end >= 0 && s(end) == ' ') end -= 1
+ var sb = "" // String
+ // 当start小于等于end的时候，执行添加操作
+ while (start <= end) {
+ var c = s(start)
+ // 当前字符不等于空，sb的最后一个字符不等于空的时候添加到sb
+ if (c != ' ' || sb(sb.length - 1) != ' ') {
+ sb ++= c.toString
+ }
+ start += 1 // 指针向右移动
+ }
+ sb.toArray
+ }
+
+ // 翻转字符串
+ def reverseString(s: Array[Char], start: Int, end: Int): Unit = {
+ var (left, right) = (start, end)
+ while (left < right) {
+ var tmp = s(left)
+ s(left) = s(right)
+ s(right) = tmp
+ left += 1
+ right -= 1
+ }
+ }
+
+ // 翻转每个单词
+ def reverseEachWord(s: Array[Char]): Unit = {
+ var i = 0
+ while (i < s.length) {
+ var j = i + 1
+ // 向后迭代寻找每个单词的坐标
+ while (j < s.length && s(j) != ' ') j += 1
+ reverseString(s, i, j - 1) // 翻转每个单词
+ i = j + 1 // i往后更新
+ }
+ }
+}
+```
From c7d356f8559fd2c46eb4e9e2889fdbe0bdaafed1 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Sun, 15 May 2022 12:59:38 +0800
Subject: [PATCH 67/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E5=89=91=E6=8C=87Of?=
=?UTF-8?q?fer58-II.=E5=B7=A6=E6=97=8B=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../剑指Offer58-II.左旋转字符串.md | 27 +++++++++++++++++++
1 file changed, 27 insertions(+)
diff --git a/problems/剑指Offer58-II.左旋转字符串.md b/problems/剑指Offer58-II.左旋转字符串.md
index fec83e1d..581ac1c7 100644
--- a/problems/剑指Offer58-II.左旋转字符串.md
+++ b/problems/剑指Offer58-II.左旋转字符串.md
@@ -290,7 +290,34 @@ func reverseString(_ s: inout [Character], startIndex: Int, endIndex: Int) {
}
```
+Scala:
+```scala
+object Solution {
+ def reverseLeftWords(s: String, n: Int): String = {
+ var str = s.toCharArray // 转换为Array
+ // abcdefg => ba cdefg
+ reverseString(str, 0, n - 1)
+ // ba cdefg => ba gfedc
+ reverseString(str, n, str.length - 1)
+ // ba gfedc => cdefgab
+ reverseString(str, 0, str.length - 1)
+ // 最终返回，return关键字可以省略
+ new String(str)
+ }
+ // 翻转字符串
+ def reverseString(s: Array[Char], start: Int, end: Int): Unit = {
+ var (left, right) = (start, end)
+ while (left < right) {
+ var tmp = s(left)
+ s(left) = s(right)
+ s(right) = tmp
+ left += 1
+ right -= 1
+ }
+ }
+}
+```
From f1061d0f8962fe8e4a4c0691d8401ee5fe505f99 Mon Sep 17 00:00:00 2001
From: GitHubQAQ <31883473+GitHubQAQ@users.noreply.github.com>
Date: Sun, 15 May 2022 19:12:13 +0800
Subject: [PATCH 68/99] =?UTF-8?q?Update=200056.=E5=90=88=E5=B9=B6=E5=8C=BA?=
=?UTF-8?q?=E9=97=B4.md=20=20-=20-=E8=A7=84=E8=8C=83C++=E4=BB=A3=E7=A0=81?=
=?UTF-8?q?=E4=B8=AD=E7=9A=84lambda=E8=A1=A8=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0056.合并区间.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0056.合并区间.md b/problems/0056.合并区间.md
index b44d602c..52a98d70 100644
--- a/problems/0056.合并区间.md
+++ b/problems/0056.合并区间.md
@@ -96,7 +96,7 @@ public:
vector> merge(vector>& intervals) {
vector> result;
if (intervals.size() == 0) return result;
- // 排序的参数使用了lamda表达式
+ // 排序的参数使用了lambda表达式
sort(intervals.begin(), intervals.end(), [](const vector& a, const vector& b){return a[0] < b[0];});
result.push_back(intervals[0]);
From 224b3d293b6b2c9465e00b2127cf1d75f44775df Mon Sep 17 00:00:00 2001
From: wangning
Date: Sun, 15 May 2022 20:15:11 +0800
Subject: [PATCH 69/99] =?UTF-8?q?=E4=BF=AE=E6=94=B9=EF=BC=9A0404=E5=B7=A6?=
=?UTF-8?q?=E5=8F=B6=E5=AD=90=E4=B9=8B=E5=92=8Cjavascript=E7=89=88?=
=?UTF-8?q?=E6=9C=AC=E8=B0=83=E7=94=A8=E6=96=B9=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0404.左叶子之和.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
index d7fd629e..4ef68d3b 100644
--- a/problems/0404.左叶子之和.md
+++ b/problems/0404.左叶子之和.md
@@ -336,8 +336,8 @@ var sumOfLeftLeaves = function(root) {
if(node===null){
return 0;
}
- let leftValue = sumOfLeftLeaves(node.left);
- let rightValue = sumOfLeftLeaves(node.right);
+ let leftValue = nodesSum(node.left);
+ let rightValue = nodesSum(node.right);
// 3. 单层递归逻辑
let midValue = 0;
if(node.left&&node.left.left===null&&node.left.right===null){
From aa22b802a5986f06a123c59f395bf49aba779d1a Mon Sep 17 00:00:00 2001
From: unknown
Date: Sun, 15 May 2022 14:39:41 +0100
Subject: [PATCH 70/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E8=83=8C=E5=8C=85?=
=?UTF-8?q?=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=8001-2.mc=20C=E8=AF=AD?=
=?UTF-8?q?=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/背包理论基础01背包-2.md | 33 ++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index dabdfb2d..a99a872b 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -315,6 +315,39 @@ function test () {
test();
```
+### C
+```c
+#include
+#include
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define ARR_SIZE(arr) ((sizeof((arr))) / sizeof((arr)[0]))
+#define BAG_WEIGHT 4
+
+void test_back_pack(int* weights, int weightSize, int* values, int valueSize, int bagWeight) {
+ int dp[bagWeight + 1];
+ memset(dp, 0, sizeof(int) * (bagWeight + 1));
+
+ int i, j;
+ // 先遍历物品
+ for(i = 0; i < weightSize; ++i) {
+ // 后遍历重量。从后向前遍历
+ for(j = bagWeight; j >= weights[i]; --j) {
+ dp[j] = MAX(dp[j], dp[j - weights[i]] + values[i]);
+ }
+ }
+
+ // 打印最优结果
+ printf("%d\n", dp[bagWeight]);
+}
+
+int main(int argc, char** argv) {
+ int weights[] = {1, 3, 4};
+ int values[] = {15, 20, 30};
+ test_back_pack(weights, ARR_SIZE(weights), values, ARR_SIZE(values), BAG_WEIGHT);
+ return 0;
+}
+```
-----------------------
From 19abe18019814af74ee51ba56e4e8ee6106b1253 Mon Sep 17 00:00:00 2001
From: unknown
Date: Sun, 15 May 2022 15:26:23 +0100
Subject: [PATCH 71/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200416.=E5=88=86?=
=?UTF-8?q?=E5=89=B2=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md=20C=E8=AF=AD?=
=?UTF-8?q?=E8=A8=80=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0416.分割等和子集.md | 100 ++++++++++++++++++++++++++++
1 file changed, 100 insertions(+)
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index 6e93ae8e..76cfd87f 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -416,6 +416,106 @@ var canPartition = function(nums) {
};
```
+C:
+二维dp：
+```c
+/**
+1. dp数组含义：dp[i][j]为背包重量为j时，从[0-i]元素和最大值
+2. 递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i])
+3. 初始化：dp[i][0]初始化为0。因为背包重量为0时，不可能放入元素。dp[0][j] = nums[0]，当j >= nums[0] && j < target时
+4. 遍历顺序：先遍历物品，再遍历背包
+*/
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+int getSum(int* nums, int numsSize) {
+ int sum = 0;
+
+ int i;
+ for(i = 0; i < numsSize; ++i) {
+ sum += nums[i];
+ }
+ return sum;
+}
+
+bool canPartition(int* nums, int numsSize){
+ // 求出元素总和
+ int sum = getSum(nums, numsSize);
+ // 若元素总和为奇数，则不可能得到两个和相等的子数组
+ if(sum % 2)
+ return false;
+
+ // 若子数组的和等于target，则nums可以被分割
+ int target = sum / 2;
+ // 初始化dp数组
+ int dp[numsSize][target + 1];
+ // dp[j][0]都应被设置为0。因为当背包重量为0时，不可放入元素
+ memset(dp, 0, sizeof(int) * numsSize * (target + 1));
+
+ int i, j;
+ // 当背包重量j大于nums[0]时，可以在dp[0][j]中放入元素nums[0]
+ for(j = nums[0]; j <= target; ++j) {
+ dp[0][j] = nums[0];
+ }
+
+ for(i = 1; i < numsSize; ++i) {
+ for(j = 1; j <= target; ++j) {
+ // 若当前背包重量j小于nums[i]，则其值等于只考虑0到i-1物品时的值
+ if(j < nums[i])
+ dp[i][j] = dp[i - 1][j];
+ // 否则，背包重量等于在背包中放入num[i]/不放入nums[i]的较大值
+ else
+ dp[i][j] = MAX(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
+ }
+ }
+ // 判断背包重量为target，且考虑到所有物品时，放入的元素和是否等于target
+ return dp[numsSize - 1][target] == target;
+}
+```
+滚动数组：
+```c
+/**
+1. dp数组含义：dp[j]为背包重量为j时，其中可放入元素的最大值
+2. 递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
+3. 初始化：均初始化为0即可
+4. 遍历顺序：先遍历物品，再后序遍历背包
+*/
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+int getSum(int* nums, int numsSize) {
+ int sum = 0;
+
+ int i;
+ for(i = 0; i < numsSize; ++i) {
+ sum += nums[i];
+ }
+ return sum;
+}
+
+bool canPartition(int* nums, int numsSize){
+ // 求出元素总和
+ int sum = getSum(nums, numsSize);
+ // 若元素总和为奇数，则不可能得到两个和相等的子数组
+ if(sum % 2)
+ return false;
+ // 背包容量
+ int target = sum / 2;
+
+ // 初始化dp数组，元素均为0
+ int dp[target + 1];
+ memset(dp, 0, sizeof(int) * (target + 1));
+
+ int i, j;
+ // 先遍历物品，后遍历背包
+ for(i = 0; i < numsSize; ++i) {
+ for(j = target; j >= nums[i]; --j) {
+ dp[j] = MAX(dp[j], dp[j - nums[i]] + nums[i]);
+ }
+ }
+
+ // 查看背包容量为target时，元素总和是否等于target
+ return dp[target] == target;
+}
+```
From 14afd23b9ea5e491a60d91f07c0b8211f4f9ae00 Mon Sep 17 00:00:00 2001
From: HanMengnan <1448189829@qq.com>
Date: Mon, 16 May 2022 10:46:43 +0800
Subject: [PATCH 72/99] =?UTF-8?q?=E6=9B=B4=E6=96=B00516.=E6=9C=80=E9=95=BF?=
=?UTF-8?q?=E5=9B=9E=E6=96=87=E5=AD=90=E5=BA=8F=E5=88=97=E7=9A=84Go?=
=?UTF-8?q?=E5=AE=9E=E7=8E=B0=E6=8F=90=E4=BE=9B=E4=BA=86=E4=B8=80=E7=A7=8D?=
=?UTF-8?q?=E6=9B=B4=E4=BC=98=E7=9A=84=E6=96=B9=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0516.最长回文子序列.md | 39 +++++++++++++-------------
1 file changed, 19 insertions(+), 20 deletions(-)
diff --git a/problems/0516.最长回文子序列.md b/problems/0516.最长回文子序列.md
index 69536cef..63120b14 100644
--- a/problems/0516.最长回文子序列.md
+++ b/problems/0516.最长回文子序列.md
@@ -186,29 +186,28 @@ class Solution:
Go：
```Go
func longestPalindromeSubseq(s string) int {
- lenth:=len(s)
- dp:=make([][]int,lenth)
- for i:=0;i b {
+ return a
+ }
+ return b
+ }
+ dp := make([][]int, size)
+ for i := 0; i < size; i++ {
+ dp[i] = make([]int, size)
+ dp[i][i] = 1
+ }
+ for i := size - 1; i >= 0; i-- {
+ for j := i + 1; j < size; j++ {
+ if s[i] == s[j] {
+ dp[i][j] = dp[i+1][j-1] + 2
+ } else {
+ dp[i][j] = max(dp[i][j-1], dp[i+1][j])
}
}
}
- for i:=lenth-1;i>=0;i--{
- for j:=i+1;j
Date: Mon, 16 May 2022 14:51:05 +0900
Subject: [PATCH 73/99] chore: Add new solution to LeetCode 203
Without using pre Node
---
problems/0203.移除链表元素.md | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index c34831b7..9cedfe93 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -234,6 +234,27 @@ public ListNode removeElements(ListNode head, int val) {
}
return head;
}
+/**
+ * 不添加虚拟节点and pre Node方式
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(1)
+ * @param head
+ * @param val
+ * @return
+ */
+public ListNode removeElements(ListNode head, int val) {
+ while(head!=null && head.val==val){
+ head = head.next;
+ }
+ ListNode curr = head;
+ while(curr!=null){
+ while(curr.next!=null && curr.next.val == val){
+ curr.next = curr.next.next;
+ }
+ curr = curr.next;
+ }
+ return head;
+}
```
Python：
From 08147d132c4611e190d03a47bc870294d3cc1292 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Mon, 16 May 2022 14:28:02 +0800
Subject: [PATCH 74/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200232.=E7=94=A8?=
=?UTF-8?q?=E6=A0=88=E5=AE=9E=E7=8E=B0=E9=98=9F=E5=88=97.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0232.用栈实现队列.md | 39 +++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 1a56d9f3..d9ba8e26 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -495,6 +495,45 @@ void myQueueFree(MyQueue* obj) {
obj->stackOutTop = 0;
}
```
+Scala:
+```scala
+class MyQueue() {
+ import scala.collection.mutable
+ val stackIn = mutable.Stack[Int]() // 负责出栈
+ val stackOut = mutable.Stack[Int]() // 负责入栈
+ // 添加元素
+ def push(x: Int) {
+ stackIn.push(x)
+ }
+
+ // 复用代码，如果stackOut为空就把stackIn的所有元素都压入StackOut
+ def dumpStackIn(): Unit = {
+ if (!stackOut.isEmpty) return
+ while (!stackIn.isEmpty) {
+ stackOut.push(stackIn.pop())
+ }
+ }
+
+ // 弹出元素
+ def pop(): Int = {
+ dumpStackIn()
+ stackOut.pop()
+ }
+
+ // 获取队头
+ def peek(): Int = {
+ dumpStackIn()
+ val res: Int = stackOut.pop()
+ stackOut.push(res)
+ res
+ }
+
+ // 判断是否为空
+ def empty(): Boolean = {
+ stackIn.isEmpty && stackOut.isEmpty
+ }
+}
+```
-----------------------
From f4d98a744ee9c14ed88d07be559aa310508d89f9 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Mon, 16 May 2022 14:56:10 +0800
Subject: [PATCH 75/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200225.=E7=94=A8?=
=?UTF-8?q?=E9=98=9F=E5=88=97=E5=AE=9E=E7=8E=B0=E6=A0=88.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0225.用队列实现栈.md | 83 +++++++++++++++++++++++++++++
1 file changed, 83 insertions(+)
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index 3457c4b3..3c134870 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -815,6 +815,89 @@ class MyStack {
}
}
```
+Scala:
+使用两个队列模拟栈:
+```scala
+import scala.collection.mutable
+
+class MyStack() {
+
+ val queue1 = new mutable.Queue[Int]()
+ val queue2 = new mutable.Queue[Int]()
+
+ def push(x: Int) {
+ queue1.enqueue(x)
+ }
+
+ def pop(): Int = {
+ var size = queue1.size
+ // 将queue1中的每个元素都移动到queue2
+ for (i <- 0 until size - 1) {
+ queue2.enqueue(queue1.dequeue())
+ }
+ var res = queue1.dequeue()
+ // 再将queue2中的每个元素都移动到queue1
+ while (!queue2.isEmpty) {
+ queue1.enqueue(queue2.dequeue())
+ }
+ res
+ }
+
+ def top(): Int = {
+ var size = queue1.size
+ for (i <- 0 until size - 1) {
+ queue2.enqueue(queue1.dequeue())
+ }
+ var res = queue1.dequeue()
+ while (!queue2.isEmpty) {
+ queue1.enqueue(queue2.dequeue())
+ }
+ // 最终还需要把res送进queue1
+ queue1.enqueue(res)
+ res
+ }
+
+ def empty(): Boolean = {
+ queue1.isEmpty
+ }
+}
+```
+使用一个队列模拟:
+```scala
+import scala.collection.mutable
+
+class MyStack() {
+
+ val queue = new mutable.Queue[Int]()
+
+ def push(x: Int) {
+ queue.enqueue(x)
+ }
+
+ def pop(): Int = {
+ var size = queue.size
+ for (i <- 0 until size - 1) {
+ queue.enqueue(queue.head) // 把头添到队列最后
+ queue.dequeue() // 再出队
+ }
+ queue.dequeue()
+ }
+
+ def top(): Int = {
+ var size = queue.size
+ var res = 0
+ for (i <- 0 until size) {
+ queue.enqueue(queue.head) // 把头添到队列最后
+ res = queue.dequeue() // 再出队
+ }
+ res
+ }
+
+ def empty(): Boolean = {
+ queue.isEmpty
+ }
+}
+```
-----------------------
From 8df1b4b237552c189fa1a5788442c422c9296d07 Mon Sep 17 00:00:00 2001
From: madeai
Date: Mon, 16 May 2022 16:38:53 +0800
Subject: [PATCH 76/99] =?UTF-8?q?Update=200739.=E6=AF=8F=E6=97=A5=E6=B8=A9?=
=?UTF-8?q?=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0739.每日温度.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/problems/0739.每日温度.md b/problems/0739.每日温度.md
index 5f53e412..2305d135 100644
--- a/problems/0739.每日温度.md
+++ b/problems/0739.每日温度.md
@@ -192,7 +192,7 @@ class Solution {
否则的话，可以直接入栈。
注意，单调栈里 加入的元素是 下标。
*/
- Stackstack=new Stack<>();
+ Deque stack=new LinkedList<>();
stack.push(0);
for(int i=1;istack=new Stack<>();
+ Deque stack=new LinkedList<>();
for(int i=0;itemperatures[stack.peek()]){
From 61f5d920d05ea01858272bc04f8bcea0a89d6991 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Mon, 16 May 2022 17:07:23 +0800
Subject: [PATCH 77/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200020.=E6=9C=89?=
=?UTF-8?q?=E6=95=88=E7=9A=84=E6=8B=AC=E5=8F=B7.md=20Scala=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0020.有效的括号.md | 23 ++++++++++++++++++++++-
1 file changed, 22 insertions(+), 1 deletion(-)
diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index 7bb7f746..a0df0d07 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -400,6 +400,27 @@ bool isValid(char * s){
return !stackTop;
}
```
-
+Scala:
+```scala
+object Solution {
+ import scala.collection.mutable
+ def isValid(s: String): Boolean = {
+ if(s.length % 2 != 0) return false // 如果字符串长度是奇数直接返回false
+ val stack = mutable.Stack[Char]()
+ // 循环遍历字符串
+ for (i <- s.indices) {
+ val c = s(i)
+ if (c == '(' || c == '[' || c == '{') stack.push(c)
+ else if(stack.isEmpty) return false // 如果没有(、[、{则直接返回false
+ // 以下三种情况，不满足则直接返回false
+ else if(c==')' && stack.pop() != '(') return false
+ else if(c==']' && stack.pop() != '[') return false
+ else if(c=='}' && stack.pop() != '{') return false
+ }
+ // 如果为空则正确匹配，否则还有余孽就不匹配
+ stack.isEmpty
+ }
+}
+```
-----------------------
From 98bdccbe16bbb6c8c66e027d901f4fbd3baafffe Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Mon, 16 May 2022 17:24:47 +0800
Subject: [PATCH 78/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=201047.=E5=88=A0?=
=?UTF-8?q?=E9=99=A4=E5=AD=97=E7=AC=A6=E4=B8=B2=E4=B8=AD=E7=9A=84=E6=89=80?=
=?UTF-8?q?=E6=9C=89=E7=9B=B8=E9=82=BB=E9=87=8D=E5=A4=8D=E9=A1=B9.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...除字符串中的所有相邻重复项.md | 23 ++++++++++++++++++-
1 file changed, 22 insertions(+), 1 deletion(-)
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index 638c8f4e..a92a3911 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -374,6 +374,27 @@ func removeDuplicates(_ s: String) -> String {
return String(stack)
}
```
-
+Scala:
+```scala
+object Solution {
+ import scala.collection.mutable
+ def removeDuplicates(s: String): String = {
+ var stack = mutable.Stack[Int]()
+ var str = "" // 保存最终结果
+ for (i <- s.indices) {
+ var tmp = s(i)
+ // 如果栈非空并且栈顶元素等于当前字符，那么删掉栈顶和字符串最后一个元素
+ if (!stack.isEmpty && tmp == stack.head) {
+ str = str.take(str.length - 1)
+ stack.pop()
+ } else {
+ stack.push(tmp)
+ str += tmp
+ }
+ }
+ str
+ }
+}
+```
-----------------------
From 8c394c9f8588a1e94250dc93bede24b7380996f8 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 17 May 2022 17:08:11 +0800
Subject: [PATCH 79/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200150.=E9=80=86?=
=?UTF-8?q?=E6=B3=A2=E5=85=B0=E8=A1=A8=E8=BE=BE=E5=BC=8F=E6=B1=82=E5=80=BC?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0150.逆波兰表达式求值.md | 29 ++++++++++++++++++++++-
1 file changed, 28 insertions(+), 1 deletion(-)
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index fd3d69aa..47da06f6 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -325,6 +325,33 @@ func evalRPN(_ tokens: [String]) -> Int {
return stack.last!
}
```
-
+Scala:
+```scala
+object Solution {
+ import scala.collection.mutable
+ def evalRPN(tokens: Array[String]): Int = {
+ val stack = mutable.Stack[Int]() // 定义栈
+ // 抽取运算操作，需要传递x,y，和一个函数
+ def operator(x: Int, y: Int, f: (Int, Int) => Int): Int = f(x, y)
+ for (token <- tokens) {
+ // 模式匹配，匹配不同的操作符做什么样的运算
+ token match {
+ // 最后一个参数 _+_，代表x+y，遵循Scala的函数至简原则，以下运算同理
+ case "+" => stack.push(operator(stack.pop(), stack.pop(), _ + _))
+ case "-" => stack.push(operator(stack.pop(), stack.pop(), -_ + _))
+ case "*" => stack.push(operator(stack.pop(), stack.pop(), _ * _))
+ case "/" => {
+ var pop1 = stack.pop()
+ var pop2 = stack.pop()
+ stack.push(operator(pop2, pop1, _ / _))
+ }
+ case _ => stack.push(token.toInt) // 不是运算符就入栈
+ }
+ }
+ // 最后返回栈顶，不需要加return关键字
+ stack.pop()
+ }
+}
+```
-----------------------
From 349383321ff1ed393effb9ebaad075a7736cf98e Mon Sep 17 00:00:00 2001
From: SevenMonths
Date: Tue, 17 May 2022 17:45:40 +0800
Subject: [PATCH 80/99] =?UTF-8?q?=E5=A2=9E=E5=8A=A0KMP=20php=E7=89=88?=
=?UTF-8?q?=E6=9C=AC=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0028.实现strStr.md | 75 +++++++++++++++++++++++++++++++++++
1 file changed, 75 insertions(+)
diff --git a/problems/0028.实现strStr.md b/problems/0028.实现strStr.md
index d67e5f70..1cdd5292 100644
--- a/problems/0028.实现strStr.md
+++ b/problems/0028.实现strStr.md
@@ -1166,5 +1166,80 @@ func strStr(_ haystack: String, _ needle: String) -> Int {
```
+PHP：
+
+> 前缀表统一减一
+```php
+function strStr($haystack, $needle) {
+ if (strlen($needle) == 0) return 0;
+ $next= [];
+ $this->getNext($next,$needle);
+
+ $j = -1;
+ for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+ while($j >= 0 && $haystack[$i] != $needle[$j + 1]) {
+ $j = $next[$j];
+ }
+ if ($haystack[$i] == $needle[$j + 1]) {
+ $j++;
+ }
+ if ($j == (strlen($needle) - 1) ) {
+ return ($i - strlen($needle) + 1);
+ }
+ }
+ return -1;
+}
+
+function getNext(&$next, $s){
+ $j = -1;
+ $next[0] = $j;
+ for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+ while ($j >= 0 && $s[$i] != $s[$j + 1]) {
+ $j = $next[$j];
+ }
+ if ($s[$i] == $s[$j + 1]) {
+ $j++;
+ }
+ $next[$i] = $j;
+ }
+}
+```
+
+> 前缀表统一不减一
+```php
+function strStr($haystack, $needle) {
+ if (strlen($needle) == 0) return 0;
+ $next= [];
+ $this->getNext($next,$needle);
+
+ $j = 0;
+ for ($i = 0;$i < strlen($haystack); $i++) { // 注意i就从0开始
+ while($j > 0 && $haystack[$i] != $needle[$j]) {
+ $j = $next[$j-1];
+ }
+ if ($haystack[$i] == $needle[$j]) {
+ $j++;
+ }
+ if ($j == strlen($needle)) {
+ return ($i - strlen($needle) + 1);
+ }
+ }
+ return -1;
+}
+
+function getNext(&$next, $s){
+ $j = 0;
+ $next[0] = $j;
+ for($i = 1; $i < strlen($s); $i++) { // 注意i从1开始
+ while ($j > 0 && $s[$i] != $s[$j]) {
+ $j = $next[$j-1];
+ }
+ if ($s[$i] == $s[$j]) {
+ $j++;
+ }
+ $next[$i] = $j;
+ }
+}
+```
-----------------------
From 748a728420be62c835866e7027171462ef90f888 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 17 May 2022 18:41:52 +0800
Subject: [PATCH 81/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200239.=E6=BB=91?=
=?UTF-8?q?=E5=8A=A8=E7=AA=97=E5=8F=A3=E6=9C=80=E5=A4=A7=E5=80=BC.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0239.滑动窗口最大值.md | 47 ++++++++++++++++++++++++++
1 file changed, 47 insertions(+)
diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
index f269450f..eb32fdd2 100644
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@@ -630,6 +630,53 @@ func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
return result
}
```
+Scala:
+```scala
+import scala.collection.mutable.ArrayBuffer
+object Solution {
+ def maxSlidingWindow(nums: Array[Int], k: Int): Array[Int] = {
+ var len = nums.length - k + 1 // 滑动窗口长度
+ var res: Array[Int] = new Array[Int](len) // 声明存储结果的数组
+ var index = 0 // 结果数组指针
+ val queue: MyQueue = new MyQueue // 自定义队列
+ // 将前k个添加到queue
+ for (i <- 0 until k) {
+ queue.add(nums(i))
+ }
+ res(index) = queue.peek // 第一个滑动窗口的最大值
+ index += 1
+ for (i <- k until nums.length) {
+ queue.poll(nums(i - k)) // 首先移除第i-k个元素
+ queue.add(nums(i)) // 添加当前数字到队列
+ res(index) = queue.peek() // 赋值
+ index+=1
+ }
+ // 最终返回res，return关键字可以省略
+ res
+ }
+}
+
+class MyQueue {
+ var queue = ArrayBuffer[Int]()
+
+ // 移除元素，如果传递进来的跟队头相等，那么移除
+ def poll(value: Int): Unit = {
+ if (!queue.isEmpty && queue.head == value) {
+ queue.remove(0)
+ }
+ }
+
+ // 添加元素，当队尾大于当前元素就删除
+ def add(value: Int): Unit = {
+ while (!queue.isEmpty && value > queue.last) {
+ queue.remove(queue.length - 1)
+ }
+ queue.append(value)
+ }
+
+ def peek(): Int = queue.head
+}
+```
-----------------------
From 47c4cc102123b1b43f09b7b766fdd2f1e1b979a9 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Tue, 17 May 2022 19:52:32 +0800
Subject: [PATCH 82/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200347.=E5=89=8DK?=
=?UTF-8?q?=E4=B8=AA=E9=AB=98=E9=A2=91=E5=85=83=E7=B4=A0.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0347.前K个高频元素.md | 42 ++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 1d6a358b..20932b28 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -374,7 +374,49 @@ function topKFrequent(nums: number[], k: number): number[] {
};
```
+Scala:
+解法一: 优先级队列
+```scala
+object Solution {
+ import scala.collection.mutable
+ def topKFrequent(nums: Array[Int], k: Int): Array[Int] = {
+ val map = mutable.HashMap[Int, Int]()
+ // 将所有元素都放入Map
+ for (num <- nums) {
+ map.put(num, map.getOrElse(num, 0) + 1)
+ }
+ // 声明一个优先级队列，在函数柯里化那块需要指明排序方式
+ var queue = mutable.PriorityQueue[(Int, Int)]()(Ordering.fromLessThan((x, y) => x._2 > y._2))
+ // 将map里面的元素送入优先级队列
+ for (elem <- map) {
+ queue.enqueue(elem)
+ if(queue.size > k){
+ queue.dequeue // 如果队列元素大于k个，出队
+ }
+ }
+ // 最终只需要key的Array形式就可以了，return关键字可以省略
+ queue.map(_._1).toArray
+ }
+}
+```
+解法二: 相当于一个wordCount程序
+```scala
+object Solution {
+ def topKFrequent(nums: Array[Int], k: Int): Array[Int] = {
+ // 首先将数据变为(x,1)，然后按照x分组，再使用map进行转换(x,sum)，变换为Array
+ // 再使用sort针对sum进行排序，最后take前k个，再把数据变为x,y,z这种格式
+ nums.map((_, 1)).groupBy(_._1)
+ .map {
+ case (x, arr) => (x, arr.map(_._2).sum)
+ }
+ .toArray
+ .sortWith(_._2 > _._2)
+ .take(k)
+ .map(_._1)
+ }
+}
+```
-----------------------
From 6457d2d99775e9eddc1ab8386cdd5ca2d916b4b7 Mon Sep 17 00:00:00 2001
From: whusky <31883473+GitHubQAQ@users.noreply.github.com>
Date: Tue, 17 May 2022 21:22:17 +0800
Subject: [PATCH 83/99] =?UTF-8?q?Update=200063.=E4=B8=8D=E5=90=8C=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84II.md=20=20=E6=B7=BB=E5=8A=A0=E9=A2=84=E5=88=A4?=
=?UTF-8?q?=E6=96=AD=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
1. 优化代码高亮格式
2. 对于C++的第一种解法添加预判断代码
---
problems/0063.不同路径II.md | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/problems/0063.不同路径II.md b/problems/0063.不同路径II.md
index a40cceda..0e51e0fe 100644
--- a/problems/0063.不同路径II.md
+++ b/problems/0063.不同路径II.md
@@ -66,7 +66,7 @@ dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路
所以代码为：
-```
+```cpp
if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
@@ -76,7 +76,7 @@ if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i
在[62.不同路径](https://programmercarl.com/0062.不同路径.html)不同路径中我们给出如下的初始化：
-```
+```cpp
vector> dp(m, vector(n, 0)); // 初始值为0
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;
@@ -138,6 +138,8 @@ public:
int uniquePathsWithObstacles(vector>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
+ if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
+ return 0;
vector> dp(m, vector(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
From 552e24b171bae840f32ab865ae4518c8674492e3 Mon Sep 17 00:00:00 2001
From: molonlu
Date: Wed, 18 May 2022 11:49:55 +0800
Subject: [PATCH 84/99] =?UTF-8?q?Update=200226.=E7=BF=BB=E8=BD=AC=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
通过tmp显示交换的方式改为golang风格的交换
---
problems/0226.翻转二叉树.md | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index a3ebe24d..af5b8043 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -368,9 +368,7 @@ func invertTree(root *TreeNode) *TreeNode {
if root ==nil{
return nil
}
- temp:=root.Left
- root.Left=root.Right
- root.Right=temp
+ root.Left,root.Right=root.Right,root.Left//交换
invertTree(root.Left)
invertTree(root.Right)
From f389dcd987a7f9b381f146de9846fc4abfdb92ae Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 18 May 2022 16:23:50 +0800
Subject: [PATCH 85/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80.md=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/二叉树理论基础.md | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/problems/二叉树理论基础.md b/problems/二叉树理论基础.md
index 9c151e32..9e10ac20 100644
--- a/problems/二叉树理论基础.md
+++ b/problems/二叉树理论基础.md
@@ -258,6 +258,13 @@ class TreeNode {
}
}
```
-
+Scala:
+```scala
+class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+ var value: Int = _value
+ var left: TreeNode = _left
+ var right: TreeNode = _right
+}
+```
-----------------------
From b2be41e4bcd2c1ef6bc4951519e5134209b55689 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 18 May 2022 16:54:15 +0800
Subject: [PATCH 86/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=9A=84=E9=80=92=E5=BD=92=E9=81=8D=E5=8E=86.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/二叉树的递归遍历.md | 51 ++++++++++++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 186c39d3..29c0cfda 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -470,5 +470,56 @@ func postorder(_ root: TreeNode?, res: inout [Int]) {
res.append(root!.val)
}
```
+Scala: 前序遍历：（144.二叉树的前序遍历）
+```scala
+object Solution {
+ import scala.collection.mutable.ListBuffer
+ def preorderTraversal(root: TreeNode): List[Int] = {
+ val res = ListBuffer[Int]()
+ def traversal(curNode: TreeNode): Unit = {
+ if(curNode == null) return
+ res.append(curNode.value)
+ traversal(curNode.left)
+ traversal(curNode.right)
+ }
+ traversal(root)
+ res.toList
+ }
+}
+```
+中序遍历：（94. 二叉树的中序遍历）
+```scala
+object Solution {
+ import scala.collection.mutable.ListBuffer
+ def inorderTraversal(root: TreeNode): List[Int] = {
+ val res = ListBuffer[Int]()
+ def traversal(curNode: TreeNode): Unit = {
+ if(curNode == null) return
+ traversal(curNode.left)
+ res.append(curNode.value)
+ traversal(curNode.right)
+ }
+ traversal(root)
+ res.toList
+ }
+}
+```
+后序遍历：（145. 二叉树的后序遍历）
+```scala
+object Solution {
+ import scala.collection.mutable.ListBuffer
+ def postorderTraversal(root: TreeNode): List[Int] = {
+ val res = ListBuffer[Int]()
+ def traversal(curNode: TreeNode): Unit = {
+ if (curNode == null) return
+ traversal(curNode.left)
+ traversal(curNode.right)
+ res.append(curNode.value)
+ }
+ traversal(root)
+ res.toList
+ }
+}
+```
-----------------------
From d6d227c4affd046a47429454aa241bae12c7def2 Mon Sep 17 00:00:00 2001
From: areslk <543430610@qq.com>
Date: Wed, 18 May 2022 17:07:40 +0800
Subject: [PATCH 87/99] =?UTF-8?q?Update=200110.=E5=B9=B3=E8=A1=A1=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
修改注释
---
problems/0110.平衡二叉树.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index d98ff8a9..b7598365 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -208,7 +208,7 @@ int getHeight(TreeNode* node) {
```CPP
class Solution {
public:
- // 返回以该节点为根节点的二叉树的高度，如果不是二叉搜索树了则返回-1
+ // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
int getHeight(TreeNode* node) {
if (node == NULL) {
return 0;
From 4aad0f9ca58c0188248af5a1043a21722aae0129 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Wed, 18 May 2022 17:26:22 +0800
Subject: [PATCH 88/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=9A=84=E8=BF=AD=E4=BB=A3=E9=81=8D=E5=8E=86.md=20Sca?=
=?UTF-8?q?la=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/二叉树的迭代遍历.md | 65 ++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
diff --git a/problems/二叉树的迭代遍历.md b/problems/二叉树的迭代遍历.md
index 13ba5f1e..fac30f99 100644
--- a/problems/二叉树的迭代遍历.md
+++ b/problems/二叉树的迭代遍历.md
@@ -568,6 +568,71 @@ func inorderTraversal(_ root: TreeNode?) -> [Int] {
return result
}
```
+Scala:
+```scala
+// 前序遍历（迭代法）
+object Solution {
+ import scala.collection.mutable
+ def preorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ if (root == null) return res.toList
+ // 声明一个栈，泛型为TreeNode
+ val stack = mutable.Stack[TreeNode]()
+ stack.push(root) // 先把根节点压入栈
+ while (!stack.isEmpty) {
+ var curNode = stack.pop()
+ res.append(curNode.value) // 先把这个值压入栈
+ // 如果当前节点的左右节点不为空，则入栈，先放右节点，再放左节点
+ if (curNode.right != null) stack.push(curNode.right)
+ if (curNode.left != null) stack.push(curNode.left)
+ }
+ res.toList
+ }
+}
+// 中序遍历（迭代法）
+object Solution {
+ import scala.collection.mutable
+ def inorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ArrayBuffer[Int]()
+ if (root == null) return res.toList
+ val stack = mutable.Stack[TreeNode]()
+ var curNode = root
+ // 将左节点都入栈，当遍历到最左（到空）的时候，再弹出栈顶元素，加入res
+ // 再把栈顶元素的右节点加进来，继续下一轮遍历
+ while (curNode != null || !stack.isEmpty) {
+ if (curNode != null) {
+ stack.push(curNode)
+ curNode = curNode.left
+ } else {
+ curNode = stack.pop()
+ res.append(curNode.value)
+ curNode = curNode.right
+ }
+ }
+ res.toList
+ }
+}
+
+// 后序遍历（迭代法）
+object Solution {
+ import scala.collection.mutable
+ def postorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ if (root == null) return res.toList
+ val stack = mutable.Stack[TreeNode]()
+ stack.push(root)
+ while (!stack.isEmpty) {
+ val curNode = stack.pop()
+ res.append(curNode.value)
+ // 这次左节点先入栈，右节点再入栈
+ if(curNode.left != null) stack.push(curNode.left)
+ if(curNode.right != null) stack.push(curNode.right)
+ }
+ // 最后需要翻转List
+ res.reverse.toList
+ }
+}
+```
-----------------------
From b8b62ffc32de46005c4317150f952ad1aa483f5c Mon Sep 17 00:00:00 2001
From: 3Xpl0it3r
Date: Wed, 18 May 2022 18:31:37 +0800
Subject: [PATCH 89/99] =?UTF-8?q?=E6=A0=91=E6=B7=B1=E5=BA=A6=20rust?=
=?UTF-8?q?=E5=AE=9E=E7=8E=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0104.二叉树的最大深度.md | 27 ++++++++++
problems/0111.二叉树的最小深度.md | 64 +++++++++++++++++++++++
2 files changed, 91 insertions(+)
diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 2229a854..65a155fb 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -192,6 +192,33 @@ public:
};
```
+rust:
+```rust
+impl Solution {
+ pub fn max_depth(root: Option>>) -> i32 {
+ if root.is_none(){
+ return 0;
+ }
+ let mut max_depth: i32 = 0;
+ let mut stack = vec![root.unwrap()];
+ while !stack.is_empty() {
+ let num = stack.len();
+ for _i in 0..num{
+ let top = stack.remove(0);
+ if top.borrow_mut().left.is_some(){
+ stack.push(top.borrow_mut().left.take().unwrap());
+ }
+ if top.borrow_mut().right.is_some(){
+ stack.push(top.borrow_mut().right.take().unwrap());
+ }
+ }
+ max_depth+=1;
+ }
+ max_depth
+ }
+```
+
+
那么我们可以顺便解决一下n叉树的最大深度问题
# 559.n叉树的最大深度
diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index 224caa5e..b1331659 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -488,5 +488,69 @@ func minDepth(_ root: TreeNode?) -> Int {
}
```
+rust:
+```rust
+impl Solution {
+ pub fn min_depth(root: Option>>) -> i32 {
+ return Solution::bfs(root)
+ }
+
+ // 递归
+ pub fn dfs(node: Option>>) -> i32{
+ if node.is_none(){
+ return 0;
+ }
+ let parent = node.unwrap();
+ let left_child = parent.borrow_mut().left.take();
+ let right_child = parent.borrow_mut().right.take();
+ if left_child.is_none() && right_child.is_none(){
+ return 1;
+ }
+ let mut min_depth = i32::MAX;
+ if left_child.is_some(){
+ let left_depth = Solution::dfs(left_child);
+ if left_depth <= min_depth{
+ min_depth = left_depth
+ }
+ }
+ if right_child.is_some(){
+ let right_depth = Solution::dfs(right_child);
+ if right_depth <= min_depth{
+ min_depth = right_depth
+ }
+ }
+ min_depth + 1
+
+ }
+
+ // 迭代
+ pub fn bfs(node: Option>>) -> i32{
+ let mut min_depth = 0;
+ if node.is_none(){
+ return min_depth
+ }
+ let mut stack = vec![node.unwrap()];
+ while !stack.is_empty(){
+ min_depth += 1;
+ let num = stack.len();
+ for _i in 0..num{
+ let top = stack.remove(0);
+ let left_child = top.borrow_mut().left.take();
+ let right_child = top.borrow_mut().right.take();
+ if left_child.is_none() && right_child.is_none(){
+ return min_depth;
+ }
+ if left_child.is_some(){
+ stack.push(left_child.unwrap());
+ }
+ if right_child.is_some(){
+ stack.push(right_child.unwrap());
+ }
+ }
+ }
+ min_depth
+ }
+```
+
-----------------------
From 54d10fc3b893d50c278349c9de9d09bab5924ae7 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 00:21:29 +0800
Subject: [PATCH 90/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880300.=E6=9C=80?=
=?UTF-8?q?=E9=95=BF=E4=B8=8A=E5=8D=87=E5=AD=90=E5=BA=8F=E5=88=97.md?=
=?UTF-8?q?=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0300.最长上升子序列.md | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index f68edb5a..5ccb2d76 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -220,6 +220,27 @@ const lengthOfLIS = (nums) => {
};
```
+TypeScript
+
+```typescript
+function lengthOfLIS(nums: number[]): number {
+ /**
+ dp[i]: 前i个元素中，以nums[i]结尾，最长子序列的长度
+ */
+ const dp: number[] = new Array(nums.length).fill(1);
+ let resMax: number = 0;
+ for (let i = 0, length = nums.length; i < length; i++) {
+ for (let j = 0; j < i; j++) {
+ if (nums[i] > nums[j]) {
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ resMax = Math.max(resMax, dp[i]);
+ }
+ return resMax;
+};
+```
+
From 52a486101d0525074a7b1f6a54a98b5940f9ab50 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 00:43:00 +0800
Subject: [PATCH 91/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880674.=E6=9C=80?=
=?UTF-8?q?=E9=95=BF=E8=BF=9E=E7=BB=AD=E9=80=92=E5=A2=9E=E5=BA=8F=E5=88=97?=
=?UTF-8?q?.md=EF=BC=89=EF=BC=9A=E5=A2=9E=E5=8A=A0typescript=E7=89=88?=
=?UTF-8?q?=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0674.最长连续递增序列.md | 39 +++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/problems/0674.最长连续递增序列.md b/problems/0674.最长连续递增序列.md
index 56e95d97..6ec4a6c7 100644
--- a/problems/0674.最长连续递增序列.md
+++ b/problems/0674.最长连续递增序列.md
@@ -319,6 +319,45 @@ const findLengthOfLCIS = (nums) => {
};
```
+TypeScript：
+
+> 动态规划：
+
+```typescript
+function findLengthOfLCIS(nums: number[]): number {
+ /**
+ dp[i]: 前i个元素，以nums[i]结尾，最长连续子序列的长度
+ */
+ const dp: number[] = new Array(nums.length).fill(1);
+ let resMax: number = 1;
+ for (let i = 1, length = nums.length; i < length; i++) {
+ if (nums[i] > nums[i - 1]) {
+ dp[i] = dp[i - 1] + 1;
+ }
+ resMax = Math.max(resMax, dp[i]);
+ }
+ return resMax;
+};
+```
+
+> 贪心：
+
+```typescript
+function findLengthOfLCIS(nums: number[]): number {
+ let resMax: number = 1;
+ let count: number = 1;
+ for (let i = 0, length = nums.length; i < length - 1; i++) {
+ if (nums[i] < nums[i + 1]) {
+ count++;
+ } else {
+ count = 1;
+ }
+ resMax = Math.max(resMax, count);
+ }
+ return resMax;
+};
+```
+
From 648014b28a54e953d335e822d7e7a5f98a82e3ea Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 10:19:22 +0800
Subject: [PATCH 92/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=9A=84=E7=BB=9F=E4=B8=80=E8=BF=AD=E4=BB=A3=E6=B3=95?=
=?UTF-8?q?.md=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/二叉树的统一迭代法.md | 74 +++++++++++++++++++++++++
1 file changed, 74 insertions(+)
diff --git a/problems/二叉树的统一迭代法.md b/problems/二叉树的统一迭代法.md
index f6edf586..9ca6ac39 100644
--- a/problems/二叉树的统一迭代法.md
+++ b/problems/二叉树的统一迭代法.md
@@ -591,6 +591,80 @@ function postorderTraversal(root: TreeNode | null): number[] {
return res;
};
```
+Scala:
+```scala
+// 前序遍历
+object Solution {
+ import scala.collection.mutable
+ def preorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ val stack = mutable.Stack[TreeNode]()
+ if (root != null) stack.push(root)
+ while (!stack.isEmpty) {
+ var curNode = stack.top
+ if (curNode != null) {
+ stack.pop()
+ if (curNode.right != null) stack.push(curNode.right)
+ if (curNode.left != null) stack.push(curNode.left)
+ stack.push(curNode)
+ stack.push(null)
+ } else {
+ stack.pop()
+ res.append(stack.pop().value)
+ }
+ }
+ res.toList
+ }
+}
+// 中序遍历
+object Solution {
+ import scala.collection.mutable
+ def inorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ val stack = mutable.Stack[TreeNode]()
+ if (root != null) stack.push(root)
+ while (!stack.isEmpty) {
+ var curNode = stack.top
+ if (curNode != null) {
+ stack.pop()
+ if (curNode.right != null) stack.push(curNode.right)
+ stack.push(curNode)
+ stack.push(null)
+ if (curNode.left != null) stack.push(curNode.left)
+ } else {
+ // 等于空的时候好办，弹出这个元素
+ stack.pop()
+ res.append(stack.pop().value)
+ }
+ }
+ res.toList
+ }
+}
+
+// 后序遍历
+object Solution {
+ import scala.collection.mutable
+ def postorderTraversal(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ val stack = mutable.Stack[TreeNode]()
+ if (root != null) stack.push(root)
+ while (!stack.isEmpty) {
+ var curNode = stack.top
+ if (curNode != null) {
+ stack.pop()
+ stack.push(curNode)
+ stack.push(null)
+ if (curNode.right != null) stack.push(curNode.right)
+ if (curNode.left != null) stack.push(curNode.left)
+ } else {
+ stack.pop()
+ res.append(stack.pop().value)
+ }
+ }
+ res.toList
+ }
+}
+```
-----------------------
From 33ed3d980eecec6824fb5b9edad83d7b916c4142 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 10:35:55 +0800
Subject: [PATCH 93/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20102.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86?=
=?UTF-8?q?=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 25 +++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..5afce73a 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -298,6 +298,31 @@ func levelOrder(_ root: TreeNode?) -> [[Int]] {
return result
}
```
+Scala:
+```scala
+// 102.二叉树的层序遍历
+object Solution {
+ import scala.collection.mutable
+ def levelOrder(root: TreeNode): List[List[Int]] = {
+ val res = mutable.ListBuffer[List[Int]]()
+ if (root == null) return res.toList
+ val queue = mutable.Queue[TreeNode]() // 声明一个队列
+ queue.enqueue(root) // 把根节点加入queue
+ while (!queue.isEmpty) {
+ val tmp = mutable.ListBuffer[Int]()
+ val len = queue.size // 求出len的长度
+ for (i <- 0 until len) { // 从0到当前队列长度的所有节点都加入到结果集
+ val curNode = queue.dequeue()
+ tmp.append(curNode.value)
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ res.append(tmp.toList)
+ }
+ res.toList
+ }
+}
+```
**此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒！**
From 04339562c7ce6c46dbd081551e51f36dcaf5fe8d Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 10:36:51 +0800
Subject: [PATCH 94/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20107.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E6=AC=A1=E9=81=8D=E5=8E=86?=
=?UTF-8?q?II=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 27 +++++++++++++++++++++++
1 file changed, 27 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 5afce73a..e707ce27 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -553,6 +553,33 @@ func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
}
```
+Scala:
+```scala
+// 107.二叉树的层次遍历II
+object Solution {
+ import scala.collection.mutable
+ def levelOrderBottom(root: TreeNode): List[List[Int]] = {
+ val res = mutable.ListBuffer[List[Int]]()
+ if (root == null) return res.toList
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val tmp = mutable.ListBuffer[Int]()
+ val len = queue.size
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ tmp.append(curNode.value)
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ res.append(tmp.toList)
+ }
+ // 最后翻转一下
+ res.reverse.toList
+ }
+}
+```
+
# 199.二叉树的右视图
[力扣题目链接](https://leetcode-cn.com/problems/binary-tree-right-side-view/)
From ba51a4947adb197fcc4551e3157c509795fd0a82 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 11:03:09 +0800
Subject: [PATCH 95/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20199.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=8F=B3=E8=A7=86=E5=9B=BE=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 25 +++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..b74f1a0b 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -750,6 +750,31 @@ func rightSideView(_ root: TreeNode?) -> [Int] {
}
```
+Scala:
+```scala
+// 199.二叉树的右视图
+object Solution {
+ import scala.collection.mutable
+ def rightSideView(root: TreeNode): List[Int] = {
+ val res = mutable.ListBuffer[Int]()
+ if (root == null) return res.toList
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val len = queue.size
+ var curNode: TreeNode = null
+ for (i <- 0 until len) {
+ curNode = queue.dequeue()
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ res.append(curNode.value) // 把最后一个节点的值加入解集
+ }
+ res.toList // 最后需要把res转换为List，return关键字可以省略
+ }
+}
+```
+
# 637.二叉树的层平均值
[力扣题目链接](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/)
From 0b88af0824b696be6d2f107adde3758f1df1c3f8 Mon Sep 17 00:00:00 2001
From: lizhendong128
Date: Thu, 19 May 2022 11:08:59 +0800
Subject: [PATCH 96/99] =?UTF-8?q?=E4=BF=AE=E6=94=B90150=E9=80=86=E6=B3=A2?=
=?UTF-8?q?=E5=85=B0=E8=A1=A8=E8=BE=BE=E5=BC=8F=E6=B1=82=E5=80=BC=20Java?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
将for循环改为for each，使代码更加简洁。因为循环除了对token进行遍历，i并没有其他用途。
---
problems/0150.逆波兰表达式求值.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index fd3d69aa..6ce7e2f9 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -136,19 +136,19 @@ java:
class Solution {
public int evalRPN(String[] tokens) {
Deque stack = new LinkedList();
- for (int i = 0; i < tokens.length; ++i) {
- if ("+".equals(tokens[i])) { // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
+ for (String s : tokens) {
+ if ("+".equals(s)) { // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
stack.push(stack.pop() + stack.pop()); // 注意 - 和/ 需要特殊处理
- } else if ("-".equals(tokens[i])) {
+ } else if ("-".equals(s)) {
stack.push(-stack.pop() + stack.pop());
- } else if ("*".equals(tokens[i])) {
+ } else if ("*".equals(s)) {
stack.push(stack.pop() * stack.pop());
- } else if ("/".equals(tokens[i])) {
+ } else if ("/".equals(s)) {
int temp1 = stack.pop();
int temp2 = stack.pop();
stack.push(temp2 / temp1);
} else {
- stack.push(Integer.valueOf(tokens[i]));
+ stack.push(Integer.valueOf(s));
}
}
return stack.pop();
From 9af80d3007aed88bd8d09538ab6710218c3e9dfd Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 11:10:07 +0800
Subject: [PATCH 97/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20637.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E5=B9=B3=E5=9D=87=E5=80=BC?=
=?UTF-8?q?=20Scala=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 24 +++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index b74f1a0b..a99449fb 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1006,6 +1006,30 @@ func averageOfLevels(_ root: TreeNode?) -> [Double] {
return result
}
```
+Scala:
+```scala
+// 637.二叉树的层平均值
+object Solution {
+ import scala.collection.mutable
+ def averageOfLevels(root: TreeNode): Array[Double] = {
+ val res = mutable.ArrayBuffer[Double]()
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ var sum = 0.0
+ var len = queue.size
+ for (i <- 0 until len) {
+ var curNode = queue.dequeue()
+ sum += curNode.value // 累加该层的值
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ res.append(sum / len) // 平均值即为sum/len
+ }
+ res.toArray // 最后需要转换为Array，return关键字可以省略
+ }
+}
+```
# 429.N叉树的层序遍历
From c922fbc0e3ee16bbd0f3406227ce51a44cfe636d Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 12:19:10 +0800
Subject: [PATCH 98/99] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20429.N=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86=20Scala?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0102.二叉树的层序遍历.md | 28 +++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index a99449fb..6964e1f0 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1274,6 +1274,34 @@ func levelOrder(_ root: Node?) -> [[Int]] {
}
```
+Scala:
+```scala
+// 429.N叉树的层序遍历
+object Solution {
+ import scala.collection.mutable
+ def levelOrder(root: Node): List[List[Int]] = {
+ val res = mutable.ListBuffer[List[Int]]()
+ if (root == null) return res.toList
+ val queue = mutable.Queue[Node]()
+ queue.enqueue(root) // 根节点入队
+ while (!queue.isEmpty) {
+ val tmp = mutable.ListBuffer[Int]() // 存储每层节点
+ val len = queue.size
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ tmp.append(curNode.value) // 将该节点的值加入tmp
+ // 循环遍历该节点的子节点，加入队列
+ for (child <- curNode.children) {
+ queue.enqueue(child)
+ }
+ }
+ res.append(tmp.toList) // 将该层的节点放到结果集
+ }
+ res.toList
+ }
+}
+```
+
# 515.在每个树行中找最大值
[力扣题目链接](https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/)
From 0281b82d48a4f21429d35a89270843357f801c15 Mon Sep 17 00:00:00 2001
From: SevenMonths
Date: Mon, 16 May 2022 15:26:21 +0800
Subject: [PATCH 99/99] =?UTF-8?q?=E5=A2=9E=E5=8A=A0php=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../剑指Offer58-II.左旋转字符串.md | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/problems/剑指Offer58-II.左旋转字符串.md b/problems/剑指Offer58-II.左旋转字符串.md
index fec83e1d..8781ffb4 100644
--- a/problems/剑指Offer58-II.左旋转字符串.md
+++ b/problems/剑指Offer58-II.左旋转字符串.md
@@ -290,6 +290,25 @@ func reverseString(_ s: inout [Character], startIndex: Int, endIndex: Int) {
}
```
+### PHP
+
+```php
+function reverseLeftWords($s, $n) {
+ $this->reverse($s,0,$n-1); //反转区间为前n的子串
+ $this->reverse($s,$n,strlen($s)-1); //反转区间为n到末尾的子串
+ $this->reverse($s,0,strlen($s)-1); //反转整个字符串
+ return $s;
+}
+
+// 按指定进行翻转 【array、string都可】
+function reverse(&$s, $start, $end) {
+ for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
+ $tmp = $s[$i];
+ $s[$i] = $s[$j];
+ $s[$j] = $tmp;
+ }
+}
+```