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 01/74] =?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 78c6602ff20c309132007795956f332d66ff7130 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 13 May 2022 10:05:27 +0800
Subject: [PATCH 02/74] =?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 03/74] =?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 04/74] =?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 05/74] =?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 06/74] =?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 07/74] =?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 08/74] =?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 09/74] =?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 10/74] =?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 11/74] =?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 12/74] =?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 13/74] =?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 14/74] =?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 15/74] =?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 16/74] =?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 17/74] =?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 18/74] =?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 19/74] =?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 20/74] 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 ab4d42cf0c41ce9089838dee087e961aac1b6357 Mon Sep 17 00:00:00 2001
From: n4feng
Date: Sat, 14 May 2022 12:52:11 -0400
Subject: [PATCH 21/74] =?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 22/74] =?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 23/74] =?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 24/74] =?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 25/74] =?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 14afd23b9ea5e491a60d91f07c0b8211f4f9ae00 Mon Sep 17 00:00:00 2001
From: HanMengnan <1448189829@qq.com>
Date: Mon, 16 May 2022 10:46:43 +0800
Subject: [PATCH 26/74] =?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 27/74] 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 28/74] =?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 29/74] =?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 30/74] =?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 31/74] =?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 32/74] =?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 33/74] =?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 34/74] =?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 35/74] =?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 36/74] =?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 37/74] =?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 38/74] =?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 39/74] =?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 40/74] =?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 41/74] =?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 42/74] =?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 43/74] =?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 44/74] =?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 45/74] =?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 46/74] =?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 47/74] =?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 48/74] =?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 49/74] =?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 50/74] =?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 51/74] =?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 52/74] =?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 80301657b305bcbd614d5294b1d483d31419755f Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 12:29:12 +0800
Subject: [PATCH 53/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20515.=E5=9C=A8?=
=?UTF-8?q?=E6=AF=8F=E4=B8=AA=E6=A0=91=E8=A1=8C=E4=B8=AD=E6=89=BE=E6=9C=80?=
=?UTF-8?q?=E5=A4=A7=E5=80=BC=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 | 26 +++++++++++++++++++++++
1 file changed, 26 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ab8f2e57..db27c73d 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1433,6 +1433,32 @@ func largestValues(_ root: TreeNode?) -> [Int] {
}
```
+Scala:
+```scala
+// 515.在每个树行中找最大值
+object Solution {
+ import scala.collection.mutable
+ def largestValues(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) {
+ var max = Int.MinValue // 初始化max为系统最小值
+ val len = queue.size
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ max = math.max(max, curNode.value) // 对比求解最大值
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ res.append(max) // 将最大值放入结果集
+ }
+ res.toList
+ }
+}
+```
+
# 116.填充每个节点的下一个右侧节点指针
[力扣题目链接](https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/)
From a3179499d03b05594b8808a1d11a0ab22048cf32 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 12:58:52 +0800
Subject: [PATCH 54/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20116.=E5=A1=AB?=
=?UTF-8?q?=E5=85=85=E6=AF=8F=E4=B8=AA=E8=8A=82=E7=82=B9=E7=9A=84=E4=B8=8B?=
=?UTF-8?q?=E4=B8=80=E4=B8=AA=E5=8F=B3=E4=BE=A7=E8=8A=82=E7=82=B9=E6=8C=87?=
=?UTF-8?q?=E9=92=88=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 | 29 +++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index db27c73d..18fdfcb3 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1718,6 +1718,35 @@ func connect(_ root: Node?) -> Node? {
}
```
+Scala:
+```scala
+// 116.填充每个节点的下一个右侧节点指针
+object Solution {
+ import scala.collection.mutable
+
+ def connect(root: Node): Node = {
+ if (root == null) return root
+ val queue = mutable.Queue[Node]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val len = queue.size
+ val tmp = mutable.ListBuffer[Node]()
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ tmp.append(curNode)
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ // 处理next指针
+ for (i <- 0 until tmp.size - 1) {
+ tmp(i).next = tmp(i + 1)
+ }
+ tmp(tmp.size-1).next = null
+ }
+ root
+ }
+}
+```
# 117.填充每个节点的下一个右侧节点指针II
[力扣题目链接](https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/)
From 7a62a75e399325cf439eebf507e8ce2d576e618d Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 12:59:45 +0800
Subject: [PATCH 55/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20117.=E5=A1=AB?=
=?UTF-8?q?=E5=85=85=E6=AF=8F=E4=B8=AA=E8=8A=82=E7=82=B9=E7=9A=84=E4=B8=8B?=
=?UTF-8?q?=E4=B8=80=E4=B8=AA=E5=8F=B3=E4=BE=A7=E8=8A=82=E7=82=B9=E6=8C=87?=
=?UTF-8?q?=E9=92=88II=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 | 29 +++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 18fdfcb3..a2130f7e 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1998,6 +1998,35 @@ func connect(_ root: Node?) -> Node? {
}
```
+Scala:
+```scala
+// 117.填充每个节点的下一个右侧节点指针II
+object Solution {
+ import scala.collection.mutable
+
+ def connect(root: Node): Node = {
+ if (root == null) return root
+ val queue = mutable.Queue[Node]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val len = queue.size
+ val tmp = mutable.ListBuffer[Node]()
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ tmp.append(curNode)
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ // 处理next指针
+ for (i <- 0 until tmp.size - 1) {
+ tmp(i).next = tmp(i + 1)
+ }
+ tmp(tmp.size-1).next = null
+ }
+ root
+ }
+}
+```
# 104.二叉树的最大深度
[力扣题目链接](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
From 32f0599243e7e9585a9b18a8b36fa0e50f120a24 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 13:38:22 +0800
Subject: [PATCH 56/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20104.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6?=
=?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 ab8f2e57..95a6b5d6 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2160,6 +2160,30 @@ func maxDepth(_ root: TreeNode?) -> Int {
}
```
+Scala:
+```scala
+// 104.二叉树的最大深度
+object Solution {
+ import scala.collection.mutable
+ def maxDepth(root: TreeNode): Int = {
+ if (root == null) return 0
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ var depth = 0
+ while (!queue.isEmpty) {
+ val len = queue.length
+ depth += 1
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ }
+ depth
+ }
+}
+```
+
# 111.二叉树的最小深度
[力扣题目链接](https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/)
From f5c5a58b137adad5490c04b57f82953101789999 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Thu, 19 May 2022 13:42:12 +0800
Subject: [PATCH 57/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20111.=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6?=
=?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 95a6b5d6..b411816a 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2403,6 +2403,30 @@ func minDepth(_ root: TreeNode?) -> Int {
}
```
+Scala:
+```scala
+// 111.二叉树的最小深度
+object Solution {
+ import scala.collection.mutable
+ def minDepth(root: TreeNode): Int = {
+ if (root == null) return 0
+ var depth = 0
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ depth += 1
+ val len = queue.size
+ for (i <- 0 until len) {
+ val curNode = queue.dequeue()
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ if (curNode.left == null && curNode.right == null) return depth
+ }
+ }
+ depth
+ }
+}
+```
# 总结
From afcf6cd5a1093c3bc4f525b211858da02e4c47c6 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 15:03:09 +0800
Subject: [PATCH 58/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880718.=E6=9C=80?=
=?UTF-8?q?=E9=95=BF=E9=87=8D=E5=A4=8D=E5=AD=90=E6=95=B0=E7=BB=84.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/0718.最长重复子数组.md | 50 ++++++++++++++++++++++++++
1 file changed, 50 insertions(+)
diff --git a/problems/0718.最长重复子数组.md b/problems/0718.最长重复子数组.md
index 87b1492a..0b7b5199 100644
--- a/problems/0718.最长重复子数组.md
+++ b/problems/0718.最长重复子数组.md
@@ -297,6 +297,56 @@ const findLength = (nums1, nums2) => {
}
```
+TypeScript:
+
+> 动态规划:
+
+```typescript
+function findLength(nums1: number[], nums2: number[]): number {
+ /**
+ dp[i][j]:nums[i-1]和nums[j-1]结尾,最长重复子数组的长度
+ */
+ const length1: number = nums1.length,
+ length2: number = nums2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ let resMax: number = 0;
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (nums1[i - 1] === nums2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ resMax = Math.max(resMax, dp[i][j]);
+ }
+ }
+ }
+ return resMax;
+};
+```
+
+> 滚动数组:
+
+```typescript
+function findLength(nums1: number[], nums2: number[]): number {
+ const length1: number = nums1.length,
+ length2: number = nums2.length;
+ const dp: number[] = new Array(length1 + 1).fill(0);
+ let resMax: number = 0;
+ for (let i = 1; i <= length1; i++) {
+ for (let j = length2; j >= 1; j--) {
+ if (nums1[i - 1] === nums2[j - 1]) {
+ dp[j] = dp[j - 1] + 1;
+ resMax = Math.max(resMax, dp[j]);
+ } else {
+ dp[j] = 0;
+ }
+ }
+ }
+ return resMax;
+};
+```
+
+
+
-----------------------
From a4b024705b276e5cf69a2a521af8b923a32daaca Mon Sep 17 00:00:00 2001
From: xuxiaomeng <961592690@qq.com>
Date: Thu, 19 May 2022 20:25:16 +0800
Subject: [PATCH 59/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A00704.=E4=BA=8C=E5=88=86?=
=?UTF-8?q?=E6=9F=A5=E6=89=BE=20Kotlin=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0704.二分查找.md | 32 ++++++++++++++++++++++++++++++++
1 file changed, 32 insertions(+)
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 55625130..9173d1da 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -611,6 +611,38 @@ public class Solution{
}
```
+**Kotlin:**
+```Kotlin
+// (版本一)左闭右开区间
+class Solution {
+ fun search(nums: IntArray, target: Int): Int {
+ var left = 0
+ var right = nums.size // [left,right) 右侧为开区间,right 设置为 nums.size
+ while (left < right) {
+ val mid = (left + right) / 2
+ if (nums[mid] < target) left = mid + 1
+ else if (nums[mid] > target) right = mid // 代码的核心,循环中 right 是开区间,这里也应是开区间
+ else return mid
+ }
+ return -1 // 没有找到 target ,返回 -1
+ }
+}
+// (版本二)左闭右闭区间
+class Solution {
+ fun search(nums: IntArray, target: Int): Int {
+ var left = 0
+ var right = nums.size - 1 // [left,right] 右侧为闭区间,right 设置为 nums.size - 1
+ while (left <= right) {
+ val mid = (left + right) / 2
+ if (nums[mid] < target) left = mid + 1
+ else if (nums[mid] > target) right = mid - 1 // 代码的核心,循环中 right 是闭区间,这里也应是闭区间
+ else return mid
+ }
+ return -1 // 没有找到 target ,返回 -1
+ }
+}
+```
+
-----------------------
From 568a569f0572cd500c152c7d836bc3aea42a59ad Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 20:39:58 +0800
Subject: [PATCH 60/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=881143.=E6=9C=80?=
=?UTF-8?q?=E9=95=BF=E5=85=AC=E5=85=B1=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/1143.最长公共子序列.md | 26 ++++++++++++++++++++++++++
1 file changed, 26 insertions(+)
diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md
index ecedf89b..d58330ec 100644
--- a/problems/1143.最长公共子序列.md
+++ b/problems/1143.最长公共子序列.md
@@ -236,6 +236,32 @@ const longestCommonSubsequence = (text1, text2) => {
};
```
+TypeScript:
+
+```typescript
+function longestCommonSubsequence(text1: string, text2: string): number {
+ /**
+ dp[i][j]: text1中前i-1个和text2中前j-1个,最长公共子序列的长度
+ */
+ const length1: number = text1.length,
+ length2: number = text2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (text1[i - 1] === text2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
+ }
+ }
+ }
+ return dp[length1][length2];
+};
+```
+
+
+
-----------------------
From b3335f78a9a5c0910577835f8e61069594a23a0f Mon Sep 17 00:00:00 2001
From: zhouchaoyu1
Date: Thu, 19 May 2022 20:47:08 +0800
Subject: [PATCH 61/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20763.=E5=88=92?=
=?UTF-8?q?=E5=88=86=E5=AD=97=E6=AF=8D=E5=8C=BA=E9=97=B4=20=E8=A1=A5?=
=?UTF-8?q?=E5=85=85=E6=80=9D=E8=B7=AF=E7=9A=84Java=E4=BB=A3=E7=A0=81?=
=?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/0763.划分字母区间.md | 65 +++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
diff --git a/problems/0763.划分字母区间.md b/problems/0763.划分字母区间.md
index 2210cffa..2f4d1b48 100644
--- a/problems/0763.划分字母区间.md
+++ b/problems/0763.划分字母区间.md
@@ -158,6 +158,71 @@ class Solution {
return list;
}
}
+
+class Solution{
+ /*解法二: 上述c++补充思路的Java代码实现*/
+
+ public int[][] findPartitions(String s) {
+ List temp = new ArrayList<>();
+ int[][] hash = new int[26][2];//26个字母2列 表示该字母对应的区间
+
+ for (int i = 0; i < s.length(); i++) {
+ //更新字符c对应的位置i
+ char c = s.charAt(i);
+ if (hash[c - 'a'][0] == 0) hash[c - 'a'][0] = i;
+
+ hash[c - 'a'][1] = i;
+
+ //第一个元素区别对待一下
+ hash[s.charAt(0) - 'a'][0] = 0;
+ }
+
+
+ List> h = new LinkedList<>();
+ //组装区间
+ for (int i = 0; i < 26; i++) {
+ //if (hash[i][0] != hash[i][1]) {
+ temp.clear();
+ temp.add(hash[i][0]);
+ temp.add(hash[i][1]);
+ //System.out.println(temp);
+ h.add(new ArrayList<>(temp));
+ // }
+ }
+ // System.out.println(h);
+ // System.out.println(h.size());
+ int[][] res = new int[h.size()][2];
+ for (int i = 0; i < h.size(); i++) {
+ List list = h.get(i);
+ res[i][0] = list.get(0);
+ res[i][1] = list.get(1);
+ }
+
+ return res;
+
+ }
+
+ public List partitionLabels(String s) {
+ int[][] partitions = findPartitions(s);
+ List res = new ArrayList<>();
+ Arrays.sort(partitions, (o1, o2) -> Integer.compare(o1[0], o2[0]));
+ int right = partitions[0][1];
+ int left = 0;
+ for (int i = 0; i < partitions.length; i++) {
+ if (partitions[i][0] > right) {
+ //左边界大于右边界即可纪委一次分割
+ res.add(right - left + 1);
+ left = partitions[i][0];
+ }
+ right = Math.max(right, partitions[i][1]);
+
+ }
+ //最右端
+ res.add(right - left + 1);
+ return res;
+
+ }
+}
```
### Python
From 30c1be11ff9ef77ff6cf0294f37b09ae50ea4619 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 21:26:54 +0800
Subject: [PATCH 62/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=881035.=E4=B8=8D?=
=?UTF-8?q?=E7=9B=B8=E4=BA=A4=E7=9A=84=E7=BA=BF.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/1035.不相交的线.md | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/problems/1035.不相交的线.md b/problems/1035.不相交的线.md
index 279ed816..4463c5f7 100644
--- a/problems/1035.不相交的线.md
+++ b/problems/1035.不相交的线.md
@@ -183,6 +183,30 @@ const maxUncrossedLines = (nums1, nums2) => {
};
```
+TypeScript:
+
+```typescript
+function maxUncrossedLines(nums1: number[], nums2: number[]): number {
+ /**
+ dp[i][j]: nums1前i-1个,nums2前j-1个,最大连线数
+ */
+ const length1: number = nums1.length,
+ length2: number = nums2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (nums1[i - 1] === nums2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+ return dp[length1][length2];
+};
+```
+
From 4d2b80ce7508553923c99a7786521c018c24ff8a Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Thu, 19 May 2022 21:59:33 +0800
Subject: [PATCH 63/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880053.=E6=9C=80?=
=?UTF-8?q?=E5=A4=A7=E5=AD=90=E5=BA=8F=E5=92=8C=E5=8A=A8=E6=80=81=E8=A7=84?=
=?UTF-8?q?=E5=88=92.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
---
.../0053.最大子序和(动态规划).md | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/problems/0053.最大子序和(动态规划).md b/problems/0053.最大子序和(动态规划).md
index 4c883cb6..99aa7acf 100644
--- a/problems/0053.最大子序和(动态规划).md
+++ b/problems/0053.最大子序和(动态规划).md
@@ -186,6 +186,24 @@ const maxSubArray = nums => {
};
```
+TypeScript:
+
+```typescript
+function maxSubArray(nums: number[]): number {
+ /**
+ dp[i]:以nums[i]结尾的最大和
+ */
+ const dp: number[] = []
+ dp[0] = nums[0];
+ let resMax: number = 0;
+ for (let i = 1; i < nums.length; i++) {
+ dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
+ resMax = Math.max(resMax, dp[i]);
+ }
+ return resMax;
+};
+```
+
-----------------------
From 8759349af0001c6ee2f05ceece9cc0e331fbc08a Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 20 May 2022 00:35:32 +0800
Subject: [PATCH 64/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880392.=E5=88=A4?=
=?UTF-8?q?=E6=96=AD=E5=AD=90=E5=BA=8F=E5=88=97.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/0392.判断子序列.md | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/problems/0392.判断子序列.md b/problems/0392.判断子序列.md
index 671576f7..3f7eb11d 100644
--- a/problems/0392.判断子序列.md
+++ b/problems/0392.判断子序列.md
@@ -201,7 +201,32 @@ const isSubsequence = (s, t) => {
};
```
+TypeScript:
+
+```typescript
+function isSubsequence(s: string, t: string): boolean {
+ /**
+ dp[i][j]: s的前i-1个,t的前j-1个,最长公共子序列的长度
+ */
+ const sLen: number = s.length,
+ tLen: number = t.length;
+ const dp: number[][] = new Array(sLen + 1).fill(0)
+ .map(_ => new Array(tLen + 1).fill(0));
+ for (let i = 1; i <= sLen; i++) {
+ for (let j = 1; j <= tLen; j++) {
+ if (s[i - 1] === t[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+ return dp[sLen][tLen] === s.length;
+};
+```
+
Go:
+
```go
func isSubsequence(s string, t string) bool {
dp := make([][]int,len(s)+1)
From 4eefc546c62d0b5d63f08d1b51e5603ee722d7d5 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 20 May 2022 13:41:23 +0800
Subject: [PATCH 65/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880115.=E4=B8=8D?=
=?UTF-8?q?=E5=90=8C=E7=9A=84=E5=AD=90=E5=BA=8F=E5=88=97.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
---
problems/0115.不同的子序列.md | 30 +++++++++++++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
index 0f762969..ca66e20d 100644
--- a/problems/0115.不同的子序列.md
+++ b/problems/0115.不同的子序列.md
@@ -267,6 +267,36 @@ const numDistinct = (s, t) => {
};
```
+TypeScript:
+
+```typescript
+function numDistinct(s: string, t: string): number {
+ /**
+ dp[i][j]: s前i个字符,t前j个字符,s子序列中t出现的个数
+ dp[0][0]=1, 表示s前0个字符为'',t前0个字符为''
+ */
+ const sLen: number = s.length,
+ tLen: number = t.length;
+ const dp: number[][] = new Array(sLen + 1).fill(0)
+ .map(_ => new Array(tLen + 1).fill(0));
+ for (let m = 0; m < sLen; m++) {
+ dp[m][0] = 1;
+ }
+ for (let i = 1; i <= sLen; i++) {
+ for (let j = 1; j <= tLen; j++) {
+ if (s[i - 1] === t[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
+ } else {
+ dp[i][j] = dp[i - 1][j];
+ }
+ }
+ }
+ return dp[sLen][tLen];
+};
+```
+
+
+
-----------------------
From 58c4ad4947506310ef7c05d9603972af684c9b96 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 20 May 2022 15:11:12 +0800
Subject: [PATCH 66/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880583.=E4=B8=A4?=
=?UTF-8?q?=E4=B8=AA=E5=AD=97=E7=AC=A6=E4=B8=B2=E7=9A=84=E5=88=A0=E9=99=A4?=
=?UTF-8?q?=E6=93=8D=E4=BD=9C.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
---
.../0583.两个字符串的删除操作.md | 61 +++++++++++++++++++
1 file changed, 61 insertions(+)
diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
index 53c1a125..00f11700 100644
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@@ -229,6 +229,67 @@ const minDistance = (word1, word2) => {
};
```
+TypeScript:
+
+> dp版本一:
+
+```typescript
+function minDistance(word1: string, word2: string): number {
+ /**
+ dp[i][j]: word1前i个字符,word2前j个字符,所需最小步数
+ dp[0][0]=0: word1前0个字符为'', word2前0个字符为''
+ */
+ const length1: number = word1.length,
+ length2: number = word2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ for (let i = 0; i <= length1; i++) {
+ dp[i][0] = i;
+ }
+ for (let i = 0; i <= length2; i++) {
+ dp[0][i] = i;
+ }
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (word1[i - 1] === word2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1];
+ } else {
+ dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1;
+ }
+ }
+ }
+ return dp[length1][length2];
+};
+```
+
+> dp版本二:
+
+```typescript
+function minDistance(word1: string, word2: string): number {
+ /**
+ dp[i][j]: word1前i个字符,word2前j个字符,最长公共子序列的长度
+ dp[0][0]=0: word1前0个字符为'', word2前0个字符为''
+ */
+ const length1: number = word1.length,
+ length2: number = word2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (word1[i - 1] === word2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ } else {
+ dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
+ }
+ }
+ }
+ const maxLen: number = dp[length1][length2];
+ return length1 + length2 - maxLen * 2;
+};
+```
+
+
+
-----------------------
From fa3a45c3dbd3cb58b9c0027cb2c8fe9e7727a439 Mon Sep 17 00:00:00 2001
From: Steve2020 <841532108@qq.com>
Date: Fri, 20 May 2022 16:33:34 +0800
Subject: [PATCH 67/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=EF=BC=880072.=E7=BC=96?=
=?UTF-8?q?=E8=BE=91=E8=B7=9D=E7=A6=BB.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/0072.编辑距离.md | 37 +++++++++++++++++++++++++++++++++++
1 file changed, 37 insertions(+)
diff --git a/problems/0072.编辑距离.md b/problems/0072.编辑距离.md
index 3802c228..530774ee 100644
--- a/problems/0072.编辑距离.md
+++ b/problems/0072.编辑距离.md
@@ -327,5 +327,42 @@ const minDistance = (word1, word2) => {
};
```
+TypeScript:
+
+```typescript
+function minDistance(word1: string, word2: string): number {
+ /**
+ dp[i][j]: word1前i个字符,word2前j个字符,最少操作数
+ dp[0][0]=0:表示word1前0个字符为'', word2前0个字符为''
+ */
+ const length1: number = word1.length,
+ length2: number = word2.length;
+ const dp: number[][] = new Array(length1 + 1).fill(0)
+ .map(_ => new Array(length2 + 1).fill(0));
+ for (let i = 0; i <= length1; i++) {
+ dp[i][0] = i;
+ }
+ for (let i = 0; i <= length2; i++) {
+ dp[0][i] = i;
+ }
+ for (let i = 1; i <= length1; i++) {
+ for (let j = 1; j <= length2; j++) {
+ if (word1[i - 1] === word2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1];
+ } else {
+ dp[i][j] = Math.min(
+ dp[i - 1][j],
+ dp[i][j - 1],
+ dp[i - 1][j - 1]
+ ) + 1;
+ }
+ }
+ }
+ return dp[length1][length2];
+};
+```
+
+
+
-----------------------
From be7d6e1325009d5f404c8abeaae0cbed49ed2303 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 20 May 2022 19:36:10 +0800
Subject: [PATCH 68/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200226.=E7=BF=BB?=
=?UTF-8?q?=E8=BD=AC=E4=BA=8C=E5=8F=89=E6=A0=91.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/0226.翻转二叉树.md | 48 ++++++++++++++++++++++++++++++++
1 file changed, 48 insertions(+)
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index a3ebe24d..e378cbc1 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -820,5 +820,53 @@ func invertTree(_ root: TreeNode?) -> TreeNode? {
}
```
+### Scala
+
+深度优先遍历(前序遍历):
+```scala
+object Solution {
+ def invertTree(root: TreeNode): TreeNode = {
+ if (root == null) return root
+ // 递归
+ def process(node: TreeNode): Unit = {
+ if (node == null) return
+ // 翻转节点
+ val curNode = node.left
+ node.left = node.right
+ node.right = curNode
+ process(node.left)
+ process(node.right)
+ }
+ process(root)
+ root
+ }
+}
+```
+
+广度优先遍历(层序遍历):
+```scala
+object Solution {
+ import scala.collection.mutable
+ def invertTree(root: TreeNode): TreeNode = {
+ if (root == null) return root
+ val queue = mutable.Queue[TreeNode]()
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val len = queue.size
+ for (i <- 0 until len) {
+ var curNode = queue.dequeue()
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ // 翻转
+ var tmpNode = curNode.left
+ curNode.left = curNode.right
+ curNode.right = tmpNode
+ }
+ }
+ root
+ }
+}
+```
+
-----------------------
From 81d4685e36603ec59e3e02d8243f60e660081541 Mon Sep 17 00:00:00 2001
From: ZongqinWang <1722249371@qq.com>
Date: Fri, 20 May 2022 21:12:54 +0800
Subject: [PATCH 69/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=200101.=E5=AF=B9?=
=?UTF-8?q?=E7=A7=B0=E4=BA=8C=E5=8F=89=E6=A0=91.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/0101.对称二叉树.md | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index e4e232c8..97ca0685 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -725,5 +725,25 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
}
```
+## Scala
+
+递归:
+```scala
+object Solution {
+ def isSymmetric(root: TreeNode): Boolean = {
+ if (root == null) return true // 如果等于空直接返回true
+ def compare(left: TreeNode, right: TreeNode): Boolean = {
+ if (left == null && right == null) return true // 如果左右都为空,则为true
+ if (left == null && right != null) return false // 如果左空右不空,不对称,返回false
+ if (left != null && right == null) return false // 如果左不空右空,不对称,返回false
+ // 如果左右的值相等,并且往下递归
+ left.value == right.value && compare(left.left, right.right) && compare(left.right, right.left)
+ }
+ // 分别比较左子树和右子树
+ compare(root.left, root.right)
+ }
+}
+```
+
-----------------------
From 3de2992235e43b6ce40a35624a42a08b5a5a866b Mon Sep 17 00:00:00 2001
From: xuxiaomeng <961592690@qq.com>
Date: Sat, 21 May 2022 21:02:59 +0800
Subject: [PATCH 70/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A00027.=E7=A7=BB=E9=99=A4?=
=?UTF-8?q?=E5=85=83=E7=B4=A0=20Kotlin=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
problems/0027.移除元素.md | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..f0cb5375 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -329,5 +329,16 @@ int removeElement(int* nums, int numsSize, int val){
}
```
+Kotlin:
+```kotlin
+fun removeElement(nums: IntArray, `val`: Int): Int {
+ var slowIndex = 0 // 初始化慢指针
+ for (fastIndex in nums.indices) {
+ if (nums[fastIndex] != `val`) nums[slowIndex++] = nums[fastIndex] // 在慢指针所在位置存储未被删除的元素
+ }
+ return slowIndex
+ }
+```
+
-----------------------
From 10b440ec27b814715dad23110b919c33d59403b6 Mon Sep 17 00:00:00 2001
From: xuxiaomeng <961592690@qq.com>
Date: Mon, 23 May 2022 09:38:24 +0800
Subject: [PATCH 71/74] =?UTF-8?q?=E6=B7=BB=E5=8A=A00977.=E6=9C=89=E5=BA=8F?=
=?UTF-8?q?=E6=95=B0=E7=BB=84=E7=9A=84=E5=B9=B3=E6=96=B9=20Kotlin=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/0977.有序数组的平方.md | 23 ++++++++++++++++++++++-
1 file changed, 22 insertions(+), 1 deletion(-)
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 24276bcf..9c06d8a3 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -359,7 +359,28 @@ class Solution {
}
```
-
+Kotlin:
+```kotlin
+class Solution {
+ // 双指针法
+ fun sortedSquares(nums: IntArray): IntArray {
+ var res = IntArray(nums.size)
+ var left = 0 // 指向数组的最左端
+ var right = nums.size - 1 // 指向数组端最右端
+ // 选择平方数更大的那一个往 res 数组中倒序填充
+ for (index in nums.size - 1 downTo 0) {
+ if (nums[left] * nums[left] > nums[right] * nums[right]) {
+ res[index] = nums[left] * nums[left]
+ left++
+ } else {
+ res[index] = nums[right] * nums[right]
+ right--
+ }
+ }
+ return res
+ }
+}
+```
-----------------------
From 0281b82d48a4f21429d35a89270843357f801c15 Mon Sep 17 00:00:00 2001
From: SevenMonths
Date: Mon, 16 May 2022 15:26:21 +0800
Subject: [PATCH 72/74] =?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;
+ }
+}
+```
From f5f5f5a2a530845483708938064c05aae698487c Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Fri, 10 Jun 2022 11:02:44 +0800
Subject: [PATCH 73/74] Update
---
problems/0027.移除元素.md | 14 +-
problems/0035.搜索插入位置.md | 12 +-
problems/0704.二分查找.md | 2 +
problems/0977.有序数组的平方.md | 2 +
problems/qita/gitserver.md | 312 +++++++++++++++++++
problems/qita/server.md | 126 ++++++++
problems/{其他 => qita}/参与本项目.md | 0
7 files changed, 460 insertions(+), 8 deletions(-)
create mode 100644 problems/qita/gitserver.md
create mode 100644 problems/qita/server.md
rename problems/{其他 => qita}/参与本项目.md (100%)
diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 590cf0b9..72860ffd 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -28,6 +28,8 @@
## 思路
+[本题B站视频讲解](https://www.bilibili.com/video/BV12A4y1Z7LP)
+
有的同学可能说了,多余的元素,删掉不就得了。
**要知道数组的元素在内存地址中是连续的,不能单独删除数组中的某个元素,只能覆盖。**
@@ -75,10 +77,20 @@ public:
双指针法(快慢指针法): **通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。**
+定义快慢指针
+
+* 快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
+* 慢指针:指向更新 新数组下标的位置
+
+很多同学这道题目做的很懵,就是不理解 快慢指针究竟都是什么含义,所以一定要明确含义,后面的思路就更容易理解了。
+
删除过程如下:

+很多同学不了解
+
+
**双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法。**
后序都会一一介绍到,本题代码如下:
@@ -104,8 +116,6 @@ public:
* 时间复杂度:O(n)
* 空间复杂度:O(1)
-旧文链接:[数组:就移除个元素很难么?](https://programmercarl.com/0027.移除元素.html)
-
```CPP
/**
* 相向双指针方法,基于元素顺序可以改变的题目描述改变了元素相对位置,确保了移动最少元素
diff --git a/problems/0035.搜索插入位置.md b/problems/0035.搜索插入位置.md
index 8a8f9706..ff1b0292 100644
--- a/problems/0035.搜索插入位置.md
+++ b/problems/0035.搜索插入位置.md
@@ -73,8 +73,8 @@ public:
};
```
-* 时间复杂度:$O(n)$
-* 空间复杂度:$O(1)$
+* 时间复杂度:O(n)
+* 空间复杂度:O(1)
效率如下:
@@ -135,14 +135,14 @@ public:
// 目标值在数组所有元素之前 [0, -1]
// 目标值等于数组中某一个元素 return middle;
// 目标值插入数组中的位置 [left, right],return right + 1
- // 目标值在数组所有元素之后的情况 [left, right], return right + 1
+ // 目标值在数组所有元素之后的情况 [left, right], 因为是右闭区间,所以 return right + 1
return right + 1;
}
};
```
-* 时间复杂度:$O(\log n)$
-* 时间复杂度:$O(1)$
+* 时间复杂度:O(log n)
+* 时间复杂度:O(1)
效率如下:

@@ -178,7 +178,7 @@ public:
// 目标值在数组所有元素之前 [0,0)
// 目标值等于数组中某一个元素 return middle
// 目标值插入数组中的位置 [left, right) ,return right 即可
- // 目标值在数组所有元素之后的情况 [left, right),return right 即可
+ // 目标值在数组所有元素之后的情况 [left, right),因为是右开区间,所以 return right
return right;
}
};
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 55625130..ce8253af 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -36,6 +36,8 @@
## 思路
+为了易于大家理解,我还录制了视频,可以看这里:[手把手带你撕出正确的二分法](https://www.bilibili.com/video/BV1fA4y1o715)
+
**这道题目的前提是数组为有序数组**,同时题目还强调**数组中无重复元素**,因为一旦有重复元素,使用二分查找法返回的元素下标可能不是唯一的,这些都是使用二分法的前提条件,当大家看到题目描述满足如上条件的时候,可要想一想是不是可以用二分法了。
二分查找涉及的很多的边界条件,逻辑比较简单,但就是写不好。例如到底是 `while(left < right)` 还是 `while(left <= right)`,到底是`right = middle`呢,还是要`right = middle - 1`呢?
diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 24276bcf..8811f3d7 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -23,6 +23,8 @@
# 思路
+为了易于大家理解,我还特意录制了视频,[本题视频讲解](https://www.bilibili.com/video/BV1QB4y1D7ep)
+
## 暴力排序
最直观的想法,莫过于:每个数平方之后,排个序,美滋滋,代码如下:
diff --git a/problems/qita/gitserver.md b/problems/qita/gitserver.md
new file mode 100644
index 00000000..9ee06ae4
--- /dev/null
+++ b/problems/qita/gitserver.md
@@ -0,0 +1,312 @@
+
+# 一文手把手教你搭建Git私服
+
+## 为什么要搭建Git私服
+
+很多同学都问文章,文档,资料怎么备份啊,自己电脑和公司电脑怎么随时同步资料啊等等,这里呢我写一个搭建自己的git私服的详细教程
+
+为什么要搭建一个Git私服呢,而不是用Github免费的私有仓库,有以下几点:
+* Github 私有仓库真的慢,文件一旦多了,或者有图片文件,git pull 的时候半天拉不下来
+* 自己的文档难免有自己个人信息,放在github心里也是担心的
+* 想建几个库就建几个,想几个人合作开发都可以,不香么?
+
+**网上可以搜到很多git搭建,但是说的模棱两可**,而且有的直接是在本地搭建git服务,既然是备份,搭建在本地哪有备份的意义,一定要有一个远端服务器, 而且自己的电脑和公司的电脑还是同步自己的文章,文档和资料等等。
+
+
+适合人群: 想通过git私服来备份自己的文章,Markdown,并做版本管理的同学
+最后,写好每篇 Chat 是对我的责任,也是对你的尊重。谢谢大家~
+
+正文如下:
+
+-----------------------------
+
+## 如何找到可以外网访问服务器
+
+有的同学问了,自己的电脑就不能作为服务器么?
+
+这里要说一下,安装家庭带宽,运营商默认是不会给我们独立分配公网IP的
+
+一般情况下是一片区域公用一个公网IP池,所以外网是不能访问到在家里我们使用的电脑的
+
+除非我们自己去做映射,这其实非常麻烦而且公网IP池 是不断变化的
+
+辛辛苦苦做了映射,运营商给IP一换,我们的努力就白扯了
+
+那我们如何才能找到一个外网可以访问的服务器呢,此时云计算拯救了我们。
+
+推荐大家选一家云厂商(阿里云,腾讯云,百度云都可以)在上面上买一台云服务器
+
+* [阿里云活动期间服务器购买](https://www.aliyun.com/minisite/goods?taskCode=shareNew2205&recordId=3641992&userCode=roof0wob)
+* [腾讯云活动期间服务器购买](https://curl.qcloud.com/EiaMXllu)
+
+云厂商经常做活动,如果从来没有买过云服务器的账号更便宜,低配一年一百块左右的样子,强烈推荐一起买个三年。
+
+买云服务器的时候推荐直接安装centos系统。
+
+这里要说一下,有了自己的云服务器之后 不仅仅可以用来做git私服
+
+**同时还可以做网站,做程序后台,跑程序,做测试**(这样我们自己的电脑就不会因为自己各种搭建环境下载各种包而搞的的烂糟糟),等等等。
+
+有自己云服务器和一个公网IP真的是一件非常非常幸福的事情,能体验到自己的服务随时可以部署上去提供给所有人使用的喜悦。
+
+外网可以访问的服务器解决了,接下来就要部署git服务了
+
+本文将采用centos系统来部署git私服
+
+## 服务器端安装Git
+
+切换至root账户
+
+```
+su root
+```
+
+看一下服务器有没有安装git,如果出现下面信息就说明是有git的
+```
+[root@instance-5fcyjde7 ~]# git
+usage: git [--version] [--help] [-c name=value]
+ [--exec-path[=]] [--html-path] [--man-path] [--info-path]
+ [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
+ [--git-dir=] [--work-tree=] [--namespace=]
+ []
+
+The most commonly used git commands are:
+ add Add file contents to the index
+ bisect Find by binary search the change that introduced a bug
+ branch List, create, or delete branches
+ checkout Checkout a branch or paths to the working tree
+ clone Clone a repository into a new directory
+ commit Record changes to the repository
+ diff Show changes between commits, commit and working tree, etc
+ fetch Download objects and refs from another repository
+ grep Print lines matching a pattern
+ init Create an empty Git repository or reinitialize an existing one
+ log Show commit logs
+ merge Join two or more development histories together
+ mv Move or rename a file, a directory, or a symlink
+ pull Fetch from and merge with another repository or a local branch
+ push Update remote refs along with associated objects
+ rebase Forward-port local commits to the updated upstream head
+ reset Reset current HEAD to the specified state
+ rm Remove files from the working tree and from the index
+ show Show various types of objects
+ status Show the working tree status
+ tag Create, list, delete or verify a tag object signed with GPG
+
+'git help -a' and 'git help -g' lists available subcommands and some
+concept guides. See 'git help ' or 'git help '
+to read about a specific subcommand or concept.
+```
+
+如果没有git,就安装一下,yum安装的版本默认是 `1.8.3.1`
+
+```
+yum install git
+```
+
+安装成功之后,看一下自己安装的版本
+
+```
+git --version
+```
+
+## 服务器端设置Git账户
+
+创建一个git的linux账户,这个账户只做git私服的操作,也是为了安全起见
+
+如果不新创建一个linux账户,在自己的常用的linux账户下创建的话,哪天手抖 来一个`rm -rf *` 操作 数据可全没了
+
+**这里linux git账户的密码设置的尽量复杂一些,我这里为了演示,就设置成为'gitpassword'**
+```
+adduser git
+passwd gitpassword
+```
+
+然后就要切换成git账户,进行后面的操作了
+```
+[root@instance-5fcyjde7 ~]# su - git
+```
+
+看一下自己所在的目录,是不是在git目录下面
+
+```
+[git@instance-5fcyjde7 ~]$ pwd
+/home/git
+```
+
+## 服务器端密钥管理
+
+创建`.ssh` 目录,如果`.ssh` 已经存在了,可以忽略这一项
+
+为啥用配置ssh公钥呢,同学们记不记得我急使用github上传上传代码的时候也要把自己的公钥配置上github上
+
+这也是方面每次操作git仓库的时候不用再去输入密码
+
+```
+cd ~/
+mkdir .ssh
+```
+
+进入.ssh 文件下,创建一个 `authorized_keys` 文件,这个文件就是后面就是要放我们客户端的公钥
+
+```
+cd ~/.ssh
+touch authorized_keys
+```
+
+别忘了`authorized_keys`给设置权限,很多同学发现自己不能免密登陆,都是因为忘记了给`authorized_keys` 设置权限
+
+```
+chmod 700 /home/git/.ssh
+chmod 600 /home/git/.ssh/authorized_keys
+```
+
+接下来我们要把客户端的公钥放在git服务器上,我们在回到客户端,创建一个公钥
+
+在我们自己的电脑上,有公钥和私钥 两个文件分别是:`id_rsa` 和 `id_rsa.pub`
+
+如果是`windows`系统公钥私钥的目录在`C:\Users\用户名\.ssh` 下
+
+如果是mac 或者 linux, 公钥和私钥的目录这里 `cd ~/.ssh/`, 如果发现自己的电脑上没有公钥私钥,那就自己创建一个
+
+创建密钥的命令
+
+```
+ssh-keygen -t rsa
+```
+
+创建密钥的过程中,一路点击回车就可以了。不需要填任何东西
+
+把公钥拷贝到git服务器上,将我们刚刚生成的`id_rsa.pub`,拷贝到git服务器的`/home/git/.ssh/`目录
+
+在git服务器上,将公钥添加到`authorized_keys` 文件中
+
+```
+cd /home/git/.ssh/
+cat id_rsa.pub >> authorized_keys
+```
+
+如何看我们配置的密钥是否成功呢, 在客户点直接登录git服务器,看看是否是免密登陆
+```
+ssh git@git服务器ip
+```
+
+例如:
+
+```
+ssh git@127.0.0.1
+```
+
+如果可以免密登录,那就说明服务器端密钥配置成功了
+
+## 服务器端部署Git 仓库
+
+我们在登陆到git 服务器端,切换为成 git账户
+
+如果是root账户切换成git账户
+```
+su - git
+```
+
+如果是其他账户切换为git账户
+```
+sudo su - git
+```
+
+进入git目录下
+```
+cd ~/git
+```
+
+创建我们的第一个Git私服的仓库,我们叫它为world仓库
+
+那么首先创建一个文件夹名为: world.git ,然后进入这个目录
+
+有同学问,为什么文件夹名字后面要放`.git`, 其实不这样命名也是可以的
+
+但是细心的同学可能注意到,我们平时在github上 `git clone` 其他人的仓库的时候,仓库名字后面,都是加上`.git`的
+
+例如下面这个例子,其实就是github对仓库名称的一个命名规则,所以我们也遵守github的命名规则。
+
+```
+git clone https://github.com/youngyangyang04/NoSQLAttack.git
+```
+
+所以我们的操作是
+```
+[git@localhost git]# mkdir world.git
+[git@localhost git]# cd world.git
+```
+
+初始化我们的`world`仓库
+
+```
+git init --bare
+
+```
+
+**如果我们想创建多个仓库,就在这里创建多个文件夹并初始化就可以了,和world仓库的操作过程是一样一样的**
+
+现在我们服务端的git仓库就部署完了,接下来就看看客户端,如何使用这个仓库呢
+
+## 客户端连接远程仓库
+
+我们在自己的电脑上创建一个文件夹 也叫做`world`吧
+
+其实这里命名是随意的,但是我们为了和git服务端的仓库名称保持同步。 这样更直观我们操作的是哪一个仓库。
+
+```
+mkdir world
+cd world
+```
+
+进入world文件,并初始化操作
+
+```
+cd world
+git init
+```
+
+在world目录上创建一个测试文件,并且将其添加到git版本管理中
+
+```
+touch test
+git add test
+git commit -m "add test file"
+```
+
+将次仓库和远端仓库同步
+
+```
+git remote add origin git@git服务器端的ip:world.git
+git push -u origin master
+```
+
+此时这个test测试文件就已经提交到我们的git远端私服上了
+
+## Git私服安全问题
+
+这里有两点安全问题
+
+### linux git的密码不要泄露出去
+
+否则,别人可以通过 ssh git@git服务器IP 来登陆到你的git私服服务器上
+
+当然了,这里同学们如果买的是云厂商的云服务器的话
+
+如果有人恶意想通过 尝试不同密码链接的方式来链接你的服务器,重试三次以上
+
+这个客户端的IP就会被封掉,同时邮件通知我们可以IP来自哪里
+
+所以大可放心 密码只要我们不泄露出去,基本上不会有人同时不断尝试密码的方式来登上我们的git私服服务器
+
+### 私钥文件`id_rsa` 不要给别人
+
+如果有人得到了这个私钥,就可以免密码登陆我们的git私服上了,我相信大家也不至于把自己的私钥主动给别人吧
+
+## 总结
+
+这里就是整个git私服搭建的全过程,安全问题我也给大家列举了出来,接下来好好享受自己的Git私服吧
+
+**enjoy!**
+
diff --git a/problems/qita/server.md b/problems/qita/server.md
new file mode 100644
index 00000000..16995d70
--- /dev/null
+++ b/problems/qita/server.md
@@ -0,0 +1,126 @@
+
+# 一台服务器有什么用!
+
+但在组织这场活动的时候,了解到大家都有一个共同的问题: **这个服务器究竟有啥用??**
+
+这真是一个好问题,而且我一句两句还说不清楚,所以就专门发文来讲一讲。
+
+同时我还录制的一期视频,哈哈我的视频号,大家可以关注一波。
+
+
+一说到服务器,可能很多人都说搞分布式,做计算,搞爬虫,做程序后台服务,多人合作等等。
+
+其实这些普通人都用不上,我来说一说大家能用上的吧。
+
+## 搭建git私服
+
+大家平时工作的时候一定有一个自己的工作文件夹,学生的话就是自己的课件,考试,准备面试的资料等等。
+
+已经工作的录友,会有一个文件夹放着自己重要的文档,Markdown,图片,简历等等。
+
+这么重要的文件夹,而且我们每天都要更新,也担心哪天电脑丢了,或者坏了,突然这些都不见了。
+
+所以我们想备份嘛。
+
+还有就是我们经常个人电脑和工作电脑要同步一些私人资料,而不是用微信传来传去。
+
+这些都是git私服的使用场景,而且很好用。
+
+大家也知道 github,gitee也可以搞私人仓库 用来备份,同步文件,但自己的文档可能放着很多重要的信息,包括自己的各种密码,密钥之类的,放到上面未必安全。你就不怕哪些重大bug把你的信息都泄漏了么[机智]
+
+更关键的是,github 和 gitee都限速的。毕竟人家的功能定位并不是网盘。
+
+项目里有大文件(几百M以上),例如pdf,ppt等等 其上传和下载速度会让你窒息。
+
+**后面我会发文专门来讲一讲,如何大家git私服!**
+
+## 搞一个文件存储
+
+这个可以用来生成文件的下载链接,也可以把本地文件传到服务器上。
+
+相当于自己做一个对象存储,其实云厂商也有对象存储的产品。
+
+不过我们自己也可以做一个,不够很多很同学应该都不知道对象存储怎么用吧,其实我们用服务器可以自己做一个类似的公司。
+
+我现在就用自己用go写的一个工具,部署在服务器上。 用来和服务器传文件,或者生成一些文件的临时下载链接。
+
+这些都是直接命令行操作的,
+
+操作方式这样,我把命令包 包装成一个shell命令,想传那个文件,直接 uploadtomyserver,然后就返回可以下载的链接,这个文件也同时传到了我的服务器上。
+
+
+
+我也把我的项目代码放在了github上:
+
+https://github.com/youngyangyang04/fileHttpServer
+
+感兴趣的录友可以去学习一波,顺便给个star 哈哈
+
+
+## 网站
+
+做网站,例如 大家知道用html 写几行代码,就可以生成一个网页,但怎么给别人展示呢?
+
+大家如果用自己的电脑做服务器,只能同一个路由器下的设备可以访问你的网站,可能这个设备出了这个屋子 都访问不了你的网站了。
+
+因为你的IP不是公网IP。
+
+如果有了一台云服务器,都是配公网IP,你的网站就可以让任何人访问了。
+
+或者说 你提供的一个服务就可以让任何人使用。
+
+例如第二个例子中,我们可以自己开发一个文件存储,这个服务,我只把把命令行给其他人,其他人都可以使用我的服务来生成链接,当然他们的文件也都传到了我的服务器上。
+
+再说一个使用场景。
+
+我之前在组织免费里服务器的活动的时候,阿里云给我一个excel,让面就是从我这里买服务器录友的名单,我直接把这个名单甩到群里,让大家自己检查,出现在名单里就可以找我返现,这样做是不是也可以。
+
+这么做有几个很大的问题:
+* 大家都要去下载excel,做对比,会有人改excel的内容然后就说是从你这里买的,我不可能挨个去比较excel有没有改动
+* excel有其他人的个人信息,这是不能暴漏的。
+* 如果每个人自己用excel查询,私信我返现,一个将近两千人找我返现,我微信根本处理不过来,这就变成体力活了。
+
+那应该怎么做呢,
+
+我就简单写一个查询的页面,后端逻辑就是读一个execel表格,大家在查询页面输入自己的阿里云ID,如果在excel里,页面就会返回返现群的二维码,大家就可以自主扫码加群了。
+
+这样,我最后就直接在返现群里 发等额红包就好了,是不是极大降低人力成本了
+
+当然我是把 17个返现群的二维码都生成好了,按照一定的规则,展现给查询通过的录友。
+
+就是这样一个非常普通的查询页面。
+
+
+
+查询通过之后,就会展现返现群二维码。
+
+
+
+但要部署在服务器上,因为没有公网IP,别人用不了你的服务。
+
+
+## 学习linux
+
+学习linux其实在自己的电脑上搞一台虚拟机,或者安装双系统也可以学习,不过这很考验你的电脑性能如何了。
+
+如果你有一个服务器,那就是独立的一台电脑,你怎么霍霍就怎么霍霍,而且一年都不用关机的,可以一直跑你的任务,和你本地电脑也完全隔离。
+
+更方便的是,你目前系统假如是centos,想做一个实验需要在unbantu上,如果是云服务器,更换系统就是在 后台点一下,一键重装,云厂商基本都是支持所有系统一件安装的。
+
+我们平时自己玩linux经常是配各种环境,然后这个linux就被自己玩坏了(一般都是毫无节制使用root权限导致的),总之就是环境配不起来了,基本就要重装了。
+
+那云服务器重装系统可太方便了。
+
+还有就是加入你好不容易配好的环境,如果以后把这个环境玩坏了,你先回退这之前配好的环境而不是重装系统在重新配一遍吧。
+
+那么可以用云服务器的镜像保存功能,就是你配好环境的那一刻就可以打一个镜像包,以后如果环境坏了,直接回退到上次镜像包的状态,这是不是就很香了。
+
+
+## 总结
+
+其实云服务器还有很多其他用处,不过我就说一说大家普遍能用的上的。
+
+
+* [阿里云活动期间服务器购买](https://www.aliyun.com/minisite/goods?taskCode=shareNew2205&recordId=3641992&userCode=roof0wob)
+* [腾讯云活动期间服务器购买](https://curl.qcloud.com/EiaMXllu)
+
diff --git a/problems/其他/参与本项目.md b/problems/qita/参与本项目.md
similarity index 100%
rename from problems/其他/参与本项目.md
rename to problems/qita/参与本项目.md
From 2c1aa6ebf83cca21a8c6536922f2d652fa45c5cc Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Mon, 13 Jun 2022 17:23:30 +0800
Subject: [PATCH 74/74] Update
---
problems/0202.快乐数.md | 1 +
problems/0209.长度最小的子数组.md | 29 ++++++++++++++++++-----
problems/0349.两个数组的交集.md | 2 ++
problems/0383.赎金信.md | 1 +
problems/0454.四数相加II.md | 1 +
problems/qita/server.md | 3 +++
6 files changed, 31 insertions(+), 6 deletions(-)
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index be8686f7..7738b2f6 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -417,6 +417,7 @@ object Solution {
}
sum
}
+```
C#:
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index fbef7692..69e0da4f 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -5,7 +5,7 @@
参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
-## 209.长度最小的子数组
+# 209.长度最小的子数组
[力扣题目链接](https://leetcode-cn.com/problems/minimum-size-subarray-sum/)
@@ -17,6 +17,9 @@
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
+# 思路
+
+为了易于大家理解,我特意录制了[拿下滑动窗口! | LeetCode 209 长度最小的子数组](https://www.bilibili.com/video/BV1tZ4y1q7XE)
## 暴力解法
@@ -47,8 +50,8 @@ public:
}
};
```
-时间复杂度:O(n^2)
-空间复杂度:O(1)
+* 时间复杂度:O(n^2)
+* 空间复杂度:O(1)
## 滑动窗口
@@ -56,6 +59,20 @@ public:
所谓滑动窗口,**就是不断的调节子序列的起始位置和终止位置,从而得出我们要想的结果**。
+在暴力解法中,是一个for循环滑动窗口的起始位置,一个for循环为滑动窗口的终止位置,用两个for循环 完成了一个不断搜索区间的过程。
+
+那么滑动窗口如何用一个for循环来完成这个操作呢。
+
+首先要思考 如果用一个for循环,那么应该表示 滑动窗口的起始位置,还是终止位置。
+
+如果只用一个for循环来表示 滑动窗口的起始位置,那么如何遍历剩下的终止位置?
+
+此时难免再次陷入 暴力解法的怪圈。
+
+所以 只用一个for循环,那么这个循环的索引,一定是表示 滑动窗口的终止位置。
+
+那么问题来了, 滑动窗口的起始位置如何移动呢?
+
这里还是以题目中的示例来举例,s=7, 数组是 2,3,1,2,4,3,来看一下查找的过程:

@@ -74,7 +91,7 @@ public:
窗口的起始位置如何移动:如果当前窗口的值大于s了,窗口就要向前移动了(也就是该缩小了)。
-窗口的结束位置如何移动:窗口的结束位置就是遍历数组的指针,窗口的起始位置设置为数组的起始位置就可以了。
+窗口的结束位置如何移动:窗口的结束位置就是遍历数组的指针,也就是for循环里的索引。
解题的关键在于 窗口的起始位置如何移动,如图所示:
@@ -107,8 +124,8 @@ public:
};
```
-时间复杂度:O(n)
-空间复杂度:O(1)
+* 时间复杂度:O(n)
+* 空间复杂度:O(1)
**一些录友会疑惑为什么时间复杂度是O(n)**。
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index f7dab3d7..4fbdd414 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -356,6 +356,8 @@ object Solution {
}
}
+```
+
C#:
```csharp
diff --git a/problems/0383.赎金信.md b/problems/0383.赎金信.md
index 75dafb72..9c3dda8c 100644
--- a/problems/0383.赎金信.md
+++ b/problems/0383.赎金信.md
@@ -425,6 +425,7 @@ object Solution {
true
}
}
+```
C#:
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index bfdee26e..726fdb15 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -354,6 +354,7 @@ object Solution {
res
}
}
+```
C#:
```csharp
diff --git a/problems/qita/server.md b/problems/qita/server.md
index 16995d70..1d7a1d6b 100644
--- a/problems/qita/server.md
+++ b/problems/qita/server.md
@@ -1,6 +1,9 @@
# 一台服务器有什么用!
+* [阿里云活动期间服务器购买](https://www.aliyun.com/minisite/goods?taskCode=shareNew2205&recordId=3641992&userCode=roof0wob)
+* [腾讯云活动期间服务器购买](https://curl.qcloud.com/EiaMXllu)
+
但在组织这场活动的时候,了解到大家都有一个共同的问题: **这个服务器究竟有啥用??**
这真是一个好问题,而且我一句两句还说不清楚,所以就专门发文来讲一讲。