algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-19 07:17:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Finetune the chapter of hashing,

Browse Source 
divide and conquer, backtracking, tree
This commit is contained in:
krahets
2023-07-24 03:04:55 +08:00
parent 9d56622c75
commit 17f995b432
16 changed files with 258 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
docs/chapter_tree/array_representation_of_tree.md
View File

@@ -6,21 +6,21 @@
## 表示完美二叉树
先分析一个简单案例，给定一个完美二叉树，我们将节点按照层序遍历的顺序编号（从 $0$ 开始），此时每个节点都对应唯一的索引。
先分析一个简单案例。给定一个完美二叉树，我们将所有节点按照层序遍历的顺序存储在一个数组中，则每个节点都对应唯一的数组索引。
根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：**若节点的索引为 $i$ ，则该节点的左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$** 。
![完美二叉树的数组表示](array_representation_of_tree.assets/array_representation_binary_tree.png)
**映射公式的作用相当于链表中的指针**。如果我们将节点按照层序遍历的顺序存储在一个数组中，那么对于数组中的任意节点，我们都可以通过映射公式来访问其子节点。
**映射公式的角色相当于链表中的指针**。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。
## 表示任意二叉树
然而，完美二叉树只是一个特例。在二叉树的中间层，通常存在许多 $\text{None}$ ，而层序遍历序列并不包含这些 $\text{None}$ 。我们无法仅凭该序列来推测 $\text{None}$ 的数量和分布位置，**这意味着存在多种二叉树结构都符合该层序遍历序列**。显然在这种情况下，上述的数组表示方法已经失效。
然而完美二叉树是一个特例，在二叉树的中间层，通常存在许多 $\text{None}$ 。由于层序遍历序列并不包含这些 $\text{None}$ ，因此我们无法仅凭该序列来推测 $\text{None}$ 的数量和分布位置。**这意味着存在多种二叉树结构都符合该层序遍历序列**。显然在这种情况下，上述的数组表示方法已经失效。
![层序遍历序列对应多种二叉树可能性](array_representation_of_tree.assets/array_representation_without_empty.png)
为了解决此问题，**我们可以考虑在层序遍历序列中显式地写出所有 $\text{None}$**。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。
为了解决此问题，**我们可以考虑在层序遍历序列中显式地写出所有 $\text{None}$** 。如下图所示，这样处理后，层序遍历序列就可以唯一表示二叉树了。
=== "Java"
@@ -42,7 +42,7 @@
```python title=""
# 二叉树的数组表示
# 直接使用 None 来表示空位
# 使用 None 来表示空位
tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
```
@@ -58,7 +58,7 @@
```javascript title=""
/* 二叉树的数组表示 */
// 直接使用 null 来表示空位
// 使用 null 来表示空位
let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
```
@@ -66,7 +66,7 @@
```typescript title=""
/* 二叉树的数组表示 */
// 直接使用 null 来表示空位
// 使用 null 来表示空位
let tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
```
@@ -110,10 +110,14 @@
![任意类型二叉树的数组表示](array_representation_of_tree.assets/array_representation_with_empty.png)
以下为数组表示下二叉树的实现，包括：
值得说明的是，**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{None}$ 只出现在最底层且靠右的位置，**因此所有 $\text{None}$ 一定出现在层序遍历序列的末尾**。这意味着使用数组表示完全二叉树时，可以省略存储所有 $\text{None}$ ，非常方便。
- 获取节点数量、节点值、左（右）子节点、父节点等基础操作；
- 获取前序遍历、中序遍历、后序遍历、层序遍历的节点值序列；
![完全二叉树的数组表示](array_representation_of_tree.assets/array_representation_complete_binary_tree.png)
如下代码给出了数组表示下的二叉树的简单实现，包括以下操作：
- 给定某节点，获取它的值、左（右）子节点、父节点；
- 获取前序遍历、中序遍历、后序遍历、层序遍历序列；
=== "Java"
@@ -183,18 +187,14 @@
## 优势与局限性
二叉树的数组表示存在以下优点：
二叉树的数组表示的优点包括：
- 数组存储在连续的内存空间中，缓存友好，访问与遍历速度较快；
- 数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快；
- 不需要存储指针，比较节省空间；
- 允许随机访问节点；
然而，数组表示也具有一些局限性：
- 数组存储需要连续内存空间，因此不适合存储数据量过大的树。
- 数组存储需要连续内存空间，因此不适合存储数据量过大的树；
- 增删节点需要通过数组插入与删除操作实现，效率较低；
- 当二叉树中存在大量 $\text{None}$ 时，数组中包含的节点数据比重较低，空间利用率较低。
**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{None}$ 只出现在最底层且靠右的位置，**这意味着所有 $\text{None}$ 一定出现在层序遍历序列的末尾**。因此，在使用数组表示完全二叉树时，可以省略存储所有 $\text{None}$ 。
![完全二叉树的数组表示](array_representation_of_tree.assets/array_representation_complete_binary_tree.png)
- 当二叉树中存在大量 $\text{None}$ 时，数组中包含的节点数据比重较低，空间利用率较低；

35
docs/chapter_tree/binary_tree_traversal.md
View File

@@ -12,8 +12,6 @@
![二叉树的层序遍历](binary_tree_traversal.assets/binary_tree_bfs.png)
### 算法实现
广度优先遍历通常借助「队列」来实现。队列遵循“先进先出”的规则，而广度优先遍历则遵循“逐层推进”的规则，两者背后的思想是一致的。
=== "Java"
@@ -82,8 +80,6 @@
[class]{}-[func]{levelOrder}
```
### 复杂度分析
**时间复杂度**：所有节点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为节点数量。
**空间复杂度**：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 $\frac{n + 1}{2}$ 个节点，占用 $O(n)$ 空间。
@@ -92,21 +88,11 @@
相应地，前序、中序和后序遍历都属于「深度优先遍历 Depth-First Traversal」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。
如下图所示，左侧是深度优先遍历的示意图，右上方是对应的递归实现代码。深度优先遍历就像是绕着整个二叉树的外围“走”一圈，在这个过程中，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
如下图所示，左侧是深度优先遍历的示意图，右上方是对应的递归代码。深度优先遍历就像是绕着整个二叉树的外围“走”一圈，在这个过程中，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
![二叉搜索树的前、中、后序遍历](binary_tree_traversal.assets/binary_tree_dfs.png)
<div class="center-table" markdown>
| 位置 | 含义 | 此处访问节点时对应 |
| ---------- | ------------------------------------ | ----------------------------- |
| 橙色圆圈处 | 刚进入此节点，即将访问该节点的左子树 | 前序遍历 Pre-Order Traversal |
| 蓝色圆圈处 | 已访问完左子树，即将访问右子树 | 中序遍历 In-Order Traversal |
| 紫色圆圈处 | 已访问完左子树和右子树，即将返回 | 后序遍历 Post-Order Traversal |
</div>
### 算法实现
以下给出了实现代码，请配合上图理解深度优先遍历的递归过程。
=== "Java"
@@ -218,11 +204,18 @@
[class]{}-[func]{postOrder}
```
**时间复杂度**：所有节点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为节点数量。
**空间复杂度**：在最差情况下，即树退化为链表时，递归深度达到 $n$ ，系统占用 $O(n)$ 栈帧空间。
!!! note
我们也可以仅基于循环实现前、中、后序遍历，有兴趣的同学可以自行实现。
我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行研究。
递归过程可分为“递”和“归”两个相反的部分。“递”表示开启新方法，程序在此过程中访问下一个节点；“归”表示函数返回，代表该节点已经访问完毕。如下图所示，为前序遍历二叉树的递归过程。
下图展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分：
1. “递”表示开启新方法，程序在此过程中访问下一个节点。
2. “归”表示函数返回，代表当前节点已经访问完毕。
=== "<1>"
![前序遍历的递归过程](binary_tree_traversal.assets/preorder_step1.png)
@@ -256,9 +249,3 @@
=== "<11>"
![preorder_step11](binary_tree_traversal.assets/preorder_step11.png)
### 复杂度分析
**时间复杂度**：所有节点被访问一次，使用 $O(n)$ 时间，其中 $n$ 为节点数量。
**空间复杂度**：在最差情况下，即树退化为链表时，递归深度达到 $n$ ，系统占用 $O(n)$ 栈帧空间。