mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2025-07-08 00:43:04 +08:00
Merge branch 'youngyangyang04:master' into master
This commit is contained in:
fusunx
@ -2,6 +2,7 @@
|
||||
|
||||
> 1. **介绍**：本项目是一套完整的刷题计划，旨在帮助大家少走弯路，循序渐进学算法，[关注作者](#关于作者)
|
||||
> 2. **PDF版本** ： [「代码随想录」算法精讲 PDF 版本](https://mp.weixin.qq.com/s/RsdcQ9umo09R6cfnwXZlrQ) 。
|
||||
> 3. **刷题顺序** ： README已经将刷题顺序排好了，按照顺序一道一道刷就可以。
|
||||
> 3. **学习社区** : 一起学习打卡/面试技巧/如何选择offer/大厂内推/职场规则/简历修改/技术分享/程序人生。欢迎加入[「代码随想录」学习社区](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ) 。
|
||||
> 4. **提交代码**：本项目统一使用C++语言进行讲解，但已经有Java、Python、Go、JavaScript等等多语言版本，感谢[这里的每一位贡献者](https://github.com/youngyangyang04/leetcode-master/graphs/contributors)，如果你也想贡献代码点亮你的头像，[点击这里](https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A)了解提交代码的方式。
|
||||
> 5. **转载须知** ：以下所有文章皆为我（[程序员Carl](https://github.com/youngyangyang04)）的原创。引用本项目文章请注明出处，发现恶意抄袭或搬运，会动用法律武器维护自己的权益。让我们一起维护一个良好的技术创作环境！
|
||||
@ -41,7 +42,7 @@
|
||||
|
||||
对于刷题，我们都是想用最短的时间**按照循序渐进的难度顺序把经典题目都做一遍**，这样效率才是最高的！
|
||||
|
||||
所以我整理了leetcode刷题攻略：一个超级详细的刷题顺序，**每道题目都是我精心筛选，都是经典题目高频面试题**，大家只要按照这个顺序刷就可以了，**你没看错，就是题目顺序都排好了，文章顺序就是刷题顺序！挨个刷就可以，不用自己再去题海里选题了！**
|
||||
所以我整理了leetcode刷题攻略：一个超级详细的刷题顺序，**每道题目都是我精心筛选，都是经典题目高频面试题**，大家只要按照这个顺序刷就可以了，**你没看错，README已经把题目顺序都排好了，文章顺序就是刷题顺序！挨个刷就可以，不用自己再去题海里选题了！**
|
||||
|
||||
而且每道题目我都写了的详细题解（图文并茂，难点配有视频），力扣上我的题解都是排在对应题目的首页，质量是有目共睹的。
|
||||
|
||||
@ -117,7 +118,7 @@
|
||||
|
||||
（持续更新中.....）
|
||||
|
||||
## 备战秋招
|
||||
## 知识星球精选
|
||||
|
||||
1. [选择方向的时候，我也迷茫了](https://mp.weixin.qq.com/s/ZCzFiAHZHLqHPLJQXNm75g)
|
||||
2. [刷题就用库函数了，怎么了？](https://mp.weixin.qq.com/s/6K3_OSaudnHGq2Ey8vqYfg)
|
||||
|
||||
@ -279,9 +279,7 @@ Python：
|
||||
```python
|
||||
class Solution: # 动态规划
|
||||
def uniquePaths(self, m: int, n: int) -> int:
|
||||
dp = [[0 for i in range(n)] for j in range(m)]
|
||||
for i in range(m): dp[i][0] = 1
|
||||
for j in range(n): dp[0][j] = 1
|
||||
dp = [[1 for i in range(n)] for j in range(m)]
|
||||
for i in range(1, m):
|
||||
for j in range(1, n):
|
||||
dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
|
||||
|
||||
@ -376,6 +376,28 @@ func isBST(root *TreeNode, min, max int) bool {
|
||||
return isBST(root.Left, min, root.Val) && isBST(root.Right, root.Val, max)
|
||||
}
|
||||
```
|
||||
```go
|
||||
// 中序遍历解法
|
||||
func isValidBST(root *TreeNode) bool {
|
||||
// 保存上一个指针
|
||||
var prev *TreeNode
|
||||
var travel func(node *TreeNode) bool
|
||||
travel = func(node *TreeNode) bool {
|
||||
if node == nil {
|
||||
return true
|
||||
}
|
||||
leftRes := travel(node.Left)
|
||||
// 当前值小于等于前一个节点的值，返回false
|
||||
if prev != nil && node.Val <= prev.Val {
|
||||
return false
|
||||
}
|
||||
prev = node
|
||||
rightRes := travel(node.Right)
|
||||
return leftRes && rightRes
|
||||
}
|
||||
return travel(root)
|
||||
}
|
||||
```
|
||||
|
||||
JavaScript版本
|
||||
|
||||
|
||||
@ -54,7 +54,7 @@
|
||||
|
||||
如下两棵树，都是这个数组的平衡二叉搜索树：
|
||||
|
||||
|
||||
|
||||
|
||||
如果要分割的数组长度为偶数的时候，中间元素为两个，是取左边元素 就是树1，取右边元素就是树2。
|
||||
|
||||
|
||||
@ -313,63 +313,47 @@ func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
JavaScript版本
|
||||
> 递归
|
||||
|
||||
JavaScript版本：
|
||||
1. 使用递归的方法
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val) {
|
||||
* this.val = val;
|
||||
* this.left = this.right = null;
|
||||
* }
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {TreeNode} p
|
||||
* @param {TreeNode} q
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var lowestCommonAncestor = function(root, p, q) {
|
||||
if(root.val > p.val && root.val > q.val)
|
||||
return lowestCommonAncestor(root.left, p , q);
|
||||
else if(root.val < p.val && root.val < q.val)
|
||||
return lowestCommonAncestor(root.right, p , q);
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
> 迭代
|
||||
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val) {
|
||||
* this.val = val;
|
||||
* this.left = this.right = null;
|
||||
* }
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {TreeNode} p
|
||||
* @param {TreeNode} q
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var lowestCommonAncestor = function(root, p, q) {
|
||||
while(1) {
|
||||
if(root.val > p.val && root.val > q.val)
|
||||
root = root.left;
|
||||
else if(root.val < p.val && root.val < q.val)
|
||||
root = root.right;
|
||||
else
|
||||
break;
|
||||
// 使用递归的方法
|
||||
// 1. 使用给定的递归函数lowestCommonAncestor
|
||||
// 2. 确定递归终止条件
|
||||
if(root === null) {
|
||||
return root;
|
||||
}
|
||||
if(root.val>p.val&&root.val>q.val) {
|
||||
// 向左子树查询
|
||||
let left = lowestCommonAncestor(root.left,p,q);
|
||||
return left !== null&&left;
|
||||
}
|
||||
if(root.val<p.val&&root.val<q.val) {
|
||||
// 向右子树查询
|
||||
let right = lowestCommonAncestor(root.right,p,q);
|
||||
return right !== null&&right;
|
||||
}
|
||||
return root;
|
||||
};
|
||||
```
|
||||
2. 使用迭代的方法
|
||||
```javascript
|
||||
var lowestCommonAncestor = function(root, p, q) {
|
||||
// 使用迭代的方法
|
||||
while(root) {
|
||||
if(root.val>p.val&&root.val>q.val) {
|
||||
root = root.left;
|
||||
}else if(root.val<p.val&&root.val<q.val) {
|
||||
root = root.right;
|
||||
}else {
|
||||
return root;
|
||||
}
|
||||
|
||||
}
|
||||
return null;
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -311,35 +311,34 @@ func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||||
}
|
||||
```
|
||||
|
||||
JavaScript版本
|
||||
|
||||
JavaScript版本：
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val) {
|
||||
* this.val = val;
|
||||
* this.left = this.right = null;
|
||||
* }
|
||||
*/
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {TreeNode} p
|
||||
* @param {TreeNode} q
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var lowestCommonAncestor = function(root, p, q) {
|
||||
if(root === p || root === q || root === null)
|
||||
return root;
|
||||
let left = lowestCommonAncestor(root.left, p , q);
|
||||
let right = lowestCommonAncestor(root.right, p, q);
|
||||
if(left && right)
|
||||
return root;
|
||||
if(!left)
|
||||
return right;
|
||||
return left;
|
||||
// 使用递归的方法
|
||||
// 需要从下到上，所以使用后序遍历
|
||||
// 1. 确定递归的函数
|
||||
const travelTree = function(root,p,q) {
|
||||
// 2. 确定递归终止条件
|
||||
if(root === null || root === p||root === q) {
|
||||
return root;
|
||||
}
|
||||
// 3. 确定递归单层逻辑
|
||||
let left = travelTree(root.left,p,q);
|
||||
let right = travelTree(root.right,p,q);
|
||||
if(left !== null&&right !== null) {
|
||||
return root;
|
||||
}
|
||||
if(left ===null) {
|
||||
return right;
|
||||
}
|
||||
return left;
|
||||
}
|
||||
return travelTree(root,p,q);
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||||
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
|
||||
|
||||
@ -214,8 +214,26 @@ class Solution:
|
||||
return dp[n]
|
||||
```
|
||||
|
||||
Python3:
|
||||
```python
|
||||
class Solution:
|
||||
def numSquares(self, n: int) -> int:
|
||||
# 初始化
|
||||
# 组成和的完全平方数的最多个数，就是只用1构成
|
||||
# 因此，dp[i] = i
|
||||
dp = [i for i in range(n + 1)]
|
||||
# dp[0] = 0 无意义，只是为了方便记录特殊情况:
|
||||
# n本身就是完全平方数，dp[n] = min(dp[n], dp[n - n] + 1) = 1
|
||||
|
||||
for i in range(1, n): # 遍历物品
|
||||
if i * i > n:
|
||||
break
|
||||
num = i * i
|
||||
for j in range(num, n + 1): # 遍历背包
|
||||
dp[j] = min(dp[j], dp[j - num] + 1)
|
||||
|
||||
return dp[n]
|
||||
```
|
||||
|
||||
Go：
|
||||
```go
|
||||
|
||||
@ -240,6 +240,26 @@ class Solution:
|
||||
Go：
|
||||
|
||||
|
||||
javaScript:
|
||||
|
||||
```js
|
||||
var canPartition = function(nums) {
|
||||
const sum = (nums.reduce((p, v) => p + v));
|
||||
if (sum & 1) return false;
|
||||
const dp = Array(sum / 2 + 1).fill(0);
|
||||
for(let i = 0; i < nums.length; i++) {
|
||||
for(let j = sum / 2; j >= nums[i]; j--) {
|
||||
dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
|
||||
if (dp[j] === sum / 2) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[sum / 2] === sum / 2;
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -67,7 +67,6 @@ if (root == nullptr) return root;
|
||||
第五种情况有点难以理解，看下面动画：
|
||||
|
||||
|
||||
<img src='../video/450.删除二叉搜索树中的节点.gif' width=600> </img></div>
|
||||
|
||||
动画中颗二叉搜索树中，删除元素7， 那么删除节点（元素7）的左孩子就是5，删除节点（元素7）的右子树的最左面节点是元素8。
|
||||
|
||||
@ -359,6 +358,51 @@ func deleteNode1(root *TreeNode)*TreeNode{
|
||||
}
|
||||
```
|
||||
|
||||
JavaScript版本
|
||||
|
||||
> 递归
|
||||
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val, left, right) {
|
||||
* this.val = (val===undefined ? 0 : val)
|
||||
* this.left = (left===undefined ? null : left)
|
||||
* this.right = (right===undefined ? null : right)
|
||||
* }
|
||||
*/
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {number} key
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var deleteNode = function (root, key) {
|
||||
if (root === null)
|
||||
return root;
|
||||
if (root.val === key) {
|
||||
if (!root.left)
|
||||
return root.right;
|
||||
else if (!root.right)
|
||||
return root.left;
|
||||
else {
|
||||
let cur = root.right;
|
||||
while (cur.left) {
|
||||
cur = cur.left;
|
||||
}
|
||||
cur.left = root.left;
|
||||
let temp = root;
|
||||
root = root.right;
|
||||
delete root;
|
||||
return root;
|
||||
}
|
||||
}
|
||||
if (root.val > key)
|
||||
root.left = deleteNode(root.left, key);
|
||||
if (root.val < key)
|
||||
root.right = deleteNode(root.right, key);
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
@ -41,13 +41,11 @@ https://leetcode-cn.com/problems/repeated-substring-pattern/
|
||||
* [帮你把KMP算法学个通透！（求next数组代码篇）](https://www.bilibili.com/video/BV1M5411j7Xx)
|
||||
|
||||
|
||||
如果KMP还不够了解，可以看我的这个视频[帮你把KMP算法学个通透！B站](https://www.bilibili.com/video/BV1PD4y1o7nd/)
|
||||
|
||||
我们在[字符串：都来看看KMP的看家本领！](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)里提到了，在一个串中查找是否出现过另一个串，这是KMP的看家本领。
|
||||
我们在[字符串：KMP算法精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)里提到了，在一个串中查找是否出现过另一个串，这是KMP的看家本领。
|
||||
|
||||
那么寻找重复子串怎么也涉及到KMP算法了呢？
|
||||
|
||||
这里就要说一说next数组了，next 数组记录的就是最长相同前后缀( [字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ) 这里介绍了什么是前缀，什么是后缀，什么又是最长相同前后缀)， 如果 next[len - 1] != -1，则说明字符串有最长相同的前后缀（就是字符串里的前缀子串和后缀子串相同的最长长度）。
|
||||
这里就要说一说next数组了，next 数组记录的就是最长相同前后缀( [字符串：KMP算法精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg) 这里介绍了什么是前缀，什么是后缀，什么又是最长相同前后缀)， 如果 next[len - 1] != -1，则说明字符串有最长相同的前后缀（就是字符串里的前缀子串和后缀子串相同的最长长度）。
|
||||
|
||||
最长相等前后缀的长度为：next[len - 1] + 1。
|
||||
|
||||
@ -62,7 +60,7 @@ https://leetcode-cn.com/problems/repeated-substring-pattern/
|
||||
|
||||
如图：
|
||||
|
||||
|
||||
|
||||
|
||||
next[len - 1] = 7，next[len - 1] + 1 = 8，8就是此时字符串asdfasdfasdf的最长相同前后缀的长度。
|
||||
|
||||
@ -70,7 +68,7 @@ next[len - 1] = 7，next[len - 1] + 1 = 8，8就是此时字符串asdfasdfasdf
|
||||
(len - (next[len - 1] + 1)) 也就是： 12(字符串的长度) - 8(最长公共前后缀的长度) = 4， 4正好可以被 12(字符串的长度) 整除，所以说明有重复的子字符串（asdf）。
|
||||
|
||||
|
||||
代码如下：（这里使用了前缀表统一减一的实现方式）
|
||||
C++代码如下：（这里使用了前缀表统一减一的实现方式）
|
||||
|
||||
```C++
|
||||
class Solution {
|
||||
@ -104,7 +102,7 @@ public:
|
||||
```
|
||||
|
||||
|
||||
前缀表（不减一）的代码实现
|
||||
前缀表（不减一）的C++代码实现
|
||||
|
||||
```C++
|
||||
class Solution {
|
||||
@ -139,12 +137,11 @@ public:
|
||||
|
||||
# 拓展
|
||||
|
||||
此时我们已经分享了三篇KMP的文章，首先是[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)讲解KMP算法的基础理论，给出next数组究竟是如何来了，前缀表又是怎么回事，为什么要选择前缀表。
|
||||
在[字符串：KMP算法精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)中讲解KMP算法的基础理论，给出next数组究竟是如何来了，前缀表又是怎么回事，为什么要选择前缀表。
|
||||
|
||||
然后通过[字符串：都来看看KMP的看家本领！](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)讲解一道KMP的经典题目，判断文本串里是否出现过模式串，这里涉及到构造next数组的代码实现，以及使用next数组完成模式串与文本串的匹配过程。
|
||||
|
||||
后来很多同学反馈说：搞不懂前后缀，什么又是最长相同前后缀（最长公共前后缀我认为这个用词不准确），以及为什么前缀表要统一减一（右移）呢，不减一行不行？针对这些问题，我在[字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ)中又给出了详细的讲解。
|
||||
讲解一道KMP的经典题目，力扣：28. 实现 strStr()，判断文本串里是否出现过模式串，这里涉及到构造next数组的代码实现，以及使用next数组完成模式串与文本串的匹配过程。
|
||||
|
||||
后来很多同学反馈说：搞不懂前后缀，什么又是最长相同前后缀（最长公共前后缀我认为这个用词不准确），以及为什么前缀表要统一减一（右移）呢，不减一行不行？针对这些问题，我在[字符串：KMP算法精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)给出了详细的讲解。
|
||||
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
@ -158,7 +158,7 @@ dp[j] 表示：填满j（包括j）这么大容积的包，有dp[i]种方法
|
||||
|
||||
那么只需要搞到一个2（nums[i]），有dp[3]方法可以凑齐容量为3的背包，相应的就有多少种方法可以凑齐容量为5的背包。
|
||||
|
||||
那么需要把 这些方法累加起来就可以了，dp[i] += dp[j - nums[i]]
|
||||
那么需要把 这些方法累加起来就可以了，dp[j] += dp[j - nums[i]]
|
||||
|
||||
所以求组合类问题的公式，都是类似这种：
|
||||
|
||||
|
||||
@ -474,7 +474,7 @@ func traversal(root *TreeNode,history map[int]int){
|
||||
}
|
||||
```
|
||||
|
||||
计数法BSL（此代码在执行代码里能执行，但提交后报错，不知为何，思路是对的）
|
||||
计数法，不使用额外空间，利用二叉树性质，中序遍历
|
||||
|
||||
```go
|
||||
/**
|
||||
@ -485,90 +485,108 @@ func traversal(root *TreeNode,history map[int]int){
|
||||
* Right *TreeNode
|
||||
* }
|
||||
*/
|
||||
var count,maxCount int //统计计数
|
||||
func findMode(root *TreeNode) []int {
|
||||
var result []int
|
||||
var pre *TreeNode //前指针
|
||||
if root.Left==nil&&root.Right==nil{
|
||||
result=append(result,root.Val)
|
||||
return result
|
||||
}
|
||||
traversal(root,&result,pre)
|
||||
return result
|
||||
}
|
||||
func traversal(root *TreeNode,result *[]int,pre *TreeNode){//遍历统计
|
||||
//如果BSL中序遍历相邻的两个节点值相同，则统计频率；如果不相同，依据BSL中序遍历排好序的性质，重新计数
|
||||
if pre==nil{
|
||||
count=1
|
||||
}else if pre.Val==root.Val{
|
||||
count++
|
||||
}else {
|
||||
count=1
|
||||
}
|
||||
//如果统计的频率等于最大频率，则加入结果集；如果统计的频率大于最大频率，更新最大频率且重新将结果加入新的结果集中
|
||||
if count==maxCount{
|
||||
*result=append(*result,root.Val)
|
||||
}else if count>maxCount{
|
||||
maxCount=count//重新赋值maxCount
|
||||
*result=[]int{}//清空result中的内容
|
||||
*result=append(*result,root.Val)
|
||||
}
|
||||
pre=root//保存上一个的节点
|
||||
if root.Left!=nil{
|
||||
traversal(root.Left,result,pre)
|
||||
}
|
||||
if root.Right!=nil{
|
||||
traversal(root.Right,result,pre)
|
||||
func findMode(root *TreeNode) []int {
|
||||
res := make([]int, 0)
|
||||
count := 1
|
||||
max := 1
|
||||
var prev *TreeNode
|
||||
var travel func(node *TreeNode)
|
||||
travel = func(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
travel(node.Left)
|
||||
if prev != nil && prev.Val == node.Val {
|
||||
count++
|
||||
} else {
|
||||
count = 1
|
||||
}
|
||||
if count >= max {
|
||||
if count > max && len(res) > 0 {
|
||||
res = []int{node.Val}
|
||||
} else {
|
||||
res = append(res, node.Val)
|
||||
}
|
||||
max = count
|
||||
}
|
||||
prev = node
|
||||
travel(node.Right)
|
||||
}
|
||||
travel(root)
|
||||
return res
|
||||
}
|
||||
```
|
||||
|
||||
JavaScript版本
|
||||
|
||||
JavaScript版本：
|
||||
使用额外空间map的方法：
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val, left, right) {
|
||||
* this.val = (val===undefined ? 0 : val)
|
||||
* this.left = (left===undefined ? null : left)
|
||||
* this.right = (right===undefined ? null : right)
|
||||
* }
|
||||
*/
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @return {number[]}
|
||||
*/
|
||||
var findMode = function (root) {
|
||||
let maxCount = 0;
|
||||
let curCount = 0;
|
||||
let pre = null;
|
||||
let res = [];
|
||||
const inOrder = (root) => {
|
||||
if (root === null)
|
||||
return;
|
||||
inOrder(root.left);
|
||||
|
||||
if (pre === null)
|
||||
curCount = 1;
|
||||
else if (pre.val === root.val)
|
||||
curCount++;
|
||||
else
|
||||
curCount = 1;
|
||||
pre = root;
|
||||
|
||||
if (curCount === maxCount)
|
||||
res.push(root.val);
|
||||
|
||||
if (curCount > maxCount) {
|
||||
maxCount = curCount;
|
||||
res.splice(0, res.length);
|
||||
res.push(root.val);
|
||||
var findMode = function(root) {
|
||||
// 使用递归中序遍历
|
||||
let map = new Map();
|
||||
// 1. 确定递归函数以及函数参数
|
||||
const traverTree = function(root) {
|
||||
// 2. 确定递归终止条件
|
||||
if(root === null) {
|
||||
return ;
|
||||
}
|
||||
|
||||
inOrder(root.right);
|
||||
return;
|
||||
traverTree(root.left);
|
||||
// 3. 单层递归逻辑
|
||||
map.set(root.val,map.has(root.val)?map.get(root.val)+1:1);
|
||||
traverTree(root.right);
|
||||
}
|
||||
inOrder(root);
|
||||
traverTree(root);
|
||||
//上面把数据都存储到map
|
||||
//下面开始寻找map里面的
|
||||
// 定义一个最大出现次数的初始值为root.val的出现次数
|
||||
let maxCount = map.get(root.val);
|
||||
// 定义一个存放结果的数组res
|
||||
let res = [];
|
||||
for(let [key,value] of map) {
|
||||
// 如果当前值等于最大出现次数就直接在res增加该值
|
||||
if(value === maxCount) {
|
||||
res.push(key);
|
||||
}
|
||||
// 如果value的值大于原本的maxCount就清空res的所有值，因为找到了更大的
|
||||
if(value>maxCount) {
|
||||
res = [];
|
||||
maxCount = value;
|
||||
res.push(key);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
};
|
||||
```
|
||||
不使用额外空间，利用二叉树性质，中序遍历(有序)：
|
||||
```javascript
|
||||
var findMode = function(root) {
|
||||
// 不使用额外空间，使用中序遍历,设置出现最大次数初始值为1
|
||||
let count = 0,maxCount = 1;
|
||||
let pre = root,res = [];
|
||||
// 1.确定递归函数及函数参数
|
||||
const travelTree = function(cur) {
|
||||
// 2. 确定递归终止条件
|
||||
if(cur === null) {
|
||||
return ;
|
||||
}
|
||||
travelTree(cur.left);
|
||||
// 3. 单层递归逻辑
|
||||
if(pre.val === cur.val) {
|
||||
count++;
|
||||
}else {
|
||||
count = 1;
|
||||
}
|
||||
pre = cur;
|
||||
if(count === maxCount) {
|
||||
res.push(cur.val);
|
||||
}
|
||||
if(count > maxCount) {
|
||||
res = [];
|
||||
maxCount = count;
|
||||
res.push(cur.val);
|
||||
}
|
||||
travelTree(cur.right);
|
||||
}
|
||||
travelTree(root);
|
||||
return res;
|
||||
};
|
||||
```
|
||||
|
||||
@ -255,6 +255,29 @@ func findMIn(root *TreeNode,res *[]int){
|
||||
findMIn(root.Right,res)
|
||||
}
|
||||
```
|
||||
```go
|
||||
// 中序遍历的同时计算最小值
|
||||
func getMinimumDifference(root *TreeNode) int {
|
||||
// 保留前一个节点的指针
|
||||
var prev *TreeNode
|
||||
// 定义一个比较大的值
|
||||
min := math.MaxInt64
|
||||
var travel func(node *TreeNode)
|
||||
travel = func(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
travel(node.Left)
|
||||
if prev != nil && node.Val - prev.Val < min {
|
||||
min = node.Val - prev.Val
|
||||
}
|
||||
prev = node
|
||||
travel(node.Right)
|
||||
}
|
||||
travel(root)
|
||||
return min
|
||||
}
|
||||
```
|
||||
|
||||
JavaScript版本
|
||||
|
||||
|
||||
@ -320,7 +320,84 @@ var insertIntoBST = function (root, val) {
|
||||
};
|
||||
```
|
||||
|
||||
> 无返回值的递归
|
||||
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val, left, right) {
|
||||
* this.val = (val===undefined ? 0 : val)
|
||||
* this.left = (left===undefined ? null : left)
|
||||
* this.right = (right===undefined ? null : right)
|
||||
* }
|
||||
*/
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {number} val
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var insertIntoBST = function (root, val) {
|
||||
let parent = new TreeNode(0);
|
||||
const preOrder = (cur, val) => {
|
||||
if (cur === null) {
|
||||
let node = new TreeNode(val);
|
||||
if (parent.val > val)
|
||||
parent.left = node;
|
||||
else
|
||||
parent.right = node;
|
||||
return;
|
||||
}
|
||||
parent = cur;
|
||||
if (cur.val > val)
|
||||
preOrder(cur.left, val);
|
||||
if (cur.val < val)
|
||||
preOrder(cur.right, val);
|
||||
}
|
||||
if (root === null)
|
||||
root = new TreeNode(val);
|
||||
preOrder(root, val);
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
> 迭代
|
||||
|
||||
```javascript
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* function TreeNode(val, left, right) {
|
||||
* this.val = (val===undefined ? 0 : val)
|
||||
* this.left = (left===undefined ? null : left)
|
||||
* this.right = (right===undefined ? null : right)
|
||||
* }
|
||||
*/
|
||||
/**
|
||||
* @param {TreeNode} root
|
||||
* @param {number} val
|
||||
* @return {TreeNode}
|
||||
*/
|
||||
var insertIntoBST = function (root, val) {
|
||||
if (root === null) {
|
||||
root = new TreeNode(val);
|
||||
} else {
|
||||
let parent = new TreeNode(0);
|
||||
let cur = root;
|
||||
while (cur) {
|
||||
parent = cur;
|
||||
if (cur.val > val)
|
||||
cur = cur.left;
|
||||
else
|
||||
cur = cur.right;
|
||||
}
|
||||
let node = new TreeNode(val);
|
||||
if (parent.val > val)
|
||||
parent.left = node;
|
||||
else
|
||||
parent.right = node;
|
||||
}
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
-----------------------
|
||||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||||
|
||||
@ -118,6 +118,27 @@ class Solution {
|
||||
}
|
||||
```
|
||||
|
||||
```python
|
||||
# 方法一：可以使用切片方法
|
||||
class Solution:
|
||||
def reverseLeftWords(self, s: str, n: int) -> str:
|
||||
return s[n:] + s[0:n]
|
||||
|
||||
# 方法二：也可以使用上文描述的方法，有些面试中不允许使用切片，那就使用上文作者提到的方法
|
||||
# class Solution:
|
||||
# def reverseLeftWords(self, s: str, n: int) -> str:
|
||||
# s = list(s)
|
||||
# s[0:n] = list(reversed(s[0:n]))
|
||||
# s[n:] = list(reversed(s[n:]))
|
||||
# s.reverse()
|
||||
|
||||
# return "".join(s)
|
||||
|
||||
|
||||
# 时间复杂度：O(n)
|
||||
# 空间复杂度：O(n)，python的string为不可变，需要开辟同样大小的list空间来修改
|
||||
```
|
||||
|
||||
Go：
|
||||
|
||||
```go
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
|
||||
# 数组篇
|
||||
|
||||
在[数组：就移除个元素很难么？](https://mp.weixin.qq.com/s/wj0T-Xs88_FHJFwayElQlA)中，原地移除数组上的元素，我们说到了数组上的元素，不能真正的删除，只能覆盖。
|
||||
在[数组：就移除个元素很难么？](https://mp.weixin.qq.com/s/RMkulE4NIb6XsSX83ra-Ww)中，原地移除数组上的元素，我们说到了数组上的元素，不能真正的删除，只能覆盖。
|
||||
|
||||
一些同学可能会写出如下代码（伪代码）：
|
||||
|
||||
@ -30,11 +30,11 @@ for (int i = 0; i < array.size(); i++) {
|
||||
|
||||
# 字符串篇
|
||||
|
||||
在[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA)中讲解了反转字符串，注意这里强调要原地反转，要不然就失去了题目的意义。
|
||||
在[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/_rNm66OJVl92gBDIbGpA3w)中讲解了反转字符串，注意这里强调要原地反转，要不然就失去了题目的意义。
|
||||
|
||||
使用双指针法，**定义两个指针（也可以说是索引下表），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。**，时间复杂度是O(n)。
|
||||
|
||||
在[替换空格](https://mp.weixin.qq.com/s/t0A9C44zgM-RysAQV3GZpg) 中介绍使用双指针填充字符串的方法，如果想把这道题目做到极致，就不要只用额外的辅助空间了！
|
||||
在[替换空格](https://mp.weixin.qq.com/s/69HNjR4apcRSAo_KyknPjA) 中介绍使用双指针填充字符串的方法，如果想把这道题目做到极致，就不要只用额外的辅助空间了！
|
||||
|
||||
思路就是**首先扩充数组到每个空格替换成"%20"之后的大小。然后双指针从后向前替换空格。**
|
||||
|
||||
@ -44,7 +44,7 @@ for (int i = 0; i < array.size(); i++) {
|
||||
|
||||
**其实很多数组（字符串）填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。**
|
||||
|
||||
那么在[字符串：花式反转还不够！](https://mp.weixin.qq.com/s/X3qpi2v5RSp08mO-W5Vicw)中，我们使用双指针法，用O(n)的时间复杂度完成字符串删除类的操作，因为题目要产出冗余空格。
|
||||
那么在[字符串：花式反转还不够！](https://mp.weixin.qq.com/s/4j6vPFHkFAXnQhmSkq2X9g)中，我们使用双指针法，用O(n)的时间复杂度完成字符串删除类的操作，因为题目要产出冗余空格。
|
||||
|
||||
**在删除冗余空格的过程中，如果不注意代码效率，很容易写成了O(n^2)的时间复杂度。其实使用双指针法O(n)就可以搞定。**
|
||||
|
||||
@ -54,19 +54,19 @@ for (int i = 0; i < array.size(); i++) {
|
||||
|
||||
翻转链表是现场面试，白纸写代码的好题，考察了候选者对链表以及指针的熟悉程度，而且代码也不长，适合在白纸上写。
|
||||
|
||||
在[链表：听说过两天反转链表又写不出来了？](https://mp.weixin.qq.com/s/pnvVP-0ZM7epB8y3w_Njwg)中，讲如何使用双指针法来翻转链表，**只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表。**
|
||||
在[链表：听说过两天反转链表又写不出来了？](https://mp.weixin.qq.com/s/ckEvIVGcNLfrz6OLOMoT0A)中，讲如何使用双指针法来翻转链表，**只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表。**
|
||||
|
||||
思路还是很简单的，代码也不长，但是想在白纸上一次性写出bugfree的代码，并不是容易的事情。
|
||||
|
||||
在链表中求环，应该是双指针在链表里最经典的应用，在[链表：环找到了，那入口呢？](https://mp.weixin.qq.com/s/_QVP3IkRZWx9zIpQRgajzA)中讲解了如何通过双指针判断是否有环，而且还要找到环的入口。
|
||||
在链表中求环，应该是双指针在链表里最经典的应用，在[链表：环找到了，那入口呢？](https://mp.weixin.qq.com/s/gt_VH3hQTqNxyWcl1ECSbQ)中讲解了如何通过双指针判断是否有环，而且还要找到环的入口。
|
||||
|
||||
**使用快慢指针（双指针法），分别定义 fast 和 slow指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。**
|
||||
|
||||
那么找到环的入口，其实需要点简单的数学推理，我在文章中把找环的入口清清楚楚的推理的一遍，如果对找环入口不够清楚的同学建议自己看一看[链表：环找到了，那入口呢？](https://mp.weixin.qq.com/s/_QVP3IkRZWx9zIpQRgajzA)。
|
||||
那么找到环的入口，其实需要点简单的数学推理，我在文章中把找环的入口清清楚楚的推理的一遍，如果对找环入口不够清楚的同学建议自己看一看[链表：环找到了，那入口呢？](https://mp.weixin.qq.com/s/gt_VH3hQTqNxyWcl1ECSbQ)。
|
||||
|
||||
# N数之和篇
|
||||
|
||||
在[哈希表：解决了两数之和，那么能解决三数之和么？](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)中，讲到使用哈希法可以解决1.两数之和的问题
|
||||
在[哈希表：解决了两数之和，那么能解决三数之和么？](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)中，讲到使用哈希法可以解决1.两数之和的问题
|
||||
|
||||
其实使用双指针也可以解决1.两数之和的问题，只不过1.两数之和求的是两个元素的下标，没法用双指针，如果改成求具体两个元素的数值就可以了，大家可以尝试用双指针做一个leetcode上两数之和的题目，就可以体会到我说的意思了。
|
||||
|
||||
@ -82,7 +82,7 @@ for (int i = 0; i < array.size(); i++) {
|
||||
|
||||
只用双指针法时间复杂度为O(n^2)，但比哈希法的O(n^2)效率高得多，哈希法在使用两层for循环的时候，能做的剪枝操作很有限。
|
||||
|
||||
在[双指针法：一样的道理，能解决四数之和](https://mp.weixin.qq.com/s/nQrcco8AZJV1pAOVjeIU_g)中，讲到了四数之和，其实思路是一样的，**在三数之和的基础上再套一层for循环，依然是使用双指针法。**
|
||||
在[双指针法：一样的道理，能解决四数之和](https://mp.weixin.qq.com/s/SBU3THi1Kv6Sar7htqCB2Q)中，讲到了四数之和，其实思路是一样的，**在三数之和的基础上再套一层for循环，依然是使用双指针法。**
|
||||
|
||||
对于三数之和使用双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
|
||||
|
||||
@ -94,18 +94,6 @@ for (int i = 0; i < array.size(); i++) {
|
||||
本文中一共介绍了leetcode上九道使用双指针解决问题的经典题目，除了链表一些题目一定要使用双指针，其他题目都是使用双指针来提高效率，一般是将O(n^2)的时间复杂度，降为O(n)。
|
||||
|
||||
建议大家可以把文中涉及到的题目在好好做一做，琢磨琢磨，基本对双指针法就不在话下了。
|
||||
## 其他语言版本
|
||||
|
||||
|
||||
Java：
|
||||
|
||||
|
||||
Python：
|
||||
|
||||
|
||||
Go：
|
||||
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -43,9 +43,10 @@ for (int i = 0; i < a.size(); i++) {
|
||||
|
||||
所以想处理字符串，我们还是会定义一个string类型。
|
||||
|
||||
|
||||
# 要不要使用库函数
|
||||
|
||||
在文章[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA)中强调了**打基础的时候，不要太迷恋于库函数。**
|
||||
在文章[344.反转字符串](https://mp.weixin.qq.com/s/_rNm66OJVl92gBDIbGpA3w)中强调了**打基础的时候，不要太迷恋于库函数。**
|
||||
|
||||
甚至一些同学习惯于调用substr，split，reverse之类的库函数，却不知道其实现原理，也不知道其时间复杂度，这样实现出来的代码，如果在面试现场，面试官问：“分析其时间复杂度”的话，一定会一脸懵逼！
|
||||
|
||||
@ -56,15 +57,15 @@ for (int i = 0; i < a.size(); i++) {
|
||||
# 双指针法
|
||||
|
||||
|
||||
在[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA) ，我们使用双指针法实现了反转字符串的操作，**双指针法在数组，链表和字符串中很常用。**
|
||||
在[344.反转字符串](https://mp.weixin.qq.com/s/_rNm66OJVl92gBDIbGpA3w) ，我们使用双指针法实现了反转字符串的操作，**双指针法在数组，链表和字符串中很常用。**
|
||||
|
||||
接着在[字符串：替换空格](https://mp.weixin.qq.com/s/t0A9C44zgM-RysAQV3GZpg)，同样还是使用双指针法在时间复杂度O(n)的情况下完成替换空格。
|
||||
接着在[字符串：替换空格](https://mp.weixin.qq.com/s/69HNjR4apcRSAo_KyknPjA)，同样还是使用双指针法在时间复杂度O(n)的情况下完成替换空格。
|
||||
|
||||
**其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。**
|
||||
|
||||
那么针对数组删除操作的问题，其实在[数组：就移除个元素很难么？](https://mp.weixin.qq.com/s/wj0T-Xs88_FHJFwayElQlA)中就已经提到了使用双指针法进行移除操作。
|
||||
那么针对数组删除操作的问题，其实在[27. 移除元素](https://mp.weixin.qq.com/s/RMkulE4NIb6XsSX83ra-Ww)中就已经提到了使用双指针法进行移除操作。
|
||||
|
||||
同样的道理在[字符串：花式反转还不够！](https://mp.weixin.qq.com/s/X3qpi2v5RSp08mO-W5Vicw)中我们使用O(n)的时间复杂度，完成了删除冗余空格。
|
||||
同样的道理在[151.翻转字符串里的单词](https://mp.weixin.qq.com/s/4j6vPFHkFAXnQhmSkq2X9g)中我们使用O(n)的时间复杂度，完成了删除冗余空格。
|
||||
|
||||
一些同学会使用for循环里调用库函数erase来移除元素，这其实是O(n^2)的操作，因为erase就是O(n)的操作，所以这也是典型的不知道库函数的时间复杂度，上来就用的案例了。
|
||||
|
||||
@ -72,7 +73,7 @@ for (int i = 0; i < a.size(); i++) {
|
||||
|
||||
在反转上还可以在加一些玩法，其实考察的是对代码的掌控能力。
|
||||
|
||||
[字符串：简单的反转还不够！](https://mp.weixin.qq.com/s/XGSk1GyPWhfqj2g7Cb1Vgw)中，一些同学可能为了处理逻辑：每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。
|
||||
[541. 反转字符串II](https://mp.weixin.qq.com/s/pzXt6PQ029y7bJ9YZB2mVQ)中，一些同学可能为了处理逻辑：每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。
|
||||
|
||||
其实**当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章**。
|
||||
|
||||
@ -80,34 +81,34 @@ for (int i = 0; i < a.size(); i++) {
|
||||
|
||||
因为要找的也就是每2 * k 区间的起点，这样写程序会高效很多。
|
||||
|
||||
在[字符串：花式反转还不够！](https://mp.weixin.qq.com/s/X3qpi2v5RSp08mO-W5Vicw)中要求翻转字符串里的单词，这道题目可以说是综合考察了字符串的多种操作。是考察字符串的好题。
|
||||
在[151.翻转字符串里的单词](https://mp.weixin.qq.com/s/4j6vPFHkFAXnQhmSkq2X9g)中要求翻转字符串里的单词，这道题目可以说是综合考察了字符串的多种操作。是考察字符串的好题。
|
||||
|
||||
这道题目通过 **先整体反转再局部反转**，实现了反转字符串里的单词。
|
||||
|
||||
后来发现反转字符串还有一个牛逼的用处，就是达到左旋的效果。
|
||||
|
||||
在[字符串：反转个字符串还有这个用处？](https://mp.weixin.qq.com/s/PmcdiWSmmccHAONzU0ScgQ)中，我们通过**先局部反转再整体反转**达到了左旋的效果。
|
||||
在[字符串：反转个字符串还有这个用处？](https://mp.weixin.qq.com/s/Px_L-RfT2b_jXKcNmccPsw)中，我们通过**先局部反转再整体反转**达到了左旋的效果。
|
||||
|
||||
# KMP
|
||||
|
||||
KMP的主要思想是**当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。**
|
||||
|
||||
KMP的精髓所在就是前缀表，在[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)中提到了，什么是KMP，什么是前缀表，以及为什么要用前缀表。
|
||||
KMP的精髓所在就是前缀表，在[KMP精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)中提到了，什么是KMP，什么是前缀表，以及为什么要用前缀表。
|
||||
|
||||
前缀表：起始位置到下表i之前（包括i）的子串中，有多大长度的相同前缀后缀。
|
||||
|
||||
那么使用KMP可以解决两类经典问题：
|
||||
|
||||
1. 匹配问题：[28. 实现 strStr()](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)
|
||||
2. 重复子串问题：[459.重复的子字符串](https://mp.weixin.qq.com/s/lR2JPtsQSR2I_9yHbBmBuQ)
|
||||
1. 匹配问题：[28. 实现 strStr()](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)
|
||||
2. 重复子串问题：[459.重复的子字符串](https://mp.weixin.qq.com/s/32Pve4j8IWvdgxYEZdTeFg)
|
||||
|
||||
在[字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ) 强调了什么是前缀，什么是后缀，什么又是最长相等前后缀。
|
||||
再一次强调了什么是前缀，什么是后缀，什么又是最长相等前后缀。
|
||||
|
||||
前缀：指不包含最后一个字符的所有以第一个字符开头的连续子串。
|
||||
|
||||
后缀：指不包含第一个字符的所有以最后一个字符结尾的连续子串。
|
||||
|
||||
然后**针对前缀表到底要不要减一，这其实是不同KMP实现的方式**，我们在[字符串：前缀表不右移，难道就写不出KMP了？](https://mp.weixin.qq.com/s/p3hXynQM2RRROK5c6X7xfw)中针对之前两个问题，分别给出了两个不同版本的的KMP实现。
|
||||
然后**针对前缀表到底要不要减一，这其实是不同KMP实现的方式**，我们在[KMP精讲](https://mp.weixin.qq.com/s/MoRBHbS4hQXn7LcPdmHmIg)中针对之前两个问题，分别给出了两个不同版本的的KMP实现。
|
||||
|
||||
其中主要**理解j=next[x]这一步最为关键！**
|
||||
|
||||
@ -123,18 +124,6 @@ KMP算法是字符串查找最重要的算法，但彻底理解KMP并不容易
|
||||
|
||||
|
||||
|
||||
## 其他语言版本
|
||||
|
||||
|
||||
Java：
|
||||
|
||||
|
||||
Python：
|
||||
|
||||
|
||||
Go：
|
||||
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -82,7 +82,7 @@ leetcode上没有纯01背包的问题，都是01背包应用方面的题目，
|
||||
|
||||
那么可以有两个方向推出来dp[i][j]，
|
||||
|
||||
* 由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]
|
||||
* 由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以被背包内的价值依然和前面相同。)
|
||||
* 由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
|
||||
|
||||
所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
|
||||
@ -380,6 +380,52 @@ func main() {
|
||||
}
|
||||
```
|
||||
|
||||
javaScript:
|
||||
|
||||
```js
|
||||
function testWeightBagProblem (wight, value, size) {
|
||||
const len = wight.length,
|
||||
dp = Array.from({length: len + 1}).map(
|
||||
() => Array(size + 1).fill(0)
|
||||
);
|
||||
|
||||
for(let i = 1; i <= len; i++) {
|
||||
for(let j = 0; j <= size; j++) {
|
||||
if(wight[i - 1] <= j) {
|
||||
dp[i][j] = Math.max(
|
||||
dp[i - 1][j],
|
||||
value[i - 1] + dp[i - 1][j - wight[i - 1]]
|
||||
)
|
||||
} else {
|
||||
dp[i][j] = dp[i - 1][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// console.table(dp);
|
||||
|
||||
return dp[len][size];
|
||||
}
|
||||
|
||||
function testWeightBagProblem2 (wight, value, size) {
|
||||
const len = wight.length,
|
||||
dp = Array(size + 1).fill(0);
|
||||
for(let i = 1; i <= len; i++) {
|
||||
for(let j = size; j >= wight[i - 1]; j--) {
|
||||
dp[j] = Math.max(dp[j], value[i - 1] + dp[j - wight[i - 1]]);
|
||||
}
|
||||
}
|
||||
return dp[size];
|
||||
}
|
||||
|
||||
|
||||
function test () {
|
||||
console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
|
||||
}
|
||||
|
||||
test();
|
||||
```
|
||||
|
||||
-----------------------
|
||||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||||
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
|
||||
|
||||
@ -294,6 +294,29 @@ func main() {
|
||||
}
|
||||
```
|
||||
|
||||
javaScript:
|
||||
|
||||
```js
|
||||
|
||||
function testWeightBagProblem(wight, value, size) {
|
||||
const len = wight.length,
|
||||
dp = Array(size + 1).fill(0);
|
||||
for(let i = 1; i <= len; i++) {
|
||||
for(let j = size; j >= wight[i - 1]; j--) {
|
||||
dp[j] = Math.max(dp[j], value[i - 1] + dp[j - wight[i - 1]]);
|
||||
}
|
||||
}
|
||||
return dp[size];
|
||||
}
|
||||
|
||||
|
||||
function test () {
|
||||
console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
|
||||
}
|
||||
|
||||
test();
|
||||
```
|
||||
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
Reference in New Issue
Block a user