python中如何用邻接矩阵建图

在Python中，使用邻接矩阵构建图是一种常见且有效的方法。首先，邻接矩阵是一种用于表示图的二维数组，其中行和列分别表示图的顶点，数组中的每个元素表示顶点之间的连接关系。对于一个无向图，矩阵是对称的；对于有向图，矩阵可能不对称。使用邻接矩阵可以方便地进行图的存储和基本操作。接下来，我将详细解释如何在Python中使用邻接矩阵构建图。

一、创建邻接矩阵

邻接矩阵本质上是一个二维数组，可以用Python的列表(list)或NumPy库来实现。使用列表适合小规模图，使用NumPy更适合大规模图的高效操作。

使用列表创建邻接矩阵

# 创建一个包含4个顶点的无向图的邻接矩阵
num_vertices = 4
adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]
添加边
def add_edge(matrix, u, v):
    matrix[u][v] = 1
    matrix[v][u] = 1  # 无向图，双向连接
add_edge(adj_matrix, 0, 1)
add_edge(adj_matrix, 0, 2)
add_edge(adj_matrix, 1, 2)
add_edge(adj_matrix, 2, 3)
print(adj_matrix)

使用NumPy创建邻接矩阵

import numpy as np
创建一个包含4个顶点的无向图的邻接矩阵
num_vertices = 4
adj_matrix = np.zeros((num_vertices, num_vertices), dtype=int)
添加边
def add_edge(matrix, u, v):
    matrix[u][v] = 1
    matrix[v][u] = 1  # 无向图，双向连接
add_edge(adj_matrix, 0, 1)
add_edge(adj_matrix, 0, 2)
add_edge(adj_matrix, 1, 2)
add_edge(adj_matrix, 2, 3)
print(adj_matrix)

二、邻接矩阵的基本操作

一旦我们创建了邻接矩阵，就可以执行一些基本的图操作，例如添加边、删除边、检查边的存在以及获取邻接顶点等。

添加和删除边

def remove_edge(matrix, u, v):
    matrix[u][v] = 0
    matrix[v][u] = 0  # 无向图，双向连接
添加边
add_edge(adj_matrix, 1, 3)
删除边
remove_edge(adj_matrix, 0, 2)
print(adj_matrix)

检查边的存在

def has_edge(matrix, u, v):
    return matrix[u][v] == 1
print(has_edge(adj_matrix, 1, 3))  # 输出: True
print(has_edge(adj_matrix, 0, 2))  # 输出: False

获取邻接顶点

def get_adjacent_vertices(matrix, u):
    adjacent_vertices = []
    for v, is_connected in enumerate(matrix[u]):
        if is_connected:
            adjacent_vertices.append(v)
    return adjacent_vertices
print(get_adjacent_vertices(adj_matrix, 2))  # 输出: [1, 3]

三、应用邻接矩阵进行图算法

邻接矩阵不仅可以用于存储图，还可以用于实现许多图算法，例如深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（如Dijkstra算法）等。

深度优先搜索（DFS）

def dfs(matrix, start_vertex, visited=None):
    if visited is None:
        visited = set()
    visited.add(start_vertex)
    print(start_vertex, end=' ')
    for v, is_connected in enumerate(matrix[start_vertex]):
        if is_connected and v not in visited:
            dfs(matrix, v, visited)
dfs(adj_matrix, 0)  # 从顶点0开始进行DFS

广度优先搜索（BFS）

from collections import deque
def bfs(matrix, start_vertex):
    visited = set()
    queue = deque([start_vertex])
    visited.add(start_vertex)
    while queue:
        vertex = queue.popleft()
        print(vertex, end=' ')
        for v, is_connected in enumerate(matrix[vertex]):
            if is_connected and v not in visited:
                queue.append(v)
                visited.add(v)
bfs(adj_matrix, 0)  # 从顶点0开始进行BFS

Dijkstra算法

import heapq
def dijkstra(matrix, start_vertex):
    num_vertices = len(matrix)
    distances = [float('inf')] * num_vertices
    distances[start_vertex] = 0
    priority_queue = [(0, start_vertex)]
    while priority_queue:
        current_distance, current_vertex = heapq.heappop(priority_queue)
        if current_distance > distances[current_vertex]:
            continue
        for neighbor, weight in enumerate(matrix[current_vertex]):
            if weight > 0:
                distance = current_distance + weight
                if distance < distances[neighbor]:
                    distances[neighbor] = distance
                    heapq.heappush(priority_queue, (distance, neighbor))
    return distances
使用加权邻接矩阵
weighted_adj_matrix = [
    [0, 1, 4, 0],
    [1, 0, 4, 2],
    [4, 4, 0, 5],
    [0, 2, 5, 0]
]
print(dijkstra(weighted_adj_matrix, 0))  # 从顶点0开始计算最短路径