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 71d1fd5

Browse files
committed
更新题解列表
1 parent f1dfdd6 commit 71d1fd5

8 files changed

+313
-38
lines changed

‎Solutions/0100. 相同的树.md

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

66
## 题目大意
77

8-
给定两个二叉树 p 和 q。判断这两棵树是否相同。
8+
**描述**:给定两个二叉树的根节点 $p$ 和 $q$。
99

10-
两棵树相同的定义:
10+
**要求**:判断这两棵树是否相同。
1111

12-
- 结构上相同;
13-
- 节点具有相同的值
12+
**说明**:
13+
14+
- **两棵树相同的定义**:结构上相同;节点具有相同的值。
15+
- 两棵树上的节点数目都在范围 $[0, 100]$ 内。
16+
- $-10^4 \le Node.val \le 10^4$。
17+
18+
**示例**:
19+
20+
- 示例 1:
21+
22+
![](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)
23+
24+
```python
25+
输入:p = [1,2,3], q = [1,2,3]
26+
输出:True
27+
```
28+
29+
- 示例 2:
30+
31+
![](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)
32+
33+
```python
34+
输入:p = [1,2], q = [1,null,2]
35+
输出:False
36+
```
1437

1538
## 解题思路
1639

17-
先判断两棵树的根节点是否相同,在递归地判断左右子树是否相同。
40+
### 思路 1:递归
41+
42+
1. 先判断两棵树的根节点是否相同。
43+
2. 然后再递归地判断左右子树是否相同。
1844

19-
##代码
45+
### 思路 1:代码
2046

2147
```python
2248
class Solution:
@@ -30,3 +56,7 @@ class Solution:
3056
return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
3157
```
3258

59+
### 思路 1:复杂度分析
60+
61+
- **时间复杂度**:$O(min(m, n)),ドル其中 $m$、$n$ 分别为两棵树中的节点数量。
62+
- **空间复杂度**:$O(min(m, n))$。

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

Lines changed: 38 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5,22 +5,49 @@
55

66
## 题目大意
77

8-
给定一个二叉树,返回其「自底向上」,且按「层序遍历」得到的节点值。
8+
**描述**:给定一个二叉树的根节点 $root$。
9+
10+
**要求**:返回其节点值按照「自底向上」的「层序遍历」(即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)。
11+
12+
**说明**:
13+
14+
- 树中节点数目在范围 $[0, 2000]$ 内。
15+
- $-1000 \le Node.val \le 1000$。
16+
17+
**示例**:
18+
19+
- 示例 1:
20+
21+
![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
22+
23+
```python
24+
输入:root = [3,9,20,null,null,15,7]
25+
输出:[[15,7],[9,20],[3]]
26+
```
27+
28+
- 示例 2:
29+
30+
```python
31+
输入:root = [1]
32+
输出:[[1]]
33+
```
934

1035
## 解题思路
1136

37+
### 思路 1:二叉树的层次遍历
38+
1239
先得到层次遍历的节点顺序,再将其进行反转返回即可。
1340

1441
其中层次遍历用到了广度优先搜索,不过需要增加一些变化。普通广度优先搜索只取一个元素,变化后的广度优先搜索每次取出第 i 层上所有元素。
1542

1643
具体步骤如下:
1744

18-
- 根节点入队
19-
- 当队列不为空时,求出当前队列长度 $s_i$
20-
-依次从队列中取出这 $s_i$ 个元素,将其左右子节点入队,然后继续迭代
21-
- 当队列为空时,结束
45+
1. 根节点入队。
46+
2. 当队列不为空时,求出当前队列长度 $s_i$。
47+
3.依次从队列中取出这 $s_i$ 个元素,将其左右子节点入队,然后继续迭代。
48+
4. 当队列为空时,结束。
2249

23-
##代码
50+
### 思路 1:代码
2451

2552
```python
2653
class Solution:
@@ -44,3 +71,8 @@ class Solution:
4471
return order[::-1]
4572
```
4673

74+
### 思路 1:复杂度分析
75+
76+
- **时间复杂度**:$O(n),ドル其中 $n$ 为树中节点个数。
77+
- **空间复杂度**:$O(n)$。
78+

‎Solutions/0111. 二叉树的最小深度.md

Lines changed: 35 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,17 +5,44 @@
55

66
## 题目大意
77

8-
给定一个二叉树,找出其最小深度。
8+
**描述**:给定一个二叉树的根节点 $root$。
99

10-
- 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
10+
**要求**:找出该二叉树的最小深度。
11+
12+
**说明**:
13+
14+
- **最小深度**:从根节点到最近叶子节点的最短路径上的节点数量。
15+
- **叶子节点**:指没有子节点的节点。
16+
- 树中节点数的范围在 $[0, 10^5]$ 内。
17+
- $-1000 \le Node.val \le 1000$。
18+
19+
**示例**:
20+
21+
- 示例 1:
22+
23+
![](https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg)
24+
25+
```python
26+
输入:root = [3,9,20,null,null,15,7]
27+
输出:2
28+
```
29+
30+
- 示例 2:
31+
32+
```python
33+
输入:root = [2,null,3,null,4,null,5,null,6]
34+
输出:5
35+
```
1136

1237
## 解题思路
1338

39+
### 思路 1:深度优先搜索
40+
1441
深度优先搜索递归遍历左右子树,记录最小深度。
1542

1643
对于每一个非叶子节点,计算其左右子树的最小叶子节点深度,将较小的深度+1 即为当前节点的最小叶子节点深度。
1744

18-
##代码
45+
### 思路 1:代码
1946

2047
```python
2148
class Solution:
@@ -42,3 +69,8 @@ class Solution:
4269
return min_depth + 1
4370
```
4471

72+
### 思路 1:复杂度分析
73+
74+
- **时间复杂度**:$O(n),ドル其中 $n$ 是树中的节点数量。
75+
- **空间复杂度**:$O(n)$。
76+

‎Solutions/0116. 填充每个节点的下一个右侧节点指针.md

Lines changed: 38 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55

66
## 题目大意
77

8-
给定一个完美二叉树,所有叶子节点都在同一层,每个父节点都有两个子节点。二叉树结构如下:
8+
**描述**:给定一个完美二叉树,所有叶子节点都在同一层,每个父节点都有两个子节点。完美二叉树结构如下:
99

1010
```python
1111
struct Node {
@@ -16,16 +16,44 @@ struct Node {
1616
}
1717
```
1818

19-
要求填充每个 next 指针,是的这个指针指向下一个右侧节点。如果找不到下一个右侧节点,则将 next 置为 None。
20-
示例:
19+
**要求**:填充每个 `next` 指针,使得这个指针指向下一个右侧节点。如果找不到下一个右侧节点,则将 `next` 置为 `None`。
20+
21+
**说明**:
22+
23+
- 初始状态下,所有 next 指针都被设置为 `None`。
24+
- 树中节点的数量在 $[0, 2^{12} - 1]$ 范围内。
25+
- $-1000 \le node.val \le 1000$。
26+
- 进阶:
27+
- 只能使用常量级额外空间。
28+
- 使用递归解题也符合要求,本题中递归程序占用的栈空间不算做额外的空间复杂度。
29+
30+
31+
**示例**:
32+
33+
- 示例 1:
2134

2235
![](https://assets.leetcode.com/uploads/2019/02/14/116_sample.png)
2336

37+
```python
38+
输入:root = [1,2,3,4,5,6,7]
39+
输出:[1,#,2,3,#,4,5,6,7,#]
40+
解释:给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化的输出按层序遍历排列,同一层节点由 next 指针连接,'#' 标志着每一层的结束。
41+
```
42+
43+
- 示例 2:
44+
45+
```python
46+
输入:root = []
47+
输出:[]
48+
```
49+
2450
## 解题思路
2551

26-
层次遍历。在层次遍历的过程中,依次取出每一层的节点,并进行连接。然后再扩展下一层节点。
52+
### 思路 1:层次遍历
2753

28-
## 代码
54+
在层次遍历的过程中,依次取出每一层的节点,并进行连接。然后再扩展下一层节点。
55+
56+
### 思路 1:代码
2957

3058
```python
3159
import collections
@@ -50,3 +78,8 @@ class Solution:
5078
return root
5179
```
5280

81+
### 思路 1:复杂度分析
82+
83+
- **时间复杂度**:$O(n)$,其中 $n$ 为树中的节点数量。
84+
- **空间复杂度**:$O(1)$。
85+

‎Solutions/0117. 填充每个节点的下一个右侧节点指针 II.md

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

66
## 题目大意
77

8-
给定一个完美二叉树,二叉树结构如下:
8+
**描述**:给定一个二叉树。二叉树结构如下:
99

1010
```python
1111
struct Node {
@@ -16,14 +16,43 @@ struct Node {
1616
}
1717
```
1818

19-
要求填充每个 next 指针,是的这个指针指向下一个右侧节点。如果找不到下一个右侧节点,则将 next 置为 None。
20-
示例:
19+
**要求**:填充每个 `next` 指针,使得这个指针指向下一个右侧节点。如果找不到下一个右侧节点,则将 `next` 置为 `None`。
20+
21+
**说明**:
22+
23+
- 初始状态下,所有 next 指针都被设置为 `None`。
24+
- 树中节点的数量在 $[0, 6000]$ 范围内。
25+
- $-100 \le Node.val \le 100$。
26+
- 进阶:
27+
- 只能使用常量级额外空间。
28+
- 使用递归解题也符合要求,本题中递归程序占用的栈空间不算做额外的空间复杂度。
29+
30+
**示例**:
31+
32+
- 示例 1:
33+
34+
![](https://assets.leetcode.com/uploads/2019/02/15/117_sample.png)
35+
36+
```python
37+
输入:root = [1,2,3,4,5,null,7]
38+
输出:[1,#,2,3,#,4,5,7,#]
39+
解释:给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化输出按层序遍历顺序(由 next 指针连接),'#' 表示每层的末尾。
40+
```
41+
42+
- 示例 2:
43+
44+
```python
45+
输入:root = []
46+
输出:[]
47+
```
2148

2249
## 解题思路
2350

24-
层次遍历。在层次遍历的过程中,依次取出每一层的节点,并进行连接。然后再扩展下一层节点。
51+
### 思路 1:层次遍历
2552

26-
## 代码
53+
在层次遍历的过程中,依次取出每一层的节点,并进行连接。然后再扩展下一层节点。
54+
55+
### 思路 1:代码
2756

2857
```python
2958
import collections
@@ -48,3 +77,8 @@ class Solution:
4877
return root
4978
```
5079

80+
### 思路 1:复杂度分析
81+
82+
- **时间复杂度**:$O(n)$,其中 $n$ 为树中的节点数量。
83+
- **空间复杂度**:$O(1)$。
84+

‎Solutions/0173. 二叉搜索树迭代器.md

Lines changed: 32 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,21 +5,46 @@
55

66
## 题目大意
77

8-
实现一个二叉搜索树的迭代器 BSTIterator。表示一个按中序遍历二叉搜索树(BST)的迭代器:
8+
**要求**:实现一个二叉搜索树的迭代器 BSTIterator。表示一个按中序遍历二叉搜索树(BST)的迭代器:
99

1010
- `def __init__(self, root: TreeNode):`:初始化 BSTIterator 类的一个对象,会给出二叉搜索树的根节点。
1111
- `def hasNext(self) -> bool:`:如果向右指针遍历存在数字,则返回 True,否则返回 False。
1212
- `def next(self) -> int:`:将指针向右移动,返回指针处的数字。
1313

14+
**说明**:
15+
16+
- 指针初始化为一个不存在于 BST 中的数字,所以对 `next()` 的首次调用将返回 BST 中的最小元素。
17+
- 可以假设 `next()` 调用总是有效的,也就是说,当调用 `next()` 时,BST 的中序遍历中至少存在一个下一个数字。
18+
- 树中节点的数目在范围 $[1, 10^5]$ 内。
19+
- 0ドル \le Node.val \le 10^6$。
20+
- 最多调用 10ドル^5$ 次 `hasNext` 和 `next` 操作。
21+
- 进阶:设计一个满足下述条件的解决方案,`next()` 和 `hasNext()` 操作均摊时间复杂度为 `O(1)` ,并使用 `O(h)` 内存。其中 `h` 是树的高度。
22+
23+
**示例**:
24+
25+
- 示例 1:
26+
27+
![](https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png)
28+
29+
```python
30+
输入
31+
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
32+
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
33+
输出
34+
[null, 3, 7, true, 9, true, 15, true, 20, false]
35+
```
36+
1437
## 解题思路
1538

39+
### 思路 1:中序遍历二叉搜索树
40+
1641
中序遍历的顺序是:左、根、右。我们使用一个栈来保存节点,以便于迭代的时候取出对应节点。
1742

1843
- 初始的遍历当前节点的左子树,将其路径上的节点存储到栈中。
1944
- 调用 next 方法的时候,从栈顶取出节点,因为之前已经将路径上的左子树全部存入了栈中,所以此时该节点的左子树为空,这时候取出节点右子树,再将右子树的左子树进行递归遍历,并将其路径上的节点存储到栈中。
2045
- 调用 hasNext 的方法的时候,直接判断栈中是否有值即可。
2146

22-
##代码
47+
### 思路 1:代码
2348

2449
```python
2550
class BSTIterator:
@@ -43,3 +68,8 @@ class BSTIterator:
4368
return len(self.stack) != 0
4469
```
4570

71+
### 思路 1:复杂度分析
72+
73+
- **时间复杂度**:$O(n),ドル其中 $n$ 为树中节点数量。
74+
- **空间复杂度**:$O(n)$。
75+

0 commit comments

Comments
(0)

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