当前位置：首页 > 行业动态 > 正文

dfs java语言

admin
行业动态
2025-04-05
1

DFS（深度优先搜索）是一种用于遍历或搜索树、图等数据结构的算法，Java语言中可通过递归或栈实现。

深度优先搜索（Depth First Search，简称DFS）是一种重要的图遍历算法，在Java语言中实现DFS可以帮助我们解决许多复杂的问题，如迷宫求解、拓扑排序等，下面将详细介绍如何在Java中实现DFS算法。

节点结构定义

我们需要定义图中节点的结构，通常可以通过一个类来表示节点，该类包含节点的标识符和其相邻节点的信息，以下是一个简单的节点类示例：

class Node {
    int id; // 节点的标识符
    List<Node> neighbors; // 相邻节点列表
    public Node(int id) {
        this.id = id;
        this.neighbors = new ArrayList<>();
    }
    // 添加相邻节点的方法
    public void addNeighbor(Node neighbor) {
        this.neighbors.add(neighbor);
    }
}

创建图的邻接表

我们通过邻接表来表示图中的节点的连接关系，以下代码展示如何创建图：

dfs java语言

Node node1 = new Node(1);
Node node2 = new Node(2);
Node node3 = new Node(3);
Node node4 = new Node(4);
Node node5 = new Node(5);
node1.addNeighbor(node2);
node1.addNeighbor(node3);
node2.addNeighbor(node4);
node3.addNeighbor(node4);
node4.addNeighbor(node5);

在上面的代码中，我们创建了五个节点，并设置了它们之间的相邻关系，节点1与节点2和节点3相邻，节点2与节点4相邻，以此类推。

实现DFS算法

DFS算法可以通过递归或使用栈来实现，下面分别介绍这两种实现方式。

递归实现DFS

递归实现DFS是最常见的方式之一，在递归方法中，我们首先将当前节点标记为已访问，然后递归地访问其所有未被访问过的相邻节点，以下是递归实现DFS的代码示例：

dfs java语言

public class DFSExample {
    private boolean[] visited; // 记录节点是否被访问过
    public DFSExample(int numOfNodes) {
        this.visited = new boolean[numOfNodes + 1]; // 初始化访问数组
    }
    // DFS递归方法
    public void dfs(Node node) {
        // 标记当前节点为已访问
        visited[node.id] = true;
        System.out.print("访问节点: " + node.id + " ");
        // 递归访问所有未被访问过的相邻节点
        for (Node neighbor : node.neighbors) {
            if (!visited[neighbor.id]) {
                dfs(neighbor);
            }
        }
    }
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.addNeighbor(node2);
        node1.addNeighbor(node3);
        node2.addNeighbor(node4);
        node3.addNeighbor(node4);
        node4.addNeighbor(node5);
        DFSExample dfsExample = new DFSExample(5);
        dfsExample.dfs(node1); // 从节点1开始DFS遍历
    }
}

在上面的代码中，我们首先创建了一个DFSExample类，该类包含一个布尔数组visited用于记录节点是否被访问过，在dfs方法中，我们首先将当前节点标记为已访问，然后递归地访问其所有未被访问过的相邻节点，在main方法中，我们创建了图的节点并设置了它们的相邻关系，然后调用dfs方法从节点1开始进行DFS遍历。

使用栈实现DFS

除了递归实现外，我们还可以使用栈来模拟递归过程，从而实现非递归的DFS算法，以下是使用栈实现DFS的代码示例：

import java.util.;
public class DFSNonRecursive {
    private boolean[] visited; // 记录节点是否被访问过
    public DFSNonRecursive(int numOfNodes) {
        this.visited = new boolean[numOfNodes + 1]; // 初始化访问数组
    }
    // 使用栈实现DFS的方法
    public void dfs(Node startNode) {
        Stack<Node> stack = new Stack<>(); // 创建一个栈用于存储待访问的节点
        stack.push(startNode); // 将起始节点压入栈中
        while (!stack.isEmpty()) {
            Node currentNode = stack.pop(); // 弹出栈顶元素作为当前节点
            if (!visited[currentNode.id]) { // 如果当前节点未被访问过
                visited[currentNode.id] = true; // 标记为已访问
                System.out.print("访问节点: " + currentNode.id + " ");
                // 将所有未被访问过的相邻节点压入栈中
                for (int i = currentNode.neighbors.size() 1; i >= 0; i--) {
                    Node neighbor = currentNode.neighbors.get(i);
                    if (!visited[neighbor.id]) {
                        stack.push(neighbor);
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        node1.addNeighbor(node2);
        node1.addNeighbor(node3);
        node2.addNeighbor(node4);
        node3.addNeighbor(node4);
        node4.addNeighbor(node5);
        DFSNonRecursive dfsNonRecursive = new DFSNonRecursive(5);
        dfsNonRecursive.dfs(node1); // 从节点1开始DFS遍历
    }
}

在上面的代码中，我们首先创建了一个DFSNonRecursive类，该类同样包含一个布尔数组visited用于记录节点是否被访问过，在dfs方法中，我们使用一个栈来存储待访问的节点，首先将起始节点压入栈中，然后在循环中不断弹出栈顶元素作为当前节点，并检查其是否已被访问过，如果未被访问过，则将其标记为已访问并输出其编号，同时将其所有未被访问过的相邻节点压入栈中，这个过程一直持续到栈为空为止。

dfs java语言