本文详细介绍了深度优先遍历（DFS）和广度优先遍历（BFS）的概念，通过游乐场游玩的例子进行解释。接着，文章阐述了DFS和BFS的实现，重点讨论了回溯和重放的概念，并以二叉树为例，提供了递归和非递归实现DFS的代码。此外，还解释了BFS的实现原理，同样以队列为基础。最后，通过一道LeetCode题目展示了DFS和BFS在实际问题中的应用。
什么是深度/广度优先遍历(DFS/BFS)？
深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。
这两种遍历方式有什么不同呢？我们来举个栗子：
我们来到一个游乐场，游乐场里有11个景点。我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？
第一种：
一头扎到底的玩法。我们选择一条支路，尽可能不断地深入，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入。
像这样先深入探索，走到头再回退寻找其他出路的遍历方式，就叫做深度优先遍历（DFS）。
除了像深度优先遍历这样一头扎到底的玩法以外，我们还有
另一种玩法：
首先把起点相邻的几个景点玩遍，然后去玩距离起点稍远一些（隔一层）的景点，然后再去玩距离起点更远一些（隔两层）的景点......
像这样一层一层由内而外的遍历方式，就叫做广度优先遍历（BFS）。
这种方式看上去很像二叉树的层序遍历，其实，二叉树的层序遍历，本质上也可以被认为是广度优先遍历。
深度/广度优先遍历 的实现
DFS VS BFS
那么如何实现深度优先遍历和广度优先遍历算法呢？
实现深度优先遍历的关键在于【回溯】，
实现广度优先遍历的关键在于【重放】。
深度优先遍历DFS
首先说说深度优先遍历的实现过程。这里所说的回溯是什么意思呢？
回溯，顾名思义，就是自后向前，追溯曾经走过的路径。要想实现回溯，可以利用栈的先入后出特性，也可以采用递归的方式（因为递归本身就是基于方法调用栈来实现）。
演算方法：
首先将根节点放入stack中。
从stack中取出第一个节点，并检验它是否为目标。
重复步骤2。
如果不存在未检测过的直接子节点。
重复步骤4。
若stack为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。
举个栗子：
树是图的一种特例(连通无环的图就是树)，接下来我们来看看树用深度优先遍历该怎么遍历。
1、我们从根节点 1 开始遍历，它相邻的节点有 2，3，4，先遍历节点 2，再遍历 2 的子节点 5，然后再遍历 5 的子节点 9。
2、上图中一条路已经走到底了(9是叶子节点，再无可遍历的节点)，此时就从 9 回退到上一个节点 5，看下节点 5 是否还有除 9 以外的节点，没有继续回退到 2，2 也没有除 5 以外的节点，回退到 1，1 有除 2 以外的节点 3，所以从节点 3 开始进行深度优先遍历，如下：
3、同理从 10 开始往上回溯到 6, 6 没有除 10 以外的子节点，再往上回溯，发现 3 有除 6 以外的子点 7，所以此时会遍历 7。
4、从 7 往上回溯到 3， 1，发现 1 还有节点 4 未遍历，所以此时沿着 4， 8 进行遍历,这样就遍历完成了。
完整的节点的遍历顺序如下(节点上的的蓝色数字代表)：
相信大家看到以上的遍历不难发现这就是树的前序遍历,实际上不管是前序遍历，还是中序遍历，亦或是后序遍历，都属于深度优先遍历。
那么深度优先遍历该怎么实现呢，有递归和非递归两种表现形式，接下来我们以二叉树为例来看下如何分别用递归和非递归来实现深度优先遍历。
1、递归实现
递归实现比较简单，由于是前序遍历，所以我们依次遍历当前节点，左节点，右节点即可，对于左右节点来说，依次遍历它们的左右节点即可，依此不断递归下去，直到叶节点(递归终止条件)，
代码如下：
public class Solution {
private static class Node {
/**
* 节点值
*/
public int value;
/**
* 左节点
*/
public Node left;
/**
* 右节点
*/
public Node right;
public Node(int value, Node left, Node right) {
this.value = value;
this.left = left;
this.right = right;
}
}
public static void dfs(Node treeNode) {
if (treeNode == null) {
return;
}
// 遍历节点
process(treeNode)
// 遍历左节点
dfs(treeNode.left);
// 遍历右节点
dfs(treeNode.right);
}
} 递归的表达性很好，也很容易理解，不过如果层级过深，很容易导致栈溢出。所以我们重点看下非递归实现。
2、非递归实现
仔细观察深度优先遍历的特点，对二叉树来说，由于是先序遍历(先遍历当前节点，再遍历左节点，再遍历右节点)，所以我们有如下思路：
-
对于每个节点来说，先遍历当前节点，然后把右节点压栈，再压左节点(这样弹栈的时候会先拿到左节点遍历，符合深度优先遍历要求)。
- 弹栈，拿到栈顶的节点，如果节点不为空，重复步骤 1， 如果为空，结束遍历。
整体思路还是比较清晰的，使用栈来将要遍历的节点压栈，然后出栈后检查此节点是否还有未遍历的节点，有的话压栈，没有的话不断回溯(出栈)，有了思路，不难写出如下用栈实现的二叉树的深度优先遍历代码。
代码如下：
/**
* 使用栈来实现 dfs
* @param root
*/
public static void dfsWithStack(Node root) {
if (root == null) {
return;
}
Stack<Node> stack = new Stack<>();
// 先把根节点压栈
stack.push(root);
while (!stack.isEmpty()) {
Node treeNode = stack.pop();
// 遍历节点
process(treeNode)
// 先压右节点
if (treeNode.right != null) {
stack.push(treeNode.right);
}
// 再压左节点
if (treeNode.left != null) {
stack.push(treeNode.left);
}
}
}
可以看到用栈实现深度优先遍历其实代码也不复杂，而且也不用担心递归那样层级过深导致的栈溢出问题。
广度优先遍历BFS
接下来该说说广度优先遍历的实现过程了。刚才所说的重放是什么意思呢？似乎听起来和回溯差不多？其实，回溯与重放是完全相反的过程。同样的，要实现重放也需要额外的存储空间，可以利用队列的先入先出特性来实现。
实现方法：
首先将根节点放入队列中。
从队列中取出第一个节点，并检验它是否为目标。
如果找到目标，则结束搜索并回传结果。
否则将它所有尚未检验过的直接子节点加入队列中。
若队列为空，表示整张图都检查过了——亦即图中没有欲搜索的目标。结束搜索并回传“找不到目标”。
重复步骤2。
上文所述树的广度优先遍历动图如下，每个节点的值即为它们的遍历顺序。所以广度优先遍历也叫层序遍历，先遍历第一层(节点 1)，再遍历第二层(节点 2，3，4)，第三层(5，6，7，8)，第四层(9，10)。
代码如下：
/**
* 使用队列实现 bfs
* @param root
*/
private static void bfs(Node root) {
if (root == null) {
return;
}
Queue<Node> stack = new LinkedList<>();
stack.add(root);
while (!stack.isEmpty()) {
Node node = stack.poll();
System.out.println("value = " + node.value);
Node left = node.left;
if (left != null) {
stack.add(left);
}
Node right = node.right;
if (right != null) {
stack.add(right);
}
}
} 习题演练：
接下来我们来看看在 leetcode 中出现的一些使用 DFS，BFS 来解题的题目：
给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。
两个网格块属于同一 连通分量 需满足下述全部条件：
两个网格块颜色相同
在上、下、左、右任意一个方向上相邻
连通分量的边界 是指连通分量中满足下述条件之一的所有网格块：
在上、下、左、右四个方向上与不属于同一连通分量的网格块相邻
在网格的边界上（第一行/列或最后一行/列）
请你使用指定颜色 color 为所有包含网格块 grid [ row ] [ col ] 的 连通分量的边界 进行着色，并返回最终的网格 grid 。
示例 1：
输入：grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
输出：[[3,3],[3,2]]
示例 2：
输入：grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
输出：[[2,2,2],[2,1,2],[2,2,2]]
常规思路：
可以使用深度优先搜索或者广度优先搜索来寻找出位置 (\textit{row},\textit{col})(row,col) 的所在的连通分量，额外要做的是搜索的时候需要判断当前的点是否属于边界。如果属于边界，需要把该点加入到一个用来存所有边界点的数组中。当搜索完毕后，再将所有边界点的进行着色。
BFS
具体的，我们可以使用 BFS 进行求解：
Java代码：
class Solution {
public int[][] colorBorder(int[][] grid, int row, int col, int color) {
int m = grid.length, n = grid[0].length;
int[][] ans = new int[m][n];
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
Deque<int[]> d = new ArrayDeque<>();
d.addLast(new int[]{row, col});
while (!d.isEmpty()) {
int[] poll = d.pollFirst();
int x = poll[0], y = poll[1], cnt = 0;
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (grid[x][y] != grid[nx][ny]) continue;
else cnt++;
if (ans[nx][ny] != 0) continue;
d.addLast(new int[]{nx, ny});
}
ans[x][y] = cnt == 4 ? grid[x][y] : color;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (ans[i][j] == 0) ans[i][j] = grid[i][j];
}
}
return ans;
}
}
时间复杂度：O(m * n)
空间复杂度：O(m * n)
DFS
同理，可以使用 DFS 进行求解。
由于使用 DFS 搜索时，我们使用「栈帧压栈/弹栈」作为拓展联通节点的容器，且仅在出队时进行上色。为防止「重复入队」问题，我们需要先在对节点 (nx, ny)(nx,ny) 入队时，先设置将 ansnxansnx 设置为 -1−1 标识位，以作为判重依据。
Java代码：
class Solution {
int m, n, c;
int[][] grid, ans;
int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};
public int[][] colorBorder(int[][] _grid, int row, int col, int color) {
grid = _grid; c = color;
m = grid.length; n = grid[0].length;
ans = new int[m][n];
dfs(row, col);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (ans[i][j] == 0) ans[i][j] = grid[i][j];
}
}
return ans;
}
void dfs(int x, int y) {
int cnt = 0;
for (int[] di : dirs) {
int nx = x + di[0], ny = y + di[1];
if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
if (grid[x][y] != grid[nx][ny]) continue;
else cnt++;
if (ans[nx][ny] != 0) continue;
ans[nx][ny] = -1;
dfs(nx, ny);
}
ans[x][y] = cnt == 4 ? grid[x][y] : c;
}
}
时间复杂度：O(m * n)
空间复杂度：O(m * n)
总结：
无论是深度优先遍历还是广度优先遍历，当我获取一个顶点的若干邻近顶点时如何判断这些顶点哪个已经被访问过，哪个没有被访问？
我们可以利用一个布尔类型的数组来存储所有顶点的遍历状态，顶点对应数组元素的初始值是false，代表未遍历，遍历之后变为true。
扫一扫
6516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
