BFS广度优先搜索

广度优先搜索

解决的问题

• 有向/无向无权图中从源节点到各个结点的最短路径

时间复杂度

O(|V|+|E|)（用邻接链表创建的图）
BFS的运行时间是关于邻接链表大小的一个线性函数。
这是一个非常理想的时间复杂度。

算法描述

颜色标记

在算法进行的过程中为图中的各个结点进行颜色的标记，其中
- 白色表示该结点还未访问过。
- 灰色表示该结点已经访问过，但是它相邻的结点中还有未访问过的结点。
- 黑色表示该结点及其相邻的结点都已经访问过了。
最初将所有结点都标记为白色。

优先队列

然后要引入一个优先队列的概念，用来确保结点的处理顺序是广度优先的。
也就是说，优先队列存储了结点的处理顺序。
优先队列的实现：
- 令源节点入队
- 开始遍历优先队列
- 头结点出队（*）
- 刚刚出队的）头结点的所有邻接结点入队
- 如果队列非空，返回步骤（*）

遍历优先队列

头结点出列，然后将它标记为灰色，遍历与它邻接的结点，如果其颜色为白色，则标记为灰色，并且更新它到s的最短路径与它的父结点，遍历结束后，将头结点标记为黑色。重复该过程直到优先队列为空。

这里需要提的一点是，为了更加清晰的描述算法，我将优先队列的构造与遍历分开了，但是在算法实现时，两者是同时进行的。

算法导论上广度优先搜索的一个C++实现

输入
第一行是两个数字，分别是源节点s的编号和图的边数。
2 10
1 2
1 5
2 6
3 6
3 7
3 4
4 7
4 8
6 7
7 8

输出：
每个结点到源节点的最短路径距离

C++代码实现

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<deque>
#include<vector>
using namespace std;
#define maxv 1005
#define INF 0xffff

typedef struct _graph{
    int vexnum;
    int edgenum;
    vector<int> Adj[maxv];
    int d[maxv];
    int color[maxv];//0->white 1->grey 2->black
    int prev[maxv];//-1->NIL
}Graph;

int initGraph(Graph G){
    G.vexnum=0;
    G.edgenum=0;
    int i;
    for(i=1;i<=G.vexnum;i++){
        (G.Adj[i]).clear();
        G.d[i]=INF;
    }

    memset(G.color,0,sizeof(G.color));
    memset(G.prev,-1,sizeof(G.prev));
    return 0;
}

int bfs(Graph G,int s){
    int i,u,len,v;

    G.d[s]=0;

    deque<int> Q;
    Q.push_back(s);

    while(!Q.empty()){
        u=Q.front();
        Q.pop_front();
        len=(G.Adj[u]).size();
        for(i=0;i<len;i++){
            v=G.Adj[u][i];
            if(G.color[v]==0){
                G.color[v]=1;
                G.d[v]=G.d[u]+1;
                G.prev[v]=u;
                Q.push_back(v);//注意这条语句的位置
            }
        }
        G.color[u]=2;
    }
    for(i=1;i<=G.vexnum;i++){
        printf("%d ",G.d[i]);
    }
    printf("\n");
    return 0;
}

int main(){

    int s,i,j,a,b,vexnum,edgenum;
    Graph G;
    while(~scanf("%d%d",&s,&edgenum)){

        initGraph(G);
        vexnum=0;
        G.edgenum=edgenum;
        for(i=0;i<G.edgenum;i++){
            scanf("%d%d",&a,&b);
            (G.Adj[a]).push_back(b);
            (G.Adj[b]).push_back(a);
            vexnum=max(vexnum,a);
            vexnum=max(vexnum,b);
        }
        G.vexnum=vexnum;
        bfs(G,s);
        //不知道为什么这里G.d[i]的值都是刚初始化之后的值
        /*for(i=1;i<=G.vexnum;i++){
            printf("%d ",G.d[i]);
        }*/
    }

    return 0;
}