广度优先遍历总结

广度优先遍历

广度优先搜索是最简便的图的搜索算法之一，其别名又叫$BFS$，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。
$BFS$ 一般通过一个 $Queue$ 来实现。

题目总结

二叉树的层次遍历

比如，给定二叉树 $[1,2,3,null,null,4,5]$
$1$
$\swarrow \searrow$
$23$
$\swarrow \searrow$
$45$
遍历结果为 $[1,2,3,4,5]$

public class BFS{
	public List<Integer> bfs(TreeNode root){
		List<Integer> ans;
		Queue<TreeNode> queue;

		ans = new ArrayList<>():
		queue = new LinkedList<>();
		if(root == null)
			return ans;
		queue.offer(root);
		while(!queue.isEmpty()){
			root = queue.poll();
			if(root.left != null)
				queue.offer(root.left);
			if(root.right != null)
				queue.offer(root.right);
		}
		return ans;
	}
}

被围绕的区域

给定一个二维的矩阵，包含 ${}^{\prime }{X}^{\prime }$ 和 ${}^{\prime }{O}^{\prime }$（字母 $O$）。
找到所有被 ${}^{\prime }{X}^{\prime }$ 围绕的区域，并将这些区域里所有的 ${}^{\prime }{O}^{\prime }$ 用 ${}^{\prime }{X}^{\prime }$ 填充。
示例:
$XXXX$
$XOOX$
$XXOX$
$XOXX$
运行你的函数后，矩阵变为：
$XXXX$
$XXXX$
$XXXX$
$XOXX$
来源：leetcode-130

思路：现在边界上找到 ${}^{\prime }{O}^{\prime }$，然后根据 $BFS$ 算法找出所有与它连起来的 ${}^{\prime }{O}^{\prime }$，标记这些 ${}^{\prime }{O}^{\prime }$，这里用 ${}^{\prime }{C}^{\prime }$，然后再遍历一次，把没标记的 ${}^{\prime }{O}^{\prime }$ 变成 ${}^{\prime }{X}^{\prime }$， 标记了的 ${}^{\prime }{C}^{\prime }$ 重现改成 ${}^{\prime }{O}^{\prime }$。

class Solution {
    public void solve(char[][] board) {
        int m, n, i, j;
        int[] next;
        Queue<int[]> queue;
        
        queue = new LinkedList<>();
        m = board.length;
        if(m == 0)
            return;
        n = board[0].length;
        if(m < 2 || n < 2)
            return;
        for(j = 0; j < n; j++){
            if(board[0][j] == 'O'){
                queue.offer(new int[]{0, j});
            }
            if(board[m-1][j] == 'O'){
                queue.offer(new int[]{m - 1, j});
            }
        }
        for(i = 1; i < m - 1; i++){
            if(board[i][0] == 'O'){
                queue.offer(new int[]{i, 0});
            }
            if(board[i][n-1] == 'O'){
                queue.offer(new int[]{i, n - 1});
            }
        }
        while(!queue.isEmpty()){
            next = queue.poll();
            i = next[0];
            j = next[1];
            board[i][j] = 'C';
            if(check(board, i + 1, j)){
                queue.offer(new int[]{i + 1, j});
            }
            if(check(board, i - 1, j)){
                queue.offer(new int[]{i - 1, j});
            }
            if(check(board, i, j + 1)){
                queue.offer(new int[]{i, j + 1});
            }
            if(check(board, i, j - 1)){
                queue.offer(new int[]{i, j - 1});
            }
        }
        for(i = 0; i < m; i++){
            for(j = 0; j < n; j++){
                if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }else if(board[i][j] == 'C'){
                    board[i][j] = 'O';
                }
            }
        }
	}

    private boolean check(char[][] board, int i, int j){
        if(i < 0 || j < 0 || i == board.length || j == board[0].length)
            return false;
        return board[i][j] == 'O';
    }
}