图寻路算法实战：基于深度优先搜索 (DFS) 的 Java 实现

图寻路算法详解：基于深度优先搜索 (DFS) 的实现

图的寻路算法是图论中的基础应用，核心目标是在网络中找到从起点到终点的路径。深度优先搜索（DFS）作为一种经典的遍历策略，通过沿着图的深度方向尽可能远地探索路径，非常适合用于判断连通性或寻找任意一条可行路径。

核心思想与数据结构

DFS 寻路的关键在于记录访问状态和回溯路径。我们需要维护两个核心数组：

1. visited 数组：标记顶点是否已被访问，防止死循环或重复计算。
2. from 数组：记录路径中每个顶点的前驱节点。一旦找到终点，即可通过 from 数组逆向回溯还原完整路径。

在实现上，我们通常从起点开始递归访问所有未访问的邻接顶点。当递归返回时，如果当前节点不是起点，则将其前驱关系记录下来。

代码实现细节

下面是一个完整的 Java 实现示例。为了保持逻辑清晰，我们将寻路逻辑封装在 Path 类中，依赖一个基础的 Graph 接口（假设已存在）。

1. 核心类结构

import java.util.Stack;
import java.util.Vector;

/**
 * 基于 DFS 的寻路算法实现
 */
public class Path {
    private Graph G;          // 图的引用
    private int s;            // 起始点
    private boolean[] visited;// 记录访问过的节点
    private int[] from;       // 记录路径，from[i] 表示 i 的前驱节点

    /**
     * 构造函数，初始化寻路对象
     * @param graph 图实例
     * @param s 起始顶点索引
     */
    public Path(Graph graph, int s) {
        G = graph;
        assert s >= 0 && s < G.V();
        
        visited = new boolean[G.V()];
        from = new int[G.V()];
        
        // 初始化状态
        for (int   ; i < G.V(); i++) {
            visited[i] = ;
            from[i] = -;
        }
        .s = s;
        
        dfs(s);
    }

    
       {
        visited[v] = ;
        
         ( i : G.adj(v)) {
             (!visited[i]) {
                from[i] = v; 
                dfs(i);      
            }
        }
    }

    
      {
         w >=  && w < G.V();
         visited[w];
    }

    
    Vector<Integer>  {
         ;
        Stack<Integer> stack =  <>();
           w;
        
         (p != -) {
            stack.push(p);
            p = from[p];
        }
        
        Vector<Integer> res =  <>();
         (!stack.empty()) {
            res.add(stack.pop());
        }
         res;
    }

    
      {
         ;
        Vector<Integer> vec = path(w);
         (   ; i < vec.size(); i++) {
            System.out.print(vec.elementAt(i));
             (i != vec.size() - )
                System.out.print();
        }
        System.out.println();
    }
}