【算法导论】--C++实现广度优先搜索bfs

一、题目

根据上次随机生成的100个顶点的无向图和有向图，对其进行广度优先搜索。

二、理解广度优先搜索

广度优先搜索可以将其想象成水滴落入水面溅起了的一圈一圈的涟漪，是由一个起始点开始一圈一圈进行扩散搜索的。

【课上老师是这样说的，大家想象一下，发现其实非常形象】

广度优先搜索总是从一个起始点出发，首先扩散这个点周围所有的邻居，然后邻居在去扩散邻居的邻居(*＾-＾*)...然后一直到最后将整张图都扩散完。

三、代码实现

对于第一次随机生成100个顶点的图进行了细节的修改，将每个顶点的类型改为了自定义的结构体类型，是为了可以记录更多的顶点的信息。

1.修改了图中顶点的类型

enum Color{white,red,green};//设定每个顶点的颜色,white表示还没有碰到的，green表示在队列中的，red表示已经完成的

struct vertextype//表示图中的每个顶点的类型
{
    int id;//每个顶点的编号
    int pred;//每个顶点的前驱顶点
    int dist;//每个顶点的距离
    enum Color color;//设定顶点的状态
};

struct MGraph//邻接矩阵表示法的结构和类型声明
{
    vertextype V[maxvertexnum];//顶点集
    edgetype E[maxvertexnum][maxvertexnum];//边集
    int n,e;//顶点数，边数
    enum GraphType GType;//设定图的类型
};

2.广度优先算法实现

void bfs(MGraph *G,vertextype s)
{
    int i,j,k=0;
    for(i=0;i<100;i++)//初始化图中所有点，使其全部为未被碰到的，以及没有前驱，没有距离,100表示生成图中只有100个顶点，根据生成的图具体定义
    {
        if (s.id==i)
        {    
            continue;//跳过初始点s
        }else
        {
            G->V[i].color=white;
            G->V[i].dist=infinity;
            G->V[i].pred=NULL;
            //cout<<"["<<G->V[i].id<<","<<G->V[i].pred<<","<<G->V[i].color<<"]	";
        }
    }
    s.color=green;//将初始点入队
    s.dist=0;
    s.pred=NULL;
    queue<vertextype> Q;//创建一个空队列
    Q.push(s);//将初始点入队列
    cout<<"["<<s.id<<","<<s.pred<<","<<s.color<<"]"<<endl;//此处都为打印验证可以将其注释

    cout<<endl;
    while(!Q.empty())//当队列非空
    {
        vertextype u,v;//建立一个空顶点
        u=Q.front();//取出队列第一个元素
        Q.pop();//将队列中第一个元素删除
        cout<<endl;
        cout<<"====["<<u.id<<","<<u.pred<<","<<u.color<<"]====="<<endl;//此处为打印验证可以注释
        
        int i,j;
        for(i=0;i<100;i++)
        {
            //v=G->V[i];
            if(G->E[u.id][i]==0)//在u的邻接矩阵中找到它的邻接顶点，当为0时跳过
            {
                continue;
            }
            else if(G->V[i].color==white)
            {
                G->V[i].color=green;
                G->V[i].dist=u.dist+1;
                G->V[i].pred=u.id;
                Q.push(G->V[i]);
                k++;//记录整张图上可以到达的点的个数
                cout<<"["<<G->V[i].id<<","<<G->V[i].pred<<","<<G->V[i].color<<","<<G->V[i].dist<<"]	";//此处为打印验证可以注释
            }
        }
        u.color=red;
    }
    cout<<endl;
    cout<<"================="<<k<<"==============="<<endl;//此处为打印验证可以注释
}

3.用广度优先搜索实现找到并打印出图上两点之间的路径

vertextype findid(MGraph *G,int id)//找到对应id的顶点，并返回,当没有时返回空
{
    return G->V[id];
}


void printpath(MGraph *G,vertextype s,vertextype v)
{
    //s为其实顶点，v为所要寻找的顶点,
    //使用递归来进行每一步的更往前寻找pred
    vertextype u;
    //vertextype *record=new vertextype[100];
    int i,j;
    if(v.id==s.id)
        cout<<" ->"<<s.id<<" ";
    else 
        {
            if(v.pred==NULL)
            {
                cout<<"没有顶点"<<s.id<<"到顶点"<<v.id<<"的路径"<<endl;
            }
            else
            {
                u=findid(G,v.pred);//u表示为v的前置节点
                printpath(G,s,u);
                cout<<"->"<<v.id<<" ";
            }
    }
}

4.最终实现调用的main方法

int main()
{
    ofstream myuggraph,mydggraph;
    myuggraph.open("myuggraph.txt");

    MGraph *UGG=new MGraph();
    CreateMGraphUG(UGG);
    for(int i=0;i<100;i++)
    {
        myuggraph<<UGG->V[i].id<<"	";
        for(int j=0;j<100;j++)
        {
            myuggraph<<UGG->E[i][j]<<" ";//将整个邻接矩阵写到一个文本文件中，也是为了便于纠错吧
        }
        myuggraph<<"
";
    }
    
    bfs(UGG,UGG->V[3]);
    cout<<endl;
    cout<<"======================";
    cout<<endl;
    printpath(UGG,UGG->V[3],UGG->V[75]);
    cout<<endl;

    return 0;
}

5.note：别忘了加上相应的头文件

广度优先搜索是通过队列这个数据结构来存储每个顶点的，而文件操作也要加入相应的文件头文件。

#include<iostream>
#include<fstream>
#include<queue>//引入队列头文件

上述代码还有许多改进的地方，期待探讨和指正。

于2017年4月8日编辑完成。