图的bfs遍历

本文基于https://www.cnblogs.com/johnsonstar/p/16645091.html与https://www.oi-wiki.org/

bfs，即广度优先遍历，在搜索方面常用于搜寻最短路，其基本实现方式是通过队列存储节点：将初始节点放入队列，再依次将该节点相邻的节点依次放入队列。遍历完成后就弹出初始节点，周而复始，直到队列为空。

下面给出几种bfs的实现方法（每种方法的图存储方式不同）

直接存边bfs：

 1 #include <iostream>
 2 #include <queue>
 3 using namespace std;
 4 typedef struct edge{
 5     int u,v;
 6 }edge;
 7 edge e[100];
 8 int vis[100];
 9 int n;//边数
10 void bfs(int m){//bfs起始点 
11     queue<int> q;
12     q.push(m);
13     vis[m]=1;
14     cout<<m<<" ";
15     while(!q.empty()){
16         int u=q.front();
17         q.pop();
18         for (int i=1;i<=n;i++){
19             if (e[i].u==u&&vis[e[i].v]==0){
20                 vis[e[i].v]=1;
21                 q.push(e[i].v);
22                 cout<<e[i].v<<" ";
23             }
24         }
25     }
26 }
27 int main(){
28     cin>>n;
29     for (int i=1;i<=n;i++)
30         cin>>e[i].u>>e[i].v;
31     bfs(1);
32     return 0;
33 }

邻接矩阵bfs：

 1 #include <iostream>
 2 #include <queue>
 3 using namespace std;
 4 int adj[100][100];
 5 int k;//点数 
 6 int n;//边数
 7 int vis[100];
 8 void bfs(int m){
 9     queue<int> q;
10     q.push(m);
11     cout<<m<<" ";
12     vis[m]=1;
13     while(!q.empty()){
14         int u=q.front();
15         q.pop();
16         for (int i=1;i<=k;i++){
17             if (adj[u][i]&&!vis[i]){
18                 q.push(i);
19                 cout<<i<<" ";
20                 vis[i]=1;
21             }
22         }
23     }
24 } 
25 int main(){
26     cin>>k>>n;
27     for (int i=1;i<=n;i++){
28         int u,v;
29         cin>>u>>v;
30         adj[u][v]=1;
31         adj[v][u]=1;
32     }
33     bfs(1);
34     return 0;
35 }

邻接表bfs：

 1 #include <iostream>
 2 #include <vector>
 3 #include <queue>
 4 using namespace std;
 5 vector<vector<int> >adj;
 6 int vis[100];
 7 int k;//点数 
 8 int n;//边数
 9 void bfs(int m){
10     queue<int> q;
11     q.push(m);
12     cout<<m<<" ";
13     vis[m]=1;
14     while(!q.empty()){
15         int u=q.front();
16         q.pop();
17         for (int i=0;i<adj[u].size();i++){
18             if (!vis[adj[u][i]]){
19                 cout<<adj[u][i]<<" ";
20                 vis[adj[u][i]]=1;
21                 q.push(adj[u][i]);
22             }
23         }
24     } 
25 }
26 int main(){
27     cin>>k>>n;
28     adj.resize(k+1);
29     for (int i=1;i<=n;i++){
30         int u,v;
31         cin>>u>>v;
32         adj[u].push_back(v);
33         adj[v].push_back(u);
34     }
35     bfs(1);
36     return 0;
37 }

链式前向星实现：

 1 #include <iostream>
 2 #include <queue>
 3 using namespace std;
 4 int cnt=0;
 5 int nxt[100];
 6 int head[100];
 7 int to[100];
 8 int vis[100];
 9 int k;
10 int n;
11 void insert(int u,int v){
12     nxt[++cnt]=head[u];
13     head[u]=cnt;
14     to[cnt]=v;
15 }
16 void bfs(int m){
17     queue<int> q;
18     q.push(m);
19     cout<<m<<" ";
20     vis[m]=1;
21     while(!q.empty()){
22         int u=q.front();
23         q.pop();
24         for (int i=head[u];i;i=nxt[i]){
25             if (!vis[to[i]]){
26                 cout<<to[i]<<" ";
27                 q.push(to[i]);
28                 vis[to[i]]=1;
29             }
30         }
31     }
32 }
33 int main(){
34     cin>>k>>n;
35     for (int i=1;i<=n;i++){
36         int u,v;
37         cin>>u>>v;
38         insert(u,v);
39         insert(v,u);
40     }
41     bfs(1);
42     return 0;
43 }