深度优先搜索(DFS)和广度优先搜索(BFS)是两种常见的图遍历算法。
深度优先搜索(DFS)
深度优先搜索是一种用于遍历或搜索树或图的算法。这个算法会尽可能深地搜索树的分支。当节点v的所在边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止。
Python实现:
def dfs(graph, start):  
     stack, visited = [start], set()  
     while stack:  
         vertex = stack.pop()  
         if vertex not in visited:  
             visited.add(vertex)  
             stack.extend(graph[vertex] - visited)  
     return visited
广度优先搜索(BFS)
广度优先搜索是另一种遍历或搜索树或图的算法。这个算法从根开始,访问根的所有相邻节点,然后对每个相邻节点执行相同的操作,这个过程递归地进行直到已发现从根可达的所有节点为止。广度优先搜索可以用队列实现。
Python实现:
from collections import deque  
   
 def bfs(graph, start):  
     visited, queue = set(), deque(start)  
     while queue:  
         vertex = queue.popleft()  
         if vertex not in visited:  
             visited.add(vertex)  
             queue.extend(graph[vertex] - visited)  
     return visited
注意:上述代码中的graph是一个字典,表示图的邻接表形式。字典的键是节点,值是该节点的邻居集合。例如,如果有一个有向图,graph可能看起来像这样:{1: {2, 3}, 2: {1, 4}, 3: {1}, 4: {2}}。这意味着节点1可以到达节点2和3,节点2可以到达节点1和4,等等。
以下是深度优先搜索(DFS)和广度优先搜索(BFS)的 Java 实现。
深度优先搜索(DFS):
import java.util.*;  
   
 public class DFS {  
     private final List<Integer>[] adjList;  
     private boolean[] visited;  
   
     public DFS(List<Integer>[] adjList) {  
         this.adjList = adjList;  
         this.visited = new boolean[adjList.length];  
     }  
   
     public void dfs(int node) {  
         visited[node] = true;  
         System.out.print(node + " ");  
   
         for (int neighbor : adjList[node]) {  
             if (!visited[neighbor]) {  
                 dfs(neighbor);  
             }  
         }  
     }  
   
     public void performDFS() {  
         for (int i = 0; i < adjList.length; i++) {  
             if (!visited[i]) {  
                 dfs(i);  
             }  
         }  
     }  
 }
广度优先搜索(BFS):
import java.util.*;  
   
 public class BFS {  
     private final List<Integer>[] adjList;  
     private final boolean[] visited;  
     private final Queue<Integer> queue;  
   
     public BFS(List<Integer>[] adjList) {  
         this.adjList = adjList;  
         this.visited = new boolean[adjList.length];  
         this.queue = new LinkedList<>();  
     }  
   
     public void bfs() {  
         for (int i = 0; i < adjList.length; i++) {  
             if (!visited[i]) {  
                 queue.offer(i);  
                 visited[i] = true;  
             }  
         }  
         while (!queue.isEmpty()) {  
             int node = queue.poll();  
             System.out.print(node + " ");  
             for (int neighbor : adjList[node]) {  
                 if (!visited[neighbor]) {  
                     queue.offer(neighbor);  
                     visited[neighbor] = true;  
                 }  
             }  
         }  
     }  
 }