深度优先搜索（java）

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Graph {
    private int V; // 图中节点的数量
    private List<List<Integer>> adj; // 邻接列表

    public Graph(int v) {
        V = v;
        adj = new ArrayList<>(v);
        for (int i = 0; i < v; ++i) {
            adj.add(new ArrayList<>());
        }
    }

    public void addEdge(int v, int w) {
        adj.get(v).add(w);
    }

    public void dfs(int start) {
        boolean[] visited = new boolean[V]; // 用于记录节点是否已访问
        Stack<Integer> stack = new Stack<>();

        // 将起始节点入栈
        stack.push(start);

        while (!stack.isEmpty()) {
            int current = stack.pop();

            // 如果当前节点未访问，则访问它并标记为已访问
            if (!visited[current]) {
                System.out.print(current + " ");
                visited[current] = true;
            }

            // 将当前节点的未访问邻居入栈
            for (int neighbor : adj.get(current)) {
                if (!visited[neighbor]) {
                    stack.push(neighbor);
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Graph g = new Graph(7); // 创建一个包含7个节点的图

        // 添加图的边
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 3);
        g.addEdge(1, 4);
        g.addEdge(2, 5);
        g.addEdge(2, 6);
        
        // 从节点0出发的深度优先遍历结果将会是 :
        // 0 2 6 5 1 4 3 
        // 后序优先（因为push栈，后进先出）

        System.out.println("深度优先遍历结果：");
        g.dfs(0); // 从节点0开始进行深度优先搜索
    }
}

1.private List<List< Integer >> adj;

private List<List< Integer >> adj; 是一个邻接列表（adjacency list）的数据结构，用于表示图中节点之间的关系。在邻接列表中，每个节点都与一个列表相关联，该列表存储与该节点直接相连的其他节点。

0 --- 1 --- 3
|     |     |
2     4     5

private List<List<Integer>> adj = new ArrayList<>();

// 添加节点0的邻居
adj.add(Arrays.asList(1, 2));

// 添加节点1的邻居
adj.add(Arrays.asList(0, 3, 4));

// 添加节点2的邻居
adj.add(Arrays.asList(0));

// 添加节点3的邻居
adj.add(Arrays.asList(1, 5));

// 添加节点4的邻居
adj.add(Arrays.asList(1));

// 添加节点5的邻居
adj.add(Arrays.asList(3));

2.for循环的作用

   for (int i = 0; i < v; ++i) {
            adj.add(new ArrayList<>());
        }

这段代码的 for 循环用于初始化邻接列表（adj）的数据结构。在构造函数 public Graph(int v) 中，参数 v 表示图中节点的数量，而 adj 是一个成员变量，用于存储图的邻接列表。

这个 for 循环的作用如下：

1. adj = new ArrayList<>(v)：这一行代码创建了一个名为 adj 的 ArrayList，其大小初始化为 v，也就是图中节点的数量。这个 ArrayList 是用来存储邻接列表的，每个列表对应图中的一个节点。

2. for (int i = 0; i < v; ++i)：这是一个循环，它从 0 开始迭代，一直到 v - 1。在每次迭代中，它执行以下操作：

   3. adj.add(new ArrayList<>())：这一行代码在 adj 列表中添加一个新的空 ArrayList。这个 ArrayList 用于存储与图中节点 i 相邻的其他节点。

因此，整个循环的目的是为每个图中的节点创建一个对应的空邻接列表，以便稍后将节点的邻居添加到相应的列表中。这是构建邻接列表数据结构的初始化步骤，为后续的图操作做好了准备。

3.adj.get(current)返回的是什么类型

adj.get(current) 返回的是一个列表类型，具体来说是List<Integer>类型的列表。在邻接列表 adj 中，每个节点的邻居信息都以整数的形式存储在这个列表中。

所以，adj.get(current) 表示获取邻接列表 adj 中索引为 current 的位置上存储的整数列表，这个列表包含了与节点 current 直接相连的邻居节点的索引。因此，返回的类型是 List<Integer>，其中 Integer 表示整数类型。这个列表包含了与当前节点相邻的其他节点的索引信息。

4. public void addEdge(int v, int w)

public void addEdge(int v, int w) 方法的

 public void addEdge(int v, int w) {
        adj.get(v).add(w);
    }

作用是将一条有向边从节点 v 指向节点 w 添加到图的邻接列表中。在这个深度优先搜索（DFS）的图类中，邻接列表 adj 用于存储节点之间的关系。

具体来说，这个方法完成以下操作：

1. 通过 adj.get(v) 获取节点 v 对应的邻居列表。
2. 然后，将节点 w 添加到 v 的邻居列表中，表示节点 v 与节点 w 有一条有向边。

这个方法是用来构建图的结构的，通过多次调用 addEdge 方法，可以将图的边逐一添加到邻接列表中，从而建立图的连接关系。

例如，在前面提供的示例中，以下代码段添加了图中的边：

g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 5);
g.addEdge(2, 6);

这些方法调用将节点之间的有向边添加到了图的邻接列表中，从而定义了图的结构。