图的广度优先遍历（Breadth First Search）

广度优先遍历的理解

广度优先遍历类似于二叉树的层序遍历，假设从图中的顶点 $V_1$出发，访问$V_1$ 之后依次访问与$V_1$相邻并且没有访问过的顶点假设为 $V_2$ $V_3$ , 保证$V_1$顶点访问先于 $V_2$ $V_3$ ，访问 $V_2$时找到 与$V_2$相邻并且没有被访问过的顶点，同理 $V_3$ 按照 $V_2$，$V_3$ “之后的顶点”依次访问，以此类推，执行相同的过程，完成深度遍历。

看图理解：

按照我刚刚说意思，我们得出广度优先遍历的遍历结果为：

$V_1$->$V_2$->$V_3$-> $V_4$-> $V_5$-> $V_6$-> $V_7$ ->$V_8$

基于这样的过程我们不难想到保存每个顶点是使用队列的结构保存顶点完成，接下来我们就一步步地看通过队列是怎么实现此过程的。

广度优先遍历的图解过程

广度优先遍历使用队列的结构遍历简述一下过程：

1. 访问初始顶点$V_1$ 访问$V_1$没有未被访问的顶点$V_2$，$V_3$，……，$V_k$。
2. 按照$V_2$，$V_3$，……，$V_k$的 次序，访问每个顶点未被访问的顶点。
3. 以此类推，重复此过程，知道图中所有顶点全部被访问。

解释一下，广度优先遍历的过程：

1. $V_0$进入队列，并访问。
2. $V_0$出队，将与$V_0$相邻的并未访问的顶点$V_1，V_2，V_4$入队访问。
3. $V_1$出队，将与$V_1$相邻的并未访问的顶点$V_3$入队访问。
4. $V_2$出队，将与$V_2$相邻的并未访问的顶点$V_5，V_6$入队访问。
5. $V_4$出队，没有与之相邻且未访问的顶点。
6. $V_3$出队，没有与之相邻且未访问的顶点。
7. $V_5$出队，没有与之相邻且未访问的顶点。
8. $V_6$出队，没有与之相邻且未访问的顶点。
9. 此时队列为空，结束访问过程。

广度优先遍历实现过程

代码如下：

void BFS(Graph G , int i){
    queue<int> q;
    q.push(i);
    vis[i] = true;
    cout << G.vexs[i] << " ";
   /* 找已经入队顶点相邻并且没有访问的顶点 上图的起始过程入队的就是
    V1 V2 V4*/
    while(!q.empty()){
        int f = q.front();
        q.pop();
        for(int j = 0; j < G.numvex; j++){
            if(G.arc[f][j] && !vis[j]){
                vis[j] = true;
                q.push(j);
                cout << G.vexs[j] << " ";
            }
        }
    }
}
void BFStraverse(Graph G){
    for(int i = 0; i < G.numvex ; i++){
        if(!vis[i]) BFS(G, i);
    }
}

完整的实现过程

#include <iostream>
#include <cstring>
#include <queue>
#define MAX_VEX 100

using namespace std;
struct Graph{
    char vexs[MAX_VEX];
    int arc[MAX_VEX][MAX_VEX];
    int numvex,numarc;
};
bool vis[MAX_VEX];
void CreateGraph(Graph &G){
    int vi, vj;
    cout << "please enter the number of vertexes and arcs : \n";
    cin >> G.numvex >> G.numarc;
    for(int i = 0; i < G.numvex; i++){
        printf("Please enter the NO.%d name of vex : ",i+1);
        cin >> G.vexs[i];
    }
    memset(G.arc, 0, sizeof(G.arc));
    cout << endl;
    for(int i = 0; i < G.numarc; i++){
        cout<< "Enter the subscripts and weights from vertex vi to vertex vj : ";
        cin >> vi >> vj ;
        G.arc[vi][vj] = 1;
        G.arc[vj][vi] = 1;
    }
}
void BFS(Graph G , int i){
    queue<int> q;
    q.push(i);
    vis[i] = true;
    cout << G.vexs[i] << " ";
    while(!q.empty()){
        int f = q.front();
        q.pop();
        for(int j = 0; j < G.numvex; j++){
            if(G.arc[f][j] && !vis[j]){
                vis[j] = true;
                q.push(j);
                cout << G.vexs[j] << " ";
            }
        }
    }
}
void BFStraverse(Graph G){
    for(int i = 0; i < G.numvex ; i++){
        if(!vis[i]) BFS(G, i);
    }
}
int main(){
    Graph G;
    CreateGraph(G);
    BFStraverse(G);
    return 0;
}
/*
7 11
0 1 2 3 4 5 6
0 1
0 2
0 4
4 2
1 2
1 3
2 3
2 5
5 6
2 5
3 6
*/