广度搜索算法，分别用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 bfs(int startVertex) {
   
8.     bool queue[MAX_VERTICES];
   
9.     int front = 0, rear = 0;
   
10.     int vertex, i;
    
11.      for (i = 0; i < numVertices; i++) {
    
12.         visited[i] = false;
    
13.     }
    
14.      visited[startVertex] = true;
    
15.     queue[rear++] = startVertex;
    
16.      while (front < rear) {
    
17.         vertex = queue[front++];
    
18.          printf("%d ", vertex);
    
19.          for (i = 0; i < numVertices; i++) {
    
20.             if (graph[vertex][i] && !visited[i]) {
    
21.                 visited[i] = true;
    
22.                 queue[rear++] = i;
    
23.             }
    
24.         }
    
25.     }
    
26. }
    
27. 
    

复制代码

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

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

1. #include <iostream>
   
2. #include <vector>
   
3. #include <queue>
   
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 bfs(int startVertex) {
    
17.         vector<bool> visited(numVertices, false);
    
18.         queue<int> queue;
    
19.          visited[startVertex] = true;
    
20.         queue.push(startVertex);
    
21.          while (!queue.empty()) {
    
22.             int currentVertex = queue.front();
    
23.             queue.pop();
    
24.              cout << currentVertex << " ";
    
25.              for (int neighbor : adjacencyList[currentVertex]) {
    
26.                 if (!visited[neighbor]) {
    
27.                     visited[neighbor] = true;
    
28.                     queue.push(neighbor);
    
29.                 }
    
30.             }
    
31.         }
    
32.     }
    
33. };
    
34. 
    

复制代码

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

3.**Java示例：**

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

复制代码

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

4.**Python示例：**

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

复制代码

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

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


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