图的广度优先遍历算法(BFS)

图的广度优先遍历算法 (BFS)

1. 算法概述

在对图的遍历，过程中为了避免重复访问我们设置了一个辅助数组visited[ ] 用来标记某顶点是否被访问过。(0表示未被访问，1代表已经访问过)
图的广度优先算法与二叉树的层次遍历算法相似，基本思想为：首先从起始顶点v出发，访问顶点v，并将其入队；顶点v出队，依次访问与v相邻接未被访问过的顶点w₁,w₂,…,w_i，并将其依次入队；然后顶点w₁出队，依次访问与w₁相邻接未被访问的顶点，并将其入队；然后顶点w₂出队，依次访问与w₂相邻接未被访问的顶点，并将其入队；直到图中所有顶点均被访问过为止。
图1.1为一个无向图G，其存储结构采用邻接矩阵存储如图1.2，能够发现无向图的邻接矩阵是关于对角线对称的。
注意：
如果我们从0号顶点出发，逻辑上来说，2号顶点和3号顶点的入队次序可能是：2在前3在后，也可能是3在前2在后。但是由于我们采用的是邻接矩阵存储，顶点的入队次序是按数组下标由小到大依次入队，所以我们得到的广度优先遍历序列也是固定的。(若采用邻接表则会有所不同，按下不表)

图1.1 一个无向图G

图1.2 邻接矩阵方式存储图G

2. 具体实现

/**
 *  图——广度优先搜索(BFS）
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100
#define INF 65535                                    //顶点相邻，INF记为无穷大
typedef char VertexType;
typedef int EdgeType;

//邻接矩阵存储结构定义
typedef struct {
    VertexType vex[MAX_VERTEX_NUM];                  //顶点集合
    EdgeType edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM];   //边集合
    int vexnum, arcnum;                              //顶点数和弧数
}MGraph;

int visited[MAX_VERTEX_NUM];                         //访问标记数组

void visit(MGraph g, int i){
    printf("%c ", g.vex[i]);                         //输出该顶点
}

int FirstNeighbor(MGraph g, int v){                  //找到v号顶点第一个邻接顶点
    for (int i = 0; i < g.vexnum; ++i) {
        if(g.edge[v][i] == 1){
            return i;
        }
    }
    return -1;                                       //没有相邻顶点
}

int NextNeighbor(MGraph g, int v, int w){
    for (int i = w + 1; i < g.vexnum; ++i) {
        if(g.edge[v][i] == 1){
            return i;
        }
    }
    return -1;
}

void BFS(MGraph g, int v){

    int Queue[g.vexnum];
    int front = -1, rear = -1;                       //定义一个队列来保存各顶点
    int w;
    visit(g ,v);
    visited[v] = 1;                                  //记录v号顶点已经被访问
    Queue[++rear] = v;                               //将当前顶点入队
    while(front != rear){
        v = Queue[++front];                          //队头元素出队
        for(w = FirstNeighbor(g, v); w >= 0; w = NextNeighbor(g, v, w)){
            if(visited[w] == 0){
                visit(g, w);
                visited[w] = 1;
                Queue[++rear] = w;
            }
        }
    }
}

void BFSTraverse(MGraph g){
    for (int i = 0; i < g.vexnum; ++i) {                //初始化访问数组，0代表顶点未被访问，1代表已经访问
        visited[i] = 0;
    }
    for (int j = 0; j < g.vexnum; ++j) {                //考虑非连通图的情况，连通分量数可能大于1
        if (visited[j] == 0){
            BFS(g, j);
        }
    }
}


int main() {
    MGraph g;
    int i,j;

    //初始化无向连通图
    g.vexnum = 7;
    g.arcnum = 7;
    char vex[7] = {'0', '1', '2', '3', '4', '5', '6'};
    for (i = 0; i < g.vexnum; ++i) {
        g.vex[i] = vex[i];
    }

    int edge[7][7] = {
            0,INF,1,1,INF,INF,INF,
            INF,0,INF,INF,1,INF,1,
            1,INF,0,INF,1,INF,INF,
            1,INF,INF,0,1,INF,INF,
            INF,1,1,1,0,INF,INF,
            INF,INF,INF,INF,INF,0,1,
            INF,1,INF,INF,INF,1,0
    };
    for (i = 0; i < g.vexnum; ++i) {
        for (j = 0; j < g.vexnum; ++j) {
            g.edge[i][j] = edge[i][j];
        }
    }

    BFSTraverse(g);
    return 0;
}