图的两种遍历算法：广度优先搜索（BFS）与深度优先搜索（DFS）

于 2025-03-23 13:05:19 发布
阅读量1.1k 收藏 34
点赞数 16
文章标签： 算法 图搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuYaoheng/article/details/146454757
版权

文章目录

图的两种遍历算法：广度优先搜索（BFS）与深度优先搜索（DFS）

图（Graph）是计算机科学中表示实体间关系的重要数据结构，广泛应用于社交网络、路径规划、网络拓扑分析等领域。图的遍历是图算法的基础，其中 广度优先搜索（BFS） 和 深度优先搜索（DFS） 是两种最核心的遍历方法。本文将从原理、实现、复杂度到经典例题进行系统讲解。

一、图的表示与基本概念

1. 图的定义

图由 顶点（Vertex/Node） 和 边（Edge） 组成，分为：

  • 无向图：边无方向（如朋友关系）。
  • 有向图：边有方向（如网页超链接）。
  • 带权图：边有权重（如地图距离）。

2. 图的存储方式

  • 邻接矩阵：二维数组表示顶点间的连接关系，适合稠密图。
  • 邻接表：链表或数组的数组，存储每个顶点的邻居，适合稀疏图。

二、广度优先搜索（BFS）

1. 算法思想

BFS 按“层次”遍历图，从起点开始逐层向外扩散，确保先访问离起点最近的节点。
核心数据结构：队列（FIFO）。

2. 算法步骤

  1. 初始化队列，将起点加入队列，并标记为已访问。
  2. 循环执行以下操作，直到队列为空：
    • 取出队列头部节点 u。
    • 访问 u 的所有未访问邻居节点，依次标记并加入队列。

3. 代码实现（C语言）

#include <stdio.h>
#include <stdlib.h>
#define MAX_NODES 100

// 邻接表节点
struct Node {
    int vertex;
    struct Node* next;
};

// 图结构
struct Graph {
    int numVertices;
    struct Node** adjLists;
    int* visited;
};

// 创建节点
struct Node* createNode(int v) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->vertex = v;
    newNode->next = NULL;
    return newNode;
}

// 创建图
struct Graph* createGraph(int vertices) {
    struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
    graph->numVertices = vertices;
    graph->adjLists = (struct Node**)malloc(vertices * sizeof(struct Node*));
    graph->visited = (int*)malloc(vertices * sizeof(int));

    for (int i = 0; i < vertices; i++) {
        graph->adjLists[i] = NULL;
        graph->visited[i] = 0;
    }
    return graph;
}

// 添加边（无向图）
void addEdge(struct Graph* graph, int src, int dest) {
    // 添加 src 到 dest 的边
    struct Node* newNode = createNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;

    // 添加 dest 到 src 的边
    newNode = createNode(src);
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}

// BFS 实现
void bfs(struct Graph* graph, int startVertex) {
    int queue[MAX_NODES];
    int front = 0, rear = 0;

    graph->visited[startVertex] = 1;
    queue[rear++] = startVertex;

    while (front < rear) {
        int currentVertex = queue[front++];
        printf("Visited %d\n", currentVertex);

        struct Node* temp = graph->adjLists[currentVertex];
        while (temp) {
            int adjVertex = temp->vertex;
            if (!graph->visited[adjVertex]) {
                graph->visited[adjVertex] = 1;
                queue[rear++] = adjVertex;
            }
            temp = temp->next;
        }
    }
}

4. 复杂度分析

  • 时间复杂度：O(V + E)，需访问所有节点和边。
  • 空间复杂度：O(V)，队列最多存储一层节点。

5. 典型应用

  • 无权图的最短路径（如迷宫最短步数）。
  • 社交网络中的“六度分隔”理论。
  • 检测图的连通性。

三、深度优先搜索（DFS）

1. 算法思想

DFS 沿一条路径尽可能深入探索，直到无法继续前进时回溯到上一个分叉点。
核心数据结构：栈（LIFO，递归隐式使用系统栈）。

2. 算法步骤

  1. 从起点出发，标记为已访问。
  2. 递归访问当前节点的未访问邻居，直到所有路径都被探索。

3. 代码实现（C语言）

// DFS 递归实现
void dfs(struct Graph* graph, int vertex) {
    struct Node* adjList = graph->adjLists[vertex];
    graph->visited[vertex] = 1;
    printf("Visited %d\n", vertex);

    while (adjList) {
        int connectedVertex = adjList->vertex;
        if (!graph->visited[connectedVertex]) {
            dfs(graph, connectedVertex);
        }
        adjList = adjList->next;
    }
}

4. 复杂度分析

  • 时间复杂度：O(V + E)，与 BFS 相同。
  • 空间复杂度：O(V)，递归栈深度最坏为节点数。

5. 典型应用

  • 寻找所有可能的路径（如迷宫所有解法）。
  • 拓扑排序（如课程安排依赖）。
  • 检测图中的环。

四、BFS 与 DFS 对比

特性BFSDFS
遍历顺序层次遍历（由近及远）深度优先（一条路走到底）
数据结构队列栈（递归或显式维护）
最短路径天然支持无权图最短路径需要额外记录路径信息
空间复杂度较高（存储一层节点）较低（递归栈深度）
适用场景最短路径、社交网络层级关系全路径搜索、拓扑排序、连通性检测

五、经典例题解析

例题 1：200. 岛屿数量（BFS/DFS）

题目描述
给定一个由 '1'（陆地）和 '0'（水）组成的二维网格，计算岛屿的数量。
解题思路
遍历每个单元格，遇到陆地时启动 BFS/DFS，标记所有相连的陆地，统计启动次数即为岛屿数量。
代码片段（DFS）

void dfs_island(char** grid, int gridSize, int gridColSize, int i, int j) {
    if (i < 0 || i >= gridSize || j < 0 || j >= gridColSize || grid[i][j] != '1') 
        return;
    
    grid[i][j] = '0'; // 标记为已访问
    dfs_island(grid, gridSize, gridColSize, i+1, j);
    dfs_island(grid, gridSize, gridColSize, i-1, j);
    dfs_island(grid, gridSize, gridColSize, i, j+1);
    dfs_island(grid, gridSize, gridColSize, i, j-1);
}

int numIslands(char** grid, int gridSize, int* gridColSize) {
    int count = 0;
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[0]; j++) {
            if (grid[i][j] == '1') {
                dfs_island(grid, gridSize, gridColSize[0], i, j);
                count++;
            }
        }
    }
    return count;
}

例题 2：133. 克隆图（BFS）

题目描述
深度复制一个无向连通图的所有节点。
解题思路
使用 BFS 遍历原图，同时用哈希表存储原节点到克隆节点的映射。
代码片段

struct Node {
    int val;
    int numNeighbors;
    struct Node** neighbors;
};

struct Node* cloneGraph(struct Node* s) {
    if (!s) return NULL;
    
    struct Node* clones[101] = {NULL}; // 假设节点值 <= 100
    struct Node* queue[101];
    int front = 0, rear = 0;
    
    // 创建起始节点克隆
    clones[s->val] = (struct Node*)malloc(sizeof(struct Node));
    clones[s->val]->val = s->val;
    clones[s->val]->numNeighbors = s->numNeighbors;
    clones[s->val]->neighbors = (struct Node**)malloc(s->numNeighbors * sizeof(struct Node*));
    
    queue[rear++] = s;
    
    while (front < rear) {
        struct Node* curr = queue[front++];
        for (int i = 0; i < curr->numNeighbors; i++) {
            struct Node* neighbor = curr->neighbors[i];
            if (!clones[neighbor->val]) {
                clones[neighbor->val] = (struct Node*)malloc(sizeof(struct Node));
                clones[neighbor->val]->val = neighbor->val;
                clones[neighbor->val]->numNeighbors = neighbor->numNeighbors;
                clones[neighbor->val]->neighbors = (struct Node**)malloc(neighbor->numNeighbors * sizeof(struct Node*));
                queue[rear++] = neighbor;
            }
            clones[curr->val]->neighbors[i] = clones[neighbor->val];
        }
    }
    return clones[s->val];
}

例题 3：797. 所有可能路径（DFS）

题目描述
给定有向无环图（DAG），找出从节点 0 到节点 n-1 的所有路径。
解题思路
使用 DFS 回溯，递归记录路径。
代码片段

void dfs_paths(int** graph, int graphSize, int* graphColSize, 
              int* returnSize, int** returnColumnSizes, 
              int** res, int* path, int pathSize, int node) {
    path[pathSize++] = node;
    
    if (node == graphSize - 1) {
        res[*returnSize] = (int*)malloc(pathSize * sizeof(int));
        memcpy(res[*returnSize], path, pathSize * sizeof(int));
        (*returnColumnSizes)[*returnSize] = pathSize;
        (*returnSize)++;
        return;
    }
    
    for (int i = 0; i < graphColSize[node]; i++) {
        dfs_paths(graph, graphSize, graphColSize, returnSize, returnColumnSizes, 
                 res, path, pathSize, graph[node][i]);
    }
}

int** allPathsSourceTarget(int** graph, int graphSize, int* graphColSize, 
                           int* returnSize, int** returnColumnSizes) {
    int** res = (int**)malloc(1000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(1000 * sizeof(int));
    int* path = (int*)malloc(graphSize * sizeof(int));
    *returnSize = 0;
    
    dfs_paths(graph, graphSize, graphColSize, returnSize, returnColumnSizes, 
             res, path, 0, 0);
    
    free(path);
    return res;
}

六、总结

  • BFS 适用场景：最短路径、层级遍历、最小步数问题。
  • DFS 适用场景：全路径搜索、连通性检测、回溯问题。
  • 关键选择依据：是否需要最短路径，或对空间复杂度有特殊要求。
LiuYaoheng
关注
Python 算法基础篇之图的遍历算法：深度优先搜索和广度优先搜索
小蓝枣的博客
07-24 1370
图的遍历是计算机科学中的一项重要任务，用于查找和访问图中的所有节点。深度优先搜索（ DFS ）和广度优先搜索（ BFS ）是两种常用的图遍历算法。本篇博客将重点介绍这两种算法的原理、应用场景以及使用 Python 实现，并通过实例演示每一行代码的运行过程。
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS）
WANGHAOXIN364的博客
03-26 4094
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS） 阅读本文前，请确保你已经掌握了递归、栈和队列的基本知识，如想掌握搜索的代码实现，请确保你能够用代码实现栈和队列的基本操作。 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search，简称 BFS)是图论中两种非常重要的算法，也是进行更高的算法阶段学习的最后一道门槛。搜索算法频繁出现在算法竞赛题中，尤其是深度优先搜索，在竞赛中，它是用来进行保底拿分的神器！ 本文将..
第九章：广度优先和深度优先搜索的一些总结
WANGHAOXIN364的博客
02-13 4924
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS） 阅读本文前，请确保你已经掌握了递归、栈和队列的基本知识，如想掌握搜索的代码实现，请确保你能够用代码实现栈和队列的基本操作。 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search，简称 BFS)是图论中两种非常重要的算法，也是进行更高的算法阶段学习的最后一道门槛。搜索算法频繁出现在算法竞赛题中，尤其是深度优先搜索，在竞赛中，它是用来进行保底拿分的神器！ 本文将..
图的遍历
简约不简单
02-17 243
转载请注明来源chengyaogen.blog.chinaunix.net   图的遍历是树的遍历的推广，是按照某种规则(或次序)访问图中各顶点依次且仅一次的操作，亦是将网络结构按某种规则线性化的过程。   由于图存在回路，为区别一顶点是否被访问过和避免顶点被多次访问，在遍历过程中，应记下每个访问过的顶点，即每个顶点对应有一个标志位，初始为False,一旦该顶点被访问，就将其置为Tr...
爱上算法，迷人的两度搜索，深度优先（DFS）和广度优先（BFS）
博学谷狂野架构师的博客
11-14 1109
深度优先搜索算法（DFS）和广度优先搜索算法（BFS）是一种用于遍历或搜索树或图的算法，在搜索遍历的过程中保证每个节点（顶点）访问一次且仅访问一次，按照节点（顶点）访问顺序的不同分为深度优先和广度优先。
bfs和dfs算法
qq_57968062的博客
10-11 5908
bfs（广度优先搜索） 从某一个顶点出发开始访问，被访问的顶点做相应的标记，输出访问顶点。 从被访问的顶点出发，搜索与该顶点有边的关联的某个未被访问的邻接点，并做相应标记。 再从根据上述中所有被访问的邻接点，访问与这些邻接点相关的未被访问的邻接点，直到所有顶点访问完为止。 实现代码 #include<iostream> #include<queue> using namespace std; int visit[101],cnt,n,g[101][101]; int main.
BFS与DFS总结
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
07-20 2606
最近一直在看DFS和BFS，感觉要晕的G
图的广度遍历和深度遍历
wj903829182的专栏
07-19 2283
图，深度遍历，广度遍历，数据结构
广度优先搜索和深度优先搜索
liulanba的博客
03-09 5834
假设从a结点开始访问，a先入队。例题：在一个n*m的矩阵上，分布着如下数字，0代表通路，1代表墙，无法通行，2代表起点，3代表终点，4代表陷阱，6代表炸弹，现在要求从起点到终点的最短路径，0可以通行，1无法通行，陷阱则需要花费3个单位时间，6可以把上下左右的四个坐标炸为通路，请给出从起点到终点的最短距离。在广度遍历的过程中，我们可以得到一棵遍历树，称为广度优先生成树，需要注意的是，一给定图的邻接矩阵存储表示是唯一的，故其广度优先生成树也是唯一的，但由于邻接表存储表示不唯一，故其广度优先生成树也是不唯一的。
广度优先搜索与深度优先搜索
weixin_30256901的博客
08-18 106
广度优先搜索 typedef struct { int que[MaxVertexNum]; int rear,front; }Queue;//广度优先搜索队列的存储结构 int visit[MaxVertexNum];//全局变量数组 void BFS(MGraph &M,int v){ printf("广度优先搜索:"); ...
【数据结构】图的遍历：广度优先（BFS），深度优先（DFS）
小人物，大梦想！
09-21 6703
算法思想，广度优先生成树，深度优先生成树，算法实现
邻接矩阵图遍历算法：广度优先与深度优先搜索
总结来说，基于邻接矩阵的图遍历通过BFS和DFS两种主要的搜索策略实现对图的深度和广度遍历，对于理解和处理网络结构有着不可替代的作用。在进行算法设计时，根据具体的问题场景和图的特性选择合适的遍历策略至关重要...
Java中的图遍历算法：如何实现深度优先与广度优先搜索
微赚淘客系统开发者博客
08-24 366
深度优先搜索和广度优先搜索是两种重要的图遍历算法，它们在图算法中扮演着关键角色。本文提供的Java实现示例展示了如何在实际开发中应用DFS和BFS，理解这些算法的工作原理和使用场景是提升编程能力的重要一步。图遍历算法是一种用于访问图中所有节点的过程。遍历图的目的是为了访问图中的每一个节点，这在图算法中是一个基本的操作。它从图的一个节点开始，首先访问其所有邻居节点，然后再访问这些邻居节点的邻居。DFS适合用于搜索解空间较大的问题，如迷宫求解、连通性检查等，而BFS则更适合用于寻找最短路径和广度优先的场景。
图——图的广度优先遍历
05-26 345
1，前面两篇博文实现了邻接矩阵和邻接链表法实现图的数据结构，什么情况下选择合适的图的类型？从时间复杂度角度来对比下； 2，时间复杂度的对比分析： 1，邻接矩阵法操作性能更好、效率更高，更在意性能，则选择邻接矩阵法； 2，链表矩阵法在空间使用率上更好，当环境资源紧张、内存比较小，选择邻接链表法； 3，小结论： ...
图的遍历（广度优先搜索）
上帝的孩纸的博客
11-12 289
#include using namespace std; int main() { int i, j, m, n, v1, v2, cur, book[51] = {0}, a[51][51]; int head, tail, que[2501]; scanf("%d %d", &m, &n); //输入图的顶点个数和边数 for (i = 1; i <= m; i++) { /
BFS和DFS算法原理（通俗易懂版）
热门推荐
尚小馨的博客
11-16 18万+
DFS 算法 思想：一直往深处走，直到找到解或者走不下去为止 BFS算法 DFS：使用栈保存未被检测的结点，结点按照深度优先的次序被访问并依次被压入栈中，并以相反的次序出栈进行新的检测。 BFS：使用队列保存未被检测的结点。结点按照宽度优先的次序被访问和进出队列。 框架： BFS: #include #include #include #include
BFS和DFS
qq_62987108的博客
02-11 1146
今天学习了两种搜索算法 1.深度优先搜索dfs 2.宽度优先搜索bfs 两种算法有相同也有不同点 都是对整个空间遍历，搜索的空间像一棵树一样 。 dfs先向深搜，搜不到就会回溯。 bfs是一层一层的搜索 。搜索完一层再进入下一层 。 数据结构来看：dfs采用的是栈，bfs采用的是队列。 使用空间看来：dfs大大小于bfs bfs具有最短路性，dfs没有。（bfs一层一层向下找，先找到的肯定是最短的）。 一：dfs（最重要的是顺序） 需要注意回溯和剪枝两种方法 1.回溯 将搜索过的区域回溯到本来的
MakeItTalk Windows deployment guide
最新发布
02-03
### MakeItTalk在Windows上的部署指南 #### 准备工作 为了确保MakeItTalk能够在Windows上顺利运行，需确认已安装必要的依赖环境。这包括但不限于Python及其相关库、Git以及其他可能需要的开发工具。 #### 获取源码 通过Git克隆MakeItTalk项目仓库到本地机器： ```bash git clone https://github.com/your-repo/makeittalk.git cd makeittalk ``` #### 设置虚拟环境并安装依赖项 创建一个新的Python虚拟环境来隔离项目的依赖关系，并激活该环境。接着利用`requirements.txt`文件安装所需的Python包。 ```bash python -m venv venv .\venv\Scripts\activate # Windows下激活命令 pip install --upgrade pip pip install -r requirements.txt ``` #### 配置环境变量 依据官方文档指示设置任何必需的操作系统级别的环境变量。这些通常涉及路径配置或是API密钥等敏感数据处理[^1]。 #### 启动服务 按照README.md或其他提供指导材料中的说明启动应用程序的服务端部分。对于某些应用来说，可能会有特定于平台（即Windows）的额外步骤或注意事项。 #### 测试部署成果 一旦服务器组件正常运作后，可以通过浏览器访问指定URL地址测试前端界面是否能够正确加载以及功能交互是否顺畅无误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值