图论基础：DFS、BFS与最小生成树算法详解-代码聚汇网

图论基础：DFS、BFS与最小生成树算法详解

Dark Nexus·2026-08-23·阅读 21 GEO检测（免费）

图论DFSBFS

|难度：普通|阅读约 15 分钟

1. 数据结构基础与图论入门

在计算机科学的世界里，数据结构就像建筑师的蓝图，决定了数据如何被组织和访问。而图（Graph）作为一种非线性数据结构，特别适合表示实体间复杂的关系网络。想象一下社交网络中的好友关系、城市间的交通路线，或是电路板上的连接点，这些都是图的典型应用场景。

图由顶点（Vertex）和边（Edge）组成，数学上表示为G=(V,E)。根据边的方向性，可分为有向图和无向图；根据边是否带权值，又分为加权图和非加权图。理解这些基本概念是掌握后续算法的前提。

提示：在学习图算法前，建议先熟悉图的两种主要表示方法——邻接矩阵和邻接表。邻接矩阵适合稠密图（边数接近顶点数平方），而邻接表更适合稀疏图（边数远小于顶点数平方）。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 图的遍历：深度优先与广度优先

2.1 深度优先搜索（DFS）原理与实现

深度优先搜索就像走迷宫时坚持右手扶墙的策略——沿着一条路径不断深入，直到无路可走再回溯。这种"一条道走到黑"的方式用递归实现非常直观：

python复制def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)  # 处理当前节点
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

DFS的时间复杂度为O(V+E)，空间复杂度取决于递归深度，最坏情况下（线性图）为O(V)。它的核心应用包括：

拓扑排序（有向无环图的线性序列）
连通分量检测
解决迷宫类问题

我在实际项目中曾用DFS检测代码文件的依赖关系。当遇到大型项目时，递归深度可能引发栈溢出，这时可以改用显式栈的迭代实现：

python复制def dfs_iterative(graph, start):
    visited = set()
    stack = [start]
    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            visited.add(vertex)
            stack.extend(reversed(graph[vertex]))  # 保持访问顺序

2.2 广度优先搜索（BFS）原理与实现

如果说DFS是探险家，BFS就像测绘员——逐层推进，确保先访问离起点最近的节点。这种特性使其特别适合寻找最短路径（在无权图中）：

python复制from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            queue.extend(graph[vertex] - visited)

BFS同样具有O(V+E)的时间复杂度，但空间复杂度在最坏情况下（完全图）会达到O(V)。典型应用场景包括：

社交网络中查找N度人脉
网络爬虫的层级抓取
广播路由算法

在最近的一个网络拓扑分析项目中，我需要找出所有设备间的跳数。使用BFS时，通过记录每个节点的"距离"字段，可以高效完成这一任务：

python复制def bfs_with_distance(graph, start):
    distances = {start: 0}
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        for neighbor in graph[vertex]:
            if neighbor not in distances:
                distances[neighbor] = distances[vertex] + 1
                queue.append(neighbor)
    return distances

2.3 DFS与BFS的对比与选择

选择哪种遍历方式取决于具体需求。当需要探索所有可能性（如解谜题）时，DFS通常更合适；而寻找最短路径或分析层级关系时，BFS更有优势。实际工程中，我曾遇到一个有趣的案例：在分析代码调用链时，DFS能直观展示深层调用关系，但当需要找出两个类的最短依赖路径时，BFS才是正确选择。

3. 最小生成树算法精解

3.1 最小生成树概念与应用

最小生成树（MST）是连接图中所有顶点的边权值之和最小的树形子图。现实中的网络布线、电路设计等问题都可抽象为MST问题。例如，为校园建筑部署网络线路时，MST能确保用最短的线缆连接所有建筑。

MST有两个重要性质：

包含所有顶点和V-1条边
在保证连通性的前提下边权总和最小

3.2 Prim算法：从点的角度构建MST

Prim算法从一个起始顶点开始，逐步"生长"出MST。它维护两个集合：已包含在MST中的顶点和未包含的顶点。每次选择连接这两个集合的最小权边，将新顶点加入MST。

python复制import heapq

def prim(graph, start):
    mst = []
    visited = set([start])
    edges = [
        (cost, start, to)
        for to, cost in graph[start].items()
    ]
    heapq.heapify(edges)
    
    while edges:
        cost, frm, to = heapq.heappop(edges)
        if to not in visited:
            visited.add(to)
            mst.append((frm, to, cost))
            for to_next, cost in graph[to].items():
                if to_next not in visited:
                    heapq.heappush(edges, (cost, to, to_next))
    return mst

Prim算法的时间复杂度取决于优先队列的实现：

二叉堆：O(E log V)
斐波那契堆：O(E + V log V)

在实现时，我发现一个常见误区是忘记检查边的目标节点是否已在MST中，这会导致重复添加和错误结果。另一个优化点是使用优先队列（如Python的heapq）来高效获取最小边。

3.3 Kruskal算法：从边的角度构建MST

Kruskal算法采用不同的策略——按边权从小到大排序，逐步选择不形成环的边，直到包含V-1条边。它需要并查集（Disjoint Set）数据结构来高效检测环：

python复制class UnionFind:
    def __init__(self, size):
        self.parent = list(range(size))
    
    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]  # 路径压缩
            x = self.parent[x]
        return x
    
    def union(self, x, y):
        x_root = self.find(x)
        y_root = self.find(y)
        if x_root != y_root:
            self.parent[y_root] = x_root

def kruskal(graph):
    edges = sorted(
        (cost, frm, to) for frm in graph for to, cost in graph[frm].items()
    )
    uf = UnionFind(len(graph))
    mst = []
    for cost, frm, to in edges:
        if uf.find(frm) != uf.find(to):
            uf.union(frm, to)
            mst.append((frm, to, cost))
            if len(mst) == len(graph) - 1:
                break
    return mst

Kruskal的时间复杂度主要来自排序步骤，为O(E log E)。当边数远大于顶点数时，Prim通常更高效；而对于稀疏图，两者性能相近。

3.4 Prim与Kruskal的工程选择

在实际项目中，选择哪种算法需要考虑图的特性和环境约束：

稠密图（E接近V²）：Prim（尤其是使用斐波那契堆实现）更优
稀疏图：Kruskal可能更简单高效
边已排序：Kruskal几乎可以线性时间完成
需要逐步构建：Prim更适合流式处理

我曾为一个物流系统设计路线规划，其中仓库（顶点）数量固定但运输路线（边）经常变化。这种情况下，使用Kruskal算法更为合适，因为可以预处理边排序，每次更新后只需少量调整。

4. 实战应用与性能优化

4.1 典型问题解决方案

问题1：城市电网规划
假设需要为10个城市铺设电网，城市间距离已知。使用Prim算法可以找到总电缆长度最短的连接方案。实践中，我们还需要考虑地形限制——这可以通过预处理，移除不可能的边来解决。

问题2：社交网络好友推荐
在社交网络中，基于BFS的二度人脉推荐很常见。但结合MST可以识别最紧密的社交圈，为好友推荐提供新维度。我曾实现一个混合方案：先用BFS找到候选集，再用MST识别核心关系。

4.2 性能优化技巧

内存优化：对于大型图，邻接表比邻接矩阵更省空间。可以使用紧凑的数据结构如CSR（Compressed Sparse Row）格式。
并行处理：Kruskal算法的排序阶段和环检测阶段可以部分并行化。我在一个分布式系统中实现了边排序的MapReduce版本。
增量更新：当图有小幅变动时，不必重新计算整个MST。对于Prim算法，可以维护优先队列；对于Kruskal，可以使用并查集的动态版本。

4.3 常见错误与调试

负权边处理：MST算法假设边权为非负。如果存在负权，需要先检查算法前提条件。
不连通图：对于不连通图，MST不存在。实际应用中，可以改为寻找最小生成森林（每个连通分量一个MST）。
浮点精度问题：当边权为浮点数时，比较操作应使用误差容忍度，而非直接相等判断。

python复制# 错误的浮点比较
if a == b:  

# 正确的浮点比较
if abs(a - b) < 1e-9:

在调试一个网络优化问题时，我曾花费数小时追踪一个微妙的bug，最终发现是浮点比较导致的。这个教训让我在后续项目中始终坚持使用误差容忍比较。

4.4 进阶应用方向

动态MST：当图频繁变化时，研究如何高效维护MST。有算法可以在O(log V)时间内处理边的添加或删除。
分布式MST：对于无法放入单机内存的超大图，研究如何在集群上计算MST。经典的GHS算法（Gallager-Humblet-Spira）提供了分布式解决方案。
近似MST：在需要实时响应的场景，可以牺牲少量准确性换取速度。例如，基于分区和采样的近似算法。

在最近的一个物联网项目中，设备网络拓扑不断变化。我们实现了一个增量Prim算法版本，将MST更新时间从秒级降到了毫秒级，显著提升了系统响应速度。