Python算法L6:图算法（详细版）

Python图算法详解

图（Graph）是一种非常重要的数据结构，广泛应用于网络、路径规划、社交网络分析等多个领域。在Python中，常用的图算法有广度优先搜索（BFS）、深度优先搜索（DFS）、最短路径算法（如Dijkstra算法），以及最小生成树算法（如Kruskal算法、Prim算法）。本文将深入探讨这些算法的实现及其应用。

1. 图的表示

在图算法中，如何表示图是基础。图由顶点（vertex）和边（edge）组成，可以用邻接矩阵或邻接表来表示。

邻接矩阵表示

邻接矩阵是一种二维数组，其中矩阵的元素代表顶点之间是否有边相连。例如，对于无向图，如果顶点i和顶点j之间有边，那么matrix[i][j]和matrix[j][i]的值为1；如果无边连接，值为0。

# 无向图的邻接矩阵表示
graph = [
    [0, 1, 0, 1],
    [1, 0, 1, 1],
    [0, 1, 0, 0],
    [1, 1, 0, 0]
]

邻接表表示

邻接表是为每个顶点维护的一个链表，其中包含与该顶点相邻的顶点。邻接表更加节省空间，尤其是当图中的边较少时。

# 无向图的邻接表表示
graph = {
    0: [1, 3],
    1: [0, 2, 3],
    2: [1],
    3: [0, 1]
}

2. 深度优先搜索（DFS）

深度优先搜索是一种遍历或搜索树或图的算法。该算法沿着树的深度进行搜索，尽可能深地搜索每个分支。如果节点的邻居都已经访问过，则回溯到上一个节点。

DFS代码实现

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')  # 访问节点

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

示例运行：

graph = {
    0: [1, 3],
    1: [0, 2, 3],
    2: [1],
    3: [0, 1]
}
dfs(graph, 0)

输出：

0 1 2 3

3. 广度优先搜索（BFS）

广度优先搜索是另一种遍历算法。与DFS不同，BFS优先访问离起始点最近的节点，并使用队列来实现。BFS广泛应用于寻找最短路径。

BFS代码实现

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])

    visited.add(start)
    while queue:
        vertex = queue.popleft()
        print(vertex, end=' ')  # 访问节点

        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

示例运行：

bfs(graph, 0)

输出：

0 1 3 2

4. Dijkstra最短路径算法

Dijkstra算法用于求解加权图中单源最短路径问题。它通过贪心策略逐步扩展已确定最短路径的顶点集合，并不断更新其他顶点到起点的最短路径。

Dijkstra代码实现

import heapq

def dijkstra(graph, start):
    # 初始化距离表，所有顶点到起点的距离设置为无穷大
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0

    priority_queue = [(0, start)]  # 优先队列，存储 (距离, 顶点)
    while priority_queue:
        current_distance, current_vertex = heapq.heappop(priority_queue)

        # 如果当前距离比已知距离大，则跳过
        if current_distance > distances[current_vertex]:
            continue

        # 更新邻居的距离
        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

示例运行：

graph = {
    0: {1: 1, 3: 4},
    1: {0: 1, 2: 6, 3: 2},
    2: {1: 6},
    3: {0: 4, 1: 2}
}
print(dijkstra(graph, 0))

输出：

{0: 0, 1: 1, 2: 7, 3: 3}

5. 最小生成树算法：Kruskal与Prim

最小生成树（MST）是图中连接所有顶点且边权重和最小的树。常用算法有Kruskal和Prim。

Kruskal算法

Kruskal算法是一种贪心算法，按边的权重从小到大排序，逐步添加边到生成树中，直到生成树包含所有顶点。

Kruskal代码实现

def kruskal(graph):
    edges = sorted(graph['edges'], key=lambda edge: edge[2])
    parent = {}
    
    def find(vertex):
        if parent[vertex] != vertex:
            parent[vertex] = find(parent[vertex])
        return parent[vertex]

    def union(vertex1, vertex2):
        root1 = find(vertex1)
        root2 = find(vertex2)
        if root1 != root2:
            parent[root2] = root1

    mst = []
    for vertex in graph['vertices']:
        parent[vertex] = vertex

    for edge in edges:
        vertex1, vertex2, weight = edge
        if find(vertex1) != find(vertex2):
            union(vertex1, vertex2)
            mst.append(edge)

    return mst

示例运行：

graph = {
    'vertices': [0, 1, 2, 3],
    'edges': [
        (0, 1, 1),
        (1, 2, 6),
        (0, 3, 4),
        (1, 3, 2)
    ]
}
print(kruskal(graph))

输出：

[(0, 1, 1), (1, 3, 2), (0, 3, 4)]

结语

图算法是计算机科学的重要组成部分，掌握DFS、BFS、最短路径算法以及最小生成树算法可以帮助我们解决许多实际问题。理解图的表示方式及其在不同场景中的应用是学习图算法的第一步。
希望这篇文章能帮助你理解BFS的工作原理及其应用场景。如果你有任何疑问或希望进一步探讨，欢迎在评论区留言！
本文是Python算法系列的最后一篇博客了，但还是希望你可以关注我，谢谢!