mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-27 14:56:29 +08:00
93ca29ca6d
* feat(graph): add go codes * feat(go/graph): add graph_adjacency_list * doc(graph): add go codes * fix(graph): fix go codes * Update graph_adjacency_matrix_test.go --------- Co-authored-by: Yudong Jin <krahets@163.com>
662 lines
20 KiB
Markdown
662 lines
20 KiB
Markdown
---
|
||
comments: true
|
||
---
|
||
|
||
# 9.2. 图基础操作
|
||
|
||
图的基础操作分为对「边」的操作和对「顶点」的操作，在「邻接矩阵」和「邻接表」这两种表示下的实现方式不同。
|
||
|
||
## 9.2.1. 基于邻接矩阵的实现
|
||
|
||
设图的顶点总数为 $n$ ，则有：
|
||
|
||
- **添加或删除边**：直接在邻接矩阵中修改指定边的对应元素即可，使用 $O(1)$ 时间。而由于是无向图，因此需要同时更新两个方向的边。
|
||
- **添加顶点**：在邻接矩阵的尾部添加一行一列，并全部填 $0$ 即可，使用 $O(n)$ 时间。
|
||
- **删除顶点**：在邻接矩阵中删除一行一列。当删除首行首列时达到最差情况，需要将 $(n-1)^2$ 个元素“向左上移动”，从而使用 $O(n^2)$ 时间。
|
||
- **初始化**：传入 $n$ 个顶点，初始化长度为 $n$ 的顶点列表 `vertices` ，使用 $O(n)$ 时间；初始化 $n \times n$ 大小的邻接矩阵 `adjMat` ，使用 $O(n^2)$ 时间。
|
||
|
||
=== "初始化邻接矩阵"
|
||
|
||
|
||
=== "添加边"
|
||
|
||
|
||
=== "删除边"
|
||
|
||
|
||
=== "添加顶点"
|
||
|
||
|
||
=== "删除顶点"
|
||
|
||
|
||
以下是基于邻接矩阵表示图的实现代码。
|
||
|
||
=== "Java"
|
||
|
||
```java title="graph_adjacency_matrix.java"
|
||
/* 基于邻接矩阵实现的无向图类 */
|
||
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 元素索引
|
||
for (int[] e : edges) {
|
||
addEdge(e[0], e[1]);
|
||
}
|
||
}
|
||
|
||
/* 获取顶点数量 */
|
||
public int size() {
|
||
return vertices.size();
|
||
}
|
||
|
||
/* 添加顶点 */
|
||
public void addVertex(int val) {
|
||
int n = size();
|
||
// 向顶点列表中添加新顶点的值
|
||
vertices.add(val);
|
||
// 在邻接矩阵中添加一行
|
||
List<Integer> newRow = new ArrayList<>(n);
|
||
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);
|
||
}
|
||
}
|
||
```
|
||
|
||
=== "C++"
|
||
|
||
```cpp title="graph_adjacency_matrix.cpp"
|
||
|
||
```
|
||
|
||
=== "Python"
|
||
|
||
```python title="graph_adjacency_matrix.py"
|
||
|
||
```
|
||
|
||
=== "Go"
|
||
|
||
```go title="graph_adjacency_matrix.go"
|
||
/* 基于邻接矩阵实现的无向图类 */
|
||
type graphAdjMat struct {
|
||
// 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
|
||
vertices []int
|
||
// 邻接矩阵，行列索引对应“顶点索引”
|
||
adjMat [][]int
|
||
}
|
||
|
||
func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
|
||
// 添加顶点
|
||
n := len(vertices)
|
||
adjMat := make([][]int, n)
|
||
for i := range adjMat {
|
||
adjMat[i] = make([]int, n)
|
||
}
|
||
// 初始化图
|
||
g := &graphAdjMat{
|
||
vertices: vertices,
|
||
adjMat: adjMat,
|
||
}
|
||
// 添加边
|
||
// 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
|
||
for i := range edges {
|
||
g.addEdge(edges[i][0], edges[i][1])
|
||
}
|
||
return g
|
||
}
|
||
|
||
/* 获取顶点数量 */
|
||
func (g *graphAdjMat) size() int {
|
||
return len(g.vertices)
|
||
}
|
||
|
||
/* 添加顶点 */
|
||
func (g *graphAdjMat) addVertex(val int) {
|
||
n := g.size()
|
||
// 向顶点列表中添加新顶点的值
|
||
g.vertices = append(g.vertices, val)
|
||
// 在邻接矩阵中添加一行
|
||
newRow := make([]int, n)
|
||
g.adjMat = append(g.adjMat, newRow)
|
||
// 在邻接矩阵中添加一列
|
||
for i := range g.adjMat {
|
||
g.adjMat[i] = append(g.adjMat[i], 0)
|
||
}
|
||
}
|
||
|
||
/* 删除顶点 */
|
||
func (g *graphAdjMat) removeVertex(index int) {
|
||
if index >= g.size() {
|
||
return
|
||
}
|
||
// 在顶点列表中移除索引 index 的顶点
|
||
g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
|
||
// 在邻接矩阵中删除索引 index 的行
|
||
g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
|
||
// 在邻接矩阵中删除索引 index 的列
|
||
for i := range g.adjMat {
|
||
g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
|
||
}
|
||
}
|
||
|
||
/* 添加边 */
|
||
// 参数 i, j 对应 vertices 元素索引
|
||
func (g *graphAdjMat) addEdge(i, j int) {
|
||
// 索引越界与相等处理
|
||
if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
|
||
fmt.Errorf("%s", "Index Out Of Bounds Exception")
|
||
}
|
||
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
|
||
g.adjMat[i][j] = 1
|
||
g.adjMat[j][i] = 1
|
||
}
|
||
|
||
/* 删除边 */
|
||
// 参数 i, j 对应 vertices 元素索引
|
||
func (g *graphAdjMat) removeEdge(i, j int) {
|
||
// 索引越界与相等处理
|
||
if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
|
||
fmt.Errorf("%s", "Index Out Of Bounds Exception")
|
||
}
|
||
g.adjMat[i][j] = 0
|
||
g.adjMat[j][i] = 0
|
||
}
|
||
```
|
||
|
||
=== "JavaScript"
|
||
|
||
```js title="graph_adjacency_matrix.js"
|
||
|
||
```
|
||
|
||
=== "TypeScript"
|
||
|
||
```typescript title="graph_adjacency_matrix.ts"
|
||
|
||
```
|
||
|
||
=== "C"
|
||
|
||
```c title="graph_adjacency_matrix.c"
|
||
|
||
```
|
||
|
||
=== "C#"
|
||
|
||
```csharp title="graph_adjacency_matrix.cs"
|
||
|
||
```
|
||
|
||
=== "Swift"
|
||
|
||
```swift title="graph_adjacency_matrix.swift"
|
||
/* 基于邻接矩阵实现的无向图类 */
|
||
class GraphAdjMat {
|
||
private var vertices: [Int] // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
|
||
private var adjMat: [[Int]] // 邻接矩阵，行列索引对应“顶点索引”
|
||
|
||
/* 构造函数 */
|
||
init(vertices: [Int], edges: [[Int]]) {
|
||
self.vertices = []
|
||
adjMat = []
|
||
// 添加顶点
|
||
for val in vertices {
|
||
addVertex(val: val)
|
||
}
|
||
// 添加边
|
||
// 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
|
||
for e in edges {
|
||
addEdge(i: e[0], j: e[1])
|
||
}
|
||
}
|
||
|
||
/* 获取顶点数量 */
|
||
func size() -> Int {
|
||
vertices.count
|
||
}
|
||
|
||
/* 添加顶点 */
|
||
func addVertex(val: Int) {
|
||
let n = size()
|
||
// 向顶点列表中添加新顶点的值
|
||
vertices.append(val)
|
||
// 在邻接矩阵中添加一行
|
||
let newRow = Array(repeating: 0, count: n)
|
||
adjMat.append(newRow)
|
||
// 在邻接矩阵中添加一列
|
||
for i in adjMat.indices {
|
||
adjMat[i].append(0)
|
||
}
|
||
}
|
||
|
||
/* 删除顶点 */
|
||
func removeVertex(index: Int) {
|
||
if index >= size() {
|
||
fatalError("越界")
|
||
}
|
||
// 在顶点列表中移除索引 index 的顶点
|
||
vertices.remove(at: index)
|
||
// 在邻接矩阵中删除索引 index 的行
|
||
adjMat.remove(at: index)
|
||
// 在邻接矩阵中删除索引 index 的列
|
||
for i in adjMat.indices {
|
||
adjMat[i].remove(at: index)
|
||
}
|
||
}
|
||
|
||
/* 添加边 */
|
||
// 参数 i, j 对应 vertices 元素索引
|
||
func addEdge(i: Int, j: Int) {
|
||
// 索引越界与相等处理
|
||
if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
|
||
fatalError("越界")
|
||
}
|
||
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
|
||
adjMat[i][j] = 1
|
||
adjMat[j][i] = 1
|
||
}
|
||
|
||
/* 删除边 */
|
||
// 参数 i, j 对应 vertices 元素索引
|
||
func removeEdge(i: Int, j: Int) {
|
||
// 索引越界与相等处理
|
||
if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
|
||
fatalError("越界")
|
||
}
|
||
adjMat[i][j] = 0
|
||
adjMat[j][i] = 0
|
||
}
|
||
}
|
||
```
|
||
|
||
=== "Zig"
|
||
|
||
```zig title="graph_adjacency_matrix.zig"
|
||
|
||
```
|
||
|
||
## 9.2.2. 基于邻接表的实现
|
||
|
||
设图的顶点总数为 $n$ 、边总数为 $m$ ，则有：
|
||
|
||
- **添加边**：在顶点对应链表的尾部添加边即可，使用 $O(1)$ 时间。因为是无向图，所以需要同时添加两个方向的边。
|
||
- **删除边**：在顶点对应链表中查询与删除指定边，使用 $O(m)$ 时间。与添加边一样，需要同时删除两个方向的边。
|
||
- **添加顶点**：在邻接表中添加一个链表即可，并以新增顶点为链表头结点，使用 $O(1)$ 时间。
|
||
- **删除顶点**：需要遍历整个邻接表，删除包含指定顶点的所有边，使用 $O(n + m)$ 时间。
|
||
- **初始化**：需要在邻接表中建立 $n$ 个结点和 $2m$ 条边，使用 $O(n + m)$ 时间。
|
||
|
||
=== "初始化邻接表"
|
||
|
||
|
||
=== "添加边"
|
||
|
||
|
||
=== "删除边"
|
||
|
||
|
||
=== "添加顶点"
|
||
|
||
|
||
=== "删除顶点"
|
||
|
||
|
||
基于邻接表实现图的代码如下所示。
|
||
|
||
=== "Java"
|
||
|
||
```java title="graph_adjacency_list.java"
|
||
/* 顶点类 */
|
||
class Vertex {
|
||
int val;
|
||
public Vertex(int val) {
|
||
this.val = val;
|
||
}
|
||
}
|
||
|
||
/* 基于邻接表实现的无向图类 */
|
||
class GraphAdjList {
|
||
// 请注意，vertices 和 adjList 中存储的都是 Vertex 对象
|
||
Map<Vertex, Set<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;
|
||
// 在邻接表中添加一个新链表（即 HashSet）
|
||
adjList.put(vet, new HashSet<>());
|
||
}
|
||
|
||
/* 删除顶点 */
|
||
public void removeVertex(Vertex vet) {
|
||
if (!adjList.containsKey(vet))
|
||
throw new IllegalArgumentException();
|
||
// 在邻接表中删除顶点 vet 对应的链表（即 HashSet）
|
||
adjList.remove(vet);
|
||
// 遍历其它顶点的链表（即 HashSet），删除所有包含 vet 的边
|
||
for (Set<Vertex> set : adjList.values()) {
|
||
set.remove(vet);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
=== "C++"
|
||
|
||
```cpp title="graph_adjacency_list.cpp"
|
||
|
||
```
|
||
|
||
=== "Python"
|
||
|
||
```python title="graph_adjacency_list.py"
|
||
|
||
```
|
||
|
||
=== "Go"
|
||
|
||
```go title="graph_adjacency_list.go"
|
||
/* 顶点类 */
|
||
type vertex struct {
|
||
val int
|
||
}
|
||
|
||
func newVertex(val int) vertex {
|
||
return vertex{
|
||
val: val,
|
||
}
|
||
}
|
||
|
||
/* 基于邻接表实现的无向图类 */
|
||
type graphAdjList struct {
|
||
// 请注意，vertices 和 adjList 中存储的都是 Vertex 对象
|
||
// 邻接表（使用哈希表实现）, 使用哈希表模拟集合
|
||
adjList map[vertex]map[vertex]struct{}
|
||
}
|
||
|
||
/* 构造函数 */
|
||
func newGraphAdjList(edges [][]vertex) *graphAdjList {
|
||
g := &graphAdjList{
|
||
adjList: make(map[vertex]map[vertex]struct{}),
|
||
}
|
||
// 添加所有顶点和边
|
||
for _, edge := range edges {
|
||
g.addVertex(edge[0])
|
||
g.addVertex(edge[1])
|
||
g.addEdge(edge[0], edge[1])
|
||
}
|
||
return g
|
||
}
|
||
|
||
/* 获取顶点数量 */
|
||
func (g *graphAdjList) size() int {
|
||
return len(g.adjList)
|
||
}
|
||
|
||
/* 添加边 */
|
||
func (g *graphAdjList) addEdge(vet1 vertex, vet2 vertex) {
|
||
_, ok1 := g.adjList[vet1]
|
||
_, ok2 := g.adjList[vet2]
|
||
if !ok1 || !ok2 || vet1 == vet2 {
|
||
panic("error")
|
||
}
|
||
// 添加边 vet1 - vet2, 添加匿名 struct{},
|
||
g.adjList[vet1][vet2] = struct{}{}
|
||
g.adjList[vet2][vet1] = struct{}{}
|
||
}
|
||
|
||
/* 删除边 */
|
||
func (g *graphAdjList) removeEdge(vet1 vertex, vet2 vertex) {
|
||
_, ok1 := g.adjList[vet1]
|
||
_, ok2 := g.adjList[vet2]
|
||
if !ok1 || !ok2 || vet1 == vet2 {
|
||
panic("error")
|
||
}
|
||
// 删除边 vet1 - vet2, 借助 delete 来删除 map 中的键
|
||
delete(g.adjList[vet1], vet2)
|
||
delete(g.adjList[vet2], vet1)
|
||
}
|
||
|
||
/* 添加顶点 */
|
||
func (g *graphAdjList) addVertex(vet vertex) {
|
||
_, ok := g.adjList[vet]
|
||
if ok {
|
||
return
|
||
}
|
||
// 在邻接表中添加一个新链表（即 set）
|
||
g.adjList[vet] = make(map[vertex]struct{})
|
||
}
|
||
|
||
/* 删除顶点 */
|
||
func (g *graphAdjList) removeVertex(vet vertex) {
|
||
_, ok := g.adjList[vet]
|
||
if !ok {
|
||
panic("error")
|
||
}
|
||
// 在邻接表中删除顶点 vet 对应的链表
|
||
delete(g.adjList, vet)
|
||
// 遍历其它顶点的链表（即 Set），删除所有包含 vet 的边
|
||
for _, set := range g.adjList {
|
||
// 操作
|
||
delete(set, vet)
|
||
}
|
||
}
|
||
```
|
||
|
||
=== "JavaScript"
|
||
|
||
```js title="graph_adjacency_list.js"
|
||
|
||
```
|
||
|
||
=== "TypeScript"
|
||
|
||
```typescript title="graph_adjacency_list.ts"
|
||
|
||
```
|
||
|
||
=== "C"
|
||
|
||
```c title="graph_adjacency_list.c"
|
||
|
||
```
|
||
|
||
=== "C#"
|
||
|
||
```csharp title="graph_adjacency_list.cs"
|
||
|
||
```
|
||
|
||
=== "Swift"
|
||
|
||
```swift title="graph_adjacency_list.swift"
|
||
/* 顶点类 */
|
||
class Vertex: Hashable {
|
||
var val: Int
|
||
|
||
init(val: Int) {
|
||
self.val = val
|
||
}
|
||
|
||
static func == (lhs: Vertex, rhs: Vertex) -> Bool {
|
||
lhs.val == rhs.val
|
||
}
|
||
|
||
func hash(into hasher: inout Hasher) {
|
||
hasher.combine(val)
|
||
}
|
||
}
|
||
|
||
/* 基于邻接表实现的无向图类 */
|
||
class GraphAdjList {
|
||
// 请注意，vertices 和 adjList 中存储的都是 Vertex 对象
|
||
private var adjList: [Vertex: Set<Vertex>] // 邻接表（使用哈希表实现）
|
||
|
||
init(edges: [[Vertex]]) {
|
||
adjList = [:]
|
||
// 添加所有顶点和边
|
||
for edge in edges {
|
||
addVertex(vet: edge[0])
|
||
addVertex(vet: edge[1])
|
||
addEdge(vet1: edge[0], vet2: edge[1])
|
||
}
|
||
}
|
||
|
||
/* 获取顶点数量 */
|
||
func size() -> Int {
|
||
adjList.count
|
||
}
|
||
|
||
/* 添加边 */
|
||
func addEdge(vet1: Vertex, vet2: Vertex) {
|
||
if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
|
||
fatalError("参数错误")
|
||
}
|
||
// 添加边 vet1 - vet2
|
||
adjList[vet1]?.insert(vet2)
|
||
adjList[vet2]?.insert(vet1)
|
||
}
|
||
|
||
/* 删除边 */
|
||
func removeEdge(vet1: Vertex, vet2: Vertex) {
|
||
if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
|
||
fatalError("参数错误")
|
||
}
|
||
// 删除边 vet1 - vet2
|
||
adjList[vet1]?.remove(vet2)
|
||
adjList[vet2]?.remove(vet1)
|
||
}
|
||
|
||
/* 添加顶点 */
|
||
func addVertex(vet: Vertex) {
|
||
if adjList[vet] != nil {
|
||
return
|
||
}
|
||
// 在邻接表中添加一个新链表（即 HashSet）
|
||
adjList[vet] = []
|
||
}
|
||
|
||
/* 删除顶点 */
|
||
func removeVertex(vet: Vertex) {
|
||
if adjList[vet] == nil {
|
||
fatalError("参数错误")
|
||
}
|
||
// 在邻接表中删除顶点 vet 对应的链表（即 HashSet）
|
||
adjList.removeValue(forKey: vet)
|
||
// 遍历其它顶点的链表（即 HashSet），删除所有包含 vet 的边
|
||
for key in adjList.keys {
|
||
adjList[key]?.remove(vet)
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
=== "Zig"
|
||
|
||
```zig title="graph_adjacency_list.zig"
|
||
|
||
```
|
||
|
||
## 9.2.3. 效率对比
|
||
|
||
设图中共有 $n$ 个顶点和 $m$ 条边，下表为邻接矩阵和邻接表的时间和空间效率对比。
|
||
|
||
<div class="center-table" markdown>
|
||
|
||
| | 邻接矩阵 | 邻接表（链表） | 邻接表（哈希表） |
|
||
| ------------ | -------- | -------------- | ---------------- |
|
||
| 判断是否邻接 | $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)$ |
|
||
|
||
</div>
|
||
|
||
观察上表，貌似邻接表（哈希表）的时间与空间效率最优。但实际上，在邻接矩阵中操作边的效率更高，只需要一次数组访问或赋值操作即可。总结以上，**邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”**。
|