mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2025-07-08 00:43:04 +08:00
@ -22,10 +22,12 @@
|
||||
|
||||
输入:head = [1,2,3,4,5], n = 2
|
||||
输出:[1,2,3,5]
|
||||
|
||||
示例 2:
|
||||
|
||||
输入:head = [1], n = 1
|
||||
输出:[]
|
||||
|
||||
示例 3:
|
||||
|
||||
输入:head = [1,2], n = 1
|
||||
@ -192,16 +194,18 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
|
||||
* @param {number} n
|
||||
* @return {ListNode}
|
||||
*/
|
||||
var removeNthFromEnd = function(head, n) {
|
||||
let ret = new ListNode(0, head),
|
||||
slow = fast = ret;
|
||||
while(n--) fast = fast.next;
|
||||
while (fast.next !== null) {
|
||||
fast = fast.next;
|
||||
slow = slow.next
|
||||
};
|
||||
slow.next = slow.next.next;
|
||||
return ret.next;
|
||||
var removeNthFromEnd = function (head, n) {
|
||||
// 创建哨兵节点,简化解题逻辑
|
||||
let dummyHead = new ListNode(0, head);
|
||||
let fast = dummyHead;
|
||||
let slow = dummyHead;
|
||||
while (n--) fast = fast.next;
|
||||
while (fast.next !== null) {
|
||||
slow = slow.next;
|
||||
fast = fast.next;
|
||||
}
|
||||
slow.next = slow.next.next;
|
||||
return dummyHead.next;
|
||||
};
|
||||
```
|
||||
### TypeScript:
|
||||
|
@ -469,28 +469,58 @@ func dfs(n int, k int, start int) {
|
||||
```
|
||||
|
||||
### 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
|
||||
let result = []
|
||||
let path = []
|
||||
var combine = function(n, k) {
|
||||
result = []
|
||||
combineHelper(n, k, 1)
|
||||
return result
|
||||
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 - (_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
|
||||
|
@ -692,27 +692,29 @@ func levelOrderBottom(root *TreeNode) [][]int {
|
||||
#### Javascript:
|
||||
|
||||
```javascript
|
||||
var levelOrderBottom = function(root) {
|
||||
let res = [], queue = [];
|
||||
queue.push(root);
|
||||
while(queue.length && root!==null) {
|
||||
// 存放当前层级节点数组
|
||||
let curLevel = [];
|
||||
// 计算当前层级节点数量
|
||||
let length = queue.length;
|
||||
while(length--) {
|
||||
let node = queue.shift();
|
||||
// 把当前层节点存入curLevel数组
|
||||
curLevel.push(node.val);
|
||||
// 把下一层级的左右节点存入queue队列
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
// 从数组前头插入值,避免最后反转数组,减少运算时间
|
||||
res.unshift(curLevel);
|
||||
var levelOrderBottom = function (root) {
|
||||
let res = [],
|
||||
queue = [];
|
||||
queue.push(root);
|
||||
while (queue.length && root !== null) {
|
||||
// 存放当前层级节点数组
|
||||
let curLevel = [];
|
||||
// 计算当前层级节点数量
|
||||
let length = queue.length;
|
||||
while (length--) {
|
||||
let node = queue.shift();
|
||||
// 把当前层节点存入curLevel数组
|
||||
curLevel.push(node.val);
|
||||
// 把下一层级的左右节点存入queue队列
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
return res;
|
||||
// 从数组前头插入值,避免最后反转数组,减少运算时间
|
||||
res.unshift(curLevel);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
#### TypeScript:
|
||||
@ -1140,7 +1142,7 @@ impl Solution {
|
||||
|
||||
### 思路
|
||||
|
||||
本题就是层序遍历的时候把一层求个总和在取一个均值。
|
||||
本题就是层序遍历的时候把一层求个总和再取一个均值。
|
||||
|
||||
C++代码:
|
||||
|
||||
@ -1295,26 +1297,26 @@ func averageOfLevels(root *TreeNode) []float64 {
|
||||
|
||||
```javascript
|
||||
var averageOfLevels = function(root) {
|
||||
//层级平均值
|
||||
let res = [], queue = [];
|
||||
queue.push(root);
|
||||
|
||||
while(queue.length && root!==null) {
|
||||
//每一层节点个数
|
||||
let length = queue.length;
|
||||
//sum记录每一层的和
|
||||
let sum = 0;
|
||||
for(let i=0; i < length; i++) {
|
||||
let node = queue.shift();
|
||||
sum += node.val;
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
//每一层的平均值存入数组res
|
||||
res.push(sum/length);
|
||||
let res = [],
|
||||
queue = [];
|
||||
queue.push(root);
|
||||
while (queue.length) {
|
||||
// 每一层节点个数;
|
||||
let lengthLevel = queue.length,
|
||||
len = queue.length,
|
||||
// sum记录每一层的和;
|
||||
sum = 0;
|
||||
while (lengthLevel--) {
|
||||
const node = queue.shift();
|
||||
sum += node.val;
|
||||
// 队列存放下一层节点
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
|
||||
return res;
|
||||
// 求平均值
|
||||
res.push(sum / len);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
```
|
||||
|
||||
@ -1925,26 +1927,28 @@ func max(x, y int) int {
|
||||
#### Javascript:
|
||||
|
||||
```javascript
|
||||
var largestValues = function(root) {
|
||||
//使用层序遍历
|
||||
let res = [], queue = [];
|
||||
queue.push(root);
|
||||
|
||||
while(root !== null && queue.length) {
|
||||
//设置max初始值就是队列的第一个元素
|
||||
let max = queue[0].val;
|
||||
let length = queue.length;
|
||||
while(length--) {
|
||||
let node = queue.shift();
|
||||
max = max > node.val ? max : node.val;
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
//把每一层的最大值放到res数组
|
||||
res.push(max);
|
||||
}
|
||||
|
||||
var largestValues = function (root) {
|
||||
let res = [],
|
||||
queue = [];
|
||||
queue.push(root);
|
||||
if (root === null) {
|
||||
return res;
|
||||
}
|
||||
while (queue.length) {
|
||||
let lengthLevel = queue.length,
|
||||
// 初始值设为负无穷大
|
||||
max = -Infinity;
|
||||
while (lengthLevel--) {
|
||||
const node = queue.shift();
|
||||
// 在当前层中找到最大值
|
||||
max = Math.max(max, node.val);
|
||||
// 找到下一层的节点
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
res.push(max);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
```
|
||||
|
||||
@ -2805,21 +2809,23 @@ func maxDepth(root *TreeNode) int {
|
||||
* @param {TreeNode} root
|
||||
* @return {number}
|
||||
*/
|
||||
var maxDepth = function(root) {
|
||||
// 最大的深度就是二叉树的层数
|
||||
if (root === null) return 0;
|
||||
let queue = [root];
|
||||
let height = 0;
|
||||
while (queue.length) {
|
||||
let n = queue.length;
|
||||
height++;
|
||||
for (let i=0; i<n; i++) {
|
||||
let node = queue.shift();
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
var maxDepth = function (root) {
|
||||
// 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
|
||||
let max = 0,
|
||||
queue = [root];
|
||||
if (root === null) {
|
||||
return max;
|
||||
}
|
||||
while (queue.length) {
|
||||
max++;
|
||||
let length = queue.length;
|
||||
while (length--) {
|
||||
let node = queue.shift();
|
||||
node.left && queue.push(node.left);
|
||||
node.right && queue.push(node.right);
|
||||
}
|
||||
return height;
|
||||
}
|
||||
return max;
|
||||
};
|
||||
```
|
||||
|
||||
|
@ -270,22 +270,21 @@ var minSubArrayLen = function(target, nums) {
|
||||
|
||||
```typescript
|
||||
function minSubArrayLen(target: number, nums: number[]): number {
|
||||
let left: number = 0, right: number = 0;
|
||||
let res: number = nums.length + 1;
|
||||
let sum: number = 0;
|
||||
while (right < nums.length) {
|
||||
sum += nums[right];
|
||||
if (sum >= target) {
|
||||
// 不断移动左指针,直到不能再缩小为止
|
||||
while (sum - nums[left] >= target) {
|
||||
sum -= nums[left++];
|
||||
}
|
||||
res = Math.min(res, right - left + 1);
|
||||
}
|
||||
right++;
|
||||
let left: number = 0,
|
||||
res: number = Infinity,
|
||||
subLen: number = 0,
|
||||
sum: number = 0;
|
||||
for (let right: number = 0; right < nums.length; right++) {
|
||||
sum += nums[right];
|
||||
while (sum >= target) {
|
||||
subLen = right - left + 1;
|
||||
res = Math.min(res, subLen);
|
||||
sum -= nums[left];
|
||||
left++;
|
||||
}
|
||||
return res === nums.length + 1 ? 0 : res;
|
||||
};
|
||||
}
|
||||
return res === Infinity ? 0 : res;
|
||||
}
|
||||
```
|
||||
|
||||
### Swift:
|
||||
|
@ -417,6 +417,7 @@ func dfs(k, n int, start int, sum int) {
|
||||
```
|
||||
|
||||
### JavaScript
|
||||
- 未剪枝:
|
||||
|
||||
```js
|
||||
/**
|
||||
@ -424,32 +425,74 @@ func dfs(k, n int, start int, sum int) {
|
||||
* @param {number} n
|
||||
* @return {number[][]}
|
||||
*/
|
||||
var combinationSum3 = function(k, n) {
|
||||
let res = [];
|
||||
let path = [];
|
||||
let sum = 0;
|
||||
const dfs = (path,index) => {
|
||||
// 剪枝操作
|
||||
if (sum > n){
|
||||
return
|
||||
}
|
||||
if (path.length == k) {
|
||||
if(sum == n){
|
||||
res.push([...path]);
|
||||
return
|
||||
}
|
||||
}
|
||||
for (let i = index; i <= 9 - (k-path.length) + 1;i++) {
|
||||
path.push(i);
|
||||
sum = sum + i;
|
||||
index += 1;
|
||||
dfs(path,index);
|
||||
sum -= i
|
||||
path.pop()
|
||||
}
|
||||
var combinationSum3 = function (k, n) {
|
||||
// 回溯法
|
||||
let result = [],
|
||||
path = [];
|
||||
const backtracking = (_k, targetSum, sum, startIndex) => {
|
||||
// 终止条件
|
||||
if (path.length === _k) {
|
||||
if (sum === targetSum) {
|
||||
result.push(path.slice());
|
||||
}
|
||||
// 如果总和不相等,就直接返回
|
||||
return;
|
||||
}
|
||||
dfs(path,1);
|
||||
return res
|
||||
|
||||
// 循环当前节点,因为只使用数字1到9,所以最大是9
|
||||
for (let i = startIndex; i <= 9; i++) {
|
||||
path.push(i);
|
||||
sum += i;
|
||||
// 回调函数
|
||||
backtracking(_k, targetSum, sum, i + 1);
|
||||
// 回溯
|
||||
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;
|
||||
}
|
||||
// 终止条件
|
||||
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;
|
||||
};
|
||||
```
|
||||
|
||||
|
@ -48,7 +48,7 @@ void traversal(TreeNode* cur, vector<int>& vec)
|
||||
if (cur == NULL) return;
|
||||
```
|
||||
|
||||
3. **确定单层递归的逻辑**:前序遍历是中左右的循序,所以在单层递归的逻辑,是要先取中节点的数值,代码如下:
|
||||
3. **确定单层递归的逻辑**:前序遍历是中左右的顺序,所以在单层递归的逻辑,是要先取中节点的数值,代码如下:
|
||||
|
||||
```cpp
|
||||
vec.push_back(cur->val); // 中
|
||||
@ -290,52 +290,91 @@ func postorderTraversal(root *TreeNode) (res []int) {
|
||||
前序遍历:
|
||||
```Javascript
|
||||
var preorderTraversal = function(root) {
|
||||
let res=[];
|
||||
const dfs=function(root){
|
||||
if(root===null)return ;
|
||||
//先序遍历所以从父节点开始
|
||||
res.push(root.val);
|
||||
//递归左子树
|
||||
dfs(root.left);
|
||||
//递归右子树
|
||||
dfs(root.right);
|
||||
}
|
||||
//只使用一个参数 使用闭包进行存储结果
|
||||
dfs(root);
|
||||
return res;
|
||||
// 第一种
|
||||
// let res=[];
|
||||
// const dfs=function(root){
|
||||
// if(root===null)return ;
|
||||
// //先序遍历所以从父节点开始
|
||||
// res.push(root.val);
|
||||
// //递归左子树
|
||||
// dfs(root.left);
|
||||
// //递归右子树
|
||||
// dfs(root.right);
|
||||
// }
|
||||
// //只使用一个参数 使用闭包进行存储结果
|
||||
// dfs(root);
|
||||
// return res;
|
||||
// 第二种
|
||||
return root
|
||||
? [
|
||||
// 前序遍历:中左右
|
||||
root.val,
|
||||
// 递归左子树
|
||||
...preorderTraversal(root.left),
|
||||
// 递归右子树
|
||||
...preorderTraversal(root.right),
|
||||
]
|
||||
: [];
|
||||
};
|
||||
```
|
||||
中序遍历
|
||||
```javascript
|
||||
var inorderTraversal = function(root) {
|
||||
let res=[];
|
||||
const dfs=function(root){
|
||||
if(root===null){
|
||||
return ;
|
||||
}
|
||||
dfs(root.left);
|
||||
res.push(root.val);
|
||||
dfs(root.right);
|
||||
}
|
||||
dfs(root);
|
||||
return res;
|
||||
// 第一种
|
||||
|
||||
// let res=[];
|
||||
// const dfs=function(root){
|
||||
// if(root===null){
|
||||
// return ;
|
||||
// }
|
||||
// dfs(root.left);
|
||||
// res.push(root.val);
|
||||
// dfs(root.right);
|
||||
// }
|
||||
// dfs(root);
|
||||
// return res;
|
||||
|
||||
// 第二种
|
||||
return root
|
||||
? [
|
||||
// 中序遍历:左中右
|
||||
// 递归左子树
|
||||
...inorderTraversal(root.left),
|
||||
root.val,
|
||||
// 递归右子树
|
||||
...inorderTraversal(root.right),
|
||||
]
|
||||
: [];
|
||||
};
|
||||
```
|
||||
|
||||
后序遍历
|
||||
```javascript
|
||||
var postorderTraversal = function(root) {
|
||||
let res=[];
|
||||
const dfs=function(root){
|
||||
if(root===null){
|
||||
return ;
|
||||
}
|
||||
dfs(root.left);
|
||||
dfs(root.right);
|
||||
res.push(root.val);
|
||||
}
|
||||
dfs(root);
|
||||
return res;
|
||||
// 第一种
|
||||
// let res=[];
|
||||
// const dfs=function(root){
|
||||
// if(root===null){
|
||||
// return ;
|
||||
// }
|
||||
// dfs(root.left);
|
||||
// dfs(root.right);
|
||||
// res.push(root.val);
|
||||
// }
|
||||
// dfs(root);
|
||||
// return res;
|
||||
|
||||
// 第二种
|
||||
// 后续遍历:左右中
|
||||
return root
|
||||
? [
|
||||
// 递归左子树
|
||||
...postorderTraversal(root.left),
|
||||
// 递归右子树
|
||||
...postorderTraversal(root.right),
|
||||
root.val,
|
||||
]
|
||||
: [];
|
||||
};
|
||||
```
|
||||
|
||||
|
@ -71,7 +71,7 @@
|
||||
|
||||
有递归的地方就有回溯,那么回溯在哪里呢?
|
||||
|
||||
就地递归函数的下面,例如如下代码:
|
||||
就递归函数的下面,例如如下代码:
|
||||
|
||||
```cpp
|
||||
void dfs(参数) {
|
||||
|
@ -16,7 +16,7 @@
|
||||
|
||||
**数组是存放在连续内存空间上的相同类型数据的集合。**
|
||||
|
||||
数组可以方便的通过下标索引的方式获取到下标下对应的数据。
|
||||
数组可以方便的通过下标索引的方式获取到下标对应的数据。
|
||||
|
||||
举一个字符数组的例子,如图所示:
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
* **数组下标都是从0开始的。**
|
||||
* **数组内存空间的地址是连续的**
|
||||
|
||||
正是**因为数组的在内存空间的地址是连续的,所以我们在删除或者增添元素的时候,就难免要移动其他元素的地址。**
|
||||
正是**因为数组在内存空间的地址是连续的,所以我们在删除或者增添元素的时候,就难免要移动其他元素的地址。**
|
||||
|
||||
例如删除下标为3的元素,需要对下标为3的元素后面的所有元素都要做移动操作,如图所示:
|
||||
|
||||
|
@ -16,7 +16,7 @@
|
||||
|
||||
**数组是存放在连续内存空间上的相同类型数据的集合。**
|
||||
|
||||
数组可以方便的通过下标索引的方式获取到下标下对应的数据。
|
||||
数组可以方便的通过下标索引的方式获取到下标对应的数据。
|
||||
|
||||
举一个字符数组的例子,如图所示:
|
||||
|
||||
@ -29,7 +29,7 @@
|
||||
* **数组下标都是从0开始的。**
|
||||
* **数组内存空间的地址是连续的**
|
||||
|
||||
正是**因为数组的在内存空间的地址是连续的,所以我们在删除或者增添元素的时候,就难免要移动其他元素的地址。**
|
||||
正是**因为数组在内存空间的地址是连续的,所以我们在删除或者增添元素的时候,就难免要移动其他元素的地址。**
|
||||
|
||||
例如删除下标为3的元素,需要对下标为3的元素后面的所有元素都要做移动操作,如图所示:
|
||||
|
||||
|
Reference in New Issue
Block a user