图的遍历算法—

图的遍历算法——BFS和DFS

一、前言

在计算机科学领域，图是一种非常重要的数据结构。图是由节点和边构成的，节点之间的关系通过边来表示。图的遍历是对图进行搜索的过程，可以帮助我们找到图中的所有节点和边。

在本文中，我们将介绍两种常见的图遍历算法——BFS和DFS。BFS（广度优先搜索）是一种广度优先搜索算法，DFS（深度优先搜索）是一种深度优先搜索算法。这两种算法都可以用来遍历图中的所有节点和边，但它们的搜索方式不同。

二、BFS算法

BFS算法是一种广度优先搜索算法，它从图的起始节点开始遍历，逐层扩展搜索范围，直到找到目标节点为止。BFS算法使用队列来存储待搜索的节点，先进先出的原则确保了搜索的广度优先。

2.1 算法思路

BFS算法的基本思路如下：

将起始节点放入队列中，并将其标记为已访问。
从队列中取出一个节点，访问它的所有未访问过的邻居节点，并将它们放入队列中。
重复步骤2，直到队列为空。

2.2 代码实现

下面是BFS算法的Java代码实现：

public class Code01_BFS {
  /**
     * BFS算法
     * @param start 起始节点
     */
    public static void bfs(Node start) {
        if (start == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        Set<Node> set = new HashSet<>();
        queue.add(start);
        set.add(start);
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            System.out.println(cur.value);
            for (Node next : cur.nexts) {
                if (!set.contains(next)) {
                    set.add(next);
                    queue.add(next);
                }
            }
        }
    }
}

三、DFS算法

DFS算法是一种深度优先搜索算法，它从图的起始节点开始遍历，一直走到最深处，直到找到目标节点为止。DFS算法使用栈来存储待搜索的节点，后进先出的原则确保了搜索的深度优先。

3.1 算法思路

DFS算法的基本思路如下：

将起始节点压入栈中，并将其标记为已访问。
从栈中弹出一个节点，访问它的所有未访问过的邻居节点，并将它们压入栈中。
重复步骤2，直到栈为空。

3.2 代码实现

下面是DFS算法的Java代码实现：

public class Code02_DFS {
 /**
     * DFS算法
     * @param node 起始节点
     */
    public static void dfs(Node node) {
        if (node == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        HashSet<Node> set = new HashSet<>();
        stack.add(node);
        set.add(node);
        while (!stack.isEmpty()) {
            Node cur = stack.pop();
            for (Node next : cur.nexts) {
                if (!set.contains(next)) {
                    stack.push(cur);
                    stack.push(next);
                    set.add(next);
                    System.out.println(next.value);
                    break;
                }
            }
        }
    }
}