邻接表与邻接矩阵

邻接表与邻接矩阵

1、 邻接表

# 定义一个有向图的邻接表
graph = {
    'A': ['B', 'C'],  # 节点 A 指向节点 B 和节点 C
    'B': ['C', 'D'],  # 节点 B 指向节点 C 和节点 D
    'C': ['D'],       # 节点 C 指向节点 D
    'D': ['A']        # 节点 D 指向节点 A（形成循环）
}

# 遍历输出邻接表
for node, neighbors in graph.items():
    print(f"Node {node} is connected to: {neighbors}")

2、 邻接矩阵

# 定义节点
nodes = ['A', 'B', 'C', 'D']

# 创建邻接矩阵（初始化为0）
adj_matrix = [
    [0, 1, 1, 0],  # A -> B, A -> C
    [0, 0, 1, 1],  # B -> C, B -> D
    [0, 0, 0, 1],  # C -> D
    [1, 0, 0, 0]   # D -> A
]

# 打印邻接矩阵
for i in range(len(nodes)):
    print(f"{nodes[i]}: {adj_matrix[i]}")

3、 计算节点之间的边得出邻接矩阵

nodes = ['A', 'B', 'C', 'D']

# 初始化邻接矩阵为全0
adj_matrix = [[0 for _ in range(len(nodes))] for _ in range(len(nodes))]

# 边的信息（示例）
edges = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D'), ('C', 'D'), ('D', 'A')]

# 根据边的信息更新邻接矩阵
for edge in edges:
    start = nodes.index(edge[0])
    end = nodes.index(edge[1])
    adj_matrix[start][end] = 1  # 标记连接关系（可以是其他值表示权重等）

# 打印邻接矩阵
for i in range(len(nodes)):
    print(f"{nodes[i]}: {adj_matrix[i]}")
    
print(adj_matrix)

4、邻接表转换为邻接矩阵

adj_list = {
    'A': ['B', 'C'],
    'B': ['C', 'D'],
    'C': ['D'],
    'D': ['A']
}


nodes = sorted(adj_list.keys())  # 获取节点列表并排序
n = len(nodes)  # 节点数量

# 创建初始的邻接矩阵，初始化为全0
adj_matrix = [[0] * n for _ in range(n)]

# 建立节点索引的映射关系
node_to_index = {node: i for i, node in enumerate(nodes)}

# 根据邻接表更新邻接矩阵
for node, neighbors in adj_list.items():
    i = node_to_index[node]  # 获取节点在邻接矩阵中的索引
    for neighbor in neighbors:
        j = node_to_index[neighbor]  # 获取相邻节点在邻接矩阵中的索引
        adj_matrix[i][j] = 1  # 标记节点与相邻节点的连接关系（可以是其他值表示权重等）

# 打印邻接矩阵
for row in adj_matrix:
    print(row)

5、邻接矩阵寻找最短路径

from collections import deque

def shortest_path(adj_matrix, start, end):
    n = len(adj_matrix)
    visited = [False] * n
    queue = deque([(start, [start])])  # 使用队列保存路径

    while queue:
        node, path = queue.popleft()
        if node == end:
            return path  # 返回最短路径

        for i in range(n):
            if adj_matrix[node][i] == 1 and not visited[i]:
                visited[i] = True
                queue.append((i, path + [i]))  # 添加新路径到队列

    return None  # 如果没有找到路径，返回None

# 假设有向图的邻接矩阵为adj_matrix
# 寻找节点A到节点D的最短路径
adj_matrix = [
    [0, 1, 1, 0],
    [0, 0, 1, 1],
    [0, 0, 0, 1],
    [1, 0, 0, 0]
]
start_node = 0  # 节点A
end_node = 3  # 节点D

result = shortest_path(adj_matrix, start_node, end_node)
if result:
    path_str = ' -> '.join(chr(ord('A') + node) for node in result)
    print(f"The shortest path from A to D: {path_str}")
else:
    print("There is no path from A to D.")

6、邻接表寻找最短路径

from collections import deque



adj_list = {
    'A': ['B', 'C'],
    'B': ['C', 'D'],
    'C': ['D'],
    'D': ['A']
}



def shortest_path(adj_list, start, end):
    visited = set()
    queue = deque([(start, [start])])  # 使用队列保存路径

    while queue:
        current, path = queue.popleft()
        if current == end:
            return path  # 返回最短路径

        if current not in visited:
            visited.add(current)
            for neighbor in adj_list.get(current, []):
                queue.append((neighbor, path + [neighbor]))  # 添加新路径到队列

    return None  # 如果没有找到路径，返回None

# 寻找节点A到节点D的最短路径
start_node = 'A'
end_node = 'D'

result = shortest_path(adj_list, start_node, end_node)
if result:
    path_str = ' -> '.join(result)
    print(f"The shortest path from {start_node} to {end_node}: {path_str}")
else:
    print(f"There is no path from {start_node} to {end_node}.")