Move docs/* to docs/zh/*
krahets
|
Before Width: | Height: | Size: 65 KiB |
|
Before Width: | Height: | Size: 65 KiB |
|
Before Width: | Height: | Size: 46 KiB |
|
Before Width: | Height: | Size: 52 KiB |
|
Before Width: | Height: | Size: 72 KiB |
|
Before Width: | Height: | Size: 54 KiB |
@ -1,83 +0,0 @@
|
||||
# 图
|
||||
|
||||
「图 graph」是一种非线性数据结构，由「顶点 vertex」和「边 edge」组成。我们可以将图 $G$ 抽象地表示为一组顶点 $V$ 和一组边 $E$ 的集合。以下示例展示了一个包含 5 个顶点和 7 条边的图。
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
V & = \{ 1, 2, 3, 4, 5 \} \newline
|
||||
E & = \{ (1,2), (1,3), (1,5), (2,3), (2,4), (2,5), (4,5) \} \newline
|
||||
G & = \{ V, E \} \newline
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
如果将顶点看作节点，将边看作连接各个节点的引用（指针），我们就可以将图看作是一种从链表拓展而来的数据结构。如下图所示，**相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高**，从而更为复杂。
|
||||
|
||||
|
||||
|
||||
## 图常见类型与术语
|
||||
|
||||
根据边是否具有方向，可分为下图所示的「无向图 undirected graph」和「有向图 directed graph」。
|
||||
|
||||
- 在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。
|
||||
- 在有向图中，边具有方向性，即 $A \rightarrow B$ 和 $A \leftarrow B$ 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系。
|
||||
|
||||
|
||||
|
||||
根据所有顶点是否连通，可分为下图所示的「连通图 connected graph」和「非连通图 disconnected graph」。
|
||||
|
||||
- 对于连通图，从某个顶点出发，可以到达其余任意顶点。
|
||||
- 对于非连通图，从某个顶点出发，至少有一个顶点无法到达。
|
||||
|
||||
|
||||
|
||||
我们还可以为边添加“权重”变量，从而得到下图所示的「有权图 weighted graph」。例如在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。
|
||||
|
||||
|
||||
|
||||
图数据结构包含以下常用术语。
|
||||
|
||||
- 「邻接 adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在上图中，顶点 1 的邻接顶点为顶点 2、3、5。
|
||||
- 「路径 path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在上图中，边序列 1-5-2-4 是顶点 1 到顶点 4 的一条路径。
|
||||
- 「度 degree」：一个顶点拥有的边数。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。
|
||||
|
||||
## 图的表示
|
||||
|
||||
图的常用表示方式包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。
|
||||
|
||||
### 邻接矩阵
|
||||
|
||||
设图的顶点数量为 $n$ ，「邻接矩阵 adjacency matrix」使用一个 $n \times n$ 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 $1$ 或 $0$ 表示两个顶点之间是否存在边。
|
||||
|
||||
如下图所示，设邻接矩阵为 $M$、顶点列表为 $V$ ，那么矩阵元素 $M[i, j] = 1$ 表示顶点 $V[i]$ 到顶点 $V[j]$ 之间存在边，反之 $M[i, j] = 0$ 表示两顶点之间无边。
|
||||
|
||||
|
||||
|
||||
邻接矩阵具有以下特性。
|
||||
|
||||
- 顶点不能与自身相连，因此邻接矩阵主对角线元素没有意义。
|
||||
- 对于无向图，两个方向的边等价，此时邻接矩阵关于主对角线对称。
|
||||
- 将邻接矩阵的元素从 $1$ 和 $0$ 替换为权重，则可表示有权图。
|
||||
|
||||
使用邻接矩阵表示图时，我们可以直接访问矩阵元素以获取边，因此增删查操作的效率很高，时间复杂度均为 $O(1)$ 。然而，矩阵的空间复杂度为 $O(n^2)$ ，内存占用较多。
|
||||
|
||||
### 邻接表
|
||||
|
||||
「邻接表 adjacency list」使用 $n$ 个链表来表示图，链表节点表示顶点。第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。下图展示了一个使用邻接表存储的图的示例。
|
||||
|
||||
|
||||
|
||||
邻接表仅存储实际存在的边，而边的总数通常远小于 $n^2$ ，因此它更加节省空间。然而，在邻接表中需要通过遍历链表来查找边，因此其时间效率不如邻接矩阵。
|
||||
|
||||
观察上图，**邻接表结构与哈希表中的“链式地址”非常相似，因此我们也可以采用类似方法来优化效率**。比如当链表较长时，可以将链表转化为 AVL 树或红黑树，从而将时间效率从 $O(n)$ 优化至 $O(\log n)$ ；还可以把链表转换为哈希表，从而将时间复杂度降低至 $O(1)$ 。
|
||||
|
||||
## 图常见应用
|
||||
|
||||
如下表所示，许多现实系统都可以用图来建模，相应的问题也可以约化为图计算问题。
|
||||
|
||||
<p align="center"> 表 <id> 现实生活中常见的图 </p>
|
||||
|
||||
| | 顶点 | 边 | 图计算问题 |
|
||||
| ------ | ---- | --------------- | ------------ |
|
||||
| 社交网络 | 用户 | 好友关系 | 潜在好友推荐 |
|
||||
| 地铁线路 | 站点 | 站点间的连通性 | 最短路线推荐 |
|
||||
| 太阳系 | 星体 | 星体间的万有引力作用 | 行星轨道计算 |
|
||||
|
Before Width: | Height: | Size: 70 KiB |
|
Before Width: | Height: | Size: 70 KiB |
|
Before Width: | Height: | Size: 66 KiB |
|
Before Width: | Height: | Size: 68 KiB |
|
Before Width: | Height: | Size: 64 KiB |
|
Before Width: | Height: | Size: 62 KiB |
|
Before Width: | Height: | Size: 70 KiB |
|
Before Width: | Height: | Size: 60 KiB |
|
Before Width: | Height: | Size: 63 KiB |
|
Before Width: | Height: | Size: 61 KiB |
@ -1,221 +0,0 @@
|
||||
# 图基础操作
|
||||
|
||||
图的基础操作可分为对“边”的操作和对“顶点”的操作。在“邻接矩阵”和“邻接表”两种表示方法下，实现方式有所不同。
|
||||
|
||||
## 基于邻接矩阵的实现
|
||||
|
||||
给定一个顶点数量为 $n$ 的无向图，则各种操作的实现方式如下图所示。
|
||||
|
||||
- **添加或删除边**：直接在邻接矩阵中修改指定的边即可，使用 $O(1)$ 时间。而由于是无向图，因此需要同时更新两个方向的边。
|
||||
- **添加顶点**：在邻接矩阵的尾部添加一行一列，并全部填 $0$ 即可，使用 $O(n)$ 时间。
|
||||
- **删除顶点**：在邻接矩阵中删除一行一列。当删除首行首列时达到最差情况，需要将 $(n-1)^2$ 个元素“向左上移动”，从而使用 $O(n^2)$ 时间。
|
||||
- **初始化**：传入 $n$ 个顶点，初始化长度为 $n$ 的顶点列表 `vertices` ，使用 $O(n)$ 时间；初始化 $n \times n$ 大小的邻接矩阵 `adjMat` ，使用 $O(n^2)$ 时间。
|
||||
|
||||
=== "初始化邻接矩阵"
|
||||
|
||||
|
||||
=== "添加边"
|
||||
|
||||
|
||||
=== "删除边"
|
||||
|
||||
|
||||
=== "添加顶点"
|
||||
|
||||
|
||||
=== "删除顶点"
|
||||
|
||||
|
||||
以下是基于邻接矩阵表示图的实现代码。
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="graph_adjacency_matrix.py"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="graph_adjacency_matrix.cpp"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="graph_adjacency_matrix.java"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="graph_adjacency_matrix.cs"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="graph_adjacency_matrix.go"
|
||||
[class]{graphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="graph_adjacency_matrix.swift"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="graph_adjacency_matrix.js"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="graph_adjacency_matrix.ts"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="graph_adjacency_matrix.dart"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="graph_adjacency_matrix.rs"
|
||||
[class]{GraphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="graph_adjacency_matrix.c"
|
||||
[class]{graphAdjMat}-[func]{}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="graph_adjacency_matrix.zig"
|
||||
|
||||
```
|
||||
|
||||
## 基于邻接表的实现
|
||||
|
||||
设无向图的顶点总数为 $n$、边总数为 $m$ ，则可根据下图所示的方法实现各种操作。
|
||||
|
||||
- **添加边**：在顶点对应链表的末尾添加边即可，使用 $O(1)$ 时间。因为是无向图，所以需要同时添加两个方向的边。
|
||||
- **删除边**：在顶点对应链表中查找并删除指定边，使用 $O(m)$ 时间。在无向图中，需要同时删除两个方向的边。
|
||||
- **添加顶点**：在邻接表中添加一个链表，并将新增顶点作为链表头节点，使用 $O(1)$ 时间。
|
||||
- **删除顶点**：需遍历整个邻接表，删除包含指定顶点的所有边，使用 $O(n + m)$ 时间。
|
||||
- **初始化**：在邻接表中创建 $n$ 个顶点和 $2m$ 条边，使用 $O(n + m)$ 时间。
|
||||
|
||||
=== "初始化邻接表"
|
||||
|
||||
|
||||
=== "添加边"
|
||||
|
||||
|
||||
=== "删除边"
|
||||
|
||||
|
||||
=== "添加顶点"
|
||||
|
||||
|
||||
=== "删除顶点"
|
||||
|
||||
|
||||
以下是基于邻接表实现图的代码示例。细心的同学可能注意到，**我们在邻接表中使用 `Vertex` 节点类来表示顶点**，而这样做是有原因的。
|
||||
|
||||
1. 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。
|
||||
2. 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。
|
||||
3. 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无须改动其余顶点了。
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="graph_adjacency_list.py"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="graph_adjacency_list.cpp"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="graph_adjacency_list.java"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="graph_adjacency_list.cs"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="graph_adjacency_list.go"
|
||||
[class]{graphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="graph_adjacency_list.swift"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="graph_adjacency_list.js"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="graph_adjacency_list.ts"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="graph_adjacency_list.dart"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="graph_adjacency_list.rs"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="graph_adjacency_list.c"
|
||||
[class]{graphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="graph_adjacency_list.zig"
|
||||
[class]{GraphAdjList}-[func]{}
|
||||
```
|
||||
|
||||
## 效率对比
|
||||
|
||||
设图中共有 $n$ 个顶点和 $m$ 条边，下表对比了邻接矩阵和邻接表的时间和空间效率。
|
||||
|
||||
<p align="center"> 表 <id> 邻接矩阵与邻接表对比 </p>
|
||||
|
||||
| | 邻接矩阵 | 邻接表（链表） | 邻接表（哈希表） |
|
||||
| ------------ | -------- | -------------- | ---------------- |
|
||||
| 判断是否邻接 | $O(1)$ | $O(m)$ | $O(1)$ |
|
||||
| 添加边 | $O(1)$ | $O(1)$ | $O(1)$ |
|
||||
| 删除边 | $O(1)$ | $O(m)$ | $O(1)$ |
|
||||
| 添加顶点 | $O(n)$ | $O(1)$ | $O(1)$ |
|
||||
| 删除顶点 | $O(n^2)$ | $O(n + m)$ | $O(n)$ |
|
||||
| 内存空间占用 | $O(n^2)$ | $O(n + m)$ | $O(n + m)$ |
|
||||
|
||||
观察上表，似乎邻接表（哈希表）的时间与空间效率最优。但实际上，在邻接矩阵中操作边的效率更高，只需要一次数组访问或赋值操作即可。综合来看，邻接矩阵体现了“以空间换时间”的原则，而邻接表体现了“以时间换空间”的原则。
|
||||
|
Before Width: | Height: | Size: 75 KiB |
|
Before Width: | Height: | Size: 66 KiB |
|
Before Width: | Height: | Size: 106 KiB |
|
Before Width: | Height: | Size: 85 KiB |
|
Before Width: | Height: | Size: 92 KiB |
|
Before Width: | Height: | Size: 97 KiB |
|
Before Width: | Height: | Size: 98 KiB |
|
Before Width: | Height: | Size: 104 KiB |
|
Before Width: | Height: | Size: 104 KiB |
|
Before Width: | Height: | Size: 104 KiB |
|
Before Width: | Height: | Size: 107 KiB |
|
Before Width: | Height: | Size: 107 KiB |
|
Before Width: | Height: | Size: 80 KiB |
|
Before Width: | Height: | Size: 56 KiB |
|
Before Width: | Height: | Size: 92 KiB |
|
Before Width: | Height: | Size: 104 KiB |
|
Before Width: | Height: | Size: 67 KiB |
|
Before Width: | Height: | Size: 70 KiB |
|
Before Width: | Height: | Size: 73 KiB |
|
Before Width: | Height: | Size: 74 KiB |
|
Before Width: | Height: | Size: 81 KiB |
|
Before Width: | Height: | Size: 79 KiB |
|
Before Width: | Height: | Size: 86 KiB |
|
Before Width: | Height: | Size: 101 KiB |
@ -1,296 +0,0 @@
|
||||
# 图的遍历
|
||||
|
||||
树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以把树看作是图的一种特例。显然，**树的遍历操作也是图的遍历操作的一种特例**。
|
||||
|
||||
图和树都需要应用搜索算法来实现遍历操作。图的遍历方式可分为两种：「广度优先遍历 breadth-first traversal」和「深度优先遍历 depth-first traversal」。它们也常被称为「广度优先搜索 breadth-first search」和「深度优先搜索 depth-first search」，简称 BFS 和 DFS 。
|
||||
|
||||
## 广度优先遍历
|
||||
|
||||
**广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外扩张**。如下图所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。
|
||||
|
||||
|
||||
|
||||
### 算法实现
|
||||
|
||||
BFS 通常借助队列来实现。队列具有“先入先出”的性质，这与 BFS 的“由近及远”的思想异曲同工。
|
||||
|
||||
1. 将遍历起始顶点 `startVet` 加入队列，并开启循环。
|
||||
2. 在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部。
|
||||
3. 循环步骤 `2.` ，直到所有顶点被访问完成后结束。
|
||||
|
||||
为了防止重复遍历顶点，我们需要借助一个哈希表 `visited` 来记录哪些节点已被访问。
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="graph_bfs.py"
|
||||
[class]{}-[func]{graph_bfs}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="graph_bfs.cpp"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="graph_bfs.java"
|
||||
[class]{graph_bfs}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="graph_bfs.cs"
|
||||
[class]{graph_bfs}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="graph_bfs.go"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="graph_bfs.swift"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="graph_bfs.js"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="graph_bfs.ts"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="graph_bfs.dart"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="graph_bfs.rs"
|
||||
[class]{}-[func]{graph_bfs}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="graph_bfs.c"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="graph_bfs.zig"
|
||||
[class]{}-[func]{graphBFS}
|
||||
```
|
||||
|
||||
代码相对抽象，建议对照下图来加深理解。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
=== "<2>"
|
||||
|
||||
|
||||
=== "<3>"
|
||||
|
||||
|
||||
=== "<4>"
|
||||
|
||||
|
||||
=== "<5>"
|
||||
|
||||
|
||||
=== "<6>"
|
||||
|
||||
|
||||
=== "<7>"
|
||||
|
||||
|
||||
=== "<8>"
|
||||
|
||||
|
||||
=== "<9>"
|
||||
|
||||
|
||||
=== "<10>"
|
||||
|
||||
|
||||
=== "<11>"
|
||||
|
||||
|
||||
!!! question "广度优先遍历的序列是否唯一？"
|
||||
|
||||
不唯一。广度优先遍历只要求按“由近及远”的顺序遍历，**而多个相同距离的顶点的遍历顺序是允许被任意打乱的**。以上图为例，顶点 $1$、$3$ 的访问顺序可以交换、顶点 $2$、$4$、$6$ 的访问顺序也可以任意交换。
|
||||
|
||||
### 复杂度分析
|
||||
|
||||
**时间复杂度：** 所有顶点都会入队并出队一次，使用 $O(|V|)$ 时间；在遍历邻接顶点的过程中，由于是无向图，因此所有边都会被访问 $2$ 次，使用 $O(2|E|)$ 时间；总体使用 $O(|V| + |E|)$ 时间。
|
||||
|
||||
**空间复杂度：** 列表 `res` ，哈希表 `visited` ，队列 `que` 中的顶点数量最多为 $|V|$ ，使用 $O(|V|)$ 空间。
|
||||
|
||||
## 深度优先遍历
|
||||
|
||||
**深度优先遍历是一种优先走到底、无路可走再回头的遍历方式**。如下图所示，从左上角顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。
|
||||
|
||||
|
||||
|
||||
### 算法实现
|
||||
|
||||
这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 `visited` 来记录已被访问的顶点，以避免重复访问顶点。
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="graph_dfs.py"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graph_dfs}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="graph_dfs.cpp"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="graph_dfs.java"
|
||||
[class]{graph_dfs}-[func]{dfs}
|
||||
|
||||
[class]{graph_dfs}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="graph_dfs.cs"
|
||||
[class]{graph_dfs}-[func]{dfs}
|
||||
|
||||
[class]{graph_dfs}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="graph_dfs.go"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="graph_dfs.swift"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="graph_dfs.js"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="graph_dfs.ts"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="graph_dfs.dart"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="graph_dfs.rs"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graph_dfs}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="graph_dfs.c"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="graph_dfs.zig"
|
||||
[class]{}-[func]{dfs}
|
||||
|
||||
[class]{}-[func]{graphDFS}
|
||||
```
|
||||
|
||||
深度优先遍历的算法流程如下图所示。
|
||||
|
||||
- **直虚线代表向下递推**，表示开启了一个新的递归方法来访问新顶点。
|
||||
- **曲虚线代表向上回溯**，表示此递归方法已经返回，回溯到了开启此递归方法的位置。
|
||||
|
||||
为了加深理解，建议将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
=== "<2>"
|
||||
|
||||
|
||||
=== "<3>"
|
||||
|
||||
|
||||
=== "<4>"
|
||||
|
||||
|
||||
=== "<5>"
|
||||
|
||||
|
||||
=== "<6>"
|
||||
|
||||
|
||||
=== "<7>"
|
||||
|
||||
|
||||
=== "<8>"
|
||||
|
||||
|
||||
=== "<9>"
|
||||
|
||||
|
||||
=== "<10>"
|
||||
|
||||
|
||||
=== "<11>"
|
||||
|
||||
|
||||
!!! question "深度优先遍历的序列是否唯一？"
|
||||
|
||||
与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探索都可以，即邻接顶点的顺序可以任意打乱，都是深度优先遍历。
|
||||
|
||||
以树的遍历为例，“根 $\rightarrow$ 左 $\rightarrow$ 右”、“左 $\rightarrow$ 根 $\rightarrow$ 右”、“左 $\rightarrow$ 右 $\rightarrow$ 根”分别对应前序、中序、后序遍历，它们展示了三种不同的遍历优先级，然而这三者都属于深度优先遍历。
|
||||
|
||||
### 复杂度分析
|
||||
|
||||
**时间复杂度：** 所有顶点都会被访问 $1$ 次，使用 $O(|V|)$ 时间；所有边都会被访问 $2$ 次，使用 $O(2|E|)$ 时间；总体使用 $O(|V| + |E|)$ 时间。
|
||||
|
||||
**空间复杂度：** 列表 `res` ，哈希表 `visited` 顶点数量最多为 $|V|$ ，递归深度最大为 $|V|$ ，因此使用 $O(|V|)$ 空间。
|
||||
@ -1,13 +0,0 @@
|
||||
# 图
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
{ width="600" }
|
||||
|
||||
</div>
|
||||
|
||||
!!! abstract
|
||||
|
||||
在生命旅途中，我们就像是每个节点，被无数看不见的边相连。
|
||||
|
||||
每一次的相识与相离，都在这张巨大的网络图中留下独特的印记。
|
||||
@ -1,30 +0,0 @@
|
||||
# 小结
|
||||
|
||||
### 重点回顾
|
||||
|
||||
- 图由顶点和边组成，可以被表示为一组顶点和一组边构成的集合。
|
||||
- 相较于线性关系（链表）和分治关系（树），网络关系（图）具有更高的自由度，因而更为复杂。
|
||||
- 有向图的边具有方向性，连通图中的任意顶点均可达，有权图的每条边都包含权重变量。
|
||||
- 邻接矩阵利用矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 $1$ 或 $0$ 表示两个顶点之间有边或无边。邻接矩阵在增删查操作上效率很高，但空间占用较多。
|
||||
- 邻接表使用多个链表来表示图，第 $i$ 条链表对应顶点 $i$ ，其中存储了该顶点的所有邻接顶点。邻接表相对于邻接矩阵更加节省空间，但由于需要遍历链表来查找边，时间效率较低。
|
||||
- 当邻接表中的链表过长时，可以将其转换为红黑树或哈希表，从而提升查询效率。
|
||||
- 从算法思想角度分析，邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”。
|
||||
- 图可用于建模各类现实系统，如社交网络、地铁线路等。
|
||||
- 树是图的一种特例，树的遍历也是图的遍历的一种特例。
|
||||
- 图的广度优先遍历是一种由近及远、层层扩张的搜索方式，通常借助队列实现。
|
||||
- 图的深度优先遍历是一种优先走到底、无路可走时再回溯的搜索方式，常基于递归来实现。
|
||||
|
||||
### Q & A
|
||||
|
||||
!!! question "路径的定义是顶点序列还是边序列？"
|
||||
|
||||
维基百科上不同语言版本的定义不一致：英文版是“路径是一个边序列”，而中文版是“路径是一个顶点序列”。以下是英文版原文：In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.
|
||||
在本文中，路径被认为是一个边序列，而不是一个顶点序列。这是因为两个顶点之间可能存在多条边连接，此时每条边都对应一条路径。
|
||||
|
||||
!!! question "非连通图中，是否会有无法遍历到的点？"
|
||||
|
||||
在非连通图中，从某个顶点出发，至少有一个顶点无法到达。遍历非连通图需要设置多个起点，以遍历到图的所有连通分量。
|
||||
|
||||
!!! question "在邻接表中，“与该顶点相连的所有顶点”的顶点顺序是否有要求？"
|
||||
|
||||
可以是任意顺序。但在实际应用中，可能会需要按照指定规则来排序，比如按照顶点添加的次序、或者按照顶点值大小的顺序等等，这样可以有助于快速查找“带有某种极值”的顶点。
|
||||