mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-24 20:16:28 +08:00
Mention figures and tables in normal texts.
Fix some figures. Finetune texts.
This commit is contained in:
krahets
parent
1aff6d6cc2
commit
106f02809a
64 changed files with 277 additions and 240 deletions
|
|
@ -12,9 +12,9 @@
|
|||
|
||||
## 内容微调
|
||||
|
||||
您可以按照以下步骤修改文本或代码：
|
||||
如下图所示，每个页面的右上角都有“编辑图标”。您可以按照以下步骤修改文本或代码：
|
||||
|
||||
1. 点击页面的右上角的“编辑图标”，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。
|
||||
1. 点击“编辑图标”，如果遇到“需要 Fork 此仓库”的提示，请同意该操作。
|
||||
2. 修改 Markdown 源文件内容，检查内容的正确性，并尽量保持排版格式的统一。
|
||||
3. 在页面底部填写修改说明，然后点击“Propose file change”按钮。页面跳转后，点击“Create pull request”按钮即可发起拉取请求。
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 数组
|
||||
|
||||
「数组 array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将某个元素在数组中的位置称为该元素的「索引 index」。
|
||||
「数组 array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的「索引 index」。下图展示了数组的主要术语和概念。
|
||||
|
||||
|
||||
|
||||
|
|
@ -201,12 +201,12 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
|||
|
||||
### 插入元素
|
||||
|
||||
数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。这意味着如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。
|
||||
数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。如下图所示，如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。
|
||||
|
||||
|
||||
|
||||
值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="array.java"
|
||||
|
|
@ -281,12 +281,12 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
|||
|
||||
### 删除元素
|
||||
|
||||
同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
|
||||
同理，如下图所示，若想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
|
||||
|
||||
|
||||
|
||||
请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="array.java"
|
||||
|
|
|
|||
|
|
@ -2,7 +2,9 @@
|
|||
|
||||
内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。
|
||||
|
||||
「链表 linked list」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
|
||||
「链表 linked list」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，通过它可以从当前节点访问到下一个节点。
|
||||
|
||||
链表的设计使得各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
|
||||
|
||||
|
||||
|
||||
|
|
@ -12,7 +14,7 @@
|
|||
- 尾节点指向的是“空”，它在 Java, C++, Python 中分别被记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。
|
||||
- 在 C, C++, Go, Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。
|
||||
|
||||
链表节点 `ListNode` 如以下代码所示。每个节点除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，**链表比数组占用更多的内存空间**。
|
||||
如以下代码所示，链表节点 `ListNode` 除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，**链表比数组占用更多的内存空间**。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -397,11 +399,11 @@
|
|||
|
||||
### 插入节点
|
||||
|
||||
**在链表中插入节点非常容易**。假设我们想在相邻的两个节点 `n0` , `n1` 之间插入一个新节点 `P` ，则只需要改变两个节点引用（指针）即可，时间复杂度为 $O(1)$ 。
|
||||
在链表中插入节点非常容易。如下图所示，假设我们想在相邻的两个节点 `n0` , `n1` 之间插入一个新节点 `P` ，**则只需要改变两个节点引用（指针）即可**，时间复杂度为 $O(1)$ 。
|
||||
|
||||
相比之下，在数组中插入元素的时间复杂度为 $O(n)$ ，在大数据量下的效率较低。
|
||||
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -477,7 +479,7 @@
|
|||
|
||||
### 删除节点
|
||||
|
||||
在链表中删除节点也非常简便，只需改变一个节点的引用（指针）即可。
|
||||
如下图所示，在链表中删除节点也非常方便，**只需改变一个节点的引用（指针）即可**。
|
||||
|
||||
请注意，尽管在删除操作完成后节点 `P` 仍然指向 `n1` ，但实际上遍历此链表已经无法访问到 `P` ，这意味着 `P` 已经不再属于该链表了。
|
||||
|
||||
|
|
@ -725,11 +727,11 @@
|
|||
|
||||
## 常见链表类型
|
||||
|
||||
**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。
|
||||
如下图所示，常见的链表类型包括三种。
|
||||
|
||||
**环形链表**。如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
|
||||
|
||||
**双向链表**。与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
|
||||
- **单向链表**：即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。
|
||||
- **环形链表**：如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
|
||||
- **双向链表**：与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
给定一个二叉树，搜索并记录所有值为 $7$ 的节点，请返回节点列表。
|
||||
|
||||
对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 $7$ ，若是则将该节点的值加入到结果列表 `res` 之中。
|
||||
对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 $7$ ，若是则将该节点的值加入到结果列表 `res` 之中。相关过程实现如下图和以下代码所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -172,7 +172,7 @@
|
|||
|
||||
在每次“尝试”中，我们通过将当前节点添加进 `path` 来记录路径；而在“回退”前，我们需要将该节点从 `path` 中弹出，**以恢复本次尝试之前的状态**。
|
||||
|
||||
观察该过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。
|
||||
观察下图所示的过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -289,7 +289,7 @@
|
|||
[class]{}-[func]{pre_order}
|
||||
```
|
||||
|
||||
剪枝是一个非常形象的名词。在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而实现搜索效率的提高。
|
||||
剪枝是一个非常形象的名词。如下图所示，在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而提高了搜索效率。
|
||||
|
||||
|
||||
|
||||
|
|
@ -761,7 +761,7 @@
|
|||
[class]{}-[func]{backtrack}
|
||||
```
|
||||
|
||||
根据题意，当找到值为 7 的节点后应该继续搜索，**因此我们需要将记录解之后的 `return` 语句删除**。下图对比了保留或删除 `return` 语句的搜索过程。
|
||||
根据题意，我们在找到值为 7 的节点后应该继续搜索，**因此需要将记录解之后的 `return` 语句删除**。下图对比了保留或删除 `return` 语句的搜索过程。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
|
||||
|
||||
本题共包含三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。
|
||||
下图展示了本题的三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。
|
||||
|
||||
|
||||
|
||||
|
|
@ -30,9 +30,9 @@
|
|||
|
||||
那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 $(row, col)$ ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，**即对角线上所有格子的 $row - col$ 为恒定值**。
|
||||
|
||||
也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助一个数组 `diag1` 来记录每条主对角线上是否有皇后。
|
||||
也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助下图所示的数组 `diag1` ，记录每条主对角线上是否有皇后。
|
||||
|
||||
同理，**次对角线上的所有格子的 $row + col$ 是恒定值**。我们可以使用相同方法，借助数组 `diag2` 来处理次对角线约束。
|
||||
同理，**次对角线上的所有格子的 $row + col$ 是恒定值**。我们同样也可以借助数组 `diag2` 来处理次对角线约束。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -155,9 +155,9 @@
|
|||
|
||||
### 相等元素剪枝
|
||||
|
||||
观察发现，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。
|
||||
观察下图，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。
|
||||
|
||||
同理，在第一轮选择 $2$ 后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也应将第二轮的 $\hat{1}$ 剪枝。
|
||||
同理，在第一轮选择 $2$ 之后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也应将第二轮的 $\hat{1}$ 剪枝。
|
||||
|
||||
本质上看，**我们的目标是在某一轮选择中，保证多个相等的元素仅被选择一次**。
|
||||
|
||||
|
|
|
|||
|
|
@ -131,11 +131,11 @@
|
|||
1. 第一轮和第二轮分别选择 $3$ , $4$ ，会生成包含这两个元素的所有子集，记为 $[3, 4, \dots]$ 。
|
||||
2. 若第一轮选择 $4$ ，**则第二轮应该跳过 $3$** ，因为该选择产生的子集 $[4, 3, \dots]$ 和 `1.` 中生成的子集完全重复。
|
||||
|
||||
分支越靠右，需要排除的分支也越多，例如：
|
||||
如下图所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。
|
||||
|
||||
1. 前两轮选择 $3$ , $5$ ，生成子集 $[3, 5, \dots]$ 。
|
||||
2. 前两轮选择 $4$ , $5$ ，生成子集 $[4, 5, \dots]$ 。
|
||||
3. 若第一轮选择 $5$ ，**则第二轮应该跳过 $3$ 和 $4$** ，因为子集 $[5, 3, \dots]$ 和子集 $[5, 4, \dots]$ 和 `1.` , `2.` 中生成的子集完全重复。
|
||||
3. 若第一轮选择 $5$ ，**则第二轮应该跳过 $3$ 和 $4$** ，因为子集 $[5, 3, \dots]$ 和子集 $[5, 4, \dots]$ 和 `1.` , `2.` 中描述的子集完全重复。
|
||||
|
||||
|
||||
|
||||
|
|
@ -258,7 +258,7 @@
|
|||
|
||||
相比于上题，**本题的输入数组可能包含重复元素**，这引入了新的问题。例如，给定数组 $[4, \hat{4}, 5]$ 和目标元素 $9$ ，则现有代码的输出结果为 $[4, 5], [\hat{4}, 5]$ ，出现了重复子集。
|
||||
|
||||
**造成这种重复的原因是相等元素在某轮中被多次选择**。如下图所示，第一轮共有三个选择，其中两个都为 $4$ ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 $4$ 也会产生重复子集。
|
||||
**造成这种重复的原因是相等元素在某轮中被多次选择**。在下图中，第一轮共有三个选择，其中两个都为 $4$ ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 $4$ 也会产生重复子集。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
Before Width: | Height: | Size: 73 KiB After Width: | Height: | Size: 72 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 78 KiB After Width: | Height: | Size: 82 KiB |
|
|
@ -671,7 +671,7 @@ $$
|
|||
|
||||
常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。
|
||||
|
||||
需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ ：
|
||||
需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，因此不会累积占用空间，空间复杂度仍为 $O(1)$ ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -847,7 +847,7 @@ $$
|
|||
[class]{}-[func]{linear}
|
||||
```
|
||||
|
||||
以下函数的递归深度为 $n$ ，即同时存在 $n$ 个未返回的 `linear_recur()` 函数，使用 $O(n)$ 大小的栈帧空间：
|
||||
如下图所示，此函数的递归深度为 $n$ ，即同时存在 $n$ 个未返回的 `linear_recur()` 函数，使用 $O(n)$ 大小的栈帧空间：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -999,7 +999,7 @@ $$
|
|||
[class]{}-[func]{quadratic}
|
||||
```
|
||||
|
||||
以下函数的递归深度为 $n$ ，在每个递归函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $n / 2$ ，因此总体占用 $O(n^2)$ 空间。
|
||||
如下图所示，该函数的递归深度为 $n$ ，在每个递归函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $n / 2$ ，因此总体占用 $O(n^2)$ 空间：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -1077,7 +1077,7 @@ $$
|
|||
|
||||
### 指数阶 $O(2^n)$
|
||||
|
||||
指数阶常见于二叉树。高度为 $n$ 的“满二叉树”的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
|
||||
指数阶常见于二叉树。观察下图，高度为 $n$ 的“满二叉树”的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -426,11 +426,11 @@ $$
|
|||
}
|
||||
```
|
||||
|
||||
算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为“常数阶”。
|
||||
下图展示了以上三个算法函数的时间复杂度。
|
||||
|
||||
算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。
|
||||
|
||||
算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为“常数阶”。
|
||||
- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为“常数阶”。
|
||||
- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。
|
||||
- 算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为“常数阶”。
|
||||
|
||||
|
||||
|
||||
|
|
@ -871,7 +871,7 @@ $$
|
|||
|
||||
**时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
|
||||
|
||||
以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
|
||||
下表展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
|
||||
|
||||
<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
|
||||
|
||||
|
|
@ -885,7 +885,7 @@ $$
|
|||
|
||||
## 常见类型
|
||||
|
||||
设输入数据大小为 $n$ ，常见的时间复杂度类型包括（按照从低到高的顺序排列）：
|
||||
设输入数据大小为 $n$ ，常见的时间复杂度类型如下图所示（按照从低到高的顺序排列）。
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
|
|
@ -1286,7 +1286,9 @@ $$
|
|||
|
||||
### 指数阶 $O(2^n)$
|
||||
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。相关代码如下：
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
|
||||
以下代码和图模拟了细胞分裂的过程，时间复杂度为 $O(2^n)$ 。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -1360,11 +1362,9 @@ $$
|
|||
[class]{}-[func]{exponential}
|
||||
```
|
||||
|
||||
下图展示了细胞分裂的过程。
|
||||
|
||||
|
||||
|
||||
在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止：
|
||||
在实际算法中，指数阶常出现于递归函数中。例如在以下代码中，其递归地一分为二，经过 $n$ 次分裂后停止：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -1442,7 +1442,9 @@ $$
|
|||
|
||||
### 对数阶 $O(\log n)$
|
||||
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。相关代码如下：
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
|
||||
|
||||
以下代码和图模拟了“每轮缩减到一半”的过程，时间复杂度为 $O(\log_2 n)$ ，简记为 $O(\log n)$ 。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -1602,7 +1604,7 @@ $$
|
|||
O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
|
||||
$$
|
||||
|
||||
因此我们通常会省略底数 $m$ ，将对数阶直接记为 $O(\log n)$ 。
|
||||
也就是说，底数 $m$ 可以在不影响复杂度的前提下转换。因此我们通常会省略底数 $m$ ，将对数阶直接记为 $O(\log n)$ 。
|
||||
|
||||
### 线性对数阶 $O(n \log n)$
|
||||
|
||||
|
|
@ -1680,6 +1682,8 @@ $$
|
|||
[class]{}-[func]{linear_log_recur}
|
||||
```
|
||||
|
||||
下图展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 $n$ ，树共有 $\log_2 n + 1$ 层，因此时间复杂度为 $O(n \log n)$ 。
|
||||
|
||||
|
||||
|
||||
主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
|
||||
|
|
@ -1692,7 +1696,7 @@ $$
|
|||
n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
|
||||
$$
|
||||
|
||||
阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
|
||||
阶乘通常使用递归实现。如下图和以下代码所示，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
## ASCII 字符集
|
||||
|
||||
「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。这包括英文字母的大小写、数字 0-9 、一些标点符号，以及一些控制字符（如换行符和制表符）。
|
||||
「ASCII 码」是最早出现的字符集，全称为“美国标准信息交换代码”。它使用 7 位二进制数（即一个字节的低 7 位）表示一个字符，最多能够表示 128 个不同的字符。如下图所示，ASCII 码包括英文字母的大小写、数字 0-9 、一些标点符号，以及一些控制字符（如换行符和制表符）。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
**逻辑结构揭示了数据元素之间的逻辑关系**。在数组和链表中，数据按照顺序依次排列，体现了数据之间的线性关系；而在树中，数据从顶部向下按层次排列，表现出祖先与后代之间的派生关系；图则由节点和边构成，反映了复杂的网络关系。
|
||||
|
||||
逻辑结构可被分为“线性”和“非线性”两大类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。
|
||||
如下图所示，逻辑结构可被分为“线性”和“非线性”两大类。线性结构比较直观，指数据在逻辑关系上呈线性排列；非线性结构则相反，呈非线性排列。
|
||||
|
||||
- **线性数据结构**：数组、链表、栈、队列、哈希表。
|
||||
- **非线性数据结构**：树、堆、图、哈希表。
|
||||
|
|
@ -25,13 +25,13 @@
|
|||
|
||||
**在算法运行过程中，相关数据都存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储一定大小的数据，在算法运行时，所有数据都被存储在这些单元格中。
|
||||
|
||||
**系统通过内存地址来访问目标位置的数据**。计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。
|
||||
**系统通过内存地址来访问目标位置的数据**。如下图所示，计算机根据特定规则为表格中的每个单元格分配编号，确保每个内存空间都有唯一的内存地址。有了这些地址，程序便可以访问内存中的数据。
|
||||
|
||||
|
||||
|
||||
内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。**因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素**。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在离散的内存空间内。
|
||||
|
||||
**物理结构反映了数据在计算机内存中的存储方式**，可分为连续空间存储（数组）和离散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。
|
||||
如下图所示，**物理结构反映了数据在计算机内存中的存储方式**，可分为连续空间存储（数组）和离散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -8,12 +8,14 @@
|
|||
|
||||
在上一节的表格中我们发现，所有整数类型能够表示的负数都比正数多一个，例如 `byte` 的取值范围是 $[-128, 127]$ 。这个现象比较反直觉，它的内在原因涉及到原码、反码、补码的相关知识。
|
||||
|
||||
实际上，**数字是以“补码”的形式存储在计算机中的**。在分析这样做的原因之前，我们首先给出三者的定义：
|
||||
首先需要指出，**数字是以“补码”的形式存储在计算机中的**。在分析这样做的原因之前，我们首先给出三者的定义：
|
||||
|
||||
- **原码**：我们将数字的二进制表示的最高位视为符号位，其中 $0$ 表示正数，$1$ 表示负数，其余位表示数字的值。
|
||||
- **反码**：正数的反码与其原码相同，负数的反码是对其原码除符号位外的所有位取反。
|
||||
- **补码**：正数的补码与其原码相同，负数的补码是在其反码的基础上加 $1$ 。
|
||||
|
||||
下图展示了原吗、反码和补码之间的转换方法。
|
||||
|
||||
|
||||
|
||||
「原码 true form」虽然最直观，但存在一些局限性。一方面，**负数的原码不能直接用于运算**。例如在原码下计算 $1 + (-2)$ ，得到的结果是 $-3$ ，这显然是不对的。
|
||||
|
|
@ -21,9 +23,9 @@
|
|||
$$
|
||||
\begin{aligned}
|
||||
& 1 + (-2) \newline
|
||||
& = 0000 \space 0001 + 1000 \space 0010 \newline
|
||||
& \rightarrow 0000 \space 0001 + 1000 \space 0010 \newline
|
||||
& = 1000 \space 0011 \newline
|
||||
& = -3
|
||||
& \rightarrow -3
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
|
|
@ -44,8 +46,8 @@ $$
|
|||
|
||||
$$
|
||||
\begin{aligned}
|
||||
+0 & = 0000 \space 0000 \newline
|
||||
-0 & = 1000 \space 0000
|
||||
+0 & \rightarrow 0000 \space 0000 \newline
|
||||
-0 & \rightarrow 1000 \space 0000
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
|
|
@ -53,7 +55,7 @@ $$
|
|||
|
||||
$$
|
||||
\begin{aligned}
|
||||
-0 = \space & 1000 \space 0000 \space \text{(原码)} \newline
|
||||
-0 \rightarrow \space & 1000 \space 0000 \space \text{(原码)} \newline
|
||||
= \space & 1111 \space 1111 \space \text{(反码)} \newline
|
||||
= 1 \space & 0000 \space 0000 \space \text{(补码)} \newline
|
||||
\end{aligned}
|
||||
|
|
@ -121,9 +123,9 @@ $$
|
|||
\end{aligned}
|
||||
$$
|
||||
|
||||
|
||||
|
||||
|
||||
给定一个示例数据 $\mathrm{S} = 0$ ， $\mathrm{E} = 124$ ，$\mathrm{N} = 2^{-2} + 2^{-3} = 0.375$ ，则有：
|
||||
观察上图，给定一个示例数据 $\mathrm{S} = 0$ ， $\mathrm{E} = 124$ ，$\mathrm{N} = 2^{-2} + 2^{-3} = 0.375$ ，则有：
|
||||
|
||||
$$
|
||||
\text { val } = (-1)^0 \times 2^{124 - 127} \times (1 + 0.375) = 0.171875
|
||||
|
|
@ -133,7 +135,7 @@ $$
|
|||
|
||||
**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。
|
||||
|
||||
进一步地，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。
|
||||
如下表所示，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。
|
||||
|
||||
<p align="center"> 表：指数位含义 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
- 前序遍历：`[ 根节点 | 左子树 | 右子树 ]` ，例如上图 `[ 3 | 9 | 2 1 7 ]` 。
|
||||
- 中序遍历：`[ 左子树 | 根节点 ｜ 右子树 ]` ，例如上图 `[ 9 | 3 | 1 2 7 ]` 。
|
||||
|
||||
以上图数据为例，我们可以通过以下步骤得到上述的划分结果：
|
||||
以上图数据为例，我们可以通过下图所示的步骤得到划分结果：
|
||||
|
||||
1. 前序遍历的首元素 3 是根节点的值。
|
||||
2. 查找根节点 3 在 `inorder` 中的索引，利用该索引可将 `inorder` 划分为 `[ 9 | 3 ｜ 1 2 7 ]` 。
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
1. **分（划分阶段）**：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止。
|
||||
2. **治（合并阶段）**：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解。
|
||||
|
||||
我们已学过的“归并排序”是分治策略的典型应用之一，其算法原理为：
|
||||
如下图所示，“归并排序”是分治策略的典型应用之一，其算法原理为：
|
||||
|
||||
1. **分**：递归地将原数组（原问题）划分为两个子数组（子问题），直到子数组只剩一个元素（最小子问题）。
|
||||
2. **治**：从底至顶地将有序的子数组（子问题的解）进行合并，从而得到有序的原数组（原问题的解）。
|
||||
|
|
@ -34,7 +34,7 @@
|
|||
|
||||
### 操作数量优化
|
||||
|
||||
以“冒泡排序”为例，其处理一个长度为 $n$ 的数组需要 $O(n^2)$ 时间。假设我们把数组从中点分为两个子数组，则划分需要 $O(n)$ 时间，排序每个子数组需要 $O((n / 2)^2)$ 时间，合并两个子数组需要 $O(n)$ 时间，总体时间复杂度为：
|
||||
以“冒泡排序”为例，其处理一个长度为 $n$ 的数组需要 $O(n^2)$ 时间。假设我们按照下图所示的方式，将数组从中点分为两个子数组，则划分需要 $O(n)$ 时间，排序每个子数组需要 $O((n / 2)^2)$ 时间，合并两个子数组需要 $O(n)$ 时间，总体时间复杂度为：
|
||||
|
||||
$$
|
||||
O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
|
||||
|
|
@ -64,7 +64,7 @@ $$
|
|||
|
||||
并行优化在多核或多处理器的环境中尤其有效，因为系统可以同时处理多个子问题，更加充分地利用计算资源，从而显著减少总体的运行时间。
|
||||
|
||||
比如在桶排序中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。
|
||||
比如在下图所示的“桶排序”中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
|
||||
### 考虑基本情况
|
||||
|
||||
对于问题 $f(1)$ ，即当只有一个圆盘时，则将它直接从 `A` 移动至 `C` 即可。
|
||||
如下图所示，对于问题 $f(1)$ ，即当只有一个圆盘时，我们将它直接从 `A` 移动至 `C` 即可。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -24,14 +24,12 @@
|
|||
=== "<2>"
|
||||
|
||||
|
||||
对于问题 $f(2)$ ，即当有两个圆盘时，**由于要时刻满足小圆盘在大圆盘之上，因此需要借助 `B` 来完成移动**，包括三步：
|
||||
如下图所示，对于问题 $f(2)$ ，即当有两个圆盘时，**由于要时刻满足小圆盘在大圆盘之上，因此需要借助 `B` 来完成移动**。
|
||||
|
||||
1. 先将上面的小圆盘从 `A` 移至 `B` 。
|
||||
2. 再将大圆盘从 `A` 移至 `C` 。
|
||||
3. 最后将小圆盘从 `B` 移至 `C` 。
|
||||
|
||||
解决问题 $f(2)$ 的过程可总结为：**将两个圆盘借助 `B` 从 `A` 移至 `C`** 。其中，`C` 称为目标柱、`B` 称为缓冲柱。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
|
|
@ -44,15 +42,18 @@
|
|||
=== "<4>"
|
||||
|
||||
|
||||
解决问题 $f(2)$ 的过程可总结为：**将两个圆盘借助 `B` 从 `A` 移至 `C`** 。其中，`C` 称为目标柱、`B` 称为缓冲柱。
|
||||
|
||||
### 子问题分解
|
||||
|
||||
对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 $f(1)$ 和 $f(2)$ 的解，因此可从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，执行以下步骤：
|
||||
对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。
|
||||
|
||||
因为已知 $f(1)$ 和 $f(2)$ 的解，所以我们可从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，执行下图所示的步骤。这样三个圆盘就被顺利地从 `A` 移动至 `C` 了。
|
||||
|
||||
1. 令 `B` 为目标柱、`C` 为缓冲柱，将两个圆盘从 `A` 移动至 `B` 。
|
||||
2. 将 `A` 中剩余的一个圆盘从 `A` 直接移动至 `C` 。
|
||||
3. 令 `C` 为目标柱、`A` 为缓冲柱，将两个圆盘从 `B` 移动至 `C` 。
|
||||
|
||||
这样三个圆盘就被顺利地从 `A` 移动至 `C` 了。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -68,7 +69,7 @@
|
|||
|
||||
本质上看，**我们将问题 $f(3)$ 划分为两个子问题 $f(2)$ 和子问题 $f(1)$** 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，而且解是可以合并的。
|
||||
|
||||
至此，我们可总结出汉诺塔问题的分治策略：将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$ 。子问题的解决顺序为：
|
||||
至此，我们可总结出下图所示的汉诺塔问题的分治策略：将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$ 。子问题的解决顺序为：
|
||||
|
||||
1. 将 $n-1$ 个圆盘借助 `C` 从 `A` 移至 `B` 。
|
||||
2. 将剩余 $1$ 个圆盘从 `A` 直接移至 `C` 。
|
||||
|
|
|
|||
|
|
@ -6,6 +6,6 @@
|
|||
- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。
|
||||
- 分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。
|
||||
- 相较于暴力搜索，自适应搜索效率更高。时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的。
|
||||
- 二分查找是分治思想的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。
|
||||
- 二分查找是分治策略的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。
|
||||
- 在构建二叉树问题中，构建树（原问题）可以被划分为构建左子树和右子树（子问题），其可以通过划分前序遍历和中序遍历的索引区间来实现。
|
||||
- 在汉诺塔问题中，一个规模为 $n$ 的问题可以被划分为两个规模为 $n-1$ 的子问题和一个规模为 $1$ 的子问题。按顺序解决这三个子问题后，原问题随之得到解决。
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ $$
|
|||
|
||||
那么，上节的爬楼梯题目有没有最优子结构呢？它的目标是求解方案数量，看似是一个计数问题，但如果换一种问法：“求解最大方案数量”。我们意外地发现，**虽然题目修改前后是等价的，但最优子结构浮现出来了**：第 $n$ 阶最大方案数量等于第 $n-1$ 阶和第 $n-2$ 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。
|
||||
|
||||
根据状态转移方程，以及初始状态 $dp[1] = cost[1]$ , $dp[2] = cost[2]$ ，可以得出动态规划代码。
|
||||
根据状态转移方程，以及初始状态 $dp[1] = cost[1]$ , $dp[2] = cost[2]$ ，我们就可以得到动态规划代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -106,6 +106,8 @@ $$
|
|||
[class]{}-[func]{min_cost_climbing_stairs_dp}
|
||||
```
|
||||
|
||||
下图展示了以上代码的动态规划过程。
|
||||
|
||||
|
||||
|
||||
本题也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
|
||||
|
|
@ -194,7 +196,7 @@ $$
|
|||
|
||||
给定一个共有 $n$ 阶的楼梯，你每步可以上 $1$ 阶或者 $2$ 阶，**但不能连续两轮跳 $1$ 阶**，请问有多少种方案可以爬到楼顶。
|
||||
|
||||
例如，爬上第 $3$ 阶仅剩 $2$ 种可行方案，其中连续三次跳 $1$ 阶的方案不满足约束条件，因此被舍弃。
|
||||
例如下图，爬上第 $3$ 阶仅剩 $2$ 种可行方案，其中连续三次跳 $1$ 阶的方案不满足约束条件，因此被舍弃。
|
||||
|
||||
|
||||
|
||||
|
|
@ -207,7 +209,7 @@ $$
|
|||
- 当 $j$ 等于 $1$ ，即上一轮跳了 $1$ 阶时，这一轮只能选择跳 $2$ 阶。
|
||||
- 当 $j$ 等于 $2$ ，即上一轮跳了 $2$ 阶时，这一轮可选择跳 $1$ 阶或跳 $2$ 阶。
|
||||
|
||||
在该定义下，$dp[i, j]$ 表示状态 $[i, j]$ 对应的方案数。在该定义下的状态转移方程为：
|
||||
如下图所示，在该定义下，$dp[i, j]$ 表示状态 $[i, j]$ 对应的方案数。此时状态转移方程为：
|
||||
|
||||
$$
|
||||
\begin{cases}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@
|
|||
|
||||
给定一个 $n \times m$ 的二维网格 `grid` ，网格中的每个单元格包含一个非负整数，表示该单元格的代价。机器人以左上角单元格为起始点，每次只能向下或者向右移动一步，直至到达右下角单元格。请返回从左上角到右下角的最小路径和。
|
||||
|
||||
例如以下示例数据，给定网格的最小路径和为 $13$ 。
|
||||
下图展示了一个例子，给定网格的最小路径和为 $13$ 。
|
||||
|
||||
|
||||
|
||||
|
|
@ -45,7 +45,7 @@
|
|||
|
||||
状态 $[i, j]$ 对应的子问题为：从起始点 $[0, 0]$ 走到 $[i, j]$ 的最小路径和，解记为 $dp[i, j]$ 。
|
||||
|
||||
至此，我们就得到了一个二维 $dp$ 矩阵，其尺寸与输入网格 $grid$ 相同。
|
||||
至此，我们就得到了下图所示的二维 $dp$ 矩阵，其尺寸与输入网格 $grid$ 相同。
|
||||
|
||||
|
||||
|
||||
|
|
@ -59,7 +59,7 @@
|
|||
|
||||
对于状态 $[i, j]$ ，它只能从上边格子 $[i-1, j]$ 和左边格子 $[i, j-1]$ 转移而来。因此最优子结构为：到达 $[i, j]$ 的最小路径和由 $[i, j-1]$ 的最小路径和与 $[i-1, j]$ 的最小路径和，这两者较小的那一个决定。
|
||||
|
||||
根据以上分析，可推出以下状态转移方程：
|
||||
根据以上分析，可推出下图所示的状态转移方程：
|
||||
|
||||
$$
|
||||
dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
|
||||
|
|
@ -77,7 +77,7 @@ $$
|
|||
|
||||
在本题中，处在首行的状态只能向右转移，首列状态只能向下转移，因此首行 $i = 0$ 和首列 $j = 0$ 是边界条件。
|
||||
|
||||
每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。
|
||||
如下图所示，由于每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。
|
||||
|
||||
|
||||
|
||||
|
|
@ -254,7 +254,7 @@ $$
|
|||
[class]{}-[func]{min_path_sum_dfs_mem}
|
||||
```
|
||||
|
||||
引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 $O(nm)$ 。
|
||||
如下图所示，在引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 $O(nm)$ 。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@
|
|||
|
||||
**第二步：找出最优子结构，进而推导出状态转移方程**
|
||||
|
||||
考虑子问题 $dp[i, j]$ ，其对应的两个字符串的尾部字符为 $s[i-1]$ 和 $t[j-1]$ ，可根据不同编辑操作分为三种情况：
|
||||
考虑子问题 $dp[i, j]$ ，其对应的两个字符串的尾部字符为 $s[i-1]$ 和 $t[j-1]$ ，可根据不同编辑操作分为下图所示的三种情况：
|
||||
|
||||
1. 在 $s[i-1]$ 之后添加 $t[j-1]$ ，则剩余子问题 $dp[i, j-1]$ 。
|
||||
2. 删除 $s[i-1]$ ，则剩余子问题 $dp[i-1, j]$ 。
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ $$
|
|||
dp[i] = dp[i-1] + dp[i-2]
|
||||
$$
|
||||
|
||||
这意味着在爬楼梯问题中，各个子问题之间存在递推关系，**原问题的解可以由子问题的解构建得来**。
|
||||
这意味着在爬楼梯问题中，各个子问题之间存在递推关系，**原问题的解可以由子问题的解构建得来**。下图展示了该递推关系。
|
||||
|
||||
|
||||
|
||||
|
|
@ -430,6 +430,10 @@ $$
|
|||
[class]{}-[func]{climbing_stairs_dp}
|
||||
```
|
||||
|
||||
下图模拟了以上代码的执行过程。
|
||||
|
||||
|
||||
|
||||
与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如，爬楼梯问题的状态定义为当前所在楼梯阶数 $i$ 。
|
||||
|
||||
总结以上，动态规划的常用术语包括：
|
||||
|
|
@ -438,8 +442,6 @@ $$
|
|||
- 将最小子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」。
|
||||
- 将递推公式 $dp[i] = dp[i-1] + dp[i-2]$ 称为「状态转移方程」。
|
||||
|
||||
|
||||
|
||||
## 状态压缩
|
||||
|
||||
细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无须使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，和一个容量为 $cap$ 的背包。每个物品只能选择一次，问在不超过背包容量下能放入物品的最大价值。
|
||||
|
||||
请注意，物品编号 $i$ 从 $1$ 开始计数，数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。
|
||||
观察下图，由于物品编号 $i$ 从 $1$ 开始计数，数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。
|
||||
|
||||
|
||||
|
||||
|
|
@ -212,6 +212,8 @@ $$
|
|||
[class]{}-[func]{knapsack_dfs_mem}
|
||||
```
|
||||
|
||||
下图展示了在记忆化递归中被剪掉的搜索分支。
|
||||
|
||||
|
||||
|
||||
### 方法三：动态规划
|
||||
|
|
@ -343,7 +345,7 @@ $$
|
|||
- 如果采取正序遍历，那么遍历到 $dp[i, j]$ 时，左上方 $dp[i-1, 1]$ ~ $dp[i-1, j-1]$ 值可能已经被覆盖，此时就无法得到正确的状态转移结果。
|
||||
- 如果采取倒序遍历，则不会发生覆盖问题，状态转移可以正确进行。
|
||||
|
||||
以下动画展示了在单个数组下从第 $i = 1$ 行转换至第 $i = 2$ 行的过程。请思考正序遍历和倒序遍历的区别。
|
||||
下图展示了在单个数组下从第 $i = 1$ 行转换至第 $i = 2$ 行的过程。请思考正序遍历和倒序遍历的区别。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ $$
|
|||
|
||||
由于当前状态是从左边和上边的状态转移而来，**因此状态压缩后应该对 $dp$ 表中的每一行采取正序遍历**。
|
||||
|
||||
这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解两者的区别。
|
||||
这个遍历顺序与 0-1 背包正好相反。请借助下图来理解两者的区别。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
|
|||
|
|
@ -10,31 +10,31 @@ G & = \{ V, E \} \newline
|
|||
\end{aligned}
|
||||
$$
|
||||
|
||||
如果将顶点看作节点，将边看作连接各个节点的引用（指针），我们就可以将图看作是一种从链表拓展而来的数据结构。如下图所示，**相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高**，从而更为复杂。
|
||||
|
||||
|
||||
|
||||
那么，图与其他数据结构的关系是什么？如果我们把顶点看作节点，把边看作连接各个节点的指针，则可将图看作是一种从链表拓展而来的数据结构。**相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，从而更为复杂**。
|
||||
## 图常见类型与术语
|
||||
|
||||
## 图常见类型
|
||||
|
||||
根据边是否具有方向，可分为「无向图 undirected graph」和「有向图 directed graph」。
|
||||
根据边是否具有方向，可分为下图所示的「无向图 undirected graph」和「有向图 directed graph」。
|
||||
|
||||
- 在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。
|
||||
- 在有向图中，边具有方向性，即 $A \rightarrow B$ 和 $A \leftarrow B$ 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系。
|
||||
|
||||
|
||||
|
||||
根据所有顶点是否连通，可分为「连通图 connected graph」和「非连通图 disconnected graph」。
|
||||
根据所有顶点是否连通，可分为下图所示的「连通图 connected graph」和「非连通图 disconnected graph」。
|
||||
|
||||
- 对于连通图，从某个顶点出发，可以到达其余任意顶点。
|
||||
- 对于非连通图，从某个顶点出发，至少有一个顶点无法到达。
|
||||
|
||||
|
||||
|
||||
我们还可以为边添加“权重”变量，从而得到「有权图 weighted graph」。例如，在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。
|
||||
我们还可以为边添加“权重”变量，从而得到下图所示的「有权图 weighted graph」。例如在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。
|
||||
|
||||
|
||||
|
||||
## 图常用术语
|
||||
图的常用术语包括：
|
||||
|
||||
- 「邻接 adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在上图中，顶点 1 的邻接顶点为顶点 2、3、5。
|
||||
- 「路径 path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在上图中，边序列 1-5-2-4 是顶点 1 到顶点 4 的一条路径。
|
||||
|
|
@ -42,7 +42,7 @@ $$
|
|||
|
||||
## 图的表示
|
||||
|
||||
图的常用表示方法包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。
|
||||
图的常用表示方式包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。
|
||||
|
||||
### 邻接矩阵
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ $$
|
|||
|
||||
### 邻接表
|
||||
|
||||
「邻接表 adjacency list」使用 $n$ 个链表来表示图，链表节点表示顶点。第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。
|
||||
「邻接表 adjacency list」使用 $n$ 个链表来表示图，链表节点表示顶点。第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。下图展示了一个使用邻接表存储的图的示例。
|
||||
|
||||
|
||||
|
||||
|
|
@ -72,7 +72,7 @@ $$
|
|||
|
||||
## 图常见应用
|
||||
|
||||
实际应用中，许多系统都可以用图来建模，相应的待求解问题也可以约化为图计算问题。
|
||||
如下图所示，许多现实系统都可以用图来建模，相应的问题也可以约化为图计算问题。
|
||||
|
||||
<p align="center"> 表：现实生活中常见的图 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
## 基于邻接矩阵的实现
|
||||
|
||||
给定一个顶点数量为 $n$ 的无向图，则有：
|
||||
给定一个顶点数量为 $n$ 的无向图，则各种操作的实现方式如下图所示。
|
||||
|
||||
- **添加或删除边**：直接在邻接矩阵中修改指定的边即可，使用 $O(1)$ 时间。而由于是无向图，因此需要同时更新两个方向的边。
|
||||
- **添加顶点**：在邻接矩阵的尾部添加一行一列，并全部填 $0$ 即可，使用 $O(n)$ 时间。
|
||||
|
|
@ -102,7 +102,7 @@
|
|||
|
||||
## 基于邻接表的实现
|
||||
|
||||
设无向图的顶点总数为 $n$ 、边总数为 $m$ ，则有：
|
||||
设无向图的顶点总数为 $n$ 、边总数为 $m$ ，则可根据下图所示的方法实现各种操作。
|
||||
|
||||
- **添加边**：在顶点对应链表的末尾添加边即可，使用 $O(1)$ 时间。因为是无向图，所以需要同时添加两个方向的边。
|
||||
- **删除边**：在顶点对应链表中查找并删除指定边，使用 $O(m)$ 时间。在无向图中，需要同时删除两个方向的边。
|
||||
|
|
@ -205,7 +205,7 @@
|
|||
|
||||
## 效率对比
|
||||
|
||||
设图中共有 $n$ 个顶点和 $m$ 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。
|
||||
设图中共有 $n$ 个顶点和 $m$ 条边，下表对比了邻接矩阵和邻接表的时间和空间效率。
|
||||
|
||||
<p align="center"> 表：邻接矩阵与邻接表对比 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
## 广度优先遍历
|
||||
|
||||
**广度优先遍历是一种由近及远的遍历方式，从距离最近的顶点开始访问，并一层层向外扩张**。具体来说，从某个顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。
|
||||
**广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外扩张**。如下图所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。
|
||||
|
||||
|
||||
|
||||
|
|
@ -96,7 +96,7 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
|
|||
[class]{}-[func]{graph_bfs}
|
||||
```
|
||||
|
||||
代码相对抽象，建议对照以下动画图示来加深理解。
|
||||
代码相对抽象，建议对照下图来加深理解。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -143,13 +143,13 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
|
|||
|
||||
## 深度优先遍历
|
||||
|
||||
**深度优先遍历是一种优先走到底、无路可走再回头的遍历方式**。具体地，从某个顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。
|
||||
**深度优先遍历是一种优先走到底、无路可走再回头的遍历方式**。如下图所示，从左上角顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。
|
||||
|
||||
|
||||
|
||||
### 算法实现
|
||||
|
||||
这种“走到尽头 + 回溯”的算法形式通常基于递归来实现。与 BFS 类似，在 DFS 中我们也需要借助一个哈希表 `visited` 来记录已被访问的顶点，以避免重复访问顶点。
|
||||
这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 `visited` 来记录已被访问的顶点，以避免重复访问顶点。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,16 +1,14 @@
|
|||
# 分数背包问题
|
||||
|
||||
分数背包是 0-1 背包的一个变种问题。
|
||||
|
||||
!!! question
|
||||
|
||||
给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，和一个容量为 $cap$ 的背包。每个物品只能选择一次，**但可以选择物品的一部分，价值根据选择的重量比例计算**，问在不超过背包容量下背包中物品的最大价值。
|
||||
|
||||
|
||||
|
||||
本题和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。
|
||||
分数背包和 0-1 背包整体上非常相似，状态包含当前物品 $i$ 和容量 $c$ ，目标是求不超过背包容量下的最大价值。
|
||||
|
||||
不同点在于，本题允许只选择物品的一部分，**这意味着可以对物品任意地进行切分，并按照重量比例来计算物品价值**，因此有：
|
||||
不同点在于，本题允许只选择物品的一部分。如下图所示，**我们可以对物品任意地进行切分，并按照重量比例来计算物品价值**。
|
||||
|
||||
1. 对于物品 $i$ ，它在单位重量下的价值为 $val[i-1] / wgt[i-1]$ ，简称为单位价值。
|
||||
2. 假设放入一部分物品 $i$ ，重量为 $w$ ，则背包增加的价值为 $w \times val[i-1] / wgt[i-1]$ 。
|
||||
|
|
@ -19,7 +17,7 @@
|
|||
|
||||
### 贪心策略确定
|
||||
|
||||
最大化背包内物品总价值，**本质上是要最大化单位重量下的物品价值**。由此便可推出本题的贪心策略：
|
||||
最大化背包内物品总价值，**本质上是要最大化单位重量下的物品价值**。由此便可推出下图所示的贪心策略：
|
||||
|
||||
1. 将物品按照单位价值从高到低进行排序。
|
||||
2. 遍历所有物品，**每轮贪心地选择单位价值最高的物品**。
|
||||
|
|
@ -139,8 +137,6 @@
|
|||
|
||||
对于该解中的其他物品，我们也可以构建出上述矛盾。总而言之，**单位价值更大的物品总是更优选择**，这说明贪心策略是有效的。
|
||||
|
||||
如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。
|
||||
|
||||
通过这个类比，我们可以从几何角度理解贪心策略的有效性。
|
||||
如下图所示，如果将物品重量和物品单位价值分别看作一个 2D 图表的横轴和纵轴，则分数背包问题可被转化为“求在有限横轴区间下的最大围成面积”。这个类比可以帮助我们从几何角度理解贪心策略的有效性。
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。
|
||||
|
||||
这道题的贪心策略在生活中很常见：给定目标金额，**我们贪心地选择不大于且最接近它的硬币**，不断循环该步骤，直至凑出目标金额为止。
|
||||
本题的贪心策略如下图所示。给定目标金额，**我们贪心地选择不大于且最接近它的硬币**，不断循环该步骤，直至凑出目标金额为止。
|
||||
|
||||
|
||||
|
||||
|
|
@ -95,7 +95,7 @@
|
|||
|
||||
**贪心算法不仅操作直接、实现简单，而且通常效率也很高**。在以上代码中，记硬币最小面值为 $\min(coins)$ ，则贪心选择最多循环 $amt / \min(coins)$ 次，时间复杂度为 $O(amt / \min(coins))$ 。这比动态规划解法的时间复杂度 $O(n \times amt)$ 提升了一个数量级。
|
||||
|
||||
然而，**对于某些硬币面值组合，贪心算法并不能找到最优解**。我们来看几个例子：
|
||||
然而，**对于某些硬币面值组合，贪心算法并不能找到最优解**。下图给出了两个示例。
|
||||
|
||||
- **正例 $coins = [1, 5, 10, 20, 50, 100]$**：在该硬币组合下，给定任意 $amt$ ，贪心算法都可以找出最优解。
|
||||
- **反例 $coins = [1, 20, 50]$**：假设 $amt = 60$ ，贪心算法只能找到 $50 + 1 \times 10$ 的兑换组合，共计 $11$ 枚硬币，但动态规划可以找到最优解 $20 + 20 + 20$ ，仅需 $3$ 枚硬币。
|
||||
|
|
|
|||
|
|
@ -26,18 +26,20 @@ $$
|
|||
|
||||
|
||||
|
||||
我们发现，**如果此时将长板 $j$ 向短板 $i$ 靠近，则容量一定变小**。这是因为在移动长板 $j$ 后：
|
||||
如下图所示，**若此时将长板 $j$ 向短板 $i$ 靠近，则容量一定变小**。这是因为在移动长板 $j$ 后：
|
||||
|
||||
- 宽度 $j-i$ 肯定变小。
|
||||
- 高度由短板决定，因此高度只可能不变（ $i$ 仍为短板）或变小（移动后的 $j$ 成为短板）。
|
||||
|
||||
|
||||
|
||||
反向思考，**我们只有向内收缩短板 $i$ ，才有可能使容量变大**。因为虽然宽度一定变小，**但高度可能会变大**（移动后的短板 $i$ 可能会变长）。
|
||||
反向思考，**我们只有向内收缩短板 $i$ ，才有可能使容量变大**。因为虽然宽度一定变小，**但高度可能会变大**（移动后的短板 $i$ 可能会变长）。例如在下图中，移动短板后面积变大。
|
||||
|
||||
|
||||
|
||||
|
||||
由此便可推出本题的贪心策略：
|
||||
由此便可推出本题的贪心策略：初始化两指针分裂容器两端，每轮向内收缩短板对应的指针，直至两指针相遇。
|
||||
|
||||
下图展示了贪心策略的执行过程。
|
||||
|
||||
1. 初始状态下，指针 $i$ , $j$ 分列与数组两端。
|
||||
2. 计算当前状态的容量 $cap[i, j]$ ，并更新最大容量。
|
||||
|
|
@ -153,7 +155,7 @@ $$
|
|||
|
||||
之所以贪心比穷举更快，是因为每轮的贪心选择都会“跳过”一些状态。
|
||||
|
||||
比如在状态 $cap[i, j]$ 下，$i$ 为短板、$j$ 为长板。若贪心地将短板 $i$ 向内移动一格，会导致以下状态被“跳过”。**这意味着之后无法验证这些状态的容量大小**。
|
||||
比如在状态 $cap[i, j]$ 下，$i$ 为短板、$j$ 为长板。若贪心地将短板 $i$ 向内移动一格，会导致下图所示的状态被“跳过”。**这意味着之后无法验证这些状态的容量大小**。
|
||||
|
||||
$$
|
||||
cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1]
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ n & \geq 4
|
|||
\end{aligned}
|
||||
$$
|
||||
|
||||
我们发现当 $n \geq 4$ 时，切分出一个 $2$ 后乘积会变大，**这说明大于等于 $4$ 的整数都应该被切分**。
|
||||
如下图所示，当 $n \geq 4$ 时，切分出一个 $2$ 后乘积会变大，**这说明大于等于 $4$ 的整数都应该被切分**。
|
||||
|
||||
**贪心策略一**：如果切分方案中包含 $\geq 4$ 的因子，那么它就应该被继续切分。最终的切分方案只应出现 $1$ , $2$ , $3$ 这三种因子。
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ $$
|
|||
|
||||
接下来思考哪个因子是最优的。在 $1$ , $2$ , $3$ 这三个因子中，显然 $1$ 是最差的，因为 $1 \times (n-1) < n$ 恒成立，即切分出 $1$ 反而会导致乘积减小。
|
||||
|
||||
我们发现，当 $n = 6$ 时，有 $3 \times 3 > 2 \times 2 \times 2$ 。**这意味着切分出 $3$ 比切分出 $2$ 更优**。
|
||||
如下图所示，当 $n = 6$ 时，有 $3 \times 3 > 2 \times 2 \times 2$ 。**这意味着切分出 $3$ 比切分出 $2$ 更优**。
|
||||
|
||||
**贪心策略二**：在切分方案中，最多只应存在两个 $2$ 。因为三个 $2$ 总是可以被替换为两个 $3$ ，从而获得更大乘积。
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ $$
|
|||
|
||||
### 代码实现
|
||||
|
||||
在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
|
||||
如下图所示，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
|
||||
|
||||
$$
|
||||
n = 3 a + b
|
||||
|
|
@ -137,7 +137,7 @@ $$
|
|||
|
||||
|
||||
|
||||
**时间复杂度取决于编程语言的幂运算的实现方法**。以 Python 为例，常用的幂计算函数有三种：
|
||||
**时间复杂度取决于编程语言的幂运算的实现方法**。以 Python 为例，常用的幂计算函数有：
|
||||
|
||||
- 运算符 `**` 和函数 `pow()` 的时间复杂度均为 $O(\log a)$ 。
|
||||
- 函数 `math.pow()` 内部调用 C 语言库的 `pow()` 函数，其执行浮点取幂，时间复杂度为 $O(1)$ 。
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
在上两节中，我们了解了哈希表的工作原理和哈希冲突的处理方法。然而无论是开放寻址还是链地址法，**它们只能保证哈希表可以在发生冲突时正常工作，但无法减少哈希冲突的发生**。
|
||||
|
||||
如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 $O(n)$ 。
|
||||
如果哈希冲突过于频繁，哈希表的性能则会急剧劣化。如下图所示，对于链地址哈希表，理想情况下键值对平均分布在各个桶中，达到最佳查询效率；最差情况下所有键值对都被存储到同一个桶中，时间复杂度退化至 $O(n)$ 。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
## 链式地址
|
||||
|
||||
在原始哈希表中，每个桶仅能存储一个键值对。「链式地址 separate chaining」将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中。
|
||||
在原始哈希表中，每个桶仅能存储一个键值对。「链式地址 separate chaining」将单个元素转换为链表，将键值对作为链表节点，将所有发生冲突的键值对都存储在同一链表中。下图展示了一个链式地址哈希表的例子。
|
||||
|
||||
|
||||
|
||||
|
|
@ -118,7 +118,9 @@
|
|||
- **插入元素**：通过哈希函数计算数组索引，若发现桶内已有元素，则从冲突位置向后线性遍历（步长通常为 $1$ ），直至找到空位，将元素插入其中。
|
||||
- **查找元素**：若发现哈希冲突，则使用相同步长向后线性遍历，直到找到对应元素，返回 `value` 即可；如果遇到空位，说明目标键值对不在哈希表中，返回 $\text{None}$ 。
|
||||
|
||||
|
||||
下图展示了一个在开放寻址（线性探测）下工作的哈希表。
|
||||
|
||||
|
||||
|
||||
然而，线性探测存在以下缺陷：
|
||||
|
||||
|
|
|
|||
|
|
@ -2,15 +2,15 @@
|
|||
|
||||
「哈希表 hash table」，又称「散列表」，其通过建立键 `key` 与值 `value` 之间的映射，实现高效的元素查询。具体而言，我们向哈希表输入一个键 `key` ，则可以在 $O(1)$ 时间内获取对应的值 `value` 。
|
||||
|
||||
以一个包含 $n$ 个学生的数据库为例，每个学生都有“姓名”和“学号”两项数据。假如我们希望实现“输入一个学号，返回对应的姓名”的查询功能，则可以采用哈希表来实现。
|
||||
如下图所示，给定 $n$ 个学生，每个学生都有“姓名”和“学号”两项数据。假如我们希望实现“输入一个学号，返回对应的姓名”的查询功能，则可以采用哈希表来实现。
|
||||
|
||||
|
||||
|
||||
除哈希表外，我们还可以使用数组或链表实现查询功能。若将学生数据看作数组（链表）元素，则有：
|
||||
除哈希表外，数组和链表也可以实现查询功能，它们的效率对比如下表所示。
|
||||
|
||||
- **添加元素**：仅需将元素添加至数组（链表）的尾部即可，使用 $O(1)$ 时间。
|
||||
- **查询元素**：由于数组（链表）是乱序的，因此需要遍历其中的所有元素，使用 $O(n)$ 时间。
|
||||
- **删除元素**：需要先查询到元素，再从数组中删除，使用 $O(n)$ 时间。
|
||||
- **删除元素**：需要先查询到元素，再从数组（链表）中删除，使用 $O(n)$ 时间。
|
||||
|
||||
<p align="center"> 表：元素查询效率对比 </p>
|
||||
|
||||
|
|
@ -578,7 +578,9 @@ index = hash(key) % capacity
|
|||
|
||||
|
||||
|
||||
容易想到，哈希表容量 $n$ 越大，多个 `key` 被分配到同一个桶中的概率就越低，冲突就越少。因此，**我们可以通过扩容哈希表来减少哈希冲突**。如下图所示，扩容前键值对 `(136, A)` 和 `(236, D)` 发生冲突，扩容后冲突消失。
|
||||
容易想到，哈希表容量 $n$ 越大，多个 `key` 被分配到同一个桶中的概率就越低，冲突就越少。因此，**我们可以通过扩容哈希表来减少哈希冲突**。
|
||||
|
||||
如下图所示，扩容前键值对 `(136, A)` 和 `(236, D)` 发生冲突，扩容后冲突消失。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -95,11 +95,11 @@
|
|||
|
||||
将上述两者相乘，可得到建堆过程的时间复杂度为 $O(n \log n)$ 。**然而，这个估算结果并不准确，因为我们没有考虑到二叉树底层节点数量远多于顶层节点的特性**。
|
||||
|
||||
接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 $n$ ，树高度为 $h$ 。上文提到，**节点堆化最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”**。
|
||||
接下来我们来进行更为详细的计算。为了减小计算难度，我们假设树是一个“完美二叉树”，该假设不会影响计算结果的正确性。设二叉树（即堆）节点数量为 $n$ ，树高度为 $h$ 。
|
||||
|
||||
|
||||
|
||||
因此，我们可以将各层的“节点数量 $\times$ 节点高度”求和，**从而得到所有节点的堆化迭代次数的总和**。
|
||||
如上图所示，**节点“从顶至底堆化”的最大迭代次数等于该节点到叶节点的距离，而该距离正是“节点高度”**。因此，我们可以将各层的“节点数量 $\times$ 节点高度”求和，**从而得到所有节点的堆化迭代次数的总和**。
|
||||
|
||||
$$
|
||||
T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 堆
|
||||
|
||||
「堆 heap」是一种满足特定条件的完全二叉树，可分为两种类型：
|
||||
「堆 heap」是一种满足特定条件的完全二叉树，主要可分为下图所示的两种类型：
|
||||
|
||||
- 「大顶堆 max heap」：任意节点的值 $\geq$ 其子节点的值。
|
||||
- 「小顶堆 min heap」：任意节点的值 $\leq$ 其子节点的值。
|
||||
|
|
@ -321,7 +321,7 @@
|
|||
|
||||
当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置。**节点指针通过索引映射公式来实现**。
|
||||
|
||||
具体而言，给定索引 $i$ ，其左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$ ，父节点索引为 $(i - 1) / 2$（向下取整）。当索引越界时，表示空节点或节点不存在。
|
||||
如下图所示，给定索引 $i$ ，其左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$ ，父节点索引为 $(i - 1) / 2$（向下取整）。当索引越界时，表示空节点或节点不存在。
|
||||
|
||||
|
||||
|
||||
|
|
@ -527,7 +527,7 @@
|
|||
|
||||
给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 heapify」。
|
||||
|
||||
考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
|
||||
考虑从入堆节点开始，**从底至顶执行堆化**。如下图所示，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -662,7 +662,7 @@
|
|||
2. 交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。
|
||||
3. 从根节点开始，**从顶至底执行堆化**。
|
||||
|
||||
顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。
|
||||
如下图所示，**“从顶至底堆化”的操作方向与“从底至顶堆化”相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换。然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
|
|||
|
|
@ -8,9 +8,9 @@
|
|||
|
||||
## 方法一：遍历选择
|
||||
|
||||
我们可以进行 $k$ 轮遍历，分别在每轮中提取第 $1$ , $2$ , $\dots$ , $k$ 大的元素，时间复杂度为 $O(nk)$ 。
|
||||
我们可以进行下图所示的 $k$ 轮遍历，分别在每轮中提取第 $1$ , $2$ , $\dots$ , $k$ 大的元素，时间复杂度为 $O(nk)$ 。
|
||||
|
||||
该方法只适用于 $k \ll n$ 的情况，因为当 $k$ 与 $n$ 比较接近时，其时间复杂度趋向于 $O(n^2)$ ，非常耗时。
|
||||
此方法只适用于 $k \ll n$ 的情况，因为当 $k$ 与 $n$ 比较接近时，其时间复杂度趋向于 $O(n^2)$ ，非常耗时。
|
||||
|
||||
|
||||
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
## 方法二：排序
|
||||
|
||||
我们可以对数组 `nums` 进行排序，并返回最右边的 $k$ 个元素，时间复杂度为 $O(n \log n)$ 。
|
||||
如下图所示，我们可以先对数组 `nums` 进行排序，再返回最右边的 $k$ 个元素，时间复杂度为 $O(n \log n)$ 。
|
||||
|
||||
显然，该方法“超额”完成任务了，因为我们只需要找出最大的 $k$ 个元素即可，而不需要排序其他元素。
|
||||
|
||||
|
|
@ -28,7 +28,7 @@
|
|||
|
||||
## 方法三：堆
|
||||
|
||||
我们可以基于堆更加高效地解决 Top-K 问题，流程如下：
|
||||
我们可以基于堆更加高效地解决 Top-K 问题，流程如下图所示。
|
||||
|
||||
1. 初始化一个小顶堆，其堆顶元素最小。
|
||||
2. 先将数组的前 $k$ 个元素依次入堆。
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@
|
|||
|
||||
上述整理扑克牌的方法本质上是“插入排序”算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
|
||||
|
||||
**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如下图所示的思考。
|
||||
**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成下图所示的思考。
|
||||
|
||||
1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。
|
||||
2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。
|
||||
|
|
@ -53,4 +53,4 @@
|
|||
|
||||
!!! tip
|
||||
|
||||
阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
|
||||
如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请不要担心，继续往下阅读，这本书将引导你迈入数据结构与算法的知识殿堂。
|
||||
|
|
|
|||
|
|
@ -23,15 +23,15 @@
|
|||
|
||||
## 数据结构与算法的关系
|
||||
|
||||
数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。
|
||||
数据结构与算法高度相关、紧密结合，具体表现在下图所示的几个方面。
|
||||
|
||||
- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
|
||||
- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
|
||||
- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
|
||||
- 算法通常可以基于不同的数据结构进行实现，并往往有对应最优的数据结构，但最终执行效率可能相差很大。
|
||||
|
||||
|
||||
|
||||
数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
|
||||
数据结构与算法犹如下图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
## 内容结构
|
||||
|
||||
本书主要内容包括：
|
||||
本书主要内容如下图所示。
|
||||
|
||||
- **复杂度分析**：数据结构和算法的评价维度与方法。时间复杂度、空间复杂度的推算方法、常见类型、示例等。
|
||||
- **数据结构**：基本数据类型，数据结构的分类方法。数组、链表、栈、队列、哈希表、树、堆、图等数据结构的定义、优缺点、常用操作、常见类型、典型应用、实现方法等。
|
||||
|
|
|
|||
|
|
@ -164,13 +164,13 @@
|
|||
|
||||
相较于文字，视频和图片具有更高的信息密度和结构化程度，更易于理解。在本书中，**重点和难点知识将主要通过动画和图解形式展示**，而文字则作为动画和图片的解释与补充。
|
||||
|
||||
在阅读本书时，如果发现某段内容提供了动画或图解，**建议以图为主线**，以文字（通常位于图像上方）为辅，综合两者来理解内容。
|
||||
如果你在阅读本书时，发现某段内容提供了下图所示的动画或图解，**请以图为主、以文字为辅**，综合两者来理解内容。
|
||||
|
||||
|
||||
|
||||
## 在代码实践中加深理解
|
||||
|
||||
本书的配套代码被托管在 [GitHub 仓库](https://github.com/krahets/hello-algo)。**源代码附有测试样例，可一键运行**。
|
||||
本书的配套代码被托管在 [GitHub 仓库](https://github.com/krahets/hello-algo)。如下图所示，**源代码附有测试样例，可一键运行**。
|
||||
|
||||
如果时间允许，**建议你参照代码自行敲一遍**。如果学习时间有限，请至少通读并运行所有代码。
|
||||
|
||||
|
|
@ -178,6 +178,8 @@
|
|||
|
||||
|
||||
|
||||
运行代码的前置工作主要分为三步。
|
||||
|
||||
**第一步：安装本地编程环境**。请参照[附录教程](https://www.hello-algo.com/chapter_appendix/installation/)进行安装，如果已安装则可跳过此步骤。
|
||||
|
||||
**第二步：下载代码仓**。如果已经安装 [Git](https://git-scm.com/downloads) ，可以通过以下命令克隆本仓库。
|
||||
|
|
@ -196,9 +198,9 @@ git clone https://github.com/krahets/hello-algo.git
|
|||
|
||||
## 在提问讨论中共同成长
|
||||
|
||||
阅读本书时，请不要“惯着”那些没学明白的知识点。**欢迎在评论区提出你的问题**，我和其他小伙伴们将竭诚为你解答，一般情况下可在两天内得到回复。
|
||||
在阅读本书时，请不要轻易跳过那些没学明白的知识点。**欢迎在评论区提出你的问题**，我和小伙伴们将竭诚为你解答，一般情况下可在两天内回复。
|
||||
|
||||
同时，也希望您能在评论区多花些时间。一方面，您可以了解大家遇到的问题，从而查漏补缺，这将有助于激发更深入的思考。另一方面，希望您能慷慨地回答其他小伙伴的问题、分享您的见解，让大家共同学习和进步。
|
||||
同时，也希望你能在评论区多花些时间。一方面，你可以了解大家遇到的问题，从而查漏补缺，激发更深入的思考。另一方面，期待你能慷慨地回答其他小伙伴的问题，分享您的见解，帮助他人进步。
|
||||
|
||||
|
||||
|
||||
|
|
@ -210,6 +212,6 @@ git clone https://github.com/krahets/hello-algo.git
|
|||
2. **刷算法题**。建议从热门题目开刷，如[剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)和[LeetCode Hot 100](https://leetcode.cn/problem-list/2cktkvj/)，先积累至少 100 道题目，熟悉主流的算法问题。初次刷题时，“知识遗忘”可能是一个挑战，但请放心，这是很正常的。我们可以按照“艾宾浩斯遗忘曲线”来复习题目，通常在进行 3-5 轮的重复后，就能将其牢记在心。
|
||||
3. **搭建知识体系**。在学习方面，我们可以阅读算法专栏文章、解题框架和算法教材，以不断丰富知识体系。在刷题方面，可以尝试采用进阶刷题策略，如按专题分类、一题多解、一解多题等，相关的刷题心得可以在各个社区找到。
|
||||
|
||||
作为一本入门教程，本书内容主要涵盖“第一阶段”，旨在帮助你更高效地展开第二和第三阶段的学习。
|
||||
如下图所示，本书内容主要涵盖“第一阶段”，旨在帮助你更高效地展开第二和第三阶段的学习。
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 二分查找
|
||||
|
||||
「二分查找 binary search」是一种基于分治思想的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。
|
||||
「二分查找 binary search」是一种基于分治策略的高效搜索算法。它利用数据的有序性，每轮减少一半搜索范围，直至找到目标元素或搜索区间为空为止。
|
||||
|
||||
!!! question
|
||||
|
||||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
|
||||
|
||||
对于上述问题，我们先初始化指针 $i = 0$ 和 $j = n - 1$ ，分别指向数组首元素和尾元素，代表搜索区间 $[0, n - 1]$ 。请注意，中括号表示闭区间，其包含边界值本身。
|
||||
如下图所示，我们先初始化指针 $i = 0$ 和 $j = n - 1$ ，分别指向数组首元素和尾元素，代表搜索区间 $[0, n - 1]$ 。请注意，中括号表示闭区间，其包含边界值本身。
|
||||
|
||||
接下来，循环执行以下两个步骤：
|
||||
|
||||
|
|
@ -199,7 +199,7 @@
|
|||
|
||||
如下图所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
|
||||
|
||||
在“双闭区间”表示法中，由于左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错。因此，**我们通常采用“双闭区间”的写法**。
|
||||
由于“双闭区间”表示中的左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错，**因此一般建议采用“双闭区间”的写法**。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@
|
|||
|
||||
实际上，我们可以利用查找最左元素的函数来查找最右元素，具体方法为：**将查找最右一个 `target` 转化为查找最左一个 `target + 1`**。
|
||||
|
||||
查找完成后，指针 $i$ 指向最左一个 `target + 1`（如果存在），而 $j$ 指向最右一个 `target` ，**因此返回 $j$ 即可**。
|
||||
如下图所示，查找完成后，指针 $i$ 指向最左一个 `target + 1`（如果存在），而 $j$ 指向最右一个 `target` ，**因此返回 $j$ 即可**。
|
||||
|
||||
|
||||
|
||||
|
|
@ -179,7 +179,7 @@
|
|||
|
||||
我们知道，当数组不包含 `target` 时，最后 $i$ , $j$ 会分别指向首个大于、小于 `target` 的元素。
|
||||
|
||||
根据上述结论，我们可以构造一个数组中不存在的元素，用于查找左右边界：
|
||||
根据上述结论，我们可以构造一个数组中不存在的元素，用于查找左右边界，如下图所示。
|
||||
|
||||
- 查找最左一个 `target` ：可以转化为查找 `target - 0.5` ，并返回指针 $i$ 。
|
||||
- 查找最右一个 `target` ：可以转化为查找 `target + 0.5` ，并返回指针 $j$ 。
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@
|
|||
|
||||
假设数组中存在多个 `target` ，则普通二分查找只能返回其中一个 `target` 的索引，**而无法确定该元素的左边和右边还有多少 `target`**。
|
||||
|
||||
题目要求将目标元素插入到最左边，**所以我们需要查找数组中最左一个 `target` 的索引**。初步考虑通过以下两步实现：
|
||||
题目要求将目标元素插入到最左边，**所以我们需要查找数组中最左一个 `target` 的索引**。初步考虑通过下图所示的步骤实现。
|
||||
|
||||
1. 执行二分查找，得到任意一个 `target` 的索引，记为 $k$ 。
|
||||
2. 从索引 $k$ 开始，向左进行线性遍历，当找到最左边的 `target` 时返回。
|
||||
|
|
@ -111,7 +111,7 @@
|
|||
|
||||
此方法虽然可用，但其包含线性查找，因此时间复杂度为 $O(n)$ 。当数组中存在很多重复的 `target` 时，该方法效率很低。
|
||||
|
||||
现考虑修改二分查找代码。整体流程不变，每轮先计算中点索引 $m$ ，再判断 `target` 和 `nums[m]` 大小关系：
|
||||
现考虑拓展二分查找代码。如下图所示，整体流程保持不变，每轮先计算中点索引 $m$ ，再判断 `target` 和 `nums[m]` 大小关系：
|
||||
|
||||
1. 当 `nums[m] < target` 或 `nums[m] > target` 时，说明还没有找到 `target` ，因此采用普通二分查找的缩小区间操作，**从而使指针 $i$ 和 $j$ 向 `target` 靠近**。
|
||||
2. 当 `nums[m] == target` 时，说明小于 `target` 的元素在区间 $[i, m - 1]$ 中，因此采用 $j = m - 1$ 来缩小区间，**从而使指针 $j$ 向小于 `target` 的元素靠近**。
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
## 线性查找：以时间换空间
|
||||
|
||||
考虑直接遍历所有可能的组合。开启一个两层循环，在每轮中判断两个整数的和是否为 `target` ，若是，则返回它们的索引。
|
||||
考虑直接遍历所有可能的组合。如下图所示，我们开启一个两层循环，在每轮中判断两个整数的和是否为 `target` ，若是则返回它们的索引。
|
||||
|
||||
|
||||
|
||||
|
|
@ -88,7 +88,7 @@
|
|||
|
||||
## 哈希查找：以空间换时间
|
||||
|
||||
考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行：
|
||||
考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行下图所示的步骤。
|
||||
|
||||
1. 判断数字 `target - nums[i]` 是否在哈希表中，若是则直接返回这两个元素的索引。
|
||||
2. 将键值对 `nums[i]` 和索引 `i` 添加进哈希表。
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
「冒泡排序 bubble sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。
|
||||
|
||||
我们可以利用元素交换操作模拟上述过程：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
|
||||
如下图所示，冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
|
||||
## 算法流程
|
||||
|
||||
设数组的长度为 $n$ ，冒泡排序的步骤为：
|
||||
设数组的长度为 $n$ ，冒泡排序的步骤如下图所示。
|
||||
|
||||
1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
|
||||
2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 $O(n \log n)$ 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性阶。
|
||||
|
||||
「桶排序 bucket sort」是分治思想的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
|
||||
「桶排序 bucket sort」是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
|
||||
|
||||
## 算法流程
|
||||
|
||||
考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如下：
|
||||
考虑一个长度为 $n$ 的数组，元素是范围 $[0, 1)$ 的浮点数。桶排序的流程如下图所示。
|
||||
|
||||
1. 初始化 $k$ 个桶，将 $n$ 个元素分配到 $k$ 个桶中。
|
||||
2. 对每个桶分别执行排序（本文采用编程语言的内置排序函数）。
|
||||
|
|
@ -101,10 +101,14 @@
|
|||
|
||||
桶排序的时间复杂度理论上可以达到 $O(n)$ ，**关键在于将元素均匀分配到各个桶中**，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。
|
||||
|
||||
为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。**分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等**。这种方法本质上是创建一个递归树，使叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。
|
||||
为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。**分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等**。
|
||||
|
||||
如下图所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。
|
||||
|
||||
|
||||
|
||||
如果我们提前知道商品价格的概率分布，**则可以根据数据概率分布设置每个桶的价格分界线**。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。
|
||||
如果我们提前知道商品价格的概率分布，**则可以根据数据概率分布设置每个桶的价格分界线**。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。
|
||||
|
||||
如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
## 简单实现
|
||||
|
||||
先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”。计数排序的整体流程如下：
|
||||
先来看一个简单的例子。给定一个长度为 $n$ 的数组 `nums` ，其中的元素都是“非负整数”，计数排序的整体流程如下图所示。
|
||||
|
||||
1. 遍历数组，找出数组中的最大数字，记为 $m$ ，然后创建一个长度为 $m + 1$ 的辅助数组 `counter` 。
|
||||
2. **借助 `counter` 统计 `nums` 中各数字的出现次数**，其中 `counter[num]` 对应数字 `num` 的出现次数。统计方法很简单，只需遍历 `nums`（设当前数字为 `num`），每轮将 `counter[num]` 增加 $1$ 即可。
|
||||
|
|
@ -90,7 +90,7 @@
|
|||
|
||||
## 完整实现
|
||||
|
||||
细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。例如，输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
|
||||
细心的同学可能发现，**如果输入数据是对象，上述步骤 `3.` 就失效了**。假设输入数据是商品对象，我们想要按照商品价格（类的成员变量）对商品进行排序，而上述算法只能给出价格的排序结果。
|
||||
|
||||
那么如何才能得到原数据的排序结果呢？我们首先计算 `counter` 的“前缀和”。顾名思义，索引 `i` 处的前缀和 `prefix[i]` 等于数组前 `i` 个元素之和，即：
|
||||
|
||||
|
|
@ -103,7 +103,7 @@ $$
|
|||
1. 将 `num` 填入数组 `res` 的索引 `prefix[num] - 1` 处。
|
||||
2. 令前缀和 `prefix[num]` 减小 $1$ ，从而得到下次放置 `num` 的索引。
|
||||
|
||||
遍历完成后，数组 `res` 中就是排序好的结果，最后使用 `res` 覆盖原数组 `nums` 即可。
|
||||
遍历完成后，数组 `res` 中就是排序好的结果，最后使用 `res` 覆盖原数组 `nums` 即可。下图展示了完整的计数排序流程。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
|
|||
|
|
@ -13,14 +13,16 @@
|
|||
|
||||
## 算法流程
|
||||
|
||||
设数组的长度为 $n$ ，堆排序的流程如下：
|
||||
设数组的长度为 $n$ ，堆排序的流程如下图所示。
|
||||
|
||||
1. 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
|
||||
2. 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 $1$ ，已排序元素数量加 $1$ 。
|
||||
3. 从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。
|
||||
4. 循环执行第 `2.` 和 `3.` 步。循环 $n - 1$ 轮后，即可完成数组排序。
|
||||
|
||||
实际上，元素出堆操作中也包含第 `2.` 和 `3.` 步，只是多了一个弹出元素的步骤。
|
||||
!!! tip
|
||||
|
||||
实际上，元素出堆操作中也包含第 `2.` 和 `3.` 步，只是多了一个弹出元素的步骤。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
|
@ -58,7 +60,7 @@
|
|||
=== "<12>"
|
||||
|
||||
|
||||
在代码实现中，我们使用了与堆章节相同的从顶至底堆化（Sift Down）的函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 Sift Down 函数添加一个长度参数 $n$ ，用于指定堆的当前有效长度。
|
||||
在代码实现中，我们使用了与堆章节相同的从顶至底堆化 `sift_down()` 函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 `sift_down()` 函数添加一个长度参数 $n$ ，用于指定堆的当前有效长度。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -4,13 +4,13 @@
|
|||
|
||||
具体来说，我们在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。
|
||||
|
||||
回忆数组的元素插入操作，设基准元素为 `base` ，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
|
||||
下图展示了数组插入元素的操作流程。设基准元素为 `base` ，我们需要将从目标索引到 `base` 之间的所有元素向右移动一位，然后再将 `base` 赋值给目标索引。
|
||||
|
||||
|
||||
|
||||
## 算法流程
|
||||
|
||||
插入排序的整体流程如下：
|
||||
插入排序的整体流程如下图所示。
|
||||
|
||||
1. 初始状态下，数组的第 1 个元素已完成排序。
|
||||
2. 选取数组的第 2 个元素作为 `base` ，将其插入到正确位置后，**数组的前 2 个元素已排序**。
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 归并排序
|
||||
|
||||
「归并排序 merge sort」基于分治思想实现排序，包含“划分”和“合并”两个阶段：
|
||||
「归并排序 merge sort」是一种基于分治策略的排序算法，包含下图所示的“划分”和“合并”阶段：
|
||||
|
||||
1. **划分阶段**：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。
|
||||
2. **合并阶段**：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。
|
||||
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
## 算法流程
|
||||
|
||||
“划分阶段”从顶至底递归地将数组从中点切为两个子数组：
|
||||
如下图所示，“划分阶段”从顶至底递归地将数组从中点切为两个子数组：
|
||||
|
||||
1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）。
|
||||
2. 递归执行步骤 `1.` ，直至子数组区间长度为 1 时，终止递归划分。
|
||||
|
|
@ -46,7 +46,7 @@
|
|||
=== "<10>"
|
||||
|
||||
|
||||
观察发现，归并排序的递归顺序与二叉树的后序遍历相同，具体来看：
|
||||
观察发现，归并排序的递归顺序与二叉树的后序遍历相同，对比来看：
|
||||
|
||||
- **后序遍历**：先递归左子树，再递归右子树，最后处理根节点。
|
||||
- **归并排序**：先递归左子数组，再递归右子数组，最后处理合并。
|
||||
|
|
|
|||
|
|
@ -1,15 +1,13 @@
|
|||
# 快速排序
|
||||
|
||||
「快速排序 quick sort」是一种基于分治思想的排序算法，运行高效，应用广泛。
|
||||
「快速排序 quick sort」是一种基于分治策略的排序算法，运行高效，应用广泛。
|
||||
|
||||
快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程为：
|
||||
快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程如下图所示。
|
||||
|
||||
1. 选取数组最左端元素作为基准数，初始化两个指针 `i` 和 `j` 分别指向数组的两端。
|
||||
2. 设置一个循环，在每轮中使用 `i`（`j`）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。
|
||||
3. 循环执行步骤 `2.` ，直到 `i` 和 `j` 相遇时停止，最后将基准数交换至两个子数组的分界线。
|
||||
|
||||
哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 $\leq$ 基准数 $\leq$ 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
|
|
@ -37,7 +35,9 @@
|
|||
=== "<9>"
|
||||
|
||||
|
||||
!!! note "快速排序的分治思想"
|
||||
哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 $\leq$ 基准数 $\leq$ 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。
|
||||
|
||||
!!! note "快速排序的分治策略"
|
||||
|
||||
哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。
|
||||
|
||||
|
|
@ -133,6 +133,8 @@
|
|||
|
||||
## 算法流程
|
||||
|
||||
快速排序的整体流程如下图所示。
|
||||
|
||||
1. 首先，对原数组执行一次“哨兵划分”，得到未排序的左子数组和右子数组。
|
||||
2. 然后，对左子数组和右子数组分别递归执行“哨兵划分”。
|
||||
3. 持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序。
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
## 算法流程
|
||||
|
||||
以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的步骤如下：
|
||||
以学号数据为例，假设数字的最低位是第 $1$ 位，最高位是第 $8$ 位，基数排序的流程如下图所示。
|
||||
|
||||
1. 初始化位数 $k = 1$ 。
|
||||
2. 对学号的第 $k$ 位执行“计数排序”。完成后，数据会根据第 $k$ 位从小到大排序。
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
「选择排序 selection sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。
|
||||
|
||||
设数组的长度为 $n$ ，选择排序的算法流程如下：
|
||||
设数组的长度为 $n$ ，选择排序的算法流程如下图所示。
|
||||
|
||||
1. 初始状态下，所有元素未排序，即未排序（索引）区间为 $[0, n-1]$ 。
|
||||
2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
|
||||
|
|
@ -121,6 +121,6 @@
|
|||
|
||||
- **时间复杂度为 $O(n^2)$ 、非自适应排序**：外循环共 $n - 1$ 轮，第一轮的未排序区间长度为 $n$ ，最后一轮的未排序区间长度为 $2$ ，即各轮外循环分别包含 $n$ , $n - 1$ , $\dots$ , $2$ 轮内循环，求和为 $\frac{(n - 1)(n + 2)}{2}$ 。
|
||||
- **空间复杂度 $O(1)$ 、原地排序**：指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
- **非稳定排序**：在交换元素时，有可能将 `nums[i]` 交换至其相等元素的右边，导致两者的相对顺序发生改变。
|
||||
- **非稳定排序**：如下图所示，元素 `nums[i]` 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
「排序算法 sorting algorithm」用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。
|
||||
|
||||
在排序算法中，数据类型可以是整数、浮点数、字符或字符串等；顺序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。
|
||||
如下图所示，排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
- 计数排序是桶排序的一个特例，它通过统计数据出现的次数来实现排序。计数排序适用于数据量大但数据范围有限的情况，并且要求数据能够转换为正整数。
|
||||
- 基数排序通过逐位排序来实现数据排序，要求数据能够表示为固定位数的数字。
|
||||
- 总的来说，我们希望找到一种排序算法，具有高效率、稳定、原地以及正向自适应性等优点。然而，正如其他数据结构和算法一样，没有一种排序算法能够同时满足所有这些条件。在实际应用中，我们需要根据数据的特性来选择合适的排序算法。
|
||||
- 下图对比了主流排序算法的效率、稳定性、就地性和自适应性等。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 双向队列
|
||||
|
||||
对于队列，我们仅能在头部删除或在尾部添加元素。然而，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
|
||||
在队列中，我们仅能在头部删除或在尾部添加元素。如下图所示，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
|
||||
|
||||
|
||||
|
||||
|
|
@ -326,7 +326,7 @@
|
|||
|
||||
对于双向队列而言，头部和尾部都可以执行入队和出队操作。换句话说，双向队列需要实现另一个对称方向的操作。为此，我们采用“双向链表”作为双向队列的底层数据结构。
|
||||
|
||||
我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。
|
||||
如下图所示，我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。
|
||||
|
||||
=== "LinkedListDeque"
|
||||
|
||||
|
|
@ -343,7 +343,7 @@
|
|||
=== "popFirst()"
|
||||
|
||||
|
||||
以下是具体实现代码。
|
||||
实现代码如下所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -441,7 +441,7 @@
|
|||
|
||||
### 基于数组的实现
|
||||
|
||||
与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。
|
||||
如下图所示，与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。
|
||||
|
||||
=== "ArrayDeque"
|
||||
|
||||
|
|
@ -458,7 +458,7 @@
|
|||
=== "popFirst()"
|
||||
|
||||
|
||||
以下是具体实现代码。
|
||||
在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
「队列 queue」是一种遵循先入先出规则的线性数据结构。顾名思义，队列模拟了排队现象，即新来的人不断加入队列的尾部，而位于队列头部的人逐个离开。
|
||||
|
||||
我们把队列的头部称为“队首”，尾部称为“队尾”，把将元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。
|
||||
如下图所示，我们将队列的头部称为“队首”，尾部称为“队尾”，将把元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。
|
||||
|
||||
|
||||
|
||||
|
|
@ -289,7 +289,7 @@
|
|||
|
||||
### 基于链表的实现
|
||||
|
||||
对于链表实现，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
|
||||
如下图所示，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
|
||||
|
||||
=== "LinkedListQueue"
|
||||
|
||||
|
|
@ -300,7 +300,7 @@
|
|||
=== "pop()"
|
||||
|
||||
|
||||
以下是用链表实现队列的示例代码。
|
||||
以下是用链表实现队列的代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -380,10 +380,10 @@
|
|||
|
||||
我们可以使用一个变量 `front` 指向队首元素的索引，并维护一个变量 `queSize` 用于记录队列长度。定义 `rear = front + queSize` ，这个公式计算出的 `rear` 指向队尾元素之后的下一个位置。
|
||||
|
||||
基于此设计，**数组中包含元素的有效区间为 [front, rear - 1]**，进而：
|
||||
基于此设计，**数组中包含元素的有效区间为 `[front, rear - 1]`**，各种操作的实现方法如下图所示。
|
||||
|
||||
- 对于入队操作，将输入元素赋值给 `rear` 索引处，并将 `queSize` 增加 1 。
|
||||
- 对于出队操作，只需将 `front` 增加 1 ，并将 `queSize` 减少 1 。
|
||||
- 入队操作：将输入元素赋值给 `rear` 索引处，并将 `queSize` 增加 1 。
|
||||
- 出队操作：只需将 `front` 增加 1 ，并将 `queSize` 减少 1 。
|
||||
|
||||
可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 $O(1)$ 。
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
我们可以将栈类比为桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。我们将盘子替换为各种类型的元素（如整数、字符、对象等），就得到了栈数据结构。
|
||||
|
||||
在栈中，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，而删除栈顶元素的操作叫做“出栈”。
|
||||
如下图所示，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，删除栈顶元素的操作叫做“出栈”。
|
||||
|
||||
|
||||
|
||||
|
|
@ -291,7 +291,7 @@
|
|||
|
||||
使用链表来实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。
|
||||
|
||||
对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。
|
||||
如下图所示，对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。
|
||||
|
||||
=== "LinkedListStack"
|
||||
|
||||
|
|
@ -378,7 +378,7 @@
|
|||
|
||||
### 基于数组的实现
|
||||
|
||||
使用数组实现栈时，我们可以将数组的尾部作为栈顶。在这样的设计下，入栈与出栈操作就分别对应在数组尾部添加元素与删除元素，时间复杂度都为 $O(1)$ 。
|
||||
使用数组实现栈时，我们可以将数组的尾部作为栈顶。如下图所示，入栈与出栈操作分别对应在数组尾部添加元素与删除元素，时间复杂度都为 $O(1)$ 。
|
||||
|
||||
=== "ArrayStack"
|
||||
|
||||
|
|
@ -465,11 +465,11 @@
|
|||
|
||||
## 两种实现对比
|
||||
|
||||
### 支持操作
|
||||
**支持操作**
|
||||
|
||||
两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。
|
||||
|
||||
### 时间效率
|
||||
**时间效率**
|
||||
|
||||
在基于数组的实现中，入栈和出栈操作都是在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 $O(n)$ 。
|
||||
|
||||
|
|
@ -480,7 +480,7 @@
|
|||
- 基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。
|
||||
- 基于链表实现的栈可以提供更加稳定的效率表现。
|
||||
|
||||
### 空间效率
|
||||
**空间效率**
|
||||
|
||||
在初始化列表时，系统会为列表分配“初始容量”，该容量可能超过实际需求。并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容，扩容后的容量也可能超出实际需求。因此，**基于数组实现的栈可能造成一定的空间浪费**。
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
先分析一个简单案例。给定一个完美二叉树，我们将所有节点按照层序遍历的顺序存储在一个数组中，则每个节点都对应唯一的数组索引。
|
||||
|
||||
根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：**若节点的索引为 $i$ ，则该节点的左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$** 。
|
||||
根据层序遍历的特性，我们可以推导出父节点索引与子节点索引之间的“映射公式”：**若节点的索引为 $i$ ，则该节点的左子节点索引为 $2i + 1$ ，右子节点索引为 $2i + 2$** 。下图展示了各个节点索引之间的映射关系。
|
||||
|
||||
|
||||
|
||||
|
|
@ -16,7 +16,9 @@
|
|||
|
||||
## 表示任意二叉树
|
||||
|
||||
然而完美二叉树是一个特例，在二叉树的中间层，通常存在许多 $\text{None}$ 。由于层序遍历序列并不包含这些 $\text{None}$ ，因此我们无法仅凭该序列来推测 $\text{None}$ 的数量和分布位置。**这意味着存在多种二叉树结构都符合该层序遍历序列**。显然在这种情况下，上述的数组表示方法已经失效。
|
||||
完美二叉树是一个特例，在二叉树的中间层通常存在许多 $\text{None}$ 。由于层序遍历序列并不包含这些 $\text{None}$ ，因此我们无法仅凭该序列来推测 $\text{None}$ 的数量和分布位置。**这意味着存在多种二叉树结构都符合该层序遍历序列**。
|
||||
|
||||
如下图所示，给定一个非完美二叉树，上述的数组表示方法已经失效。
|
||||
|
||||
|
||||
|
||||
|
|
@ -116,7 +118,9 @@
|
|||
|
||||
|
||||
|
||||
值得说明的是，**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{None}$ 只出现在最底层且靠右的位置，**因此所有 $\text{None}$ 一定出现在层序遍历序列的末尾**。这意味着使用数组表示完全二叉树时，可以省略存储所有 $\text{None}$ ，非常方便。
|
||||
值得说明的是，**完全二叉树非常适合使用数组来表示**。回顾完全二叉树的定义，$\text{None}$ 只出现在最底层且靠右的位置，**因此所有 $\text{None}$ 一定出现在层序遍历序列的末尾**。
|
||||
|
||||
这意味着使用数组表示完全二叉树时，可以省略存储所有 $\text{None}$ ，非常方便。下图给出了一个例子。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
|
||||
|
||||
再例如，在以下完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化。
|
||||
再例如，在下图的完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化。
|
||||
|
||||
|
||||
|
||||
|
|
@ -388,7 +388,7 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
|
|||
=== "<4>"
|
||||
|
||||
|
||||
此外，如果节点 `child` 本身有右子节点（记为 `grandChild` ），则需要在右旋中添加一步：将 `grandChild` 作为 `node` 的左子节点。
|
||||
如下图所示，当节点 `child` 有右子节点（记为 `grandChild` ）时，需要在右旋中添加一步：将 `grandChild` 作为 `node` 的左子节点。
|
||||
|
||||
|
||||
|
||||
|
|
@ -468,11 +468,11 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
|
|||
|
||||
### 左旋
|
||||
|
||||
相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行“左旋”操作。
|
||||
相应的，如果考虑上述失衡二叉树的“镜像”，则需要执行下图所示的“左旋”操作。
|
||||
|
||||
|
||||
|
||||
同理，若节点 `child` 本身有左子节点（记为 `grandChild` ），则需要在左旋中添加一步：将 `grandChild` 作为 `node` 的右子节点。
|
||||
同理，如下图所示，当节点 `child` 有左子节点（记为 `grandChild` ）时，需要在左旋中添加一步：将 `grandChild` 作为 `node` 的右子节点。
|
||||
|
||||
|
||||
|
||||
|
|
@ -552,13 +552,13 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
|
|||
|
||||
### 先左旋后右旋
|
||||
|
||||
对于下图中的失衡节点 3，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先左旋后右旋，即先对 `child` 执行“左旋”，再对 `node` 执行“右旋”。
|
||||
对于下图中的失衡节点 3 ，仅使用左旋或右旋都无法使子树恢复平衡。此时需要先对 `child` 执行“左旋”，再对 `node` 执行“右旋”。
|
||||
|
||||
|
||||
|
||||
### 先右旋后左旋
|
||||
|
||||
同理，对于上述失衡二叉树的镜像情况，需要先右旋后左旋，即先对 `child` 执行“右旋”，然后对 `node` 执行“左旋”。
|
||||
如下图所示，对于上述失衡二叉树的镜像情况，需要先对 `child` 执行“右旋”，然后对 `node` 执行“左旋”。
|
||||
|
||||
|
||||
|
||||
|
|
@ -568,7 +568,7 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
|
|||
|
||||
|
||||
|
||||
在代码中，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。
|
||||
如下表所示，我们通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图中的哪种情况。
|
||||
|
||||
<p align="center"> 表：四种旋转情况的选择条件 </p>
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 二叉搜索树
|
||||
|
||||
「二叉搜索树 binary search tree」满足以下条件：
|
||||
如下图所示，「二叉搜索树 binary search tree」满足以下条件：
|
||||
|
||||
1. 对于根节点，左子树中所有节点的值 $<$ 根节点的值 $<$ 右子树中所有节点的值。
|
||||
2. 任意节点的左、右子树也是二叉搜索树，即同样满足条件 `1.` 。
|
||||
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
### 查找节点
|
||||
|
||||
给定目标节点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个节点 `cur` ，从二叉树的根节点 `root` 出发，循环比较节点值 `cur.val` 和 `num` 之间的大小关系
|
||||
给定目标节点值 `num` ，可以根据二叉搜索树的性质来查找。如下图所示，我们声明一个节点 `cur` ，从二叉树的根节点 `root` 出发，循环比较节点值 `cur.val` 和 `num` 之间的大小关系：
|
||||
|
||||
- 若 `cur.val < num` ，说明目标节点在 `cur` 的右子树中，因此执行 `cur = cur.right` 。
|
||||
- 若 `cur.val > num` ，说明目标节点在 `cur` 的左子树中，因此执行 `cur = cur.left` 。
|
||||
|
|
@ -107,15 +107,18 @@
|
|||
|
||||
### 插入节点
|
||||
|
||||
给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作分为两步：
|
||||
给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，插入操作流程如下图所示。
|
||||
|
||||
1. **查找插入位置**：与查找操作相似，从根节点出发，根据当前节点值和 `num` 的大小关系循环向下搜索，直到越过叶节点（遍历至 $\text{None}$ ）时跳出循环。
|
||||
2. **在该位置插入节点**：初始化节点 `num` ，将该节点置于 $\text{None}$ 的位置。
|
||||
|
||||
二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。
|
||||
|
||||
|
||||
|
||||
在代码实现中，需要注意以下两点：
|
||||
|
||||
- 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。
|
||||
- 为了实现插入节点，我们需要借助节点 `pre` 保存上一轮循环的节点。这样在遍历至 $\text{None}$ 时，我们可以获取到其父节点，从而完成节点插入操作。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_search_tree.java"
|
||||
|
|
@ -188,25 +191,23 @@
|
|||
[class]{BinarySearchTree}-[func]{insert}
|
||||
```
|
||||
|
||||
为了插入节点，我们需要利用辅助节点 `pre` 保存上一轮循环的节点，这样在遍历至 $\text{None}$ 时，我们可以获取到其父节点，从而完成节点插入操作。
|
||||
|
||||
与查找节点相同，插入节点使用 $O(\log n)$ 时间。
|
||||
|
||||
### 删除节点
|
||||
|
||||
与插入节点类似，我们需要在删除操作后维持二叉搜索树的“左子树 < 根节点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除节点。接下来，根据待删除节点的子节点数量，删除操作需分为三种情况：
|
||||
|
||||
当待删除节点的度为 $0$ 时，表示待删除节点是叶节点，可以直接删除。
|
||||
如下图所示，当待删除节点的度为 $0$ 时，表示待删除节点是叶节点，可以直接删除。
|
||||
|
||||
|
||||
|
||||
当待删除节点的度为 $1$ 时，将待删除节点替换为其子节点即可。
|
||||
如下图所示，当待删除节点的度为 $1$ 时，将待删除节点替换为其子节点即可。
|
||||
|
||||
|
||||
|
||||
当待删除节点的度为 $2$ 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 $<$ 根 $<$ 右”的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点。
|
||||
当待删除节点的度为 $2$ 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左 $<$ 根 $<$ 右”的性质，**因此这个节点可以是右子树的最小节点或左子树的最大节点**。
|
||||
|
||||
假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作为：
|
||||
假设我们选择右子树的最小节点（即中序遍历的下一个节点），则删除操作如下图所示。
|
||||
|
||||
1. 找到待删除节点在“中序遍历序列”中的下一个节点，记为 `tmp` 。
|
||||
2. 将 `tmp` 的值覆盖待删除节点的值，并在树中递归删除节点 `tmp` 。
|
||||
|
|
@ -297,9 +298,11 @@
|
|||
[class]{BinarySearchTree}-[func]{remove}
|
||||
```
|
||||
|
||||
### 排序
|
||||
### 中序遍历性质
|
||||
|
||||
我们知道，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。
|
||||
如下图所示，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。
|
||||
|
||||
这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。
|
||||
|
||||
利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无须额外排序，非常高效。
|
||||
|
||||
|
|
@ -309,7 +312,7 @@
|
|||
|
||||
给定一组数据，我们考虑使用数组或二叉搜索树存储。
|
||||
|
||||
观察可知，二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜索树的效率更高。
|
||||
观察下表，二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜索树的效率更高。
|
||||
|
||||
<p align="center"> 表：数组与搜索树的效率对比 </p>
|
||||
|
||||
|
|
@ -321,7 +324,7 @@
|
|||
|
||||
在理想情况下，二叉搜索树是“平衡”的，这样就可以在 $\log n$ 轮循环内查找任意节点。
|
||||
|
||||
然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为链表，这时各种操作的时间复杂度也会退化为 $O(n)$ 。
|
||||
然而，如果我们在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为下图所示的链表，这时各种操作的时间复杂度也会退化为 $O(n)$ 。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -163,13 +163,13 @@
|
|||
|
||||
每个节点都有两个引用（指针），分别指向「左子节点 left-child node」和「右子节点 right-child node」，该节点被称为这两个子节点的「父节点 parent node」。当给定一个二叉树的节点时，我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」，同理可得「右子树 right subtree」。
|
||||
|
||||
**在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树**。在以下示例中，若将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。
|
||||
**在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树**。如下图所示，如果将“节点 2”视为父节点，则其左子节点和右子节点分别是“节点 4”和“节点 5”，左子树是“节点 4 及其以下节点形成的树”，右子树是“节点 5 及其以下节点形成的树”。
|
||||
|
||||
|
||||
|
||||
## 二叉树常见术语
|
||||
|
||||
二叉树涉及的术语较多，建议尽量理解并记住。
|
||||
二叉树的常用术语如下图所示。
|
||||
|
||||
- 「根节点 root node」：位于二叉树顶层的节点，没有父节点。
|
||||
- 「叶节点 leaf node」：没有子节点的节点，其两个指针均指向 $\text{None}$ 。
|
||||
|
|
@ -188,7 +188,9 @@
|
|||
|
||||
## 二叉树基本操作
|
||||
|
||||
**初始化二叉树**。与链表类似，首先初始化节点，然后构建引用指向（即指针）。
|
||||
### 初始化二叉树
|
||||
|
||||
与链表类似，首先初始化节点，然后构建引用（指针）。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|
@ -370,7 +372,9 @@
|
|||
|
||||
```
|
||||
|
||||
**插入与删除节点**。与链表类似，通过修改指针来实现插入与删除节点。
|
||||
## 插入与删除节点
|
||||
|
||||
与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现。下图给出了一个示例。
|
||||
|
||||
|
||||
|
||||
|
|
@ -522,19 +526,19 @@
|
|||
|
||||
### 完全二叉树
|
||||
|
||||
「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。
|
||||
如下图所示，「完全二叉树 complete binary tree」只有最底层的节点未被填满，且最底层节点尽量靠左填充。
|
||||
|
||||
|
||||
|
||||
### 完满二叉树
|
||||
|
||||
「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。
|
||||
如下图所示，「完满二叉树 full binary tree」除了叶节点之外，其余所有节点都有两个子节点。
|
||||
|
||||
|
||||
|
||||
### 平衡二叉树
|
||||
|
||||
「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。
|
||||
如下图所示，「平衡二叉树 balanced binary tree」中任意节点的左子树和右子树的高度之差的绝对值不超过 1 。
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
## 层序遍历
|
||||
|
||||
「层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。
|
||||
如下图所示，「层序遍历 level-order traversal」从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。
|
||||
|
||||
层序遍历本质上属于「广度优先遍历 breadth-first traversal」，它体现了一种“一圈一圈向外扩展”的逐层遍历方式。
|
||||
|
||||
|
|
@ -94,12 +94,10 @@
|
|||
|
||||
相应地，前序、中序和后序遍历都属于「深度优先遍历 depth-first traversal」，它体现了一种“先走到尽头，再回溯继续”的遍历方式。
|
||||
|
||||
如下图所示，左侧是深度优先遍历的示意图，右上方是对应的递归代码。深度优先遍历就像是绕着整个二叉树的外围“走”一圈，在这个过程中，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
|
||||
下图展示了对二叉树进行深度优先遍历的工作原理。**深度优先遍历就像是绕着整个二叉树的外围“走”一圈**，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。
|
||||
|
||||
|
||||
|
||||
以下给出了实现代码，请配合上图理解深度优先遍历的递归过程。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_tree_dfs.java"
|
||||
|
|
@ -226,7 +224,7 @@
|
|||
|
||||
!!! note
|
||||
|
||||
我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行研究。
|
||||
我们也可以不使用递归，仅基于迭代实现前、中、后序遍历，有兴趣的同学可以自行实现。
|
||||
|
||||
下图展示了前序遍历二叉树的递归过程，其可分为“递”和“归”两个逆向的部分：
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue