深度优先搜索（DFS）完全解析：从原理到 Java 实战

@TOC
作为一名程序员，你是否遇到过需要在复杂的图结构中寻找路径、检测环，或者进行树遍历的问题？深度优先搜索（Depth-First Search, DFS）作为一种经典的图遍历算法，能够轻松应对这些场景。在 CSDN 社区中，技术文章的受欢迎程度往往取决于内容的实用性、代码的可读性以及图文结合的讲解方式。因此，本文将为你带来一篇深入浅出、图文并茂、代码详尽的 DFS 指南，涵盖原理、Java 实现、应用场景和实战示例，确保你不仅理解 DFS，还能立刻上手应用！

---

什么是深度优先搜索（DFS）？

深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。它的核心思想是：从一个起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续前进时，再回溯到上一个分叉点，尝试其他路径。用一句话概括：DFS 是一种“先走到尽头再回头”的搜索策略。

与广度优先搜索（BFS）“层层扩展”的方式不同，DFS 更像是一个勇敢的探险家，优先深入某一条路，直到碰壁才返回。这种特性使得 DFS 在某些问题（如路径查找、环检测）中特别高效。

---

DFS 的工作原理（图解）

为了让你直观理解 DFS 的执行过程，我们以一个简单的图为例：

图结构：0/ \1---2|3

• 边表示：0-1, 0-2, 1-2, 2-3
• DFS 从节点 0 开始：
  1. 访问 0
  2. 从 0 进入 1，访问 1
  3. 从 1 进入 2，访问 2
  4. 从 2 进入 3，访问 3
  5. 3 没有未访问的邻居，回溯到 2
  6. 2 没有其他未访问邻居，回溯到 1
  7. 1 没有其他未访问邻居，回溯到 0
  8. 0 的所有邻居已访问，结束

访问顺序：0 -> 1 -> 2 -> 3

下图展示了 DFS 的过程（灰色表示已访问）：

初始状态       访问 0        访问 1        访问 2        访问 30            0*           0*           0*           0*/ \          / \          / \          / \          / \1---2        1---2        1*--2        1*--2*       1*--2*|            |            |            |            |3            3            3            3*           3*

这种“一条路走到黑”的方式，正是 DFS 的精髓。

---

DFS 的应用场景

DFS 在实际开发中用途广泛，以下是几个典型场景：

1. 路径查找：在迷宫或图中寻找从起点到终点的所有可能路径。
2. 环检测：判断图中是否存在环，常用于依赖关系分析。
3. 拓扑排序：对有向无环图（DAG）进行排序，例如任务调度。
4. 连通性分析：在无向图中找出所有连通分量。
5. 树遍历：实现二叉树的先序、中序、后序遍历。

---

用 Java 实现 DFS

在 Java 中，DFS 通常通过递归或显式栈实现。这里我们以邻接表表示图，并用递归方式实现 DFS，因为它代码简洁且符合直觉。

完整代码示例

以下是一个基于邻接表的 DFS 实现，包含详细注释：

import java.util.*;public class DFSGraph {private int V; // 图的节点数private LinkedList<Integer>[] adj; // 邻接表表示图// 构造函数，初始化图public DFSGraph(int v) {V = v;adj = new LinkedList[v];for (int i = 0; i < v; i++) {adj[i] = new LinkedList<>(); // 为每个节点初始化邻接表}}// 添加边（无向图）public void addEdge(int v, int w) {adj[v].add(w); // v -> wadj[w].add(v); // w -> v（无向图需添加双向边）}// DFS 核心递归方法private void dfsUtil(int v, boolean[] visited) {visited[v] = true; // 标记当前节点为已访问System.out.print(v + " "); // 访问节点（这里打印）// 遍历当前节点的所有邻接节点for (int neighbor : adj[v]) {if (!visited[neighbor]) { // 如果邻接节点未被访问dfsUtil(neighbor, visited); // 递归访问}}}// DFS 入口方法public void DFS(int start) {boolean[] visited = new boolean[V]; // 记录访问状态dfsUtil(start, visited); // 从起始节点开始 DFS}// 测试代码public static void main(String[] args) {DFSGraph graph = new DFSGraph(5); // 创建一个 5 个节点的图// 添加边graph.addEdge(0, 1);graph.addEdge(0, 2);graph.addEdge(1, 3);graph.addEdge(2, 4);graph.addEdge(3, 4);System.out.println("从节点 0 开始的 DFS 遍历：");graph.DFS(0);}
}

运行结果

从节点 0 开始的 DFS 遍历：
0 1 3 4 2

代码详解

1. 图的表示：
   • 使用 LinkedList<Integer>[] adj 作为邻接表，adj[i] 存储节点 i 的所有邻接节点。
   • V 表示节点总数。
2. 添加边：
   • addEdge 方法为无向图添加双向边。
3. DFS 实现：
   • dfsUtil 是递归核心，标记并访问当前节点，然后递归处理未访问的邻接节点。
   • DFS 方法初始化 visited 数组并启动遍历。
4. main 方法：
   • 构建一个 5 节点图，添加边后从节点 0 开始 DFS。

---

DFS 的时间与空间复杂度

• 时间复杂度：O(V + E)
  • V 是节点数，E 是边数，DFS 需要访问所有节点和边。
• 空间复杂度：O(V)
  • 递归栈的深度最多为 V，加上 visited 数组的空间。

---

实战项目：迷宫求解

让我们通过一个迷宫问题展示 DFS 的应用。假设有一个 4x4 的迷宫，0 表示通路，1 表示墙，目标是从 (0,0) 到 (3,3) 找一条路径。

迷宫表示

0 1 0 0
0 1 0 1
0 0 0 0
1 1 0 0

Java 代码

public class MazeSolver {static int[][] maze = {{0, 1, 0, 0},{0, 1, 0, 1},{0, 0, 0, 0},{1, 1, 0, 0}};static int N = 4;static int[][] path = new int[N][N]; // 记录路径// 四个方向：上、右、下、左static int[] dx = {-1, 0, 1, 0};static int[] dy = {0, 1, 0, -1};public static boolean solveMaze(int x, int y) {// 到达终点 (3,3)if (x == N - 1 && y == N - 1) {path[x][y] = 1;return true;}// 检查当前位置是否合法if (isSafe(x, y)) {path[x][y] = 1; // 标记为路径的一部分// 尝试四个方向for (int i = 0; i < 4; i++) {int nextX = x + dx[i];int nextY = y + dy[i];if (solveMaze(nextX, nextY)) {return true;}}// 回溯：如果当前路径不通，撤销标记path[x][y] = 0;}return false;}// 检查坐标是否有效public static boolean isSafe(int x, int y) {return x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 0;}public static void main(String[] args) {if (solveMaze(0, 0)) {System.out.println("找到路径：");for (int i = 0; i < N; i++) {for (int j = 0; j < N; j++) {System.out.print(path[i][j] + " ");}System.out.println();}} else {System.out.println("无解");}}
}

输出结果

找到路径：
1 0 0 0
1 0 0 0
1 1 1 1
0 0 0 1

解析

• DFS 策略：从 (0,0) 开始，尝试四个方向（上、右、下、左），遇到墙或边界回溯。
• 路径记录：path 数组标记走过的位置，成功到达 (3,3) 时返回路径。

---

总结与互动

通过这篇文章，你应该已经掌握了 DFS 的原理、Java 实现以及实战应用。无论是图遍历还是迷宫求解，DFS 都展现了其简洁而强大的能力。为了加深理解，不妨试试以下问题：

• 如何用 DFS 检测图中的环？

• 如果用栈而非递归实现 DFS，会是什么样？

  欢迎在评论区分享你的代码或疑问，一起探讨 DFS 的更多玩法！如果觉得这篇博客对你有帮助，记得点赞和收藏哦！