mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-25 21:36:29 +08:00
15 KiB
15 KiB
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}-[func]{}
```
=== "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"
```javascript 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}-[func]{}
[class]{GraphAdjList}-[func]{}
```
=== "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"
```javascript 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
条边,下表为邻接矩阵和邻接表的时间和空间效率对比。
邻接矩阵 | 邻接表(链表) | 邻接表(哈希表) | |
---|---|---|---|
判断是否邻接 | 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) |
观察上表,貌似邻接表(哈希表)的时间与空间效率最优。但实际上,在邻接矩阵中操作边的效率更高,只需要一次数组访问或赋值操作即可。总结以上,邻接矩阵体现“以空间换时间”,邻接表体现“以时间换空间”。