diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..7794435b
Binary files /dev/null and b/.DS_Store differ
diff --git a/README.md b/README.md
index c5149776..c1761f7b 100644
--- a/README.md
+++ b/README.md
@@ -5,10 +5,11 @@
> 1. **介绍**:本项目是一套完整的刷题计划,旨在帮助大家少走弯路,循序渐进学算法,[关注作者](#关于作者)
> 2. **PDF版本** : [「代码随想录」算法精讲 PDF 版本](https://programmercarl.com/other/algo_pdf.html) 。
-> 3. **刷题顺序** : README已经将刷题顺序排好了,按照顺序一道一道刷就可以。
-> 4. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
-> 5. **提交代码**:本项目统一使用C++语言进行讲解,但已经有Java、Python、Go、JavaScript等等多语言版本,感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors),如果你也想贡献代码点亮你的头像,[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
-> 6. **转载须知** :以下所有文章皆为我([程序员Carl](https://github.com/youngyangyang04))的原创。引用本项目文章请注明出处,发现恶意抄袭或搬运,会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境!
+> 3. **最强八股文:**:[代码随想录知识星球精华PDF](https://www.programmercarl.com/other/kstar_baguwen.html)
+> 4. **刷题顺序** : README已经将刷题顺序排好了,按照顺序一道一道刷就可以。
+> 5. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」知识星球](https://programmercarl.com/other/kstar.html) 。
+> 6. **提交代码**:本项目统一使用C++语言进行讲解,但已经有Java、Python、Go、JavaScript等等多语言版本,感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors),如果你也想贡献代码点亮你的头像,[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
+> 7. **转载须知** :以下所有文章皆为我([程序员Carl](https://github.com/youngyangyang04))的原创。引用本项目文章请注明出处,发现恶意抄袭或搬运,会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境!
diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index 9e4046d4..95d62e42 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -283,8 +283,60 @@ var isValid = function(s) {
};
```
+TypeScript:
+
+版本一:普通版
+
+```typescript
+function isValid(s: string): boolean {
+ let helperStack: string[] = [];
+ for (let i = 0, length = s.length; i < length; i++) {
+ let x: string = s[i];
+ switch (x) {
+ case '(':
+ helperStack.push(')');
+ break;
+ case '[':
+ helperStack.push(']');
+ break;
+ case '{':
+ helperStack.push('}');
+ break;
+ default:
+ if (helperStack.pop() !== x) return false;
+ break;
+ }
+ }
+ return helperStack.length === 0;
+};
+```
+
+版本二:优化版
+
+```typescript
+function isValid(s: string): boolean {
+ type BracketMap = {
+ [index: string]: string;
+ }
+ let helperStack: string[] = [];
+ let bracketMap: BracketMap = {
+ '(': ')',
+ '[': ']',
+ '{': '}'
+ }
+ for (let i of s) {
+ if (bracketMap.hasOwnProperty(i)) {
+ helperStack.push(bracketMap[i]);
+ } else if (i !== helperStack.pop()) {
+ return false;
+ }
+ }
+ return helperStack.length === 0;
+};
+```
Swift
+
```swift
func isValid(_ s: String) -> Bool {
var stack = [String.Element]()
diff --git a/problems/0031.下一个排列.md b/problems/0031.下一个排列.md
index 84bf3e60..2219e24d 100644
--- a/problems/0031.下一个排列.md
+++ b/problems/0031.下一个排列.md
@@ -81,7 +81,7 @@ public:
for (int j = nums.size() - 1; j > i; j--) {
if (nums[j] > nums[i]) {
swap(nums[j], nums[i]);
- sort(nums.begin() + i + 1, nums.end());
+ reverse(nums.begin() + i + 1, nums.end());
return;
}
}
diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index a39c064a..7a3f048c 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -142,6 +142,7 @@ public:
### Java
```Java
+// 版本一
class Solution {
public int jump(int[] nums) {
if (nums == null || nums.length == 0 || nums.length == 1) {
@@ -172,7 +173,30 @@ class Solution {
}
```
+```java
+// 版本二
+class Solution {
+ public int jump(int[] nums) {
+ int result = 0;
+ // 当前覆盖的最远距离下标
+ int end = 0;
+ // 下一步覆盖的最远距离下标
+ int temp = 0;
+ for (int i = 0; i <= end && end < nums.length - 1; ++i) {
+ temp = Math.max(temp, i + nums[i]);
+ // 可达位置的改变次数就是跳跃次数
+ if (i == end) {
+ end = temp;
+ result++;
+ }
+ }
+ return result;
+ }
+}
+```
+
### Python
+
```python
class Solution:
def jump(self, nums: List[int]) -> int:
diff --git a/problems/0063.不同路径II.md b/problems/0063.不同路径II.md
index 105b6402..8e82007e 100644
--- a/problems/0063.不同路径II.md
+++ b/problems/0063.不同路径II.md
@@ -4,7 +4,7 @@
参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
-## 63. 不同路径 II
+# 63. 不同路径 II
[力扣题目链接](https://leetcode-cn.com/problems/unique-paths-ii/)
@@ -22,23 +22,22 @@

-输入:obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
-输出:2
+* 输入:obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+* 输出:2
解释:
-3x3 网格的正中间有一个障碍物。
-从左上角到右下角一共有 2 条不同的路径:
-1. 向右 -> 向右 -> 向下 -> 向下
-2. 向下 -> 向下 -> 向右 -> 向右
+* 3x3 网格的正中间有一个障碍物。
+* 从左上角到右下角一共有 2 条不同的路径:
+ 1. 向右 -> 向右 -> 向下 -> 向下
+ 2. 向下 -> 向下 -> 向右 -> 向右
示例 2:

-输入:obstacleGrid = [[0,1],[0,0]]
-输出:1
+* 输入:obstacleGrid = [[0,1],[0,0]]
+* 输出:1
提示:
-
* m == obstacleGrid.length
* n == obstacleGrid[i].length
* 1 <= m, n <= 100
@@ -171,7 +170,7 @@ public:
## 其他语言版本
-Java:
+### Java
```java
class Solution {
@@ -199,7 +198,7 @@ class Solution {
```
-Python:
+### Python
```python
class Solution:
@@ -262,7 +261,7 @@ class Solution:
```
-Go:
+### Go
```go
func uniquePathsWithObstacles(obstacleGrid [][]int) int {
@@ -295,8 +294,8 @@ func uniquePathsWithObstacles(obstacleGrid [][]int) int {
```
-Javascript
-``` Javascript
+### Javascript
+```Javascript
var uniquePathsWithObstacles = function(obstacleGrid) {
const m = obstacleGrid.length
const n = obstacleGrid[0].length
diff --git a/problems/0096.不同的二叉搜索树.md b/problems/0096.不同的二叉搜索树.md
index d334a29c..41fcb8fe 100644
--- a/problems/0096.不同的二叉搜索树.md
+++ b/problems/0096.不同的二叉搜索树.md
@@ -4,7 +4,7 @@
参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
-## 96.不同的二叉搜索树
+# 96.不同的二叉搜索树
[力扣题目链接](https://leetcode-cn.com/problems/unique-binary-search-trees/)
@@ -163,7 +163,7 @@ public:
## 其他语言版本
-Java:
+### Java
```Java
class Solution {
public int numTrees(int n) {
@@ -184,7 +184,7 @@ class Solution {
}
```
-Python:
+### Python
```python
class Solution:
def numTrees(self, n: int) -> int:
@@ -196,7 +196,7 @@ class Solution:
return dp[-1]
```
-Go:
+### Go
```Go
func numTrees(n int)int{
dp:=make([]int,n+1)
@@ -210,7 +210,7 @@ func numTrees(n int)int{
}
```
-Javascript:
+### Javascript
```Javascript
const numTrees =(n) => {
let dp = new Array(n+1).fill(0);
diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index 69bc41d3..e4e232c8 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -574,6 +574,75 @@ var isSymmetric = function(root) {
};
```
+## TypeScript:
+
+> 递归法
+
+```typescript
+function isSymmetric(root: TreeNode | null): boolean {
+ function recur(node1: TreeNode | null, node2: TreeNode | null): boolean {
+ if (node1 === null && node2 === null) return true;
+ if (node1 === null || node2 === null) return false;
+ if (node1.val !== node2.val) return false
+ let isSym1: boolean = recur(node1.left, node2.right);
+ let isSym2: boolean = recur(node1.right, node2.left);
+ return isSym1 && isSym2
+ }
+ if (root === null) return true;
+ return recur(root.left, root.right);
+};
+```
+
+> 迭代法
+
+```typescript
+// 迭代法(队列)
+function isSymmetric(root: TreeNode | null): boolean {
+ let helperQueue: (TreeNode | null)[] = [];
+ let tempNode1: TreeNode | null,
+ tempNode2: TreeNode | null;
+ if (root !== null) {
+ helperQueue.push(root.left);
+ helperQueue.push(root.right);
+ }
+ while (helperQueue.length > 0) {
+ tempNode1 = helperQueue.shift()!;
+ tempNode2 = helperQueue.shift()!;
+ if (tempNode1 === null && tempNode2 === null) continue;
+ if (tempNode1 === null || tempNode2 === null) return false;
+ if (tempNode1.val !== tempNode2.val) return false;
+ helperQueue.push(tempNode1.left);
+ helperQueue.push(tempNode2.right);
+ helperQueue.push(tempNode1.right);
+ helperQueue.push(tempNode2.left);
+ }
+ return true;
+}
+
+// 迭代法(栈)
+function isSymmetric(root: TreeNode | null): boolean {
+ let helperStack: (TreeNode | null)[] = [];
+ let tempNode1: TreeNode | null,
+ tempNode2: TreeNode | null;
+ if (root !== null) {
+ helperStack.push(root.left);
+ helperStack.push(root.right);
+ }
+ while (helperStack.length > 0) {
+ tempNode1 = helperStack.pop()!;
+ tempNode2 = helperStack.pop()!;
+ if (tempNode1 === null && tempNode2 === null) continue;
+ if (tempNode1 === null || tempNode2 === null) return false;
+ if (tempNode1.val !== tempNode2.val) return false;
+ helperStack.push(tempNode1.left);
+ helperStack.push(tempNode2.right);
+ helperStack.push(tempNode1.right);
+ helperStack.push(tempNode2.left);
+ }
+ return true;
+};
+```
+
## Swift:
> 递归
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 1fb9b633..1a92d42f 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -246,7 +246,35 @@ var levelOrder = function(root) {
```
+TypeScript:
+
+```typescript
+function levelOrder(root: TreeNode | null): number[][] {
+ let helperQueue: TreeNode[] = [];
+ let res: number[][] = [];
+ let tempArr: number[] = [];
+ if (root !== null) helperQueue.push(root);
+ let curNode: TreeNode;
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ curNode = helperQueue.shift()!;
+ tempArr.push(curNode.val);
+ if (curNode.left !== null) {
+ helperQueue.push(curNode.left);
+ }
+ if (curNode.right !== null) {
+ helperQueue.push(curNode.right);
+ }
+ }
+ res.push(tempArr);
+ tempArr = [];
+ }
+ return res;
+};
+```
+
Swift:
+
```swift
func levelOrder(_ root: TreeNode?) -> [[Int]] {
var res = [[Int]]()
@@ -454,7 +482,31 @@ var levelOrderBottom = function(root) {
};
```
+TypeScript:
+
+```typescript
+function levelOrderBottom(root: TreeNode | null): number[][] {
+ let helperQueue: TreeNode[] = [];
+ let resArr: number[][] = [];
+ let tempArr: number[] = [];
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ tempArr.push(tempNode.val);
+ if (tempNode.left !== null) helperQueue.push(tempNode.left);
+ if (tempNode.right !== null) helperQueue.push(tempNode.right);
+ }
+ resArr.push(tempArr);
+ tempArr = [];
+ }
+ return resArr.reverse();
+};
+```
+
Swift:
+
```swift
func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
var res = [[Int]]()
@@ -657,7 +709,28 @@ var rightSideView = function(root) {
};
```
+TypeScript:
+
+```typescript
+function rightSideView(root: TreeNode | null): number[] {
+ let helperQueue: TreeNode[] = [];
+ let resArr: number[] = [];
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (i === length - 1) resArr.push(tempNode.val);
+ if (tempNode.left !== null) helperQueue.push(tempNode.left);
+ if (tempNode.right !== null) helperQueue.push(tempNode.right);
+ }
+ }
+ return resArr;
+};
+```
+
Swift:
+
```swift
func rightSideView(_ root: TreeNode?) -> [Int] {
var res = [Int]()
@@ -868,7 +941,32 @@ var averageOfLevels = function(root) {
};
```
+TypeScript:
+
+```typescript
+function averageOfLevels(root: TreeNode | null): number[] {
+ let helperQueue: TreeNode[] = [];
+ let resArr: number[] = [];
+ let total: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ let length = helperQueue.length;
+ for (let i = 0; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ total += tempNode.val;
+ if (tempNode.left) helperQueue.push(tempNode.left);
+ if (tempNode.right) helperQueue.push(tempNode.right);
+ }
+ resArr.push(total / length);
+ total = 0;
+ }
+ return resArr;
+};
+```
+
Swift:
+
```swift
func averageOfLevels(_ root: TreeNode?) -> [Double] {
var res = [Double]()
@@ -1092,7 +1190,30 @@ var levelOrder = function(root) {
};
```
+TypeScript:
+
+```typescript
+function levelOrder(root: Node | null): number[][] {
+ let helperQueue: Node[] = [];
+ let resArr: number[][] = [];
+ let tempArr: number[] = [];
+ if (root !== null) helperQueue.push(root);
+ let curNode: Node;
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ curNode = helperQueue.shift()!;
+ tempArr.push(curNode.val);
+ helperQueue.push(...curNode.children);
+ }
+ resArr.push(tempArr);
+ tempArr = [];
+ }
+ return resArr;
+};
+```
+
Swift:
+
```swift
func levelOrder(_ root: Node?) -> [[Int]] {
var res = [[Int]]()
@@ -1272,7 +1393,34 @@ var largestValues = function(root) {
};
```
+TypeScript:
+
+```typescript
+function largestValues(root: TreeNode | null): number[] {
+ let helperQueue: TreeNode[] = [];
+ let resArr: number[] = [];
+ let tempNode: TreeNode;
+ let max: number = 0;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (i === 0) {
+ max = tempNode.val;
+ } else {
+ max = max > tempNode.val ? max : tempNode.val;
+ }
+ if (tempNode.left) helperQueue.push(tempNode.left);
+ if (tempNode.right) helperQueue.push(tempNode.right);
+ }
+ resArr.push(max);
+ }
+ return resArr;
+};
+```
+
Swift:
+
```swift
func largestValues(_ root: TreeNode?) -> [Int] {
var res = [Int]()
@@ -1463,6 +1611,31 @@ var connect = function(root) {
};
```
+TypeScript:
+
+```typescript
+function connect(root: Node | null): Node | null {
+ let helperQueue: Node[] = [];
+ let preNode: Node, curNode: Node;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ if (i === 0) {
+ preNode = helperQueue.shift()!;
+ } else {
+ curNode = helperQueue.shift()!;
+ preNode.next = curNode;
+ preNode = curNode;
+ }
+ if (preNode.left) helperQueue.push(preNode.left);
+ if (preNode.right) helperQueue.push(preNode.right);
+ }
+ preNode.next = null;
+ }
+ return root;
+};
+```
+
go:
```GO
@@ -1689,6 +1862,31 @@ var connect = function(root) {
return root;
};
```
+TypeScript:
+
+```typescript
+function connect(root: Node | null): Node | null {
+ let helperQueue: Node[] = [];
+ let preNode: Node, curNode: Node;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ if (i === 0) {
+ preNode = helperQueue.shift()!;
+ } else {
+ curNode = helperQueue.shift()!;
+ preNode.next = curNode;
+ preNode = curNode;
+ }
+ if (preNode.left) helperQueue.push(preNode.left);
+ if (preNode.right) helperQueue.push(preNode.right);
+ }
+ preNode.next = null;
+ }
+ return root;
+};
+```
+
go:
```GO
@@ -1933,7 +2131,28 @@ var maxDepth = function(root) {
};
```
+TypeScript:
+
+```typescript
+function maxDepth(root: TreeNode | null): number {
+ let helperQueue: TreeNode[] = [];
+ let resDepth: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ resDepth++;
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (tempNode.left) helperQueue.push(tempNode.left);
+ if (tempNode.right) helperQueue.push(tempNode.right);
+ }
+ }
+ return resDepth;
+};
+```
+
Swift:
+
```swift
func maxDepth(_ root: TreeNode?) -> Int {
guard let root = root else {
@@ -2130,7 +2349,29 @@ var minDepth = function(root) {
};
```
+TypeScript:
+
+```typescript
+function minDepth(root: TreeNode | null): number {
+ let helperQueue: TreeNode[] = [];
+ let resMin: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ resMin++;
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (tempNode.left === null && tempNode.right === null) return resMin;
+ if (tempNode.left !== null) helperQueue.push(tempNode.left);
+ if (tempNode.right !== null) helperQueue.push(tempNode.right);
+ }
+ }
+ return resMin;
+};
+```
+
Swift:
+
```swift
func minDepth(_ root: TreeNode?) -> Int {
guard let root = root else {
diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 7038598b..3eecdc92 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -598,7 +598,81 @@ var maxDepth = function(root) {
};
```
+## TypeScript:
+
+> 二叉树的最大深度:
+
+```typescript
+// 后续遍历(自下而上)
+function maxDepth(root: TreeNode | null): number {
+ if (root === null) return 0;
+ return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+};
+
+// 前序遍历(自上而下)
+function maxDepth(root: TreeNode | null): number {
+ function recur(node: TreeNode | null, count: number) {
+ if (node === null) {
+ resMax = resMax > count ? resMax : count;
+ return;
+ }
+ recur(node.left, count + 1);
+ recur(node.right, count + 1);
+ }
+ let resMax: number = 0;
+ let count: number = 0;
+ recur(root, count);
+ return resMax;
+};
+
+// 层序遍历(迭代法)
+function maxDepth(root: TreeNode | null): number {
+ let helperQueue: TreeNode[] = [];
+ let resDepth: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ resDepth++;
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (tempNode.left) helperQueue.push(tempNode.left);
+ if (tempNode.right) helperQueue.push(tempNode.right);
+ }
+ }
+ return resDepth;
+};
+```
+
+> N叉树的最大深度
+
+```typescript
+// 后续遍历(自下而上)
+function maxDepth(root: TreeNode | null): number {
+ if (root === null) return 0;
+ return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+};
+
+// 前序遍历(自上而下)
+function maxDepth(root: TreeNode | null): number {
+ function recur(node: TreeNode | null, count: number) {
+ if (node === null) {
+ resMax = resMax > count ? resMax : count;
+ return;
+ }
+ recur(node.left, count + 1);
+ recur(node.right, count + 1);
+ }
+ let resMax: number = 0;
+ let count: number = 0;
+ recur(root, count);
+ return resMax;
+};
+
+
+```
+
## C
+
二叉树最大深度递归
```c
int maxDepth(struct TreeNode* root){
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index 9d43407a..a8e10297 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -604,7 +604,8 @@ func abs(a int)int{
}
```
-## JavaScript
+## JavaScript
+递归法:
```javascript
var isBalanced = function(root) {
//还是用递归三部曲 + 后序遍历 左右中 当前左子树右子树高度相差大于1就返回-1
@@ -614,8 +615,10 @@ var isBalanced = function(root) {
if(node === null) return 0;
// 3. 确定单层递归逻辑
let leftDepth = getDepth(node.left); //左子树高度
- let rightDepth = getDepth(node.right); //右子树高度
+ // 当判定左子树不为平衡二叉树时,即可直接返回-1
if(leftDepth === -1) return -1;
+ let rightDepth = getDepth(node.right); //右子树高度
+ // 当判定右子树不为平衡二叉树时,即可直接返回-1
if(rightDepth === -1) return -1;
if(Math.abs(leftDepth - rightDepth) > 1) {
return -1;
@@ -627,7 +630,68 @@ var isBalanced = function(root) {
};
```
+迭代法:
+```javascript
+// 获取当前节点的高度
+var getHeight = function (curNode) {
+ let queue = [];
+ if (curNode !== null) queue.push(curNode); // 压入当前元素
+ let depth = 0, res = 0;
+ while (queue.length) {
+ let node = queue[queue.length - 1]; // 取出栈顶
+ if (node !== null) {
+ queue.pop();
+ queue.push(node); // 中
+ queue.push(null);
+ depth++;
+ node.right && queue.push(node.right); // 右
+ node.left && queue.push(node.left); // 左
+ } else {
+ queue.pop();
+ node = queue[queue.length - 1];
+ queue.pop();
+ depth--;
+ }
+ res = res > depth ? res : depth;
+ }
+ return res;
+}
+var isBalanced = function (root) {
+ if (root === null) return true;
+ let queue = [root];
+ while (queue.length) {
+ let node = queue[queue.length - 1]; // 取出栈顶
+ queue.pop();
+ if (Math.abs(getHeight(node.left) - getHeight(node.right)) > 1) {
+ return false;
+ }
+ node.right && queue.push(node.right);
+ node.left && queue.push(node.left);
+ }
+ return true;
+};
+```
+
+## TypeScript
+
+```typescript
+// 递归法
+function isBalanced(root: TreeNode | null): boolean {
+ function getDepth(root: TreeNode | null): number {
+ if (root === null) return 0;
+ let leftDepth: number = getDepth(root.left);
+ if (leftDepth === -1) return -1;
+ let rightDepth: number = getDepth(root.right);
+ if (rightDepth === -1) return -1;
+ if (Math.abs(leftDepth - rightDepth) > 1) return -1;
+ return 1 + Math.max(leftDepth, rightDepth);
+ }
+ return getDepth(root) !== -1;
+};
+```
+
## C
+
递归法:
```c
int getDepth(struct TreeNode* node) {
diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index a439322a..224caa5e 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -404,6 +404,44 @@ var minDepth = function(root) {
};
```
+## TypeScript
+
+> 递归法
+
+```typescript
+function minDepth(root: TreeNode | null): number {
+ if (root === null) return 0;
+ if (root.left !== null && root.right === null) {
+ return 1 + minDepth(root.left);
+ }
+ if (root.left === null && root.right !== null) {
+ return 1 + minDepth(root.right);
+ }
+ return 1 + Math.min(minDepth(root.left), minDepth(root.right));
+}
+```
+
+> 迭代法
+
+```typescript
+function minDepth(root: TreeNode | null): number {
+ let helperQueue: TreeNode[] = [];
+ let resMin: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ resMin++;
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ if (tempNode.left === null && tempNode.right === null) return resMin;
+ if (tempNode.left !== null) helperQueue.push(tempNode.left);
+ if (tempNode.right !== null) helperQueue.push(tempNode.right);
+ }
+ }
+ return resMin;
+};
+```
+
## Swift
> 递归
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 5ec8ffd0..a884b278 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -531,82 +531,63 @@ class solution:
```go
//递归法
/**
- * definition for a binary tree node.
- * type treenode struct {
- * val int
- * left *treenode
- * right *treenode
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ * Val int
+ * Left *TreeNode
+ * Right *TreeNode
* }
*/
-func haspathsum(root *treenode, targetsum int) bool {
- var flage bool //找没找到的标志
- if root==nil{
- return flage
+func hasPathSum(root *TreeNode, targetSum int) bool {
+ if root == nil {
+ return false
}
- pathsum(root,0,targetsum,&flage)
- return flage
-}
-func pathsum(root *treenode, sum int,targetsum int,flage *bool){
- sum+=root.val
- if root.left==nil&&root.right==nil&&sum==targetsum{
- *flage=true
- return
- }
- if root.left!=nil&&!(*flage){//左节点不为空且还没找到
- pathsum(root.left,sum,targetsum,flage)
- }
- if root.right!=nil&&!(*flage){//右节点不为空且没找到
- pathsum(root.right,sum,targetsum,flage)
+
+ targetSum -= root.Val // 将targetSum在遍历每层的时候都减去本层节点的值
+ if root.Left == nil && root.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果
+ return true
}
+ return hasPathSum(root.Left, targetSum) || hasPathSum(root.Right, targetSum) // 否则递归找
}
```
-113 递归法
+113. 路径总和 II
```go
/**
- * definition for a binary tree node.
- * type treenode struct {
- * val int
- * left *treenode
- * right *treenode
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ * Val int
+ * Left *TreeNode
+ * Right *TreeNode
* }
*/
-func pathsum(root *treenode, targetsum int) [][]int {
- var result [][]int//最终结果
- if root==nil{
- return result
- }
- var sumnodes []int//经过路径的节点集合
- haspathsum(root,&sumnodes,targetsum,&result)
+func pathSum(root *TreeNode, targetSum int) [][]int {
+ result := make([][]int, 0)
+ traverse(root, &result, new([]int), targetSum)
return result
}
-func haspathsum(root *treenode,sumnodes *[]int,targetsum int,result *[][]int){
- *sumnodes=append(*sumnodes,root.val)
- if root.left==nil&&root.right==nil{//叶子节点
- fmt.println(*sumnodes)
- var sum int
- var number int
- for k,v:=range *sumnodes{//求该路径节点的和
- sum+=v
- number=k
- }
- tempnodes:=make([]int,number+1)//新的nodes接受指针里的值,防止最终指针里的值发生变动,导致最后的结果都是最后一个sumnodes的值
- for k,v:=range *sumnodes{
- tempnodes[k]=v
- }
- if sum==targetsum{
- *result=append(*result,tempnodes)
- }
+
+func traverse(node *TreeNode, result *[][]int, currPath *[]int, targetSum int) {
+ if node == nil { // 这个判空也可以挪到递归遍历左右子树时去判断
+ return
}
- if root.left!=nil{
- haspathsum(root.left,sumnodes,targetsum,result)
- *sumnodes=(*sumnodes)[:len(*sumnodes)-1]//回溯
- }
- if root.right!=nil{
- haspathsum(root.right,sumnodes,targetsum,result)
- *sumnodes=(*sumnodes)[:len(*sumnodes)-1]//回溯
+
+ targetSum -= node.Val // 将targetSum在遍历每层的时候都减去本层节点的值
+ *currPath = append(*currPath, node.Val) // 把当前节点放到路径记录里
+
+ if node.Left == nil && node.Right == nil && targetSum == 0 { // 如果剩余的targetSum为0, 则正好就是符合的结果
+ // 不能直接将currPath放到result里面, 因为currPath是共享的, 每次遍历子树时都会被修改
+ pathCopy := make([]int, len(*currPath))
+ for i, element := range *currPath {
+ pathCopy[i] = element
+ }
+ *result = append(*result, pathCopy) // 将副本放到结果集里
}
+
+ traverse(node.Left, result, currPath, targetSum)
+ traverse(node.Right, result, currPath, targetSum)
+ *currPath = (*currPath)[:len(*currPath)-1] // 当前节点遍历完成, 从路径记录里删除掉
}
```
diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index e24ffc1a..1653a81a 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -248,6 +248,36 @@ class Solution {
return valid[s.length()];
}
}
+
+// 回溯法+记忆化
+class Solution {
+ public boolean wordBreak(String s, List wordDict) {
+ Set wordDictSet = new HashSet(wordDict);
+ int[] memory = new int[s.length()];
+ return backTrack(s, wordDictSet, 0, memory);
+ }
+
+ public boolean backTrack(String s, Set wordDictSet, int startIndex, int[] memory) {
+ // 结束条件
+ if (startIndex >= s.length()) {
+ return true;
+ }
+ if (memory[startIndex] != 0) {
+ // 此处认为:memory[i] = 1 表示可以拼出i 及以后的字符子串, memory[i] = -1 表示不能
+ return memory[startIndex] == 1 ? true : false;
+ }
+ for (int i = startIndex; i < s.length(); ++i) {
+ // 处理 递归 回溯 循环不变量:[startIndex, i + 1)
+ String word = s.substring(startIndex, i + 1);
+ if (wordDictSet.contains(word) && backTrack(s, wordDictSet, i + 1, memory)) {
+ memory[startIndex] = 1;
+ return true;
+ }
+ }
+ memory[startIndex] = -1;
+ return false;
+ }
+}
```
Python:
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index f44703f1..f4dad823 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -210,6 +210,71 @@ var evalRPN = function(tokens) {
};
```
+TypeScript:
+
+普通版:
+
+```typescript
+function evalRPN(tokens: string[]): number {
+ let helperStack: number[] = [];
+ let temp: number;
+ let i: number = 0;
+ while (i < tokens.length) {
+ let t: string = tokens[i];
+ switch (t) {
+ case '+':
+ temp = helperStack.pop()! + helperStack.pop()!;
+ helperStack.push(temp);
+ break;
+ case '-':
+ temp = helperStack.pop()!;
+ temp = helperStack.pop()! - temp;
+ helperStack.push(temp);
+ break;
+ case '*':
+ temp = helperStack.pop()! * helperStack.pop()!;
+ helperStack.push(temp);
+ break;
+ case '/':
+ temp = helperStack.pop()!;
+ temp = Math.trunc(helperStack.pop()! / temp);
+ helperStack.push(temp);
+ break;
+ default:
+ helperStack.push(Number(t));
+ break;
+ }
+ i++;
+ }
+ return helperStack.pop()!;
+};
+```
+
+优化版:
+
+```typescript
+function evalRPN(tokens: string[]): number {
+ const helperStack: number[] = [];
+ const operatorMap: Map number> = new Map([
+ ['+', (a, b) => a + b],
+ ['-', (a, b) => a - b],
+ ['/', (a, b) => Math.trunc(a / b)],
+ ['*', (a, b) => a * b],
+ ]);
+ let a: number, b: number;
+ for (let t of tokens) {
+ if (operatorMap.has(t)) {
+ b = helperStack.pop()!;
+ a = helperStack.pop()!;
+ helperStack.push(operatorMap.get(t)!(a, b));
+ } else {
+ helperStack.push(Number(t));
+ }
+ }
+ return helperStack.pop()!;
+};
+```
+
python3
```python
diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index 8d38bace..ffbc32ff 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -447,7 +447,63 @@ var countNodes = function(root) {
};
```
+## TypeScrpt:
+
+> 递归法
+
+```typescript
+function countNodes(root: TreeNode | null): number {
+ if (root === null) return 0;
+ return 1 + countNodes(root.left) + countNodes(root.right);
+};
+```
+
+> 迭代法
+
+```typescript
+function countNodes(root: TreeNode | null): number {
+ let helperQueue: TreeNode[] = [];
+ let resCount: number = 0;
+ let tempNode: TreeNode;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ tempNode = helperQueue.shift()!;
+ resCount++;
+ if (tempNode.left) helperQueue.push(tempNode.left);
+ if (tempNode.right) helperQueue.push(tempNode.right);
+ }
+ }
+ return resCount;
+};
+```
+
+> 利用完全二叉树性质
+
+```typescript
+function countNodes(root: TreeNode | null): number {
+ if (root === null) return 0;
+ let left: number = 0,
+ right: number = 0;
+ let curNode: TreeNode | null= root;
+ while (curNode !== null) {
+ left++;
+ curNode = curNode.left;
+ }
+ curNode = root;
+ while (curNode !== null) {
+ right++;
+ curNode = curNode.right;
+ }
+ if (left === right) {
+ return 2 ** left - 1;
+ }
+ return 1 + countNodes(root.left) + countNodes(root.right);
+};
+```
+
## C:
+
递归法
```c
int countNodes(struct TreeNode* root) {
@@ -538,7 +594,7 @@ func _countNodes(_ root: TreeNode?) -> Int {
return 1 + leftCount + rightCount
}
```
-
+
> 层序遍历
```Swift
func countNodes(_ root: TreeNode?) -> Int {
@@ -564,7 +620,7 @@ func countNodes(_ root: TreeNode?) -> Int {
return res
}
```
-
+
> 利用完全二叉树性质
```Swift
func countNodes(_ root: TreeNode?) -> Int {
diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
index 524ca329..c45917db 100644
--- a/problems/0225.用队列实现栈.md
+++ b/problems/0225.用队列实现栈.md
@@ -598,7 +598,80 @@ MyStack.prototype.empty = function() {
```
+TypeScript:
+
+版本一:使用两个队列模拟栈
+
+```typescript
+class MyStack {
+ private queue: number[];
+ private tempQueue: number[];
+ constructor() {
+ this.queue = [];
+ this.tempQueue = [];
+ }
+
+ push(x: number): void {
+ this.queue.push(x);
+ }
+
+ pop(): number {
+ for (let i = 0, length = this.queue.length - 1; i < length; i++) {
+ this.tempQueue.push(this.queue.shift()!);
+ }
+ let res: number = this.queue.pop()!;
+ let temp: number[] = this.queue;
+ this.queue = this.tempQueue;
+ this.tempQueue = temp;
+ return res;
+ }
+
+ top(): number {
+ let res: number = this.pop();
+ this.push(res);
+ return res;
+ }
+
+ empty(): boolean {
+ return this.queue.length === 0;
+ }
+}
+```
+
+版本二:使用一个队列模拟栈
+
+```typescript
+class MyStack {
+ private queue: number[];
+ constructor() {
+ this.queue = [];
+ }
+
+ push(x: number): void {
+ this.queue.push(x);
+ }
+
+ pop(): number {
+ for (let i = 0, length = this.queue.length - 1; i < length; i++) {
+ this.queue.push(this.queue.shift()!);
+ }
+ return this.queue.shift()!;
+ }
+
+ top(): number {
+ let res: number = this.pop();
+ this.push(res);
+ return res;
+ }
+
+ empty(): boolean {
+ return this.queue.length === 0;
+ }
+}
+```
+
Swift
+
```Swift
// 定义一个队列数据结构
class Queue {
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index e6dbb709..8108e7ad 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -563,7 +563,135 @@ var invertTree = function(root) {
};
```
+### TypeScript:
+
+递归法:
+
+```typescript
+// 递归法(前序遍历)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ if (root === null) return root;
+ let tempNode: TreeNode | null = root.left;
+ root.left = root.right;
+ root.right = tempNode;
+ invertTree(root.left);
+ invertTree(root.right);
+ return root;
+};
+
+// 递归法(后序遍历)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ if (root === null) return root;
+ invertTree(root.left);
+ invertTree(root.right);
+ let tempNode: TreeNode | null = root.left;
+ root.left = root.right;
+ root.right = tempNode;
+ return root;
+};
+
+// 递归法(中序遍历)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ if (root === null) return root;
+ invertTree(root.left);
+ let tempNode: TreeNode | null = root.left;
+ root.left = root.right;
+ root.right = tempNode;
+ // 因为左右节点已经进行交换,此时的root.left 是原先的root.right
+ invertTree(root.left);
+ return root;
+};
+```
+
+迭代法:
+
+```typescript
+// 迭代法(栈模拟前序遍历)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ let helperStack: TreeNode[] = [];
+ let curNode: TreeNode,
+ tempNode: TreeNode | null;
+ if (root !== null) helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ // 入栈操作最好在交换节点之前进行,便于理解
+ if (curNode.right) helperStack.push(curNode.right);
+ if (curNode.left) helperStack.push(curNode.left);
+ tempNode = curNode.left;
+ curNode.left = curNode.right;
+ curNode.right = tempNode;
+ }
+ return root;
+};
+
+// 迭代法(栈模拟中序遍历-统一写法形式)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ let helperStack: (TreeNode | null)[] = [];
+ let curNode: TreeNode | null,
+ tempNode: TreeNode | null;
+ if (root !== null) helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop();
+ if (curNode !== null) {
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ helperStack.push(curNode);
+ helperStack.push(null);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ } else {
+ curNode = helperStack.pop()!;
+ tempNode = curNode.left;
+ curNode.left = curNode.right;
+ curNode.right = tempNode;
+ }
+ }
+ return root;
+};
+
+// 迭代法(栈模拟后序遍历-统一写法形式)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ let helperStack: (TreeNode | null)[] = [];
+ let curNode: TreeNode | null,
+ tempNode: TreeNode | null;
+ if (root !== null) helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop();
+ if (curNode !== null) {
+ helperStack.push(curNode);
+ helperStack.push(null);
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ } else {
+ curNode = helperStack.pop()!;
+ tempNode = curNode.left;
+ curNode.left = curNode.right;
+ curNode.right = tempNode;
+ }
+ }
+ return root;
+};
+
+// 迭代法(队列模拟层序遍历)
+function invertTree(root: TreeNode | null): TreeNode | null {
+ const helperQueue: TreeNode[] = [];
+ let curNode: TreeNode,
+ tempNode: TreeNode | null;
+ if (root !== null) helperQueue.push(root);
+ while (helperQueue.length > 0) {
+ for (let i = 0, length = helperQueue.length; i < length; i++) {
+ curNode = helperQueue.shift()!;
+ tempNode = curNode.left;
+ curNode.left = curNode.right;
+ curNode.right = tempNode;
+ if (curNode.left !== null) helperQueue.push(curNode.left);
+ if (curNode.right !== null) helperQueue.push(curNode.right);
+ }
+ }
+ return root;
+};
+```
+
### C:
+
递归法
```c
struct TreeNode* invertTree(struct TreeNode* root){
diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
index 0e4fce28..b00ffd80 100644
--- a/problems/0232.用栈实现队列.md
+++ b/problems/0232.用栈实现队列.md
@@ -348,7 +348,44 @@ MyQueue.prototype.empty = function() {
};
```
+TypeScript:
+
+```typescript
+class MyQueue {
+ private stackIn: number[]
+ private stackOut: number[]
+ constructor() {
+ this.stackIn = [];
+ this.stackOut = [];
+ }
+
+ push(x: number): void {
+ this.stackIn.push(x);
+ }
+
+ pop(): number {
+ if (this.stackOut.length === 0) {
+ while (this.stackIn.length > 0) {
+ this.stackOut.push(this.stackIn.pop()!);
+ }
+ }
+ return this.stackOut.pop()!;
+ }
+
+ peek(): number {
+ let temp: number = this.pop();
+ this.stackOut.push(temp);
+ return temp;
+ }
+
+ empty(): boolean {
+ return this.stackIn.length === 0 && this.stackOut.length === 0;
+ }
+}
+```
+
Swift:
+
```swift
class MyQueue {
diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
index d9788f63..ce215a7e 100644
--- a/problems/0239.滑动窗口最大值.md
+++ b/problems/0239.滑动窗口最大值.md
@@ -45,7 +45,7 @@
这个队列应该长这个样子:
-```
+```cpp
class MyQueue {
public:
void pop(int value) {
@@ -395,30 +395,102 @@ func maxSlidingWindow(nums []int, k int) []int {
Javascript:
```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
var maxSlidingWindow = function (nums, k) {
- // 队列数组(存放的是元素下标,为了取值方便)
- const q = [];
- // 结果数组
- const ans = [];
- for (let i = 0; i < nums.length; i++) {
- // 若队列不为空,且当前元素大于等于队尾所存下标的元素,则弹出队尾
- while (q.length && nums[i] >= nums[q[q.length - 1]]) {
- q.pop();
+ class MonoQueue {
+ queue;
+ constructor() {
+ this.queue = [];
+ }
+ enqueue(value) {
+ let back = this.queue[this.queue.length - 1];
+ while (back !== undefined && back < value) {
+ this.queue.pop();
+ back = this.queue[this.queue.length - 1];
+ }
+ this.queue.push(value);
+ }
+ dequeue(value) {
+ let front = this.front();
+ if (front === value) {
+ this.queue.shift();
+ }
+ }
+ front() {
+ return this.queue[0];
+ }
}
- // 入队当前元素下标
- q.push(i);
- // 判断当前最大值(即队首元素)是否在窗口中,若不在便将其出队
- if (q[0] <= i - k) {
- q.shift();
+ let helperQueue = new MonoQueue();
+ let i = 0, j = 0;
+ let resArr = [];
+ while (j < k) {
+ helperQueue.enqueue(nums[j++]);
}
- // 当达到窗口大小时便开始向结果中添加数据
- if (i >= k - 1) ans.push(nums[q[0]]);
- }
- return ans;
+ resArr.push(helperQueue.front());
+ while (j < nums.length) {
+ helperQueue.enqueue(nums[j]);
+ helperQueue.dequeue(nums[i]);
+ resArr.push(helperQueue.front());
+ i++, j++;
+ }
+ return resArr;
+};
+```
+
+TypeScript:
+
+```typescript
+function maxSlidingWindow(nums: number[], k: number): number[] {
+ /** 单调递减队列 */
+ class MonoQueue {
+ private queue: number[];
+ constructor() {
+ this.queue = [];
+ };
+ /** 入队:value如果大于队尾元素,则将队尾元素删除,直至队尾元素大于value,或者队列为空 */
+ public enqueue(value: number): void {
+ let back: number | undefined = this.queue[this.queue.length - 1];
+ while (back !== undefined && back < value) {
+ this.queue.pop();
+ back = this.queue[this.queue.length - 1];
+ }
+ this.queue.push(value);
+ };
+ /** 出队:只有当队头元素等于value,才出队 */
+ public dequeue(value: number): void {
+ let top: number | undefined = this.top();
+ if (top !== undefined && top === value) {
+ this.queue.shift();
+ }
+ }
+ public top(): number | undefined {
+ return this.queue[0];
+ }
+ }
+ const helperQueue: MonoQueue = new MonoQueue();
+ let i: number = 0,
+ j: number = 0;
+ let resArr: number[] = [];
+ while (j < k) {
+ helperQueue.enqueue(nums[j++]);
+ }
+ resArr.push(helperQueue.top()!);
+ while (j < nums.length) {
+ helperQueue.enqueue(nums[j]);
+ helperQueue.dequeue(nums[i]);
+ resArr.push(helperQueue.top()!);
+ j++, i++;
+ }
+ return resArr;
};
```
Swift:
+
```Swift
/// 双向链表
class DoublyListNode {
@@ -525,5 +597,39 @@ class Solution {
}
```
+Swift解法二:
+
+```swift
+func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
+ var result = [Int]()
+ var window = [Int]()
+ var right = 0, left = right - k + 1
+
+ while right < nums.count {
+ let value = nums[right]
+
+ // 因为窗口移动丢弃的左边数
+ if left > 0, left - 1 == window.first {
+ window.removeFirst()
+ }
+
+ // 保证末尾的是最大的
+ while !window.isEmpty, value > nums[window.last!] {
+ window.removeLast()
+ }
+ window.append(right)
+
+ if left >= 0 { // 窗口形成
+ result.append(nums[window.first!])
+ }
+
+ right += 1
+ left += 1
+ }
+
+ return result
+}
+```
+
-----------------------
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index 4078320f..1362897c 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -433,9 +433,9 @@ class Solution:
if cur.right:
self.traversal(cur.right, path + '->', result)
```
-
+
迭代法:
-
+
```python3
from collections import deque
@@ -463,13 +463,13 @@ class Solution:
return result
```
-
+
---
Go:
-
+
递归法:
-
+
```go
func binaryTreePaths(root *TreeNode) []string {
res := make([]string, 0)
@@ -492,7 +492,7 @@ func binaryTreePaths(root *TreeNode) []string {
return res
}
```
-
+
迭代法:
```go
@@ -581,7 +581,62 @@ var binaryTreePaths = function(root) {
};
```
+TypeScript:
+
+> 递归法
+
+```typescript
+function binaryTreePaths(root: TreeNode | null): string[] {
+ function recur(node: TreeNode, route: string, resArr: string[]): void {
+ route += String(node.val);
+ if (node.left === null && node.right === null) {
+ resArr.push(route);
+ return;
+ }
+ if (node.left !== null) recur(node.left, route + '->', resArr);
+ if (node.right !== null) recur(node.right, route + '->', resArr);
+ }
+ const resArr: string[] = [];
+ if (root === null) return resArr;
+ recur(root, '', resArr);
+ return resArr;
+};
+```
+
+> 迭代法
+
+```typescript
+// 迭代法2
+function binaryTreePaths(root: TreeNode | null): string[] {
+ let helperStack: TreeNode[] = [];
+ let tempNode: TreeNode;
+ let routeArr: string[] = [];
+ let resArr: string[] = [];
+ if (root !== null) {
+ helperStack.push(root);
+ routeArr.push(String(root.val));
+ };
+ while (helperStack.length > 0) {
+ tempNode = helperStack.pop()!;
+ let route: string = routeArr.pop()!; // tempNode 对应的路径
+ if (tempNode.left === null && tempNode.right === null) {
+ resArr.push(route);
+ }
+ if (tempNode.right !== null) {
+ helperStack.push(tempNode.right);
+ routeArr.push(route + '->' + tempNode.right.val); // tempNode.right 对应的路径
+ }
+ if (tempNode.left !== null) {
+ helperStack.push(tempNode.left);
+ routeArr.push(route + '->' + tempNode.left.val); // tempNode.left 对应的路径
+ }
+ }
+ return resArr;
+};
+```
+
Swift:
+
> 递归/回溯
```swift
func binaryTreePaths(_ root: TreeNode?) -> [String] {
diff --git a/problems/0343.整数拆分.md b/problems/0343.整数拆分.md
index 9882c6ea..b6182ed6 100644
--- a/problems/0343.整数拆分.md
+++ b/problems/0343.整数拆分.md
@@ -4,23 +4,22 @@
参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
-## 343. 整数拆分
+# 343. 整数拆分
[力扣题目链接](https://leetcode-cn.com/problems/integer-break/)
给定一个正整数 n,将其拆分为至少两个正整数的和,并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
示例 1:
-输入: 2
-输出: 1
-
-\解释: 2 = 1 + 1, 1 × 1 = 1。
+* 输入: 2
+* 输出: 1
+* 解释: 2 = 1 + 1, 1 × 1 = 1。
示例 2:
-输入: 10
-输出: 36
-解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
-说明: 你可以假设 n 不小于 2 且不大于 58。
+* 输入: 10
+* 输出: 36
+* 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
+* 说明: 你可以假设 n 不小于 2 且不大于 58。
## 思路
@@ -193,18 +192,21 @@ public:
## 其他语言版本
-Java:
+### Java
```Java
class Solution {
public int integerBreak(int n) {
- //dp[i]为正整数i拆分结果的最大乘积
- int[] dp = new int[n+1];
- dp[2] = 1;
- for (int i = 3; i <= n; ++i) {
- for (int j = 1; j < i - 1; ++j) {
- //j*(i-j)代表把i拆分为j和i-j两个数相乘
- //j*dp[i-j]代表把i拆分成j和继续把(i-j)这个数拆分,取(i-j)拆分结果中的最大乘积与j相乘
- dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
+ //dp[i] 为正整数 i 拆分后的结果的最大乘积
+ int[]dp=new int[n+1];
+ dp[2]=1;
+ for(int i=3;i<=n;i++){
+ for(int j=1;j<=i-j;j++){
+ // 这里的 j 其实最大值为 i-j,再大只不过是重复而已,
+ //并且,在本题中,我们分析 dp[0], dp[1]都是无意义的,
+ //j 最大到 i-j,就不会用到 dp[0]与dp[1]
+ dp[i]=Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j]));
+ // j * (i - j) 是单纯的把整数 i 拆分为两个数 也就是 i,i-j ,再相乘
+ //而j * dp[i - j]是将 i 拆分成两个以及两个以上的个数,再相乘。
}
}
return dp[n];
@@ -212,7 +214,7 @@ class Solution {
}
```
-Python:
+### Python
```python
class Solution:
def integerBreak(self, n: int) -> int:
@@ -226,7 +228,8 @@ class Solution:
dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
return dp[n]
```
-Go:
+
+### Go
```golang
func integerBreak(n int) int {
/**
@@ -256,7 +259,7 @@ func max(a,b int) int{
}
```
-Javascript:
+### Javascript
```Javascript
var integerBreak = function(n) {
let dp = new Array(n + 1).fill(0)
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 8bd774e9..1d6a358b 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -358,6 +358,22 @@ PriorityQueue.prototype.compare = function(index1, index2) {
}
```
+TypeScript:
+
+```typescript
+function topKFrequent(nums: number[], k: number): number[] {
+ const countMap: Map = new Map();
+ for (let num of nums) {
+ countMap.set(num, (countMap.get(num) || 0) + 1);
+ }
+ // tS没有最小堆的数据结构,所以直接对整个数组进行排序,取前k个元素
+ return [...countMap.entries()]
+ .sort((a, b) => b[1] - a[1])
+ .slice(0, k)
+ .map(i => i[0]);
+};
+```
+
-----------------------
diff --git a/problems/0376.摆动序列.md b/problems/0376.摆动序列.md
index 2bc23182..d75311eb 100644
--- a/problems/0376.摆动序列.md
+++ b/problems/0376.摆动序列.md
@@ -174,7 +174,7 @@ public:
```Java
class Solution {
public int wiggleMaxLength(int[] nums) {
- if (nums == null || nums.length <= 1) {
+ if (nums.length <= 1) {
return nums.length;
}
//当前差值
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index 45b8b416..9da1f8d5 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -210,6 +210,45 @@ class Solution {
}
```
+二维数组版本(易于理解):
+```Java
+class Solution {
+ public boolean canPartition(int[] nums) {
+ int sum = 0;
+ for (int i = 0; i < nums.length; i++) {
+ sum += nums[i];
+ }
+
+ if (sum % 2 == 1)
+ return false;
+ int target = sum / 2;
+
+ //dp[i][j]代表可装物品为0-i,背包容量为j的情况下,背包内容量的最大价值
+ int[][] dp = new int[nums.length][target + 1];
+
+ //初始化,dp[0][j]的最大价值nums[0](if j > weight[i])
+ //dp[i][0]均为0,不用初始化
+ for (int j = nums[0]; j <= target; j++) {
+ dp[0][j] = nums[0];
+ }
+
+ //遍历物品,遍历背包
+ //递推公式:
+ for (int i = 1; i < nums.length; i++) {
+ for (int j = 0; j <= target; j++) {
+ //背包容量可以容纳nums[i]
+ if (j >= nums[i]) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
+ } else {
+ dp[i][j] = dp[i - 1][j];
+ }
+ }
+ }
+
+ return dp[nums.length - 1][target] == target;
+ }
+}
+```
Python:
```python
class Solution:
diff --git a/problems/0435.无重叠区间.md b/problems/0435.无重叠区间.md
index 118360bc..389443d1 100644
--- a/problems/0435.无重叠区间.md
+++ b/problems/0435.无重叠区间.md
@@ -183,28 +183,22 @@ public:
```java
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
- if (intervals.length < 2) return 0;
-
- Arrays.sort(intervals, new Comparator() {
- @Override
- public int compare(int[] o1, int[] o2) {
- if (o1[1] != o2[1]) {
- return Integer.compare(o1[1],o2[1]);
- } else {
- return Integer.compare(o1[0],o2[0]);
- }
- }
+ Arrays.sort(intervals, (a, b) -> {
+ if (a[0] == a[0]) return a[1] - b[1];
+ return a[0] - b[0];
});
- int count = 1;
- int edge = intervals[0][1];
- for (int i = 1; i < intervals.length; i++) {
- if (edge <= intervals[i][0]){
- count ++; //non overlap + 1
+ int count = 0;
+ int edge = Integer.MIN_VALUE;
+ for (int i = 0; i < intervals.length; i++) {
+ if (edge <= intervals[i][0]) {
edge = intervals[i][1];
+ } else {
+ count++;
}
}
- return intervals.length - count;
+
+ return count;
}
}
```
diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md
index 0faef4a5..f190b734 100644
--- a/problems/0494.目标和.md
+++ b/problems/0494.目标和.md
@@ -272,7 +272,8 @@ Python:
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
sumValue = sum(nums)
- if target > sumValue or (sumValue + target) % 2 == 1: return 0
+ #注意边界条件为 target>sumValue or target<-sumValue or (sumValue + target) % 2 == 1
+ if abs(target) > sumValue or (sumValue + target) % 2 == 1: return 0
bagSize = (sumValue + target) // 2
dp = [0] * (bagSize + 1)
dp[0] = 1
diff --git a/problems/1047.删除字符串中的所有相邻重复项.md b/problems/1047.删除字符串中的所有相邻重复项.md
index d6eefd07..099ff191 100644
--- a/problems/1047.删除字符串中的所有相邻重复项.md
+++ b/problems/1047.删除字符串中的所有相邻重复项.md
@@ -267,8 +267,32 @@ var removeDuplicates = function(s) {
};
```
+TypeScript:
+
+```typescript
+function removeDuplicates(s: string): string {
+ const helperStack: string[] = [];
+ let i: number = 0;
+ while (i < s.length) {
+ let top: string = helperStack[helperStack.length - 1];
+ if (top === s[i]) {
+ helperStack.pop();
+ } else {
+ helperStack.push(s[i]);
+ }
+ i++;
+ }
+ let res: string = '';
+ while (helperStack.length > 0) {
+ res = helperStack.pop() + res;
+ }
+ return res;
+};
+```
+
C:
方法一:使用栈
+
```c
char * removeDuplicates(char * s){
//求出字符串长度
@@ -322,14 +346,12 @@ char * removeDuplicates(char * s){
Swift:
```swift
func removeDuplicates(_ s: String) -> String {
- let array = Array(s)
var stack = [Character]()
- for c in array {
- let last: Character? = stack.last
- if stack.isEmpty || last != c {
- stack.append(c)
- } else {
+ for c in s {
+ if stack.last == c {
stack.removeLast()
+ } else {
+ stack.append(c)
}
}
return String(stack)
diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md
index d64e7e56..7b67b1ac 100644
--- a/problems/1049.最后一块石头的重量II.md
+++ b/problems/1049.最后一块石头的重量II.md
@@ -153,6 +153,8 @@ public:
Java:
+
+一维数组版本
```Java
class Solution {
public int lastStoneWeightII(int[] stones) {
@@ -173,6 +175,41 @@ class Solution {
return sum - 2 * dp[target];
}
}
+```
+二维数组版本(便于理解)
+```Java
+class Solution {
+ public int lastStoneWeightII(int[] stones) {
+ int sum = 0;
+ for (int s : stones) {
+ sum += s;
+ }
+
+ int target = sum / 2;
+ //初始化,dp[i][j]为可以放0-i物品,背包容量为j的情况下背包中的最大价值
+ int[][] dp = new int[stones.length][target + 1];
+ //dp[i][0]默认初始化为0
+ //dp[0][j]取决于stones[0]
+ for (int j = stones[0]; j <= target; j++) {
+ dp[0][j] = stones[0];
+ }
+
+ for (int i = 1; i < stones.length; i++) {
+ for (int j = 1; j <= target; j++) {//注意是等于
+ if (j >= stones[i]) {
+ //不放:dp[i - 1][j] 放:dp[i - 1][j - stones[i]] + stones[i]
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]);
+ } else {
+ dp[i][j] = dp[i - 1][j];
+ }
+ }
+ }
+
+ System.out.println(dp[stones.length - 1][target]);
+ return (sum - dp[stones.length - 1][target]) - dp[stones.length - 1][target];
+ }
+}
+
```
Python:
diff --git a/problems/二叉树中递归带着回溯.md b/problems/二叉树中递归带着回溯.md
index 41d5663e..1e9f9cbf 100644
--- a/problems/二叉树中递归带着回溯.md
+++ b/problems/二叉树中递归带着回溯.md
@@ -171,7 +171,7 @@ if (cur->right) {
## 其他语言版本
-Java:
+### Java:
100. 相同的树:递归代码
```java
class Solution {
@@ -252,7 +252,7 @@ Java:
}
```
-Python:
+### Python:
100.相同的树
> 递归法
@@ -332,7 +332,7 @@ class Solution:
self.traversal(cur.right, path+"->", result) #右 回溯就隐藏在这里
```
-Go:
+### Go:
100.相同的树
```go
@@ -436,7 +436,7 @@ func traversal(root *TreeNode,result *[]string,path *[]int){
}
```
-JavaScript:
+### JavaScript:
100.相同的树
```javascript
@@ -515,7 +515,8 @@ var binaryTreePaths = function(root) {
};
```
-TypeScript:
+
+### TypeScript:
> 相同的树
@@ -560,5 +561,62 @@ function binaryTreePaths(root: TreeNode | null): string[] {
+### Swift:
+> 100.相同的树
+```swift
+// 递归
+func isSameTree(_ p: TreeNode?, _ q: TreeNode?) -> Bool {
+ return _isSameTree3(p, q)
+}
+func _isSameTree3(_ p: TreeNode?, _ q: TreeNode?) -> Bool {
+ if p == nil && q == nil {
+ return true
+ } else if p == nil && q != nil {
+ return false
+ } else if p != nil && q == nil {
+ return false
+ } else if p!.val != q!.val {
+ return false
+ }
+ let leftSide = _isSameTree3(p!.left, q!.left)
+ let rightSide = _isSameTree3(p!.right, q!.right)
+ return leftSide && rightSide
+}
+```
+
+> 257.二叉树的不同路径
+```swift
+// 递归/回溯
+func binaryTreePaths(_ root: TreeNode?) -> [String] {
+ var res = [String]()
+ guard let root = root else {
+ return res
+ }
+ var paths = [Int]()
+ _binaryTreePaths3(root, res: &res, paths: &paths)
+ return res
+}
+func _binaryTreePaths3(_ root: TreeNode, res: inout [String], paths: inout [Int]) {
+ paths.append(root.val)
+ if root.left == nil && root.right == nil {
+ var str = ""
+ for i in 0 ..< (paths.count - 1) {
+ str.append("\(paths[i])->")
+ }
+ str.append("\(paths.last!)")
+ res.append(str)
+ }
+ if let left = root.left {
+ _binaryTreePaths3(left, res: &res, paths: &paths)
+ paths.removeLast()
+ }
+ if let right = root.right {
+ _binaryTreePaths3(right, res: &res, paths: &paths)
+ paths.removeLast()
+ }
+}
+```
+
+
-----------------------
diff --git a/problems/二叉树理论基础.md b/problems/二叉树理论基础.md
index cc899850..62e3b19a 100644
--- a/problems/二叉树理论基础.md
+++ b/problems/二叉树理论基础.md
@@ -154,7 +154,7 @@
C++代码如下:
-```
+```cpp
struct TreeNode {
int val;
TreeNode *left;
@@ -163,7 +163,7 @@ struct TreeNode {
};
```
-大家会发现二叉树的定义 和链表是差不多的,相对于链表 ,二叉树的节点里多了一个指针, 有两个指针,指向左右孩子.
+大家会发现二叉树的定义 和链表是差不多的,相对于链表 ,二叉树的节点里多了一个指针, 有两个指针,指向左右孩子。
这里要提醒大家要注意二叉树节点定义的书写方式。
@@ -177,7 +177,7 @@ struct TreeNode {
本篇我们介绍了二叉树的种类、存储方式、遍历方式以及定义,比较全面的介绍了二叉树各个方面的重点,帮助大家扫一遍基础。
-**说道二叉树,就不得不说递归,很多同学对递归都是又熟悉又陌生,递归的代码一般很简短,但每次都是一看就会,一写就废。**
+**说到二叉树,就不得不说递归,很多同学对递归都是又熟悉又陌生,递归的代码一般很简短,但每次都是一看就会,一写就废。**
## 其他语言版本
@@ -227,7 +227,23 @@ function TreeNode(val, left, right) {
}
```
+TypeScript:
+
+```typescript
+class TreeNode {
+ public val: number;
+ public left: TreeNode | null;
+ public right: TreeNode | null;
+ constructor(val?: number, left?: TreeNode, right?: TreeNode) {
+ this.val = val === undefined ? 0 : val;
+ this.left = left === undefined ? null : left;
+ this.right = right === undefined ? null : right;
+ }
+}
+```
+
Swift:
+
```Swift
class TreeNode {
var value: T
diff --git a/problems/二叉树的统一迭代法.md b/problems/二叉树的统一迭代法.md
index 2ff84817..f6edf586 100644
--- a/problems/二叉树的统一迭代法.md
+++ b/problems/二叉树的统一迭代法.md
@@ -522,7 +522,75 @@ var postorderTraversal = function(root, res = []) {
```
+TypeScript:
+```typescript
+// 前序遍历(迭代法)
+function preorderTraversal(root: TreeNode | null): number[] {
+ let helperStack: (TreeNode | null)[] = [];
+ let res: number[] = [];
+ let curNode: TreeNode | null;
+ if (root === null) return res;
+ helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ if (curNode !== null) {
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ helperStack.push(curNode);
+ helperStack.push(null);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ } else {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ }
+ }
+ return res;
+};
+
+// 中序遍历(迭代法)
+function inorderTraversal(root: TreeNode | null): number[] {
+ let helperStack: (TreeNode | null)[] = [];
+ let res: number[] = [];
+ let curNode: TreeNode | null;
+ if (root === null) return res;
+ helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ if (curNode !== null) {
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ helperStack.push(curNode);
+ helperStack.push(null);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ } else {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ }
+ }
+ return res;
+};
+
+// 后序遍历(迭代法)
+function postorderTraversal(root: TreeNode | null): number[] {
+ let helperStack: (TreeNode | null)[] = [];
+ let res: number[] = [];
+ let curNode: TreeNode | null;
+ if (root === null) return res;
+ helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ if (curNode !== null) {
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ helperStack.push(curNode);
+ helperStack.push(null);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ } else {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ }
+ }
+ return res;
+};
+```
-----------------------
diff --git a/problems/二叉树的迭代遍历.md b/problems/二叉树的迭代遍历.md
index 4cb94cb5..ba38726b 100644
--- a/problems/二叉树的迭代遍历.md
+++ b/problems/二叉树的迭代遍历.md
@@ -454,6 +454,61 @@ var postorderTraversal = function(root, res = []) {
};
```
+TypeScript:
+
+```typescript
+// 前序遍历(迭代法)
+function preorderTraversal(root: TreeNode | null): number[] {
+ if (root === null) return [];
+ let res: number[] = [];
+ let helperStack: TreeNode[] = [];
+ let curNode: TreeNode = root;
+ helperStack.push(curNode);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ }
+ return res;
+};
+
+// 中序遍历(迭代法)
+function inorderTraversal(root: TreeNode | null): number[] {
+ let helperStack: TreeNode[] = [];
+ let res: number[] = [];
+ if (root === null) return res;
+ let curNode: TreeNode | null = root;
+ while (curNode !== null || helperStack.length > 0) {
+ if (curNode !== null) {
+ helperStack.push(curNode);
+ curNode = curNode.left;
+ } else {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ curNode = curNode.right;
+ }
+ }
+ return res;
+};
+
+// 后序遍历(迭代法)
+function postorderTraversal(root: TreeNode | null): number[] {
+ let helperStack: TreeNode[] = [];
+ let res: number[] = [];
+ let curNode: TreeNode;
+ if (root === null) return res;
+ helperStack.push(root);
+ while (helperStack.length > 0) {
+ curNode = helperStack.pop()!;
+ res.push(curNode.val);
+ if (curNode.left !== null) helperStack.push(curNode.left);
+ if (curNode.right !== null) helperStack.push(curNode.right);
+ }
+ return res.reverse();
+};
+```
+
Swift:
> 迭代法前序遍历
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 4beed650..c481fd11 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -270,40 +270,6 @@ func postorderTraversal(root *TreeNode) (res []int) {
}
```
-javaScript:
-
-```js
-
-前序遍历:
-
-var preorderTraversal = function(root, res = []) {
- if (!root) return res;
- res.push(root.val);
- preorderTraversal(root.left, res)
- preorderTraversal(root.right, res)
- return res;
-};
-
-中序遍历:
-
-var inorderTraversal = function(root, res = []) {
- if (!root) return res;
- inorderTraversal(root.left, res);
- res.push(root.val);
- inorderTraversal(root.right, res);
- return res;
-};
-
-后序遍历:
-
-var postorderTraversal = function(root, res = []) {
- if (!root) return res;
- postorderTraversal(root.left, res);
- postorderTraversal(root.right, res);
- res.push(root.val);
- return res;
-};
-```
Javascript版本:
前序遍历:
@@ -358,7 +324,51 @@ var postorderTraversal = function(root) {
};
```
+TypeScript:
+
+```typescript
+// 前序遍历
+function preorderTraversal(node: TreeNode | null): number[] {
+ function traverse(node: TreeNode | null, res: number[]): void {
+ if (node === null) return;
+ res.push(node.val);
+ traverse(node.left, res);
+ traverse(node.right, res);
+ }
+ const res: number[] = [];
+ traverse(node, res);
+ return res;
+}
+
+// 中序遍历
+function inorderTraversal(node: TreeNode | null): number[] {
+ function traverse(node: TreeNode | null, res: number[]): void {
+ if (node === null) return;
+ traverse(node.left, res);
+ res.push(node.val);
+ traverse(node.right, res);
+ }
+ const res: number[] = [];
+ traverse(node, res);
+ return res;
+}
+
+// 后序遍历
+function postorderTraversal(node: TreeNode | null): number[] {
+ function traverse(node: TreeNode | null, res: number[]): void {
+ if (node === null) return;
+ traverse(node.left, res);
+ traverse(node.right, res);
+ res.push(node.val);
+ }
+ const res: number[] = [];
+ traverse(node, res);
+ return res;
+}
+```
+
C:
+
```c
//前序遍历:
void preOrderTraversal(struct TreeNode* root, int* ret, int* returnSize) {
diff --git a/problems/前序/ACM模式如何构建二叉树.md b/problems/前序/ACM模式如何构建二叉树.md
index d3b2656e..fc7a1823 100644
--- a/problems/前序/ACM模式如何构建二叉树.md
+++ b/problems/前序/ACM模式如何构建二叉树.md
@@ -251,7 +251,4 @@ int main() {
```
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/BAT级别技术面试流程和注意事项都在这里了.md b/problems/前序/BAT级别技术面试流程和注意事项都在这里了.md
index c5797739..6678860d 100644
--- a/problems/前序/BAT级别技术面试流程和注意事项都在这里了.md
+++ b/problems/前序/BAT级别技术面试流程和注意事项都在这里了.md
@@ -218,7 +218,4 @@ leetcode是专门针对算法练习的题库,leetcode现在也推出了中文
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/On的算法居然超时了,此时的n究竟是多大?.md b/problems/前序/On的算法居然超时了,此时的n究竟是多大?.md
index 9a56937c..5257ceb9 100644
--- a/problems/前序/On的算法居然超时了,此时的n究竟是多大?.md
+++ b/problems/前序/On的算法居然超时了,此时的n究竟是多大?.md
@@ -280,7 +280,4 @@ public class TimeComplexity {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/上海互联网公司总结.md b/problems/前序/上海互联网公司总结.md
index 08c15895..ffcbe77b 100644
--- a/problems/前序/上海互联网公司总结.md
+++ b/problems/前序/上海互联网公司总结.md
@@ -130,7 +130,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/什么是核心代码模式,什么又是ACM模式?.md b/problems/前序/什么是核心代码模式,什么又是ACM模式?.md
index 3c5fb4e4..54c5b6ec 100644
--- a/problems/前序/什么是核心代码模式,什么又是ACM模式?.md
+++ b/problems/前序/什么是核心代码模式,什么又是ACM模式?.md
@@ -119,7 +119,4 @@ int main() {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/关于时间复杂度,你不知道的都在这里!.md b/problems/前序/关于时间复杂度,你不知道的都在这里!.md
index cfcbed1a..478b82e4 100644
--- a/problems/前序/关于时间复杂度,你不知道的都在这里!.md
+++ b/problems/前序/关于时间复杂度,你不知道的都在这里!.md
@@ -170,7 +170,4 @@ $O(2 × n^2 + 10 × n + 1000) < O(3 × n^2)$,所以说最后省略掉常数项
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/关于空间复杂度,可能有几个疑问?.md b/problems/前序/关于空间复杂度,可能有几个疑问?.md
index 95ffe597..d49b42a2 100644
--- a/problems/前序/关于空间复杂度,可能有几个疑问?.md
+++ b/problems/前序/关于空间复杂度,可能有几个疑问?.md
@@ -73,7 +73,4 @@ for (int i = 0; i < n; i++) {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/刷了这么多题,你了解自己代码的内存消耗么?.md b/problems/前序/刷了这么多题,你了解自己代码的内存消耗么?.md
index 3fccfb22..0364fc8b 100644
--- a/problems/前序/刷了这么多题,你了解自己代码的内存消耗么?.md
+++ b/problems/前序/刷了这么多题,你了解自己代码的内存消耗么?.md
@@ -150,7 +150,4 @@ char型的数据和int型的数据挨在一起,该int数据从地址1开始,
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/力扣上的代码想在本地编译运行?.md b/problems/前序/力扣上的代码想在本地编译运行?.md
index c4899a20..dca6eec3 100644
--- a/problems/前序/力扣上的代码想在本地编译运行?.md
+++ b/problems/前序/力扣上的代码想在本地编译运行?.md
@@ -67,7 +67,4 @@ int main() {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/北京互联网公司总结.md b/problems/前序/北京互联网公司总结.md
index 0e22dad6..02a877b7 100644
--- a/problems/前序/北京互联网公司总结.md
+++ b/problems/前序/北京互联网公司总结.md
@@ -116,7 +116,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/广州互联网公司总结.md b/problems/前序/广州互联网公司总结.md
index ae41c899..1cf0da36 100644
--- a/problems/前序/广州互联网公司总结.md
+++ b/problems/前序/广州互联网公司总结.md
@@ -79,7 +79,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/成都互联网公司总结.md b/problems/前序/成都互联网公司总结.md
index d44800cd..7964f23c 100644
--- a/problems/前序/成都互联网公司总结.md
+++ b/problems/前序/成都互联网公司总结.md
@@ -77,7 +77,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/杭州互联网公司总结.md b/problems/前序/杭州互联网公司总结.md
index 326a176b..029ee380 100644
--- a/problems/前序/杭州互联网公司总结.md
+++ b/problems/前序/杭州互联网公司总结.md
@@ -87,7 +87,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/深圳互联网公司总结.md b/problems/前序/深圳互联网公司总结.md
index 9e089315..61bd52e8 100644
--- a/problems/前序/深圳互联网公司总结.md
+++ b/problems/前序/深圳互联网公司总结.md
@@ -82,7 +82,4 @@
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/程序员写文档工具.md b/problems/前序/程序员写文档工具.md
index b76fb036..5504ae7a 100644
--- a/problems/前序/程序员写文档工具.md
+++ b/problems/前序/程序员写文档工具.md
@@ -135,9 +135,5 @@ Markdown支持部分html,例如这样
-
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/程序员简历.md b/problems/前序/程序员简历.md
index f47516dc..522fc5f7 100644
--- a/problems/前序/程序员简历.md
+++ b/problems/前序/程序员简历.md
@@ -133,7 +133,4 @@ Carl校招社招都拿过大厂的offer,同时也看过很多应聘者的简
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/递归算法的时间与空间复杂度分析.md b/problems/前序/递归算法的时间与空间复杂度分析.md
index 4dd340a6..914cccfd 100644
--- a/problems/前序/递归算法的时间与空间复杂度分析.md
+++ b/problems/前序/递归算法的时间与空间复杂度分析.md
@@ -269,7 +269,4 @@ int binary_search( int arr[], int l, int r, int x) {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/前序/通过一道面试题目,讲一讲递归算法的时间复杂度!.md b/problems/前序/通过一道面试题目,讲一讲递归算法的时间复杂度!.md
index 8780122f..849a025d 100644
--- a/problems/前序/通过一道面试题目,讲一讲递归算法的时间复杂度!.md
+++ b/problems/前序/通过一道面试题目,讲一讲递归算法的时间复杂度!.md
@@ -152,7 +152,4 @@ int function3(int x, int n) {
-----------------------
-* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
-* B站视频:[代码随想录](https://space.bilibili.com/525438321)
-* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
diff --git a/problems/栈与队列总结.md b/problems/栈与队列总结.md
index 8ec96a29..15093ca7 100644
--- a/problems/栈与队列总结.md
+++ b/problems/栈与队列总结.md
@@ -158,22 +158,5 @@ cd a/b/c/../../
好了,栈与队列我们就总结到这里了,接下来Carl就要带大家开启新的篇章了,大家加油!
-
-
-
-## 其他语言版本
-
-
-Java:
-
-
-Python:
-
-
-Go:
-
-
-
-
-----------------------
diff --git a/problems/背包理论基础01背包-1.md b/problems/背包理论基础01背包-1.md
index 4367aff9..6ff32017 100644
--- a/problems/背包理论基础01背包-1.md
+++ b/problems/背包理论基础01背包-1.md
@@ -3,11 +3,12 @@
参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
+
# 动态规划:关于01背包问题,你该了解这些!
这周我们正式开始讲解背包问题!
-背包问题的经典资料当然是:背包九讲。在公众号「代码随想录」后台回复:背包九讲,就可以获得背包九讲的PDF。
+背包问题的经典资料当然是:背包九讲。在公众号「代码随想录」后台回复:背包九讲,就可以获得背包九讲的pdf。
但说实话,背包九讲对于小白来说确实不太友好,看起来还是有点费劲的,而且都是伪代码理解起来也吃力。
@@ -32,7 +33,7 @@ leetcode上没有纯01背包的问题,都是01背包应用方面的题目,
## 01 背包
-有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。**每件物品只能用一次**,求解将哪些物品装入背包里物品价值总和最大。
+有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。**每件物品只能用一次**,求解将哪些物品装入背包里物品价值总和最大。

@@ -40,7 +41,7 @@ leetcode上没有纯01背包的问题,都是01背包应用方面的题目,
这样其实是没有从底向上去思考,而是习惯性想到了背包,那么暴力的解法应该是怎么样的呢?
-每一件物品其实只有两个状态,取或者不取,所以可以使用回溯法搜索出所有的情况,那么时间复杂度就是$O(2^n)$,这里的n表示物品数量。
+每一件物品其实只有两个状态,取或者不取,所以可以使用回溯法搜索出所有的情况,那么时间复杂度就是$o(2^n)$,这里的n表示物品数量。
**所以暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化!**
@@ -109,7 +110,7 @@ for (int j = 0 ; j < weight[0]; j++) { // 当然这一步,如果把dp数组
dp[0][j] = 0;
}
// 正序遍历
-for (int j = weight[0]; j <= bagWeight; j++) {
+for (int j = weight[0]; j <= bagweight; j++) {
dp[0][j] = value[0];
}
```
@@ -135,8 +136,8 @@ dp[0][j] 和 dp[i][0] 都已经初始化了,那么其他下标应该初始化
```
// 初始化 dp
-vector> dp(weight.size(), vector(bagWeight + 1, 0));
-for (int j = weight[0]; j <= bagWeight; j++) {
+vector> dp(weight.size(), vector(bagweight + 1, 0));
+for (int j = weight[0]; j <= bagweight; j++) {
dp[0][j] = value[0];
}
@@ -160,7 +161,7 @@ for (int j = weight[0]; j <= bagWeight; j++) {
```
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
- for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
+ for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
@@ -174,7 +175,7 @@ for(int i = 1; i < weight.size(); i++) { // 遍历物品
```
// weight数组的大小 就是物品个数
-for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
+for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
for(int i = 1; i < weight.size(); i++) { // 遍历物品
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
@@ -219,32 +220,32 @@ dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向(包括
主要就是自己没有动手推导一下dp数组的演变过程,如果推导明白了,代码写出来就算有问题,只要把dp数组打印出来,对比一下和自己推导的有什么差异,很快就可以发现问题了。
-## 完整C++测试代码
+## 完整c++测试代码
-```CPP
+```cpp
void test_2_wei_bag_problem1() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
- int bagWeight = 4;
+ int bagweight = 4;
// 二维数组
- vector> dp(weight.size(), vector(bagWeight + 1, 0));
+ vector> dp(weight.size(), vector(bagweight + 1, 0));
// 初始化
- for (int j = weight[0]; j <= bagWeight; j++) {
+ for (int j = weight[0]; j <= bagweight; j++) {
dp[0][j] = value[0];
}
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
- for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
+ for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}
- cout << dp[weight.size() - 1][bagWeight] << endl;
+ cout << dp[weight.size() - 1][bagweight] << endl;
}
int main() {
@@ -267,48 +268,45 @@ int main() {
## 其他语言版本
-Java:
+### java
```java
- public static void main(String[] args) {
+ public static void main(string[] args) {
int[] weight = {1, 3, 4};
int[] value = {15, 20, 30};
- int bagSize = 4;
- testWeightBagProblem(weight, value, bagSize);
+ int bagsize = 4;
+ testweightbagproblem(weight, value, bagsize);
}
- public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){
- int wLen = weight.length, value0 = 0;
+ public static void testweightbagproblem(int[] weight, int[] value, int bagsize){
+ int wlen = weight.length, value0 = 0;
//定义dp数组:dp[i][j]表示背包容量为j时,前i个物品能获得的最大价值
- int[][] dp = new int[wLen + 1][bagSize + 1];
+ int[][] dp = new int[wlen + 1][bagsize + 1];
//初始化:背包容量为0时,能获得的价值都为0
- for (int i = 0; i <= wLen; i++){
+ for (int i = 0; i <= wlen; i++){
dp[i][0] = value0;
}
//遍历顺序:先遍历物品,再遍历背包容量
- for (int i = 1; i <= wLen; i++){
- for (int j = 1; j <= bagSize; j++){
+ for (int i = 1; i <= wlen; i++){
+ for (int j = 1; j <= bagsize; j++){
if (j < weight[i - 1]){
dp[i][j] = dp[i - 1][j];
}else{
- dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
+ dp[i][j] = math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
}
}
}
//打印dp数组
- for (int i = 0; i <= wLen; i++){
- for (int j = 0; j <= bagSize; j++){
- System.out.print(dp[i][j] + " ");
+ for (int i = 0; i <= wlen; i++){
+ for (int j = 0; j <= bagsize; j++){
+ system.out.print(dp[i][j] + " ");
}
- System.out.print("\n");
+ system.out.print("\n");
}
}
```
-
-
-
-Python:
+### python
```python
def test_2_wei_bag_problem1(bag_size, weight, value) -> int:
rows, cols = len(weight), bag_size + 1
@@ -343,26 +341,26 @@ if __name__ == "__main__":
```
-Go:
+### go
```go
-func test_2_wei_bag_problem1(weight, value []int, bagWeight int) int {
+func test_2_wei_bag_problem1(weight, value []int, bagweight int) int {
// 定义dp数组
dp := make([][]int, len(weight))
for i, _ := range dp {
- dp[i] = make([]int, bagWeight+1)
+ dp[i] = make([]int, bagweight+1)
}
// 初始化
- for j := bagWeight; j >= weight[0]; j-- {
+ for j := bagweight; j >= weight[0]; j-- {
dp[0][j] = dp[0][j-weight[0]] + value[0]
}
// 递推公式
for i := 1; i < len(weight); i++ {
//正序,也可以倒序
- for j := weight[i];j<= bagWeight ; j++ {
+ for j := weight[i];j<= bagweight ; j++ {
dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
}
}
- return dp[len(weight)-1][bagWeight]
+ return dp[len(weight)-1][bagweight]
}
func max(a,b int) int {
@@ -379,19 +377,19 @@ func main() {
}
```
-javaScript:
+### javascript
```js
-function testWeightBagProblem (wight, value, size) {
+function testweightbagproblem (wight, value, size) {
const len = wight.length,
- dp = Array.from({length: len + 1}).map(
- () => Array(size + 1).fill(0)
+ dp = array.from({length: len + 1}).map(
+ () => array(size + 1).fill(0)
);
for(let i = 1; i <= len; i++) {
for(let j = 0; j <= size; j++) {
if(wight[i - 1] <= j) {
- dp[i][j] = Math.max(
+ dp[i][j] = math.max(
dp[i - 1][j],
value[i - 1] + dp[i - 1][j - wight[i - 1]]
)
diff --git a/problems/背包理论基础01背包-2.md b/problems/背包理论基础01背包-2.md
index a57bae10..dabdfb2d 100644
--- a/problems/背包理论基础01背包-2.md
+++ b/problems/背包理论基础01背包-2.md
@@ -210,7 +210,7 @@ int main() {
## 其他语言版本
-Java:
+### Java
```java
public static void main(String[] args) {
@@ -240,7 +240,7 @@ Java:
-Python:
+### Python
```python
def test_1_wei_bag_problem():
weight = [1, 3, 4]
@@ -260,7 +260,7 @@ def test_1_wei_bag_problem():
test_1_wei_bag_problem()
```
-Go:
+### Go
```go
func test_1_wei_bag_problem(weight, value []int, bagWeight int) int {
// 定义 and 初始化
@@ -292,7 +292,7 @@ func main() {
}
```
-javaScript:
+### javaScript
```js
diff --git a/problems/背包问题理论基础完全背包.md b/problems/背包问题理论基础完全背包.md
index f79310b8..cea69c72 100644
--- a/problems/背包问题理论基础完全背包.md
+++ b/problems/背包问题理论基础完全背包.md
@@ -183,11 +183,9 @@ private static void testCompletePack(){
int[] value = {15, 20, 30};
int bagWeight = 4;
int[] dp = new int[bagWeight + 1];
- for (int i = 0; i < weight.length; i++){
- for (int j = 1; j <= bagWeight; j++){
- if (j - weight[i] >= 0){
- dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
- }
+ for (int i = 0; i < weight.length; i++){ // 遍历物品
+ for (int j = weight[i]; j <= bagWeight; j++){ // 遍历背包容量
+ dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
}
}
for (int maxValue : dp){
@@ -201,8 +199,8 @@ private static void testCompletePackAnotherWay(){
int[] value = {15, 20, 30};
int bagWeight = 4;
int[] dp = new int[bagWeight + 1];
- for (int i = 1; i <= bagWeight; i++){
- for (int j = 0; j < weight.length; j++){
+ for (int i = 1; i <= bagWeight; i++){ // 遍历背包容量
+ for (int j = 0; j < weight.length; j++){ // 遍历物品
if (i - weight[j] >= 0){
dp[i] = Math.max(dp[i], dp[i - weight[j]] + value[j]);
}
diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index dd91f069..2e7226de 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -224,12 +224,14 @@ var getIntersectionNode = function(headA, headB) {
lenA = getListLen(headA),
lenB = getListLen(headB);
if(lenA < lenB) {
+ // 下面交换变量注意加 “分号” ,两个数组交换变量在同一个作用域下时
+ // 如果不加分号,下面两条代码等同于一条代码: [curA, curB] = [lenB, lenA]
[curA, curB] = [curB, curA];
[lenA, lenB] = [lenB, lenA];
}
let i = lenA - lenB;
while(i-- > 0) {
- curA = curA.next
+ curA = curA.next;
}
while(curA && curA !== curB) {
curA = curA.next;