algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-09 11:34:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2524 from awsome-knowledge/master

Browse Source 
refactor
This commit is contained in:
程序员Carl
2024-05-10 10:13:34 +08:00
committed by GitHub
parent e718d9b64b 5e6a657d90
commit c5250faf70
9 changed files with 301 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
problems/0019.删除链表的倒数第N个节点.md
View File

@ -22,10 +22,12 @@
输入：head = [1,2,3,4,5], n = 2 输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5] 输出：[1,2,3,5]
示例 2： 示例 2：
输入：head = [1], n = 1 输入：head = [1], n = 1
输出：[] 输出：[]
示例 3： 示例 3：
输入：head = [1,2], n = 1 输入：head = [1,2], n = 1
@ -193,15 +195,17 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
* @return {ListNode} * @return {ListNode}
*/ */
var removeNthFromEnd = function (head, n) { var removeNthFromEnd = function (head, n) {
let ret = new ListNode(0, head), // 创建哨兵节点，简化解题逻辑
slow = fast = ret; let dummyHead = new ListNode(0, head);
let fast = dummyHead;
let slow = dummyHead;
while (n--) fast = fast.next; while (n--) fast = fast.next;
while (fast.next !== null) { while (fast.next !== null) {
slow = slow.next;
fast = fast.next; fast = fast.next;
slow = slow.next }
};
slow.next = slow.next.next; slow.next = slow.next.next;
return ret.next; return dummyHead.next;
}; };
``` ```
### TypeScript: ### TypeScript:

62
problems/0077.组合.md
View File

@ -469,28 +469,58 @@ func dfs(n int, k int, start int) {
``` ```
### Javascript ### Javascript
未剪枝：
```js
var combine = function (n, k) {
// 回溯法
let result = [],
path = [];
let backtracking = (_n, _k, startIndex) => {
// 终止条件
if (path.length === _k) {
result.push(path.slice());
return;
}
// 循环本层集合元素
for (let i = startIndex; i <= _n; i++) {
path.push(i);
// 递归
backtracking(_n, _k, i + 1);
// 回溯操作
path.pop();
}
};
backtracking(n, k, 1);
return result;
};
```
剪枝： 剪枝：
```javascript ```javascript
let result = []
let path = []
var combine = function (n, k) { var combine = function (n, k) {
result = [] // 回溯法
combineHelper(n, k, 1) let result = [],
return result path = [];
let backtracking = (_n, _k, startIndex) => {
// 终止条件
if (path.length === _k) {
result.push(path.slice());
return;
}
// 循环本层集合元素
for (let i = startIndex; i <= _n - (_k - path.length) + 1; i++) {
path.push(i);
// 递归
backtracking(_n, _k, i + 1);
// 回溯操作
path.pop();
}
};
backtracking(n, k, 1);
return result;
}; };
const combineHelper = (n, k, startIndex) => {
if (path.length === k) {
result.push([...path])
return
}
for (let i = startIndex; i <= n - (k - path.length) + 1; ++i) {
path.push(i)
combineHelper(n, k, i + 1)
path.pop()
}
}
``` ```
### TypeScript ### TypeScript

76
problems/0102.二叉树的层序遍历.md
View File

@ -693,7 +693,8 @@ func levelOrderBottom(root *TreeNode) [][]int {
```javascript ```javascript
var levelOrderBottom = function (root) { var levelOrderBottom = function (root) {
let res = [], queue = []; let res = [],
queue = [];
queue.push(root); queue.push(root);
while (queue.length && root !== null) { while (queue.length && root !== null) {
// 存放当前层级节点数组 // 存放当前层级节点数组
@ -713,6 +714,7 @@ var levelOrderBottom = function(root) {
} }
return res; return res;
}; };
``` ```
#### TypeScript: #### TypeScript:
@ -1140,7 +1142,7 @@ impl Solution {
### 思路 ### 思路
本题就是层序遍历的时候把一层求个总和在取一个均值。 本题就是层序遍历的时候把一层求个总和再取一个均值。
C++代码: C++代码:
@ -1295,25 +1297,25 @@ func averageOfLevels(root *TreeNode) []float64 {
```javascript ```javascript
var averageOfLevels = function(root) { var averageOfLevels = function(root) {
//层级平均值 let res = [],
let res = [], queue = []; queue = [];
queue.push(root); queue.push(root);
while (queue.length) {
while(queue.length && root!==null) { // 每一层节点个数;
//每一层节点个数 let lengthLevel = queue.length,
let length = queue.length; len = queue.length,
//sum记录每一层的和 // sum记录每一层的和;
let sum = 0; sum = 0;
for(let i=0; i < length; i++) { while (lengthLevel--) {
let node = queue.shift(); const node = queue.shift();
sum += node.val; sum += node.val;
// 队列存放下一层节点
node.left && queue.push(node.left); node.left && queue.push(node.left);
node.right && queue.push(node.right); node.right && queue.push(node.right);
} }
//每一层的平均值存入数组res // 求平均值
res.push(sum/length); res.push(sum / len);
} }
return res; return res;
}; };
``` ```
@ -1926,24 +1928,26 @@ func max(x, y int) int {
```javascript ```javascript
var largestValues = function (root) { var largestValues = function (root) {
//使用层序遍历 let res = [],
let res = [], queue = []; queue = [];
queue.push(root); queue.push(root);
if (root === null) {
while(root !== null && queue.length) { return res;
//设置max初始值就是队列的第一个元素 }
let max = queue[0].val; while (queue.length) {
let length = queue.length; let lengthLevel = queue.length,
while(length--) { // 初始值设为负无穷大
let node = queue.shift(); max = -Infinity;
max = max > node.val ? max : node.val; while (lengthLevel--) {
const node = queue.shift();
// 在当前层中找到最大值
max = Math.max(max, node.val);
// 找到下一层的节点
node.left && queue.push(node.left); node.left && queue.push(node.left);
node.right && queue.push(node.right); node.right && queue.push(node.right);
} }
//把每一层的最大值放到res数组
res.push(max); res.push(max);
} }
return res; return res;
}; };
``` ```
@ -2806,20 +2810,22 @@ func maxDepth(root *TreeNode) int {
* @return {number} * @return {number}
*/ */
var maxDepth = function (root) { var maxDepth = function (root) {
// 最大的深度就是二叉树的层数 // 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
if (root === null) return 0; let max = 0,
let queue = [root]; queue = [root];
let height = 0; if (root === null) {
return max;
}
while (queue.length) { while (queue.length) {
let n = queue.length; max++;
height++; let length = queue.length;
for (let i=0; i<n; i++) { while (length--) {
let node = queue.shift(); let node = queue.shift();
node.left && queue.push(node.left); node.left && queue.push(node.left);
node.right && queue.push(node.right); node.right && queue.push(node.right);
} }
} }
return height; return max;
}; };
``` ```

23
problems/0209.长度最小的子数组.md
View File

@ -270,22 +270,21 @@ var minSubArrayLen = function(target, nums) {
```typescript ```typescript
function minSubArrayLen(target: number, nums: number[]): number { function minSubArrayLen(target: number, nums: number[]): number {
let left: number = 0, right: number = 0; let left: number = 0,
let res: number = nums.length + 1; res: number = Infinity,
let sum: number = 0; subLen: number = 0,
while (right < nums.length) { sum: number = 0;
for (let right: number = 0; right < nums.length; right++) {
sum += nums[right]; sum += nums[right];
if (sum >= target) { while (sum >= target) {
// 不断移动左指针，直到不能再缩小为止 subLen = right - left + 1;
while (sum - nums[left] >= target) { res = Math.min(res, subLen);
sum -= nums[left++]; sum -= nums[left];
left++;
} }
res = Math.min(res, right - left + 1);
} }
right++; return res === Infinity ? 0 : res;
} }
return res === nums.length + 1 ? 0 : res;
};
``` ```
### Swift: ### Swift:

83
problems/0216.组合总和III.md
View File

@ -417,6 +417,7 @@ func dfs(k, n int, start int, sum int) {
``` ```
### JavaScript ### JavaScript
- 未剪枝：
```js ```js
/** /**
@ -425,31 +426,73 @@ func dfs(k, n int, start int, sum int) {
* @return {number[][]} * @return {number[][]}
*/ */
var combinationSum3 = function (k, n) { var combinationSum3 = function (k, n) {
let res = []; // 回溯法
let path = []; let result = [],
let sum = 0; path = [];
const dfs = (path,index) => { const backtracking = (_k, targetSum, sum, startIndex) => {
// 剪枝操作 // 终止条件
if (sum > n){ if (path.length === _k) {
return if (sum === targetSum) {
result.push(path.slice());
} }
if (path.length == k) { // 如果总和不相等，就直接返回
if(sum == n){ return;
res.push([...path]);
return
} }
}
for (let i = index; i <= 9 - (k-path.length) + 1;i++) { // 循环当前节点，因为只使用数字1到9，所以最大是9
for (let i = startIndex; i <= 9; i++) {
path.push(i); path.push(i);
sum = sum + i; sum += i;
index += 1; // 回调函数
dfs(path,index); backtracking(_k, targetSum, sum, i + 1);
sum -= i // 回溯
path.pop() sum -= i;
path.pop();
} }
};
backtracking(k, n, 0, 1);
return result;
};
```
- 剪枝：
```js
/**
* @param {number} k
* @param {number} n
* @return {number[][]}
*/
var combinationSum3 = function (k, n) {
// 回溯法
let result = [],
path = [];
const backtracking = (_k, targetSum, sum, startIndex) => {
if (sum > targetSum) {
return;
} }
dfs(path,1); // 终止条件
return res if (path.length === _k) {
if (sum === targetSum) {
result.push(path.slice());
}
// 如果总和不相等，就直接返回
return;
}
// 循环当前节点，因为只使用数字1到9，所以最大是9
for (let i = startIndex; i <= 9 - (_k - path.length) + 1; i++) {
path.push(i);
sum += i;
// 回调函数
backtracking(_k, targetSum, sum, i + 1);
// 回溯
sum -= i;
path.pop();
}
};
backtracking(k, n, 0, 1);
return result;
}; };
``` ```

107
problems/二叉树的递归遍历.md
View File

@ -48,7 +48,7 @@ void traversal(TreeNode* cur, vector<int>& vec)
if (cur == NULL) return; if (cur == NULL) return;
``` ```
3. **确定单层递归的逻辑**：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下： 3. **确定单层递归的逻辑**：前序遍历是中左右的顺序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：
```cpp ```cpp
vec.push_back(cur->val); // 中 vec.push_back(cur->val); // 中
@ -290,52 +290,91 @@ func postorderTraversal(root *TreeNode) (res []int) {
前序遍历： 前序遍历：
```Javascript ```Javascript
var preorderTraversal = function(root) { var preorderTraversal = function(root) {
let res=[]; // 第一种
const dfs=function(root){ // let res=[];
if(root===null)return ; // const dfs=function(root){
//先序遍历所以从父节点开始 // if(root===null)return ;
res.push(root.val); // //先序遍历所以从父节点开始
// res.push(root.val);
// //递归左子树
// dfs(root.left);
// //递归右子树
// dfs(root.right);
// }
// //只使用一个参数 使用闭包进行存储结果
// dfs(root);
// return res;
// 第二种
return root
? [
// 前序遍历：中左右
root.val,
// 递归左子树 // 递归左子树
dfs(root.left); ...preorderTraversal(root.left),
// 递归右子树 // 递归右子树
dfs(root.right); ...preorderTraversal(root.right),
} ]
//只使用一个参数 使用闭包进行存储结果 : [];
dfs(root);
return res;
}; };
``` ```
中序遍历 中序遍历
```javascript ```javascript
var inorderTraversal = function(root) { var inorderTraversal = function(root) {
let res=[]; // 第一种
const dfs=function(root){
if(root===null){ // let res=[];
return ; // const dfs=function(root){
} // if(root===null){
dfs(root.left); // return ;
res.push(root.val); // }
dfs(root.right); // dfs(root.left);
} // res.push(root.val);
dfs(root); // dfs(root.right);
return res; // }
// dfs(root);
// return res;
// 第二种
return root
? [
// 中序遍历：左中右
// 递归左子树
...inorderTraversal(root.left),
root.val,
// 递归右子树
...inorderTraversal(root.right),
]
: [];
}; };
``` ```
后序遍历 后序遍历
```javascript ```javascript
var postorderTraversal = function(root) { var postorderTraversal = function(root) {
let res=[]; // 第一种
const dfs=function(root){ // let res=[];
if(root===null){ // const dfs=function(root){
return ; // if(root===null){
} // return ;
dfs(root.left); // }
dfs(root.right); // dfs(root.left);
res.push(root.val); // dfs(root.right);
} // res.push(root.val);
dfs(root); // }
return res; // dfs(root);
// return res;
// 第二种
// 后续遍历：左右中
return root
? [
// 递归左子树
...postorderTraversal(root.left),
// 递归右子树
...postorderTraversal(root.right),
root.val,
]
: [];
}; };
``` ```

2
problems/图论深搜理论基础.md
View File

@ -71,7 +71,7 @@
有递归的地方就有回溯，那么回溯在哪里呢？ 有递归的地方就有回溯，那么回溯在哪里呢？
就地递归函数的下面，例如如下代码： 就递归函数的下面，例如如下代码：
```cpp ```cpp
void dfs(参数) { void dfs(参数) {

4
problems/数组总结篇.md
View File

@ -16,7 +16,7 @@
**数组是存放在连续内存空间上的相同类型数据的集合。** **数组是存放在连续内存空间上的相同类型数据的集合。**
数组可以方便的通过下标索引的方式获取到下标下对应的数据。 数组可以方便的通过下标索引的方式获取到下标对应的数据。
举一个字符数组的例子，如图所示： 举一个字符数组的例子，如图所示：
@ -27,7 +27,7 @@
* **数组下标都是从0开始的。** * **数组下标都是从0开始的。**
* **数组内存空间的地址是连续的** * **数组内存空间的地址是连续的**
正是**因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。** 正是**因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。**
例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示： 例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示：

4
problems/数组理论基础.md
View File

@ -16,7 +16,7 @@
**数组是存放在连续内存空间上的相同类型数据的集合。** **数组是存放在连续内存空间上的相同类型数据的集合。**
数组可以方便的通过下标索引的方式获取到下标下对应的数据。 数组可以方便的通过下标索引的方式获取到下标对应的数据。
举一个字符数组的例子，如图所示： 举一个字符数组的例子，如图所示：
@ -29,7 +29,7 @@
* **数组下标都是从0开始的。** * **数组下标都是从0开始的。**
* **数组内存空间的地址是连续的** * **数组内存空间的地址是连续的**
正是**因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。** 正是**因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。**
例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示： 例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示：