广度优先搜索

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

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

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

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

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

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

具体见样例。

输出

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

具体见样例。

样例输入 Copy
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
样例输出 Copy
v1 v2 v3 v4 v5 v6 v7 v8

#include <iostream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;

#define MVNum 100         //最大顶点数
#define OK 1

typedef string VerTexType; //顶点信息
typedef int OtherInfo;    //和边相关的信息

//- - - - -图的邻接表存储表示- - - - -
typedef struct ArcNode {                //边结点
   int adjvex;                          //该边所指向的顶点的位置
   struct ArcNode *nextarc;          //指向下一条边的指针
   OtherInfo info;                      //和边相关的信息
} ArcNode;

typedef struct VNode {
   VerTexType data;                    //顶点信息
   ArcNode *firstarc;                //指向第一条依附该顶点的边的指针
} VNode, AdjList[MVNum];                //AdjList表示邻接表类型

typedef struct {
   AdjList vertices;                  //邻接表
   int vexnum, arcnum;              //图的当前顶点数和边数
} Graph;

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

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

//返回v的第一个邻接顶点。若顶点在G中没有邻接表顶点，则返回-1。
int FirstAdjVex(const Graph &g, int v)
{
   /****在此下面完成代码***************/
	if(LocateVex(g,g.vertices[v].data) == -1)
        return -1;
    if(g.vertices[v].firstarc)
        return g.vertices[v].firstarc->adjvex;
    return -1;

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

// 返回v的（相对于w的）下一个邻接顶点。
int NextAdjVex(const Graph &g, int v, int w)
{
  /****在此下面完成代码***************/
	ArcNode *p  = g.vertices[v].firstarc;
    while(p && w != p->adjvex)
        p = p->nextarc;
    if(!p || !p->nextarc)
        return -1;
    else
        return p->nextarc->adjvex;

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

//对每个顶点的链表排序，按顶点编号从小到大排列
void sort(ArcNode *arclist)
{
   /****在此下面完成代码***************/
	ArcNode *p,*i,*j;
    if(arclist->nextarc == NULL || arclist == NULL)
        return;
    for(i = arclist; i; i = i->nextarc)
    {
        for(p = arclist; p->nextarc; p = p->nextarc)
        {
            if(p->adjvex > p->nextarc->adjvex)
            {
                swap(p->adjvex,p->nextarc->adjvex);
            }
        }
    }

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

int CreateUDG(Graph &g)
{
   //采用邻接表表示法，创建无向图G
   /****在此下面完成代码***************/
	int i,j,k;
    ArcNode *p1,*p2;
    cin>>g.vexnum>>g.arcnum;
    k = g.vexnum;
    for(i = 0; i < k; ++i)
    {
        cin>>g.vertices[i].data;
        g.vertices[i].firstarc =  NULL;
    }
    k = g.arcnum;
    while(k--)
    {
        VerTexType v1,v2;
        cin>>v1;
        cin>>v2;
        i = LocateVex(g,v1);
        j = LocateVex(g,v2);
        p1 =  new ArcNode;
        p2 = new ArcNode;
        p1->adjvex = j;
        p1->nextarc = g.vertices[i].firstarc;
        g.vertices[i].firstarc = p1;
        p2->adjvex = i;
        p2->nextarc = g.vertices[j].firstarc;
        g.vertices[j].firstarc = p2;
    }

   /***********************************/
   for(i = 0; i < g.vexnum; ++i) {           
      sort(g.vertices[i].firstarc); 保证有序，不依赖输入次序
   }//for
   return OK;
}//CreateUDG

void DestroyUDG(Graph &g)
{
   //you should do this
   for(int i = 0; i < g.vexnum; ++i)
    {
        g.vertices[i].data = "";
        ArcNode *p =  g.vertices[i].firstarc;
        while(p)
        {
            ArcNode *r = p;
            p = p->nextarc;
            free(r);
        }
        g.vertices[i].firstarc = NULL;
    }

    g.vexnum = 0;
    g.arcnum = 0;
}
bool visited[MVNum];

void BFSTraverse(Graph G) {
	queue<int> q;
	for(int i = 0; i < G.vexnum; i++)
		visited[i] = false;
 
	for(int i = 0; i < G.vexnum; i++) {
		if(!visited[i]) {
			q.push(i);
			visited[i] = true;
			while(!q.empty()) {
				int v = q.front();
				q.pop();
				
				cout << G.vertices[v].data << " ";
				for(int w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) {
					if (!visited[w]) {
						q.push(w);
						visited[w] = true;
					}
				}
			}
		}
	}
}

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