算法（6）深度优先搜索和广度优先搜索

一、深度优先搜索（DFS）

主要思路: 从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底，不断递归重复此过程，直到所有的顶点都遍历完成，它的特点是“不撞南墙不回头”，先走完一条路，再换一条路继续走。
例子： 用深度优先搜索遍历下面的树

1、我们从根节点1开始遍历，它相邻的节点有2，3，4，先遍历节点2，再遍历2 的子节点5，然后再遍历5的子节点9。

2、上图中一条路已经走到底了，此时就从9回退到上一个节点5，看下节点5是否还有除9以外的节点，没有继续回退到2，2 也没有除5以外的节点，回退到1，1 有除2以外的节点3，所以从节点3开始进行深度优先遍历，如下：

3、同理从10开始往上回溯到6, 6 没有除10以外的子节点，再往上回溯，发现3有除6以外的子点7，所以此时会遍历7。从 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。使用栈来将要遍历的节点压栈，然后出栈后检查此节点是否还有未遍历的节点，有的话压栈，没有的话不断回溯（出栈）。

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）

广度优先遍历，指的是从图的一个未遍历的节点出发，先遍历这个节点的相邻节点，再依次遍历每个相邻节点的相邻节点。上文所述树的广度优先遍历动图如下，每个节点的值即为它们的遍历顺序。所以广度优先遍历也叫层序遍历，先遍历第一层(节点 1)，再遍历第二层(节点 2，3，4)，第三层(5，6，7，8)，第四层(9，10)。

深度优先遍历用的是栈，而广度优先遍历要用队列来实现，我们以下图二叉树为例来看看如何用队列来实现广度优先遍历。

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); 
        } 
    } 
}