Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 8fff9b9

Browse files
committed
更新题解列表
1 parent 214ccf2 commit 8fff9b9

9 files changed

+313
-100
lines changed

‎Solutions/0094. 二叉树的中序遍历.md

Lines changed: 45 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -9,35 +9,36 @@
99

1010
**要求**:返回该二叉树的中序遍历结果。
1111

12-
## 解题思路
12+
**说明**:
1313

14-
### 思路 1. 递归遍历
14+
- 树中节点数目在范围 $[0, 100]$ 内。
15+
- $-100 \le Node.val \le 100$。
1516

16-
二叉树的前序遍历递归实现步骤为:
17+
**示例**:
1718

18-
1. 判断二叉树是否为空,为空则直接返回。
19-
2. 先访问根节点。
20-
3. 然后递归遍历左子树。
21-
4. 最后递归遍历右子树。
19+
![img](https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg)
2220

23-
### 思路 2. 模拟栈迭代遍历
21+
```Python
22+
输入:root = [1,null,2,3]
23+
输出:[1,3,2]
2424

25-
二叉树的前序遍历递归实现的过程,实际上就是调用系统栈的过程。我们也可以使用一个显式栈 `stack` 来模拟递归的过程。
2625

27-
前序遍历的顺序为:根节点 - 左子树 - 右子树,而根据栈的「先入后出」特点,所以入栈的顺序应该为:先放入右子树,再放入左子树。这样可以保证最终遍历顺序为前序遍历顺序。
26+
输入:root = []
27+
输出:[]
28+
```
2829

29-
二叉树的前序遍历显式栈实现步骤如下:
30+
## 解题思路
3031

31-
1. 判断二叉树是否为空,为空则直接返回。
32-
2. 初始化维护一个栈,将根节点入栈。
33-
3. 当栈不为空时:
34-
1. 弹出栈顶元素 `node`,并访问该元素。
35-
2. 如果 `node` 的右子树不为空,则将 `node` 的右子树入栈。
36-
3. 如果 `node` 的左子树不为空,则将 `node` 的左子树入栈。
32+
### 思路 1:递归遍历
3733

38-
## 代码
34+
二叉树的前序遍历递归实现步骤为:
3935

40-
1. 递归遍历
36+
1. 判断二叉树是否为空,为空则直接返回。
37+
2. 先访问根节点。
38+
3. 然后递归遍历左子树。
39+
4. 最后递归遍历右子树。
40+
41+
### 思路 1:代码
4142

4243
```Python
4344
class Solution:
@@ -54,7 +55,27 @@ class Solution:
5455
return res
5556
```
5657

57-
2. 使用栈迭代遍历
58+
### 思路 1:复杂度分析
59+
60+
- **时间复杂度**:$O(n)$。其中 $n$ 是二叉树的节点数目。
61+
- **空间复杂度**:$O(n)$。
62+
63+
### 思路 2:模拟栈迭代遍历
64+
65+
二叉树的前序遍历递归实现的过程,实际上就是调用系统栈的过程。我们也可以使用一个显式栈 `stack` 来模拟递归的过程。
66+
67+
前序遍历的顺序为:根节点 - 左子树 - 右子树,而根据栈的「先入后出」特点,所以入栈的顺序应该为:先放入右子树,再放入左子树。这样可以保证最终遍历顺序为前序遍历顺序。
68+
69+
二叉树的前序遍历显式栈实现步骤如下:
70+
71+
1. 判断二叉树是否为空,为空则直接返回。
72+
2. 初始化维护一个栈,将根节点入栈。
73+
3. 当栈不为空时:
74+
1. 弹出栈顶元素 `node`,并访问该元素。
75+
2. 如果 `node` 的右子树不为空,则将 `node` 的右子树入栈。
76+
3. 如果 `node` 的左子树不为空,则将 `node` 的左子树入栈。
77+
78+
### 思路 2:代码
5879

5980
```Python
6081
class Solution:
@@ -76,3 +97,7 @@ class Solution:
7697
return res
7798
```
7899

100+
### 思路 2:复杂度分析
101+
102+
- **时间复杂度**:$O(n)$。其中 $n$ 是二叉树的节点数目。
103+
- **空间复杂度**:$O(n)$。

‎Solutions/0102. 二叉树的层序遍历.md

Lines changed: 19 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -9,31 +9,28 @@
99

1010
**要求**:返回该二叉树按照「层序遍历」得到的节点值。
1111

12-
**注意**:返回结果为二维数组,每一层都要存为数组返回。
12+
**说明**:
1313

14-
比如:
14+
- 返回结果为二维数组,每一层都要存为数组返回。
15+
16+
**示例**:
17+
18+
![img](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
1519

1620
```Python
17-
3
18-
/ \
19-
9 20
20-
/ \
21-
15 7
22-
```
23-
返回结果为:
21+
输入:root = [3,9,20,null,null,15,7]
22+
输出:[[3],[9,20],[15,7]]
2423

25-
```
26-
[
27-
[3],
28-
[9,20],
29-
[15,7]
30-
]
31-
```
3224

25+
输入:root = [1]
26+
输出:[[1]
27+
```
3328

3429
## 解题思路
3530

36-
广度优先搜索,需要增加一些变化。普通广度优先搜索只取一个元素,变化后的广度优先搜索每次取出第 `i` 层上所有元素。
31+
### 思路 1:广度优先搜索
32+
33+
广度优先搜索,需要增加一些变化。普通广度优先搜索只取一个元素,变化后的广度优先搜索每次取出第 $i$ 层上所有元素。
3734

3835
具体步骤如下:
3936

@@ -43,7 +40,7 @@
4340
4. 依次从队列中取出这 $s_i$ 个元素,并对这 $s_i$ 个元素依次进行访问。然后将其左右孩子节点入队,然后继续遍历下一层节点。
4441
5. 当队列为空时,结束遍历。
4542

46-
##代码
43+
### 思路 1:代码
4744

4845
```Python
4946
class Solution:
@@ -67,3 +64,7 @@ class Solution:
6764
return order
6865
```
6966

67+
### 思路 1:复杂度分析
68+
69+
- **时间复杂度**:$O(n)$。其中 $n$ 是二叉树的节点数目。
70+
- **空间复杂度**:$O(n)$。

‎Solutions/0104. 二叉树的最大深度.md

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,3 +53,7 @@ class Solution:
5353
return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
5454
```
5555

56+
### 思路 1:复杂度分析
57+
58+
- **时间复杂度**:$O(n),ドル其中 $n$ 是二叉树的节点数目。
59+
- **空间复杂度**:$O(n)$。递归函数需要用到栈空间,栈空间取决于递归深度,最坏情况下递归深度为 $n,ドル所以空间复杂度为 $O(n)$。

‎Solutions/0105. 从前序与中序遍历序列构造二叉树.md

Lines changed: 37 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,18 +5,45 @@
55

66
## 题目大意
77

8-
给定一棵二叉树的前序遍历结果和中序遍历结果,然后构造出该二叉树。假设树中没有重复的元素。
8+
**描述**:给定一棵二叉树的前序遍历结果 `preorder` 和中序遍历结果 `inorder`。
9+
10+
**要求**:构造出该二叉树并返回其根节点。
11+
12+
**说明**:
13+
14+
- 1ドル \le preorder.length \le 3000$。
15+
- $inorder.length == preorder.length$。
16+
- $-3000 \le preorder[i], inorder[i] \le 3000$。
17+
- `preorder` 和 `inorder` 均无重复元素。
18+
- `inorder` 均出现在 `preorder`。
19+
- `preorder` 保证为二叉树的前序遍历序列。
20+
- `inorder` 保证为二叉树的中序遍历序列。
21+
22+
**示例**:
23+
24+
![img](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
25+
26+
```Python
27+
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
28+
输出: [3,9,20,null,null,15,7]
29+
30+
31+
输入: preorder = [-1], inorder = [-1]
32+
输出: [-1]
33+
```
934

1035
## 解题思路
1136

37+
### 思路 1:递归
38+
1239
前序遍历的顺序是:根 -> 左 -> 右。中序遍历的顺序是:左 -> 根 -> 右。根据前序遍历的顺序,可以找到根节点位置。然后在中序遍历的结果中可以找到对应的根节点位置,就可以从根节点位置将二叉树分割成左子树、右子树。同时能得到左右子树的节点个数。此时构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历进行上述步骤,直到节点为空,具体操作步骤如下:
1340

14-
- 从前序遍历顺序中当前根节点的位置在 `postorder[0]`。
15-
- 通过在中序遍历中查找上一步根节点对应的位置 `inorder[k]`,从而将二叉树的左右子树分隔开,并得到左右子树节点的个数。
16-
- 从上一步得到的左右子树个数将前序遍历结果中的左右子树分开。
17-
- 构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历并执行上述三步,直到节点为空。
41+
1. 从前序遍历顺序中当前根节点的位置在 `postorder[0]`。
42+
2. 通过在中序遍历中查找上一步根节点对应的位置 `inorder[k]`,从而将二叉树的左右子树分隔开,并得到左右子树节点的个数。
43+
3. 从上一步得到的左右子树个数将前序遍历结果中的左右子树分开。
44+
4. 构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历并执行上述三步,直到节点为空。
1845

19-
##代码
46+
### 思路 1:代码
2047

2148
```Python
2249
class Solution:
@@ -34,3 +61,7 @@ class Solution:
3461
return createTree(preorder, inorder, len(inorder))
3562
```
3663

64+
### 思路 1:复杂度分析
65+
66+
- **时间复杂度**:$O(n),ドル其中 $n$ 是二叉树的节点数目。
67+
- **空间复杂度**:$O(n)$。递归函数需要用到栈空间,栈空间取决于递归深度,最坏情况下递归深度为 $n,ドル所以空间复杂度为 $O(n)$。

‎Solutions/0106. 从中序与后序遍历序列构造二叉树.md

Lines changed: 39 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,18 +5,46 @@
55

66
## 题目大意
77

8-
给定一棵二叉树的中序遍历结果和后序遍历结果,然后构造出该二叉树。假设树中没有重复的元素。
8+
**描述**:给定一棵二叉树的中序遍历结果 `inorder` 和后序遍历结果 `postorder`。
9+
10+
**要求**:构造出该二叉树并返回其根节点。
11+
12+
**说明**:
13+
14+
- 1ドル \le inorder.length \le 3000$。
15+
- $postorder.length == inorder.length$。
16+
- $-3000 \le inorder[i], postorder[i] \le 3000$。
17+
- `inorder` 和 `postorder` 都由不同的值组成。
18+
- `postorder` 中每一个值都在 `inorder` 中。
19+
- `inorder` 保证是二叉树的中序遍历序列。
20+
- `postorder` 保证是二叉树的后序遍历序列。
21+
- `inorder` 保证为二叉树的中序遍历序列。
22+
23+
**示例**:
24+
25+
![img](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
26+
27+
```Python
28+
输入:inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
29+
输出:[3,9,20,null,null,15,7]
30+
31+
32+
输入:inorder = [-1], postorder = [-1]
33+
输出:[-1]
34+
```
935

1036
## 解题思路
1137

38+
### 思路 1:递归
39+
1240
中序遍历的顺序是:左 -> 根 -> 右。后序遍历的顺序是:左 -> 右 -> 根。根据后序遍历的顺序,可以找到根节点位置。然后在中序遍历的结果中可以找到对应的根节点位置,就可以从根节点位置将二叉树分割成左子树、右子树。同时能得到左右子树的节点个数。此时构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历进行上述步骤,直到节点为空,具体操作步骤如下:
1341

14-
- 从后序遍历顺序中当前根节点的位置在 `postorder[n-1]`。
15-
- 通过在中序遍历中查找上一步根节点对应的位置 `inorder[k]`,从而将二叉树的左右子树分隔开,并得到左右子树节点的个数。
16-
- 从上一步得到的左右子树个数将后序遍历结果中的左右子树分开。
17-
- 构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历并执行上述三步,直到节点为空。
42+
1. 从后序遍历顺序中当前根节点的位置在 `postorder[n - 1]`。
43+
2. 通过在中序遍历中查找上一步根节点对应的位置 `inorder[k]`,从而将二叉树的左右子树分隔开,并得到左右子树节点的个数。
44+
3. 从上一步得到的左右子树个数将后序遍历结果中的左右子树分开。
45+
4. 构建当前节点,并递归建立左右子树,在左右子树对应位置继续递归遍历并执行上述三步,直到节点为空。
1846

19-
##代码
47+
### 思路 1:代码
2048

2149
```Python
2250
class Solution:
@@ -34,3 +62,8 @@ class Solution:
3462
return createTree(inorder, postorder, len(postorder))
3563
```
3664

65+
### 思路 1:复杂度分析
66+
67+
- **时间复杂度**:$O(n),ドル其中 $n$ 是二叉树的节点数目。
68+
- **空间复杂度**:$O(n)$。递归函数需要用到栈空间,栈空间取决于递归深度,最坏情况下递归深度为 $n,ドル所以空间复杂度为 $O(n)$。
69+

‎Solutions/0112. 路径总和.md

Lines changed: 42 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,15 +5,49 @@
55

66
## 题目大意
77

8-
给定一个二叉树 和一个值 targetSum,判断该树中是否存在从根节点到叶子节点的路径,使得这条路径上所有节点值相加等于 targetSum。
8+
**描述**:给定一个二叉树的根节点 `root` 和一个值 `targetSum`。
9+
10+
**要求**:判断该树中是否存在从根节点到叶子节点的路径,使得这条路径上所有节点值相加等于 `targetSum`。如果存在,返回 `True`;否则,返回 `False`。
11+
12+
**说明**:
13+
14+
- 树中节点的数目在范围 $[0, 5000]$ 内。
15+
- $-1000 \le Node.val \le 1000$。
16+
- $-1000 \le targetSum \le 1000$。
17+
18+
**示例**:
19+
20+
![img](https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg)
21+
22+
```Python
23+
输入:root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
24+
输出:true
25+
解释:等于目标和的根节点到叶节点路径如上图所示。
26+
```
27+
28+
![img](https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg)
29+
30+
```Python
31+
输入:root = [1,2,3], targetSum = 5
32+
输出:false
33+
解释:树中存在两条根节点到叶子节点的路径:
34+
(1 --> 2): 和为 3
35+
(1 --> 3): 和为 4
36+
不存在 sum = 5 的根节点到叶子节点的路径。
37+
```
938

1039
## 解题思路
1140

12-
递归求解。新增一个变量 currSum,表示为从根节点到当前节点的路径上所有节点值之和。递归遍历左右子树,同时更新维护 currSum 值。
41+
### 思路 1:递归遍历
1342

14-
当当前节点为叶子节点时,判断 currSum 是否与 targetSum 相等,否则继续遍历左右子树。
43+
1. 定义一个递归函数,递归函数传入当前根节点 `root`,目标节点和 `targetSum`,以及新增变量 `currSum`(表示为从根节点到当前节点的路径上所有节点值之和)。
44+
2. 递归遍历左右子树,同时更新维护 `currSum` 值。
45+
3. 如果当前节点为叶子节点时,判断 `currSum` 是否与 `targetSum` 相等。
46+
1. 如果 `currSum` 与 `targetSum` 相等,则返回 `True`。
47+
2. 如果 `currSum` 不与 `targetSum` 相等,则返回 `False`。
48+
4. 如果当前节点不为叶子节点,则继续递归遍历左右子树。
1549

16-
##代码
50+
### 思路 1:代码
1751

1852
```Python
1953
class Solution:
@@ -30,3 +64,7 @@ class Solution:
3064
return self.sum(root.left, targetSum, curSum) or self.sum(root.right, targetSum, curSum)
3165
```
3266

67+
### 思路 1:复杂度分析
68+
69+
- **时间复杂度**:$O(n),ドル其中 $n$ 是二叉树的节点数目。
70+
- **空间复杂度**:$O(n)$。递归函数需要用到栈空间,栈空间取决于递归深度,最坏情况下递归深度为 $n,ドル所以空间复杂度为 $O(n)$。

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /