搜索算法之深度优先搜索详细解读（附带Java代码解读）

深度优先搜索（DFS）详细介绍

1. 基本概念

• 树结构：在树结构中，DFS 从根节点开始，沿着每个分支深入直到到达叶子节点，然后回溯到上一个节点，继续对其他分支进行探索。
• 图结构：在图结构中，DFS 从一个起始节点开始，沿着每个边深入到达未访问的邻居节点，直到没有未访问的邻居节点，然后回溯。

2. 工作原理

深度优先搜索的工作原理可以分为以下几个步骤：

1. 初始化：

   • 初始化一个数据结构（栈或递归调用）来跟踪访问的节点。
   • 初始化一个集合或标记来记录已访问的节点。

2. 访问节点：

   • 从起始节点开始，将其标记为已访问，并将其添加到数据结构中。
   • 遍历该节点的所有邻居节点，对于每个未访问的邻居节点，递归调用 DFS 或将其压入栈中。

3. 递归或栈操作：

   • 递归方法：在每个节点的递归调用中，访问其所有未访问的邻居。
   • 栈方法：使用栈来保存待访问的节点，逐个处理栈顶节点，将其所有未访问的邻居压入栈中。

4. 回溯：

   • 当当前节点的所有邻居都已访问时，回溯到前一个节点，继续处理其他未访问的邻居。

5. 结束条件：

   • 直到所有节点都被访问或者满足某种特定的条件（如找到目标节点）。

3. 算法步骤

以下是深度优先搜索的详细步骤：

1. 输入：

   • 一个图或树，通常以邻接表或邻接矩阵表示。
   • 起始节点。

2. 步骤：

   • 初始化一个栈（或使用递归调用）和一个集合（或标记）来记录访问状态。
   • 将起始节点压入栈中，并标记为已访问。
   • 进入循环：
     • 从栈中弹出一个节点（或在递归调用中处理当前节点）。
     • 访问该节点并处理（例如打印节点值或执行某个操作）。
     • 遍历该节点的所有邻居，如果某个邻居未被访问，则将其压入栈中（或递归调用）。
   • 继续直到栈为空（或递归调用结束）。

3. 结束条件：

   • 如果所有节点都已访问，算法结束。
   • 如果在某些情况下找到目标节点，可以提前结束。

4. 时间复杂度分析

• 时间复杂度：在图结构中，深度优先搜索的时间复杂度是 O(V + E)，其中 V 是图中的节点数，E 是图中的边数。对于树结构，时间复杂度为 O(V)，其中 V 是树中的节点数。

• 空间复杂度：

  • 栈/递归调用：最坏情况下，栈的空间复杂度为 O(V)，取决于树或图的深度。
  • 已访问集合：需要额外的空间来存储已访问的节点，空间复杂度为 O(V)。

5. 实现代码

import java.util.*;

public class DepthFirstSearch {

    // 使用栈实现的DFS
    public static void dfsStack(Map<Integer, List<Integer>> graph, int start) {
        Set<Integer> visited = new HashSet<>();
        Stack<Integer> stack = new Stack<>();
        
        stack.push(start);

        while (!stack.isEmpty()) {
            int node = stack.pop();
            if (!visited.contains(node)) {
                System.out.print(node + " ");
                visited.add(node);

                for (int neighbor : graph.get(node)) {
                    if (!visited.contains(neighbor)) {
                        stack.push(neighbor);
                    }
                }
            }
        }
    }

    // 使用递归实现的DFS
    public static void dfsRecursive(Map<Integer, List<Integer>> graph, int start, Set<Integer> visited) {
        if (visited.contains(start)) return;

        System.out.print(start + " ");
        visited.add(start);

        for (int neighbor : graph.get(start)) {
            if (!visited.contains(neighbor)) {
                dfsRecursive(graph, neighbor, visited);
            }
        }
    }

    public static void main(String[] args) {
        // 图的邻接表表示
        Map<Integer, List<Integer>> graph = new HashMap<>();
        graph.put(1, Arrays.asList(2, 3));
        graph.put(2, Arrays.asList(1, 4, 5));
        graph.put(3, Arrays.asList(1, 6));
        graph.put(4, Arrays.asList(2));
        graph.put(5, Arrays.asList(2));
        graph.put(6, Arrays.asList(3));

        // 非递归实现的DFS
        System.out.println("DFS (using stack):");
        dfsStack(graph, 1);

        // 递归实现的DFS
        System.out.println("\nDFS (using recursion):");
        Set<Integer> visited = new HashSet<>();
        dfsRecursive(graph, 1, visited);
    }
}

代码解读：

• public static void dfsStack(Map<Integer, List<Integer>> graph, int start)：

  • 使用栈实现深度优先搜索。
  • 初始化一个栈和一个访问集合，将起始节点推入栈中。
  • 循环处理栈中的节点，访问节点，标记为已访问，并将未访问的邻居节点推入栈中。

• public static void dfsRecursive(Map<Integer, List<Integer>> graph, int start, Set<Integer> visited)：

  • 使用递归实现深度优先搜索。
  • 递归访问当前节点，标记为已访问，然后递归访问所有未访问的邻居节点。

• public static void main(String[] args)：

  • 初始化一个图的邻接表表示。
  • 演示两种实现的深度优先搜索。

6. 实际应用

• 图遍历：深度优先搜索用于图遍历、图的连通分量检测、拓扑排序等任务。
• 路径查找：在图中查找路径、解决迷宫问题。
• 树结构：在树结构中查找节点、进行树的遍历（前序遍历、中序遍历、后序遍历）。

7. 局限性

• 可能会陷入深度过深的节点：在某些情况下，DFS 可能会在深度过深的节点中停留较长时间，尤其是在处理无限图时。
• 非最短路径：DFS 不一定找到最短路径，特别是在图中存在多个路径时。