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

[pull] main from itcharge:main #166

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
pull merged 2 commits into AlgorithmAndLeetCode:main from itcharge:main
Nov 10, 2023
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
42 changes: 36 additions & 6 deletions Solutions/0100. 相同的树.md
View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -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))$。
44 changes: 38 additions & 6 deletions Solutions/0107. 二叉树的层序遍历 II.md
View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -44,3 +71,8 @@ class Solution:
return order[::-1]
```

### 思路 1:复杂度分析

- **时间复杂度**:$O(n),ドル其中 $n$ 为树中节点个数。
- **空间复杂度**:$O(n)$。

38 changes: 35 additions & 3 deletions Solutions/0111. 二叉树的最小深度.md
View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -42,3 +69,8 @@ class Solution:
return min_depth + 1
```

### 思路 1:复杂度分析

- **时间复杂度**:$O(n),ドル其中 $n$ 是树中的节点数量。
- **空间复杂度**:$O(n)$。

View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@

## 题目大意

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

```python
struct Node {
Expand All @@ -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
Expand All @@ -50,3 +78,8 @@ class Solution:
return root
```

### 思路 1:复杂度分析

- **时间复杂度**:$O(n),ドル其中 $n$ 为树中的节点数量。
- **空间复杂度**:$O(1)$。

View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@

## 题目大意

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

```python
struct Node {
Expand All @@ -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
Expand All @@ -48,3 +77,8 @@ class Solution:
return root
```

### 思路 1:复杂度分析

- **时间复杂度**:$O(n),ドル其中 $n$ 为树中的节点数量。
- **空间复杂度**:$O(1)$。

34 changes: 32 additions & 2 deletions Solutions/0173. 二叉搜索树迭代器.md
View file Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -43,3 +68,8 @@ class BSTIterator:
return len(self.stack) != 0
```

### 思路 1:复杂度分析

- **时间复杂度**:$O(n),ドル其中 $n$ 为树中节点数量。
- **空间复杂度**:$O(n)$。

Loading

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