更新题解列表

Solutions/0100. 相同的树.md

@@ -5,18 +5,44 @@
 
 ## 题目大意
 
-给定两个二叉树 p 和 q。判断这两棵树是否相同。
+**描述**：给定两个二叉树的根节点 $p$ 和 $q$。
 
-两棵树相同的定义：
+**要求**：判断这两棵树是否相同。
 
-- 结构上相同；
-- 节点具有相同的值
+**说明**：
+
+- **两棵树相同的定义**：结构上相同；节点具有相同的值。
+- 两棵树上的节点数目都在范围 $[0, 100]$ 内。
+- $-10^4 \le Node.val \le 10^4$。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg)
+
+```python
+输入：p = [1,2,3], q = [1,2,3]
+输出：True
+```
+
+- 示例 2：
+
+![](https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg)
+
+```python
+输入：p = [1,2], q = [1,null,2]
+输出：False
+```
 
 ## 解题思路
 
-先判断两棵树的根节点是否相同，在递归地判断左右子树是否相同。
+### 思路 1：递归
+
+1. 先判断两棵树的根节点是否相同。
+2. 然后再递归地判断左右子树是否相同。
 
-## 代码
+### 思路 1：代码
 
 ```python
 class Solution:
@@ -30,3 +56,7 @@ class Solution:
         return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(min(m, n))$，其中 $m$、$n$ 分别为两棵树中的节点数量。
+- **空间复杂度**：$O(min(m, n))$。

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

@@ -5,22 +5,49 @@
 
 ## 题目大意
 
-给定一个二叉树，返回其「自底向上」，且按「层序遍历」得到的节点值。
+**描述**：给定一个二叉树的根节点 $root$。
+
+**要求**：返回其节点值按照「自底向上」的「层序遍历」（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）。
+
+**说明**：
+
+- 树中节点数目在范围 $[0, 2000]$ 内。
+- $-1000 \le Node.val \le 1000$。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+```python
+输入：root = [3,9,20,null,null,15,7]
+输出：[[15,7],[9,20],[3]]
+```
+
+- 示例 2：
+
+```python
+输入：root = [1]
+输出：[[1]]
+```
 
 ## 解题思路
 
+### 思路 1：二叉树的层次遍历
+
 先得到层次遍历的节点顺序，再将其进行反转返回即可。
 
 其中层次遍历用到了广度优先搜索，不过需要增加一些变化。普通广度优先搜索只取一个元素，变化后的广度优先搜索每次取出第 i 层上所有元素。
 
 具体步骤如下：
 
-- 根节点入队
-- 当队列不为空时，求出当前队列长度 $s_i$
-  - 依次从队列中取出这 $s_i$ 个元素，将其左右子节点入队，然后继续迭代
-- 当队列为空时，结束
+1. 根节点入队。
+2. 当队列不为空时，求出当前队列长度 $s_i$。
+3. 依次从队列中取出这 $s_i$ 个元素，将其左右子节点入队，然后继续迭代。
+4. 当队列为空时，结束。
 
-## 代码
+### 思路 1：代码
 
 ```python
 class Solution:
@@ -44,3 +71,8 @@ class Solution:
         return order[::-1]
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 为树中节点个数。
+- **空间复杂度**：$O(n)$。
+

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

@@ -5,17 +5,44 @@
 
 ## 题目大意
 
-给定一个二叉树，找出其最小深度。
+**描述**：给定一个二叉树的根节点 $root$。
 
-- 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
+**要求**：找出该二叉树的最小深度。
+
+**说明**：
+
+- **最小深度**：从根节点到最近叶子节点的最短路径上的节点数量。
+- **叶子节点**：指没有子节点的节点。
+- 树中节点数的范围在 $[0, 10^5]$ 内。
+- $-1000 \le Node.val \le 1000$。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg)
+
+```python
+输入：root = [3,9,20,null,null,15,7]
+输出：2
+```
+
+- 示例 2：
+
+```python
+输入：root = [2,null,3,null,4,null,5,null,6]
+输出：5
+```
 
 ## 解题思路
 
+### 思路 1：深度优先搜索
+
 深度优先搜索递归遍历左右子树，记录最小深度。
 
 对于每一个非叶子节点，计算其左右子树的最小叶子节点深度，将较小的深度+1 即为当前节点的最小叶子节点深度。
 
-## 代码
+### 思路 1：代码
 
 ```python
 class Solution:
@@ -42,3 +69,8 @@ class Solution:
         return min_depth + 1
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 是树中的节点数量。
+- **空间复杂度**：$O(n)$。
+

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

@@ -5,7 +5,7 @@
 
 ## 题目大意
 
-给定一个完美二叉树，所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树结构如下：
+**描述**：给定一个完美二叉树，所有叶子节点都在同一层，每个父节点都有两个子节点。完美二叉树结构如下：
 
 ```python
 struct Node {
@@ -16,16 +16,44 @@ struct Node {
 }
 ```
 
-要求填充每个 next 指针，是的这个指针指向下一个右侧节点。如果找不到下一个右侧节点，则将 next 置为 None。
-示例：
+**要求**：填充每个 `next` 指针，使得这个指针指向下一个右侧节点。如果找不到下一个右侧节点，则将 `next` 置为 `None`。
+
+**说明**：
+
+- 初始状态下，所有 next 指针都被设置为 `None`。
+- 树中节点的数量在 $[0, 2^{12} - 1]$ 范围内。
+- $-1000 \le node.val \le 1000$。
+- 进阶：
+  - 只能使用常量级额外空间。
+  - 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
+
+
+**示例**：
+
+- 示例 1：
 
 ![](https://assets.leetcode.com/uploads/2019/02/14/116_sample.png)
 
+```python
+输入：root = [1,2,3,4,5,6,7]
+输出：[1,#,2,3,#,4,5,6,7,#]
+解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
+```
+
+- 示例 2：
+
+```python
+输入：root = []
+输出：[]
+```
+
 ## 解题思路
 
-层次遍历。在层次遍历的过程中，依次取出每一层的节点，并进行连接。然后再扩展下一层节点。
+### 思路 1：层次遍历
 
-## 代码
+在层次遍历的过程中，依次取出每一层的节点，并进行连接。然后再扩展下一层节点。
+
+### 思路 1：代码
 
 ```python
 import collections
@@ -50,3 +78,8 @@ class Solution:
         return root
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 为树中的节点数量。
+- **空间复杂度**：$O(1)$。
+

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

@@ -5,7 +5,7 @@
 
 ## 题目大意
 
-给定一个完美二叉树，二叉树结构如下：
+**描述**：给定一个二叉树。二叉树结构如下：
 
 ```python
 struct Node {
@@ -16,14 +16,43 @@ struct Node {
 }
 ```
 
-要求填充每个 next 指针，是的这个指针指向下一个右侧节点。如果找不到下一个右侧节点，则将 next 置为 None。
-示例：
+**要求**：填充每个 `next` 指针，使得这个指针指向下一个右侧节点。如果找不到下一个右侧节点，则将 `next` 置为 `None`。
+
+**说明**：
+
+- 初始状态下，所有 next 指针都被设置为 `None`。
+- 树中节点的数量在 $[0, 6000]$ 范围内。
+- $-100 \le Node.val \le 100$。
+- 进阶：
+  - 只能使用常量级额外空间。
+  - 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2019/02/15/117_sample.png)
+
+```python
+输入：root = [1,2,3,4,5,null,7]
+输出：[1,#,2,3,#,4,5,7,#]
+解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。
+```
+
+- 示例 2：
+
+```python
+输入：root = []
+输出：[]
+```
 
 ## 解题思路
 
-层次遍历。在层次遍历的过程中，依次取出每一层的节点，并进行连接。然后再扩展下一层节点。
+### 思路 1：层次遍历
 
-## 代码
+在层次遍历的过程中，依次取出每一层的节点，并进行连接。然后再扩展下一层节点。
+
+### 思路 1：代码
 
 ```python
 import collections
@@ -48,3 +77,8 @@ class Solution:
         return root
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 为树中的节点数量。
+- **空间复杂度**：$O(1)$。
+

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

@@ -5,21 +5,46 @@
 
 ## 题目大意
 
-实现一个二叉搜索树的迭代器 BSTIterator。表示一个按中序遍历二叉搜索树（BST）的迭代器：
+**要求**：实现一个二叉搜索树的迭代器 BSTIterator。表示一个按中序遍历二叉搜索树（BST）的迭代器：
 
 - `def __init__(self, root: TreeNode):`：初始化 BSTIterator 类的一个对象，会给出二叉搜索树的根节点。
 - `def hasNext(self) -> bool:`：如果向右指针遍历存在数字，则返回 True，否则返回 False。
 - `def next(self) -> int:`：将指针向右移动，返回指针处的数字。
 
+**说明**：
+
+- 指针初始化为一个不存在于 BST 中的数字，所以对 `next()` 的首次调用将返回 BST 中的最小元素。
+- 可以假设 `next()` 调用总是有效的，也就是说，当调用 `next()` 时，BST 的中序遍历中至少存在一个下一个数字。
+- 树中节点的数目在范围 $[1, 10^5]$ 内。
+- $0 \le Node.val \le 10^6$。
+- 最多调用 $10^5$ 次 `hasNext` 和 `next` 操作。
+- 进阶：设计一个满足下述条件的解决方案，`next()` 和 `hasNext()` 操作均摊时间复杂度为 `O(1)` ，并使用 `O(h)` 内存。其中 `h` 是树的高度。
+
+**示例**：
+
+- 示例 1：
+
+![](https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png)
+
+```python
+输入
+["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
+[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
+输出
+[null, 3, 7, true, 9, true, 15, true, 20, false]
+```
+
 ## 解题思路
 
+### 思路 1：中序遍历二叉搜索树
+
 中序遍历的顺序是：左、根、右。我们使用一个栈来保存节点，以便于迭代的时候取出对应节点。
 
 - 初始的遍历当前节点的左子树，将其路径上的节点存储到栈中。
 - 调用 next 方法的时候，从栈顶取出节点，因为之前已经将路径上的左子树全部存入了栈中，所以此时该节点的左子树为空，这时候取出节点右子树，再将右子树的左子树进行递归遍历，并将其路径上的节点存储到栈中。
 - 调用 hasNext 的方法的时候，直接判断栈中是否有值即可。
 
-## 代码
+### 思路 1：代码
 
 ```python
 class BSTIterator:
@@ -43,3 +68,8 @@ class BSTIterator:
         return len(self.stack) != 0
 ```
 
+### 思路 1：复杂度分析
+
+- **时间复杂度**：$O(n)$，其中 $n$ 为树中节点数量。
+- **空间复杂度**：$O(n)$。
+