49 KiB

Raw Blame History Unescape Escape

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);
    }

    /* 打印邻接矩阵 */
    public void print() {
        System.out.print("顶点列表 = ");
        System.out.println(vertices);
        System.out.println("邻接矩阵 =");
        PrintUtil.printMatrix(adjMat);
    }
}
```

=== "C++"

```cpp title="graph_adjacency_matrix.cpp"
/* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat {
    vector<int> vertices;        // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
    vector<vector<int>> adjMat;  // 邻接矩阵，行列索引对应“顶点索引”

public:
    /* 构造方法 */
    GraphAdjMat(const vector<int>& vertices, const vector<vector<int>>& edges) {
        // 添加顶点
        for (int val : vertices) {
            addVertex(val);
        }
        // 添加边
        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
        for (const vector<int>& edge : edges) {
            addEdge(edge[0], edge[1]);
        }
    }

    /* 获取顶点数量 */
    int size() const {
        return vertices.size();
    }

    /* 添加顶点 */
    void addVertex(int val) {
        int n = size();
        // 向顶点列表中添加新顶点的值
        vertices.push_back(val);
        // 在邻接矩阵中添加一行
        adjMat.emplace_back(n, 0);
        // 在邻接矩阵中添加一列
        for (vector<int>& row : adjMat) {
            row.push_back(0);
        }
    }

    /* 删除顶点 */
    void removeVertex(int index) {
        if (index >= size()) {
            throw out_of_range("顶点不存在");
        }
        // 在顶点列表中移除索引 index 的顶点
        vertices.erase(vertices.begin() + index);
        // 在邻接矩阵中删除索引 index 的行
        adjMat.erase(adjMat.begin() + index);
        // 在邻接矩阵中删除索引 index 的列
        for (vector<int>& row : adjMat) {
            row.erase(row.begin() + index);
        }
    }

    /* 添加边 */
    // 参数 i, j 对应 vertices 元素索引
    void addEdge(int i, int j) {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("顶点不存在");
        }
        // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
        adjMat[i][j] = 1;
        adjMat[j][i] = 1;
    }

    /* 删除边 */
    // 参数 i, j 对应 vertices 元素索引
    void removeEdge(int i, int j) {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
            throw out_of_range("顶点不存在");
        }
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }

    /* 打印邻接矩阵 */
    void print() {
        cout << "顶点列表 = ";
        PrintUtil::printVector(vertices);
        cout << "邻接矩阵 =" << endl;
        PrintUtil::printVectorMatrix(adjMat);
    }
};
```

=== "Python"

```python title="graph_adjacency_matrix.py"
""" 基于邻接矩阵实现的无向图类 """
class GraphAdjMat:
    # 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
    vertices = []
    # 邻接矩阵，行列索引对应“顶点索引”
    adj_mat = []

    """ 构造方法 """
    def __init__(self, vertices, edges):
        self.vertices = []
        self.adj_mat = []
        # 添加顶点
        for val in vertices:
            self.add_vertex(val)
        # 添加边
        # 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
        for e in edges:
            self.add_edge(e[0], e[1])

    """ 获取顶点数量 """
    def size(self):
        return len(self.vertices)

    """ 添加顶点 """
    def add_vertex(self, val):
        n = self.size()
        # 向顶点列表中添加新顶点的值
        self.vertices.append(val)
        # 在邻接矩阵中添加一行
        new_row = [0]*n
        self.adj_mat.append(new_row)
        # 在邻接矩阵中添加一列
        for row in self.adj_mat:
            row.append(0)


    """ 删除顶点 """
    def remove_vertex(self, index):
        if index >= self.size():
            raise IndexError()
        # 在顶点列表中移除索引 index 的顶点
        self.vertices.pop(index)
        # 在邻接矩阵中删除索引 index 的行
        self.adj_mat.pop(index)
        # 在邻接矩阵中删除索引 index 的列
        for row in self.adj_mat:
            row.pop(index)

    """ 添加边 """
    # 参数 i, j 对应 vertices 元素索引
    def add_edge(self, i, j):
        # 索引越界与相等处理
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        # 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
        self.adj_mat[i][j] = 1
        self.adj_mat[j][i] = 1

    """ 删除边 """
    # 参数 i, j 对应 vertices 元素索引
    def remove_edge(self, i, j):
        # 索引越界与相等处理
        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
            raise IndexError()
        self.adj_mat[i][j] = 0
        self.adj_mat[j][i] = 0

    """ 打印邻接矩阵 """
    def print(self):
        print("顶点列表 =", self.vertices)
        print("邻接矩阵 =")
        print_matrix(self.adj_mat)
```

=== "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
}

/* 打印邻接矩阵 */
func (g *graphAdjMat) print() {
    fmt.Printf("\t顶点列表 = %v\n", g.vertices)
    fmt.Printf("\t邻接矩阵 = \n")
    for i := range g.adjMat {
        fmt.Printf("\t\t\t%v\n", g.adjMat[i])
    }
}
```

=== "JavaScript"

```javascript title="graph_adjacency_matrix.js"
/* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat {
    vertices;   // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
    adjMat;     // 邻接矩阵，行列索引对应“顶点索引”

    /* 构造函数 */
    constructor(vertices, edges) {
        this.vertices = [];
        this.adjMat = [];
        // 添加顶点
        for (const val of vertices) {
            this.addVertex(val);
        }
        // 添加边
        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* 获取顶点数量 */
    size() {
        return this.vertices.length;
    }

    /* 添加顶点 */
    addVertex(val) {
        const n = this.size();
        // 向顶点列表中添加新顶点的值
        this.vertices.push(val);
        // 在邻接矩阵中添加一行
        const newRow = [];
        for (let j = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // 在邻接矩阵中添加一列
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* 删除顶点 */
    removeVertex(index) {
        if (index >= this.size()) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        // 在顶点列表中移除索引 index 的顶点
        this.vertices.splice(index, 1);

        // 在邻接矩阵中删除索引 index 的行
        this.adjMat.splice(index, 1);
        // 在邻接矩阵中删除索引 index 的列
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* 添加边 */
    // 参数 i, j 对应 vertices 元素索引
    addEdge(i, j) {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* 删除边 */
    // 参数 i, j 对应 vertices 元素索引
    removeEdge(i, j) {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* 打印邻接矩阵 */
    print() {
        console.log("顶点列表 = ", this.vertices);
        console.log("邻接矩阵 =", this.adjMat);
    }
}
```

=== "TypeScript"

```typescript title="graph_adjacency_matrix.ts"
/* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat {
    vertices: number[];     // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
    adjMat: number[][];     // 邻接矩阵，行列索引对应“顶点索引”

    /* 构造函数 */
    constructor(vertices: number[], edges: number[][]) {
        this.vertices = [];
        this.adjMat = [];
        // 添加顶点
        for (const val of vertices) {
            this.addVertex(val);
        }
        // 添加边
        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
        for (const e of edges) {
            this.addEdge(e[0], e[1]);
        }
    }

    /* 获取顶点数量 */
    size(): number {
        return this.vertices.length;
    }

    /* 添加顶点 */
    addVertex(val: number): void {
        const n: number = this.size();
        // 向顶点列表中添加新顶点的值
        this.vertices.push(val);
        // 在邻接矩阵中添加一行
        const newRow: number[] = [];
        for (let j: number = 0; j < n; j++) {
            newRow.push(0);
        }
        this.adjMat.push(newRow);
        // 在邻接矩阵中添加一列
        for (const row of this.adjMat) {
            row.push(0);
        }
    }

    /* 删除顶点 */
    removeVertex(index: number): void {
        if (index >= this.size()) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        // 在顶点列表中移除索引 index 的顶点
        this.vertices.splice(index, 1);

        // 在邻接矩阵中删除索引 index 的行
        this.adjMat.splice(index, 1);
        // 在邻接矩阵中删除索引 index 的列
        for (const row of this.adjMat) {
            row.splice(index, 1);
        }
    }

    /* 添加边 */
    // 参数 i, j 对应 vertices 元素索引
    addEdge(i: number, j: number): void {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
        this.adjMat[i][j] = 1;
        this.adjMat[j][i] = 1;
    }

    /* 删除边 */
    // 参数 i, j 对应 vertices 元素索引
    removeEdge(i: number, j: number): void {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
            throw new RangeError("Index Out Of Bounds Exception");
        }
        this.adjMat[i][j] = 0;
        this.adjMat[j][i] = 0;
    }

    /* 打印邻接矩阵 */
    print(): void {
        console.log("顶点列表 = ", this.vertices);
        console.log("邻接矩阵 =", this.adjMat);
    }
}
```

=== "C"

```c title="graph_adjacency_matrix.c"
[class]{graphAdjMat}-[func]{}
```

=== "C#"

```csharp title="graph_adjacency_matrix.cs"
/* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat
{
    List<int> vertices;     // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
    List<List<int>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”

    /* 构造函数 */
    public GraphAdjMat(int[] vertices, int[][] edges)
    {
        this.vertices = new List<int>();
        this.adjMat = new List<List<int>>();
        // 添加顶点
        foreach (int val in vertices)
        {
            addVertex(val);
        }
        // 添加边
        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
        foreach (int[] e in edges)
        {
            addEdge(e[0], e[1]);
        }
    }

    /* 获取顶点数量 */
    public int size()
    {
        return vertices.Count;
    }

    /* 添加顶点 */
    public void addVertex(int val)
    {
        int n = size();
        // 向顶点列表中添加新顶点的值
        vertices.Add(val);
        // 在邻接矩阵中添加一行
        List<int> newRow = new List<int>(n);
        for (int j = 0; j < n; j++)
        {
            newRow.Add(0);
        }
        adjMat.Add(newRow);
        // 在邻接矩阵中添加一列
        foreach (List<int> row in adjMat)
        {
            row.Add(0);
        }
    }

    /* 删除顶点 */
    public void removeVertex(int index)
    {
        if (index >= size())
            throw new IndexOutOfRangeException();
        // 在顶点列表中移除索引 index 的顶点
        vertices.RemoveAt(index);
        // 在邻接矩阵中删除索引 index 的行
        adjMat.RemoveAt(index);
        // 在邻接矩阵中删除索引 index 的列
        foreach (List<int> row in adjMat)
        {
            row.RemoveAt(index);
        }
    }

    /* 添加边 */
    // 参数 i, j 对应 vertices 元素索引
    public void addEdge(int i, int j)
    {
        // 索引越界与相等处理
        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
            throw new IndexOutOfRangeException();
        // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
        adjMat[i][j] = 1;
        adjMat[j][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 IndexOutOfRangeException();
        adjMat[i][j] = 0;
        adjMat[j][i] = 0;
    }
    
    /* 打印邻接矩阵 */
    public void print()
    {
        Console.Write("顶点列表 = ");
        PrintUtil.PrintList(vertices);
        Console.WriteLine("邻接矩阵 =");
        PrintUtil.printMatrix(adjMat);
    }
}
```

=== "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
    }

    /* 打印邻接矩阵 */
    func print() {
        Swift.print("顶点列表 = ", terminator: "")
        Swift.print(vertices)
        Swift.print("邻接矩阵 =")
        PrintUtil.printMatrix(matrix: adjMat)
    }
}
```

=== "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) 时间。

=== "初始化邻接表"