广度优先搜索

题目描述

输入一个图，用邻接表存储（实际上也可以选择邻接矩阵），并实现BFS操作。

拷贝前面已经实现的代码，主函数必须如下，完成剩下的部分。

int main()
{
   Graph g;
   CreateUDG(g);
   BFS(g, 0);//从0号顶点开始遍历
   DestroyUDG(g);
   return 0;
}//main

输入

输入的第一行是两个整数，分别是图的总顶点数n和总边数e

第二行是n个空格分开的字符串，是顶点的名字，依次对应编号0~n-1。

随后有e行，每行两个空格分开的顶点名字，表示一条边的两个顶点。

具体见样例。

输出

输出图的BFS序列，遍历次序按教材，每个顶点后面跟一个空格。

具体见样例。

样例输入

8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v2 v4
v2 v5
v3 v6
v3 v7
v4 v8
v5 v8
v6 v7

样例输出

v1 v2 v3 v4 v5 v6 v7 v8 

代码实现

先建立一个队列

typedef struct {
    QElemType* base;//初始化时动态分配存储空间
    int front;//头指针
    int rear;//尾指针
} SqQueue;

//算法3.11　循环队列的初始化
Status InitQueue(SqQueue& q)   //构造一个空队列Q
{
    q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
    q.front = q.rear = 0; //头指针和尾指针置为零，队列为空
    return OK;
}

void DestroyQueue(SqQueue& q)
{
    /* 销毁队列Q，Q不再存在 */
    if (q.base)
        delete[]q.base;
    q.base = NULL;
    q.front = q.rear = 0;
}
bool QueueEmpty(SqQueue q)
{
    /****在此下面完成代码***************/
    if (q.rear == q.front)
        return OK;
    else
        return ERROR;

    /***********************************/
}
Status EnQueue(SqQueue& q, QElemType e)   //插入元素e为Q的新的队尾元素
{
    /****在此下面完成代码***************/
    if ((q.rear + 1) % MAXQSIZE == q.front)
        return ERROR;
    q.base[q.rear] = e;
    q.rear = (q.rear + 1) % MAXQSIZE;
    return OK;

    /***********************************/
}

//算法3.14　循环队列的出队
Status DeQueue(SqQueue& q, QElemType& e)   //删除Q的队头元素，用e返回其值
{
    /****在此下面完成代码***************/
    if (q.front == q.rear)return ERROR;
    e = q.base[q.front];
    q.front = (q.front + 1) % MAXQSIZE;
    return OK;

    /***********************************/
}

 完整源代码

#include <iostream>
#include <iomanip>
#include <cstdio>
using namespace std;
#define MAXQSIZE 100
#define ERROR 0
#define OK 1
#define MVNum 100     //最大顶点数
typedef string VerTexType; //假设顶点的数据类型为字符串
typedef int ArcType;             //假设边的权值类型为整型
bool visited[MVNum];
typedef  int  Status;
typedef  int QElemType;
//建立队列
typedef struct {
    QElemType* base;//初始化时动态分配存储空间
    int front;//头指针
    int rear;//尾指针
} SqQueue;

//算法3.11　循环队列的初始化
Status InitQueue(SqQueue& q)   //构造一个空队列Q
{
    q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
    q.front = q.rear = 0; //头指针和尾指针置为零，队列为空
    return OK;
}

void DestroyQueue(SqQueue& q)
{
    /* 销毁队列Q，Q不再存在 */
    if (q.base)
        delete[]q.base;
    q.base = NULL;
    q.front = q.rear = 0;
}
bool QueueEmpty(SqQueue q)
{
    /****在此下面完成代码***************/
    if (q.rear == q.front)
        return OK;
    else
        return ERROR;

    /***********************************/
}
Status EnQueue(SqQueue& q, QElemType e)   //插入元素e为Q的新的队尾元素
{
    /****在此下面完成代码***************/
    if ((q.rear + 1) % MAXQSIZE == q.front)
        return ERROR;
    q.base[q.rear] = e;
    q.rear = (q.rear + 1) % MAXQSIZE;
    return OK;

    /***********************************/
}

//算法3.14　循环队列的出队
Status DeQueue(SqQueue& q, QElemType& e)   //删除Q的队头元素，用e返回其值
{
    /****在此下面完成代码***************/
    if (q.front == q.rear)return ERROR;
    e = q.base[q.front];
    q.front = (q.front + 1) % MAXQSIZE;
    return OK;

    /***********************************/
}
//------------图的邻接矩阵------------------
typedef struct {
    VerTexType vexs[MVNum];            //顶点表
    ArcType arcs[MVNum][MVNum];      //邻接矩阵
    int vexnum, arcnum;                //图的当前点数和边数
} Graph;

//得到顶点i的数据
VerTexType Vertexdata(const Graph& g, int i)
{
    return g.vexs[i];
}

int LocateVex(const Graph& g, VerTexType v)
{
    //确定点v在G中的位置
    for (int i = 0; i < g.vexnum; ++i)
        if (g.vexs[i] == v)
            return i;
    return -1;
}//LocateVex

int FirstAdjVex(const Graph& g, int v)
{
    //返回v的第一个邻接点编号，没有返回-1
    /****在此下面完成代码***************/
    int j;
    for (j = 0; j < g.vexnum; j++)
        if (g.arcs[v][j] == 1)
            return j;
    return -1;

    /***********************************/
}//FirstAdjVex

int NextAdjVex(const Graph& g, int v, int w)
{
    //返回v相对于w的下一个邻接点，没有返回-1
    /****在此下面完成代码***************/
    int i;
    for (i = w + 1; i < g.vexnum; i++)
    {
        if (g.arcs[v][i] == 1)
            return i;
    }
    return -1;

    /***********************************/
}//NextAdjVex
void BFS(Graph g, int v)
{
    cout << g.vexs[v] << " "; SqQueue q; int u;
    visited[v] = true;
    InitQueue(q);
    EnQueue(q, v);
    while (!QueueEmpty(q))
    {
        DeQueue(q, u);
        for (int w = FirstAdjVex(g, u); w >= 0; w = NextAdjVex(g, u, w))
            if (!visited[w])
            {
                cout <<g.vexs[w] << ' '; visited[w] = true;
                EnQueue(q, w);
            }
    }
}
void BFSTraversal(Graph g)
{
    for (int v = 0; v < g.vexnum; v++)
    {
        visited[v] = false;
    }
    for (int v = 0; v < g.vexnum; v++)
    {
        if (!visited[v])
            BFS(g, v);
    }
}
void CreateUDG(Graph& g)
{
    //采用邻接矩阵表示法，创建无向图G
    /****在此下面完成代码***************/
    int i, k, j; string v1, v2;
    cin >> g.vexnum >> g.arcnum;//输入总顶点数和总边数
    for (i = 0; i < g.vexnum; i++)//输入点的信息
        cin >> g.vexs[i];
    for (i = 0; i < g.vexnum; i++)
    {
        for (j = 0; j < g.vexnum; j++)
        {
            g.arcs[i][j] = 0;
        }
    }
    for (i = 0; i < g.arcnum; i++)
    {
        cin >> v1 >> v2;
        k = LocateVex(g, v1); j = LocateVex(g, v2);
        g.arcs[k][j] = 1;
        g.arcs[j][k] = g.arcs[k][j];
    }

    /***********************************/
}//CreateUDN

void DestroyUDG(Graph& g)
{
    //you should do this
    g.arcnum = g.vexnum = 0;
}

int main()
{
    Graph g;
    CreateUDG(g);
    BFSTraversal(g);
    DestroyUDG(g);
    return 0;
}//main