深度搜索算法，分别用C语言，C++,java,python编写出来

源码资源网

深度优先搜索的原理是：首先选择一个顶点作为起始点，接着从他各个相邻点出发进行依次访问，直到所有与起始点有路径相通的顶点都被访问到。若此时有没被访问到的节点，则选择一个其他顶点进行再次访问。

深度搜索算法，分别用C语言，C++,java,python编写出来
当涉及深度优先搜索算法时，可以使用多种编程语言来实现。以下是使用C语言、C++、Java和Python编写深度优先搜索算法的示例：
1.**C语言示例：**

1. #include <stdio.h>
   
2. #include <stdbool.h>
   
3. #define MAX_VERTICES 100
   
4. bool visited[MAX_VERTICES];
   
5. int graph[MAX_VERTICES][MAX_VERTICES];
   
6. int numVertices;
   
7. void dfs(int vertex) {
   
8.     visited[vertex] = true;
   
9.     printf("%d ", vertex);
   
10.      for (int i = 0; i < numVertices; i++) {
    
11.         if (graph[vertex][i] && !visited[i]) {
    
12.             dfs(i);
    
13.         }
    
14.     }
    
15. }
    
16. void depthFirstSearch() {
    
17.     for (int i = 0; i < numVertices; i++) {
    
18.         visited[i] = false;
    
19.     }
    
20.      for (int i = 0; i < numVertices; i++) {
    
21.         if (!visited[i]) {
    
22.             dfs(i);
    
23.         }
    
24.     }
    
25. }
    
26. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

2.**C++示例：**

1. #include <iostream>
   
2. #include <vector>
   
3. #include <stack>
   
4. using namespace std;
   
5. class Graph {
   
6.     int numVertices;
   
7.     vector<vector<int>> adjacencyList;
   
8. public:
   
9.     Graph(int vertices) {
   
10.         numVertices = vertices;
    
11.         adjacencyList.resize(numVertices);
    
12.     }
    
13.      void addEdge(int source, int destination) {
    
14.         adjacencyList[source].push_back(destination);
    
15.     }
    
16.      void dfs(int startVertex) {
    
17.         vector<bool> visited(numVertices, false);
    
18.         stack<int> stack;
    
19.          stack.push(startVertex);
    
20.          while (!stack.empty()) {
    
21.             int currentVertex = stack.top();
    
22.             stack.pop();
    
23.              if (!visited[currentVertex]) {
    
24.                 visited[currentVertex] = true;
    
25.                 cout << currentVertex << " ";
    
26.                  for (int neighbor : adjacencyList[currentVertex]) {
    
27.                     if (!visited[neighbor]) {
    
28.                         stack.push(neighbor);
    
29.                     }
    
30.                 }
    
31.             }
    
32.         }
    
33.     }
    
34. };
    
35. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

3.**Java示例：**

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. import java.util.Stack;
   
4. class Graph {
   
5.     private int numVertices;
   
6.     private List<List<Integer>> adjacencyList;
   
7.      public Graph(int vertices) {
   
8.         numVertices = vertices;
   
9.         adjacencyList = new ArrayList<>(numVertices);
   
10.          for (int i = 0; i < numVertices; i++) {
    
11.             adjacencyList.add(new ArrayList<>());
    
12.         }
    
13.     }
    
14.      public void addEdge(int source, int destination) {
    
15.         adjacencyList.get(source).add(destination);
    
16.     }
    
17.      public void dfs(int startVertex) {
    
18.         boolean[] visited = new boolean[numVertices];
    
19.         Stack<Integer> stack = new Stack<>();
    
20.          stack.push(startVertex);
    
21.          while (!stack.isEmpty()) {
    
22.             int currentVertex = stack.pop();
    
23.              if (!visited[currentVertex]) {
    
24.                 visited[currentVertex] = true;
    
25.                 System.out.print(currentVertex + " ");
    
26.                  for (int neighbor : adjacencyList.get(currentVertex)) {
    
27.                     if (!visited[neighbor]) {
    
28.                         stack.push(neighbor);
    
29.                     }
    
30.                 }
    
31.             }
    
32.         }
    
33.     }
    
34. }
    
35. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

4.**Python示例：**

1. class Graph:
   
2.     def __init__(self, vertices):
   
3.         self.numVertices = vertices
   
4.         self.adjacencyList = [[] for _ in range(self.numVertices)]
   
5.      def addEdge(self, source, destination):
   
6.         self.adjacencyList[source].append(destination)
   
7.      def dfs(self, startVertex):
   
8.         visited = [False] * self.numVertices
   
9.         stack = [startVertex]
   
10.          while stack:
    
11.             currentVertex = stack.pop()
    
12.              if not visited[currentVertex]:
    
13.                 visited[currentVertex] = True
    
14.                 print(currentVertex, end=" ")
    
15.                  for neighbor in self.adjacencyList[currentVertex]:
    
16.                     if not visited[neighbor]:
    
17.                         stack.append(neighbor)
    
18. # Initialize the graph and add edges
    
19. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

这些示例展示了使用不同编程语言实现深度优先搜索算法。每个示例都使用类似的思路，通过使用堆栈（或递归）来遍历图中的节点。您可以根据需要修改算法和输入图形。请注意，这只是深度优先搜索算法的简单示例，实际应用中可能会有更复杂的问题和算法。


扫码关注微信公众号，免费查看完整算法内容。