【数据结构算法】图（五）：基于邻接矩阵的广度优先搜索（BFS）C++实现

利用邻接矩阵的数据结构表示图，并实现BFS

如下图两张图片所示，广度优先搜索就是先找到A，然后接着找BF，找到B接着找CIG；这是一种以A的走向为前方的右手原则。用队列实现这种逻辑。

/*
ADT 队列（Queue）
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
InitQueue(*Q):初始化操作，建立一个空队列Q。
DestoryQueue(*Q):若队列Q存在，则销毁它。
ClearQueue(*Q):将队列Q清空。
QueueEmpty(Q):若队列为空，则返回true，否则返回false。
GetHead(Q,*e):若队列Q存在且非空，用e来返回队列Q的队头元素。
EnQueue(*Q,e):若队列Q存在，插入新元素e到队列Q中成为队尾元素。
DeQueue(*Q,*e):删除队列Q的队头元素，并用e返回其值。
QueueLength(Q):返回队列Q的元素个数。
*/


// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include<stdio.h>
#include<queue>
#include<iostream>
#define Acsii   -48       //将输入字符转换成数字
#define MaxVex  100       //最大顶点数
#define INF     65535     //定义最大值（充当无穷大）
bool visited[MaxVex];     //在深度优先遍历中判断是否被遍历过
typedef char VertexType;  //顶点类型
typedef int  EdgeType;    //边类型
using namespace std;

//邻接矩阵结构体
typedef struct{
    VertexType vexs[MaxVex];
    EdgeType   arc[MaxVex][MaxVex];
    int numVertexs, numEdges;
}AdjacencyMatrix;


//创建邻接矩阵
void CreateAMatrix(AdjacencyMatrix* AM)
{
    cout << "输入顶点数和边数:";
    cin >> AM->numVertexs >> AM->numEdges;
    cout << "==============================\n";
    cout << "输入各个顶点:" << endl;

    //邻接矩阵顶点输入
    for(int i = 0; i<AM->numVertexs; i++)
    {
        char v;
        cout << "顶点：" << i + 1;
        cin >> v;
        AM->vexs[i] = v;
    }

        //邻接矩阵初始化
    for (int i = 0; i < AM->numVertexs; i++)
    {
        for (int j = 0; j<AM->numVertexs; j++)
        {
            AM->arc[i][j] = INF;
        }
    }

    cout << "==============================\n";
    //输入边的值
    for (int k = 0; k<AM->numEdges; k++)
    {
        char i, j, w;
        cout << "输入边（vi，vj）中的下标i和j和权重w：";
        cin >> i >> j >> w;
        AM->arc[i + Acsii][j + Acsii] = w;
        AM->arc[j + Acsii][i + Acsii] = AM->arc[i + Acsii][j + Acsii];
    }

}
void DisplayAMatrix(AdjacencyMatrix* AM)
{
    //打印顶点
    //for (int i = 0; i < AM->numVertexs; i++)
    //{
    //  cout << AM->vexs[i] << endl;
    //}

    //打印矩阵信息
    for (int i = 0; i < AM->numVertexs; i++)
    {
        for (int j = 0; j < AM->numVertexs; j++)
        {
            cout << AM->arc[i][j] << "  ";
        }
        cout << endl;
    }
}

//图的广度优先遍历
void BFSTraverse(AdjacencyMatrix* AM)
{
    queue<int> Q;
    for (int i = 0; i<AM->numVertexs; i++)
        visited[i] = 0;

    //InitQueue(&Q);                        //初始化一个空列表
    for (int i = 0; i<AM->numVertexs; i++)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            cout << AM->vexs[i];
            //EnQueue(&Q, i);               //将i插入到队列的队尾
            Q.push(i);

            while (!Q.empty())
            {
                i = Q.front();            //删除队列的队头元素，并用i返回这个值
                Q.pop();                  //你用的时候用front取出来尽管用，等到用完了再pop。
                                        //删除队列的队头元素，并用i返回这个值
                                        //这边除了在队列中把第一个元素删掉以外
                                        //还要把这个值返回，就像表中给的，还要根据
                                        //返回的A来找到B和F呢
                for (int j = 0; j<AM->numVertexs; j++)
                {
                    if (!visited[j] && AM->arc[i][j] != INF)
                    {
                        visited[j] = 1;
                        cout << AM->vexs[j];
                        //EnQueue(&Q, &j);
                        Q.push(j);     //这就相当于把B和F分步输入到队列中
                    }
                }

            }
        }
    }
}




int main(){
    AdjacencyMatrix G,h;

    CreateAMatrix(&G);

    DisplayAMatrix(&G);

    BFSTraverse(&G);


    return 0;
}