概念
「图 graph」是一种非线性数据结构，由「顶点 vertex」和「边 edge」组成。我们可以将图𝐺 抽象地表示为一组顶点 𝑉 和一组边 𝐸 的集合。以下示例展示了一个包含 5 个顶点和 7 条边的图。𝑉 = {1, 2, 3, 4, 5}𝐸 = {(1, 2), (1, 3), (1, 5), (2, 3), (2, 4), (2, 5), (4, 5)}𝐺 = {𝑉 , 𝐸}如果将顶点看作节点，将边看作连接各个节点的引用（指针），我们就可以将图看作是一种从链表拓展而来的数据结构。如下图所示， 相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高 ，从而更为复杂。
图常见类型与术语
1.类型
根据边是否具有方向，可分为下图所示的「无向图 undirected graph」和「有向图 directed graph」。‧ 在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”。‧ 在有向图中，边具有方向性，即𝐴 → 𝐵 和 𝐴 ← 𝐵 两个方向的边是相互独立的，例如微博或抖音上 的“关注”与“被关注”关系。
根据所有顶点是否连通，可分为下图所示的「连通图 connected graph」和「非连通图 disconnectedgraph」。‧ 对于连通图，从某个顶点出发，可以到达其余任意顶点。‧ 对于非连通图，从某个顶点出发，至少有一个顶点无法到达。
我们还可以为边添加“权重”变量，从而得到下图所示的「有权图 weighted graph」。例如在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。
2.常见术语
图数据结构包含以下常用术语。‧「邻接 adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在上图中，顶点 1 的邻接顶点为顶点 2、3、5。‧「路径 path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在上图 中，边序列 1‑5‑2‑4 是顶点 1 到顶点 4 的一条路径。‧「度 degree」：一个顶点拥有的边数。对于有向图，「入度 In‑Degree」表示有多少条边指向该顶点，「出度 Out‑Degree」表示有多少条边从该顶点指出。
3.图的表示
图的常用表示方式包括“邻接矩阵”和“邻接表”。以下使用无向图进行举例。
1. 邻接矩阵
设图的顶点数量为
𝑛
，「邻接矩阵 adjacency matrix」使用一个 𝑛 × 𝑛 大小的矩阵来表示图，每一行（列） 代表一个顶点，矩阵元素代表边，用1 或
0
表示两个顶点之间是否存在边。
如下图所示，设邻接矩阵为
𝑀、顶点列表为 𝑉 ，那么矩阵元素 𝑀[𝑖, 𝑗] = 1 表示顶点 𝑉 [𝑖]
到顶点
𝑉 [𝑗]之间存在边，反之M[i,j]=0表示两顶点之间不存在边
邻接矩阵具有以下特性。
‧ 顶点不能与自身相连，因此邻接矩阵主对角线元素没有意义
。
‧ 对于无向图，两个方向的边等价，此时邻接矩阵关于主对角线对称。
‧ 将邻接矩阵的元素从1 和
0
替换为权重，则可表示有权图。
使用邻接矩阵表示图时，我们可以直接访问矩阵元素以获取边，因此增删查操作的效率很高，时间复杂度均 为 𝑂(1)
。然而，矩阵的空间复杂度为
𝑂(𝑛
2
)
，内存占用较多。
2. 邻接表
「邻接表 adjacency list」使用
𝑛
个链表来表示图，链表节点表示顶点。第
𝑖
条链表对应顶点
𝑖
，其中存储了
该顶点的所有邻接顶点（即与该顶点相连的顶点）。图 9‑6 展示了一个使用邻接表存储的图的示例。
4.图的常见应用
|
顶点
|
边
|
图计算问题
| |
|
社交网络
|
用户
|
好友关系
|
潜在好友推荐
|
|
地铁线路
|
站点
|
站点间的连通性
|
最短路线推荐
|
|
太阳系
|
星体
|
星体间的万有引力作用
|
行星轨道计算
|
5.图基础操作
图的基础操作可分为对“边”的操作和对“顶点”的操作。在“邻接矩阵”和“邻接表”两种表示方法下，实
现方式有所不同。
5.1基于邻接矩阵的实现
给定一个顶点数量为
𝑛 的无向图，则各种操作的实现方式如下图所示。
‧
添加或删除边
：直接在邻接矩阵中修改指定的边即可，使用
𝑂(1)
时间。而由于是无向图，因此需要同
时更新两个方向的边。
‧
添加顶点
：在邻接矩阵的尾部添加一行一列，并全部填
0
即可，使用
𝑂(𝑛)
时间。
‧
删除顶点
：在邻接矩阵中删除一行一列。当删除首行首列时达到最差情况，需要将
(𝑛 − 1)
2
个元素
“向左上移动”，从而使用
𝑂(𝑛
2
)
时间。
‧
初始化
：传入
𝑛
个顶点，初始化长度为
𝑛
的顶点列表
vertices
，使用
𝑂(𝑛)
时间；初始化
𝑛 × 𝑛
大
小的邻接矩阵
adjMat
，使用
𝑂(𝑛
2
)
时间。
package com.syctest.test1.test.model;
import java.util.ArrayList;
import java.util.List;
public class GraphAdjMat {
List<Integer> vertices; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
List<List<Integer>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”
/* 构造方法 */
public GraphAdjMat(int[] vertices, int[][] edges) {
this.vertices = new ArrayList<>();
this.adjMat = new ArrayList<>();
// 添加顶点
for (int val : vertices) {
addVertex(val);
}
// 添加边
// 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
//假设有五个顶点，顺序为：13254，此时edges二维数组长这样：
// int[][] edges = {
// {0, 2}, // 1连接2
// {0, 3}, // 1连接5
// {3, 2}, // 5连接2
// {4, 2}, // 4连接2
// {2, 1}, // 2连接3
// {2, 0}, // 2连接1
// {2, 3}, // 2连接5
// {2, 4}, // 2连接4
// {1, 2} // 3连接2
// };
for (int[] e : edges) {
addEdge(e[0], e[1]);
}
}
/* 获取顶点数量 */
public int size() {
return vertices.size();
}
/* 添加顶点 */
//创建出这样一个邻接矩阵
// [0, 0, 0]
// [0, 0, 0]
// [0, 0, 0]
public void addVertex(int val) {
int n = size();
// 向顶点列表中添加新顶点的值
vertices.add(val);
// 在邻接矩阵中添加一行
List<Integer> newRow = new ArrayList<>(n);//创建初始容量为1的集合
for (int j = 0; j < n; j++) {
newRow.add(0);
}
//邻接矩阵添加一行
adjMat.add(newRow);
// 在邻接矩阵中添加一列
for (List<Integer> row : adjMat) {
row.add(0);
}
}
/* 删除顶点 */
public void removeVertex(int index) {
if (index >= size())
throw new IndexOutOfBoundsException();
// 在顶点列表中移除索引 index 的顶点
vertices.remove(index);
// 在邻接矩阵中删除索引 index 的行
adjMat.remove(index);
// 在邻接矩阵中删除索引 index 的列
for (List<Integer> row : adjMat) {
row.remove(index);
}
}
/* 添加边 */
// 参数 i, j 对应 vertices 元素索引
public void addEdge(int i, int j) {
// 索引越界与相等处理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
throw new IndexOutOfBoundsException();
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)，也就是顶点自己不可能跟顶点自己连接
adjMat.get(i).set(j, 1);
adjMat.get(j).set(i, 1);
}
/* 删除边 */
// 参数 i, j 对应 vertices 元素索引
public void removeEdge(int i, int j) {
// 索引越界与相等处理
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
throw new IndexOutOfBoundsException();
adjMat.get(i).set(j, 0);
adjMat.get(j).set(i, 0);
}
/* 打印邻接矩阵 */
public void print() {
System.out.print(" 顶点列表 = ");
System.out.println(vertices);
System.out.println(" 邻接矩阵 =");
// PrintUtil.printMatrix(adjMat);
}
}
5.2基于邻接表的实现
设无向图的顶点总数为
𝑛
、边总数为
𝑚 ，则可根据下图所示的方法实现各种操作。
‧
添加边
：在顶点对应链表的末尾添加边即可，使用
𝑂(1)
时间。因为是无向图，所以需要同时添加两个 方向的边。
‧
删除边
：在顶点对应链表中查找并删除指定边，使用
𝑂(𝑚)
时间。在无向图中，需要同时删除两个方 向的边。
‧
添加顶点
：在邻接表中添加一个链表，并将新增顶点作为链表头节点，使用
𝑂(1)
时间。
‧
删除顶点
：需遍历整个邻接表，删除包含指定顶点的所有边，使用
𝑂(𝑛 + 𝑚)
时间。
‧
初始化
：在邻接表中创建
𝑛
个顶点和
2𝑚
条边，使用
𝑂(𝑛 + 𝑚)
时间。
以下是邻接表的代码实现。
‧ 为了方便添加与删除顶点，以及简化代码，我们使用列表（动态数组）来代替链表。
‧ 使用哈希表来存储邻接表，
key
为顶点实例，
value
为该顶点的邻接顶点列表（链表）。
另外，我们在邻接表中使用
Vertex
类来表示顶点，这样做的原因是：如果与邻接矩阵一样，用列表索引来区 分不同顶点，那么假设要删除索引为 𝑖
的顶点，则需遍历整个邻接表，将所有大于
𝑖
的索引全部减
1
，效率 很低。而如果每个顶点都是唯一的 Vertex
实例，删除某一顶点之后就无须改动其他顶点了
package com.syctest.test1.test.model;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class GraphAdjList {
// 邻接表，key: 顶点，value：该顶点的所有邻接顶点
Map<Vertex, List<Vertex>> adjList;
/* 构造方法 */
public GraphAdjList(Vertex[][] edges) {
this.adjList = new HashMap<>();
// 添加所有顶点和边
for (Vertex[] edge : edges) {
addVertex(edge[0]);
addVertex(edge[1]);
addEdge(edge[0], edge[1]);
}
}
/* 获取顶点数量 */
public int size() {
return adjList.size();
}
/* 添加边 */
public void addEdge(Vertex vet1, Vertex vet2) {
if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
throw new IllegalArgumentException();
// 添加边 vet1 - vet2
adjList.get(vet1).add(vet2);
adjList.get(vet2).add(vet1);
}
/* 删除边 */
public void removeEdge(Vertex vet1, Vertex vet2) {
if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
throw new IllegalArgumentException();
// 删除边 vet1 - vet2
adjList.get(vet1).remove(vet2);
adjList.get(vet2).remove(vet1);
}
/* 添加顶点 */
public void addVertex(Vertex vet) {
if (adjList.containsKey(vet))
return;
// 在邻接表中添加一个新链表
adjList.put(vet, new ArrayList<>());
}
/* 删除顶点 */
public void removeVertex(Vertex vet) {
if (!adjList.containsKey(vet))
throw new IllegalArgumentException();
// 在邻接表中删除顶点 vet 对应的链表
adjList.remove(vet);
// 遍历其他顶点的链表，删除所有包含 vet 的边
for (List<Vertex> list : adjList.values()) {
list.remove(vet);
}
}
/* 打印邻接表 */
public void print() {
System.out.println(" 邻接表 =");
for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {
List<Integer> tmp = new ArrayList<>();
for (Vertex vertex : pair.getValue())
tmp.add(vertex.val);
System.out.println(pair.getKey().val + ": " + tmp + ",");
}
}
}
package com.syctest.test1.test.model;
public class Vertex {
int val;
public Vertex(int val) {
this.val = val;
}
}
5.3效率对比
6.图的遍历
树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以 把树看作是图的一种特例。显然，树的遍历操作也是图的遍历操作的一种特例
。
图和树都需要应用搜索算法来实现遍历操作。图的遍历方式可分为两种：「广度优先遍历 breadth‑first traversal」和「深度优先遍历 depth‑first traversal」。它们也常被称为「广度优先搜索 breadth‑first search」 和「深度优先搜索 depth‑first search」，简称 BFS 和 DFS 。
6.1广度优先遍历
广度优先遍历是一种由近及远的遍历方式，从某个节点出发，始终优先访问距离最近的顶点，并一层层向外
扩张
。如下图所示，从左上角顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接 顶点，以此类推，直至所有顶点访问完毕。
1. 算法实现
BFS 通常借助队列来实现。队列具有“先入先出”的性质，这与 BFS 的“由近及远”的思想异曲同工。
1. 将遍历起始顶点
startVet
加入队列，并开启循环。
2. 在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部。
3. 循环步骤
2.
，直到所有顶点被访问完成后结束。
为了防止重复遍历顶点，我们需要借助一个哈希表
visited
来记录哪些节点已被访问。
List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
// 顶点遍历序列
List<Vertex> res = new ArrayList<>();
// 哈希表，用于记录已被访问过的顶点
Set<Vertex> visited = new HashSet<>();
visited.add(startVet);
// 队列用于实现 BFS
Queue<Vertex> que = new LinkedList<>();
que.offer(startVet);
// 以顶点 vet 为起点，循环直至访问完所有顶点
while (!que.isEmpty()) {
Vertex vet = que.poll(); // 队首顶点出队
res.add(vet); // 记录访问顶点
// 遍历该顶点的所有邻接顶点
for (Vertex adjVet : graph.adjList.get(vet)) {
if (visited.contains(adjVet))
continue; // 跳过已被访问过的顶点
que.offer(adjVet); // 只入队未访问的顶点
visited.add(adjVet); // 标记该顶点已被访问
}
}
// 返回顶点遍历序列
return res;
}
代码相对抽象，建议对照下图来加深理解。
Q
广度优先遍历的序列是否唯一？不唯一。广度优先遍历只要求按“由近及远”的顺序遍历， 而多个相同距离的顶点的遍历顺序是允许被任意打乱的 。以图 9‑10 为例，顶点 1 、 3 的访问顺序可以交换、顶点 2 、 4 、 6 的访问顺序也可以任意交换。
6.2. 复杂度分析
时间复杂度：
所有顶点都会入队并出队一次，使用
𝑂(|𝑉 |)
时间；在遍历邻接顶点的过程中，由于是无向图，
因此所有边都会被访问
2
次，使用
𝑂(2|𝐸|)
时间；总体使用
𝑂(|𝑉 | + |𝐸|)
时间。
空间复杂度：
列表
res
，哈希表
visited
，队列
que
中的顶点数量最多为
|𝑉 |
，使用
𝑂(|𝑉 |)
空间。
6.3深度优先遍历
深度优先遍历是一种优先走到底、无路可走再回头的遍历方式
。如图 9‑11 所示，从左上角顶点出发，访问 当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。
1. 算法实现
这种“走到尽头再返回”的算法范式通常基于递归来实现。与广度优先遍历类似，在深度优先遍历中我们也需要借助一个哈希表 visited
来记录已被访问的顶点，以避免重复访问顶点。
/* 深度优先遍历 DFS 辅助函数 */
void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
res.add(vet); // 记录访问顶点
visited.add(vet); // 标记该顶点已被访问
// 遍历该顶点的所有邻接顶点
for (Vertex adjVet : graph.adjList.get(vet)) {
if (visited.contains(adjVet))
continue; // 跳过已被访问过的顶点
// 递归访问邻接顶点
dfs(graph, visited, res, adjVet);
}
}
/* 深度优先遍历 DFS */
// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
// 顶点遍历序列
List<Vertex> res = new ArrayList<>();
// 哈希表，用于记录已被访问过的顶点
Set<Vertex> visited = new HashSet<>();
dfs(graph, visited, res, startVet);
return res;
}
深度优先遍历的算法流程如图所示。
‧
直虚线代表向下递推
，表示开启了一个新的递归方法来访问新顶点。
‧
曲虚线代表向上回溯
，表示此递归方法已经返回，回溯到了开启此递归方法的位置。
为了加深理解，建议将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。
Q
深度优先遍历的序列是否唯一？与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探 索都可以，即邻接顶点的顺序可以任意打乱，都是深度优先遍历。以树的遍历为例，“根 → 左 → 右”、“左 → 根 → 右”、“左 → 右 → 根”分别对应前序、中序、后序遍历，它们展示了三种不同的遍历优先级，然而这三者都属于深度优先遍历。
2. 复杂度分析
时间复杂度：
所有顶点都会被访问
1
次，使用
𝑂(|𝑉 |)
时间；所有边都会被访问
2
次，使用
𝑂(2|𝐸|)
时间； 总体使用 𝑂(|𝑉 | + |𝐸|)
时间。
空间复杂度：
列表
res
，哈希表
visited
顶点数量最多为
|𝑉 |
，递归深度最大为
|𝑉 |
，因此使用
𝑂(|𝑉 |)
空 间。
扫一扫
1029
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
