Java 深度优先搜索

深度优先搜索(Depth-First Search, DFS)是一种用于遍历或搜索树或图的算法。在Java中,可以使用递归或迭代的方法来实现DFS。下面我将分别介绍这两种实现方式。

递归实现

递归实现通常更为直观和简洁。在递归方法中,我们会使用一个栈(在递归调用栈中)来保存节点信息。

import java.util.*;  
  
class Graph {  
    private int numVertices;  
    private LinkedList<Integer>[] adjLists;  
  
    // 构造函数  
    Graph(int vertices) {  
        numVertices = vertices;  
        adjLists = new LinkedList[vertices];  
        for (int i = 0; i < vertices; i++) {  
            adjLists[i] = new LinkedList<>();  
        }  
    }  
  
    // 添加边  
    void addEdge(int src, int dest) {  
        adjLists[src].add(dest);  
    }  
  
    // 递归的深度优先搜索(DFS)辅助函数  
    private void DFSUtil(int vertex, boolean[] visited) {  
        // 标记当前节点为已访问  
        visited[vertex] = true;  
        System.out.print(vertex + " ");  
  
        // 递归访问所有邻接节点  
        Iterator<Integer> iterator = adjLists[vertex].listIterator();  
        while (iterator.hasNext()) {  
            int adjVertex = iterator.next();  
            if (!visited[adjVertex]) {  
                DFSUtil(adjVertex, visited);  
            }  
        }  
    }  
  
    // 深度优先搜索算法  
    void DFS(int startVertex) {  
        // 标记所有节点为未访问  
        boolean[] visited = new boolean[numVertices];  
  
        // 从指定节点开始DFS  
        DFSUtil(startVertex, visited);  
    }  
  
    public static void main(String[] args) {  
        Graph graph = new Graph(5);  
  
        graph.addEdge(0, 1);  
        graph.addEdge(0, 2);  
        graph.addEdge(1, 2);  
        graph.addEdge(2, 0);  
        graph.addEdge(2, 3);  
        graph.addEdge(3, 3);  
  
        System.out.println("深度优先搜索(DFS)遍历起始节点为 2:");  
  
        graph.DFS(2);  
    }  
}

迭代实现

迭代实现DFS需要使用显式栈来保存节点信息。以下是一个使用栈实现DFS的例子:

import java.util.*;  
  
class Graph {  
    private int numVertices;  
    private LinkedList<Integer>[] adjLists;  
  
    // 构造函数  
    Graph(int vertices) {  
        numVertices = vertices;  
        adjLists = new LinkedList[vertices];  
        for (int i = 0; i < vertices; i++) {  
            adjLists[i] = new LinkedList<>();  
        }  
    }  
  
    // 添加边  
    void addEdge(int src, int dest) {  
        adjLists[src].add(dest);  
    }  
  
    // 深度优先搜索算法(迭代方式)  
    void DFS(int startVertex) {  
        // 标记所有节点为未访问  
        boolean[] visited = new boolean[numVertices];  
  
        // 创建一个栈并压入起始节点  
        Stack<Integer> stack = new Stack<>();  
        stack.push(startVertex);  
  
        // 遍历栈,直到栈为空  
        while (!stack.isEmpty()) {  
            int vertex = stack.pop();  
  
            // 如果该节点未被访问  
            if (!visited[vertex]) {  
                // 标记为已访问并打印  
                visited[vertex] = true;  
                System.out.print(vertex + " ");  
  
                // 将所有邻接节点压入栈中  
                Iterator<Integer> iterator = adjLists[vertex].listIterator();  
                while (iterator.hasNext()) {  
                    int adjVertex = iterator.next();  
                    if (!visited[adjVertex]) {  
                        stack.push(adjVertex);  
                    }  
                }  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        Graph graph = new Graph(5);  
  
        graph.addEdge(0, 1);  
        graph.addEdge(0, 2);  
        graph.addEdge(1, 2);  
        graph.addEdge(2, 0);  
        graph.addEdge(2, 3);  
        graph.addEdge(3, 3);  
  
        System.out.println("深度优先搜索(DFS)遍历起始节点为 2:");  
  
        graph.DFS(2);  
    }  
}

总结

  1. 递归实现:代码更简洁,但对于非常深的图(例如递归深度非常大)可能会导致栈溢出。
  2. 迭代实现:使用显式栈来控制递归深度,更适合处理深图,但代码相对复杂一些。

你可以根据具体的需求选择合适的实现方式。

### Java深度优先搜索算法的实现 #### 使用递归方式实现 DFS 在 Java 中,深度优先搜索可以通过递归来实现。这种方法利用了函数调用栈来保存状态信息。 ```java import java.util.*; public class DepthFirstSearch { private boolean[] visited; public void dfs(int[][] graph, int startNode) { visited = new boolean[graph.length]; recursiveDfs(graph, startNode); } private void recursiveDfs(int[][] graph, int currentNode) { System.out.println("Visit node " + currentNode); // 访问当前节点 visited[currentNode] = true; for (int i = 0; i < graph[currentNode].length; ++i) { if (!visited[i] && graph[currentNode][i] > 0) { // 如果相邻节点未被访问过,则继续向下探索 recursiveDfs(graph, i); } } } } ``` 这段代码展示了如何使用递归的方式执行深度优先搜索[^1]。`dfs()` 方法初始化了一个布尔数组 `visited` 来记录哪些顶点已经被访问过了;而 `recursiveDfs()` 则负责具体地遍历过程,在每次进入新的子程序时都会打印出所到达的新位置并标记该位置已访问。 #### 非递归版本的 DFS 实现 除了递归外,也可以采用显式的栈结构来进行迭代形式下的深度优先搜索: ```java import java.util.*; public class IterativeDepthFirstSearch { public static void iterativeDfs(int[][] adjacencyMatrix, int startVertex) { Stack<Integer> stack = new Stack<>(); boolean[] visited = new boolean[adjacencyMatrix.length]; stack.push(startVertex); while(!stack.isEmpty()) { Integer vertex = stack.pop(); if (!visited[vertex]) { System.out.print(vertex + " "); visited[vertex] = true; List<Integer> neighbors = getNeighbors(adjacencyMatrix, vertex); Collections.reverse(neighbors); // 确保先压入右边邻居 for(Integer neighbor : neighbors){ if(!visited[neighbor]){ stack.push(neighbor); } } } } } private static List<Integer> getNeighbors(int[][] adjMat, int v) { List<Integer> result = new ArrayList<>(); for (int i = 0; i < adjMat[v].length; i++) { if (adjMat[v][i] != 0) { result.add(i); } } return result; } } ``` 此段代码实现了基于堆栈的数据结构完成非递归版的深度优先搜索逻辑[^4]。这里的关键在于维护一个外部的 LIFO(Last In First Out)容器——即栈,用于存储待处理结点列表,并且每当弹出一个元素时都要检查其是否已被访问过以避免重复操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值