连通图的广度优先搜索实现-邻接矩阵表示图

广度优先搜索过程：

（1）从图中的某和顶点v出发，访问v。

（2）依次访问v的各个未曾访问过的邻接点。

（3）从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问。重复步骤（3），直到图中所有已被访问的顶点的邻接点都被访问到。

算法步骤：

（1）从图中某个顶点v出发，访问v；置visited[v]为true，v入队；

（2）只要队列非空，重复下述操作：

第一：队头顶点u出队；

第二：一次检查u的所有邻接点w，如果visited[w]=false，访问w，并置visited[w]=true，然后将w入队。

当图使用邻接矩阵表示时，算法实现如下：

//采用邻接矩阵表示图的广度优先遍历 
void BFS(AMGraph &G, int v, SQueue &Q){
	cout<<G.vexs[v];
	visited[v]=true;
	InitQueue(Q);
	EnQueue(Q, v);
	while(!IsEmptyQueue(Q)){
		int u;
		DeQueue(Q, u);
		for(int w=0;w<G.vexnum;w++){
			if(G.arcs[u][w]!=0 && !visited[w]){
				cout<<G.vexs[w];
				visited[w]=true;
				EnQueue(Q, w);
			}
		}
	} 
} 

完整的代码实现如下：

#include<stdio.h>
#include<stack> 
#include <iostream>
#define MAXSIZE 100
#define MaxInt 32767 //表示最大值，即正无穷大 
#define MVNum 100 //定义最大顶点数 
using namespace std;

typedef char VerTexType;//假设顶点数据类型为字符型
typedef int ArcType;//假设边的权值为整型
typedef struct {
	VerTexType vexs[MVNum];//顶点表 
	ArcType arcs[MVNum][MVNum];//邻接矩阵
	int vexnum,arcnum;//图的当前顶点数和边数 
}AMGraph;

bool visited[MVNum]; //访问标志数组,初试为false 

//=========================队列的定义和实现=============================== 
typedef struct{
	int *base;//存储基地址 
	int front;//队头指针 
	int rear;//队尾指针 
}SQueue;

//初始化顺序队列 
bool InitQueue(SQueue &Q){
	Q.base=new int[MAXSIZE];//分配存储空间
	if(!Q.base){
		return false;
	}
	Q.front=Q.rear=0; 
	return true;
} 

//入队
bool EnQueue(SQueue &Q, int e){
	if((Q.rear+1)%MAXSIZE==Q.front){
		return false;//队满,入队失败 
	}
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXSIZE;
	return true;
} 

//计算队列长度 
int QueueLength(SQueue &Q){
	return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

//队列是否为空 
bool IsEmptyQueue(SQueue &Q){
	return Q.rear==Q.front ? true : false;
}

//出队 
bool DeQueue(SQueue &Q, int &e){
	if(Q.rear==Q.front){
		return false;//队空 
	}
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXSIZE;
	return true;
}

//====================图的操作======================

//查找一个顶点在图G中的位置 
int LocateVex(AMGraph &G, VerTexType vex){
	for(int i=0;i<G.vexnum;i++){
		if(G.vexs[i]==vex){
			return i;
		}
	}
}

//采用邻接矩阵表示法创建无向网
/*
1.输入总订单数和总边数；
2.依次输入点的信息，存入顶点表；
3.初始化邻接矩阵，每个边的权值初始化为最大值；
4.构造邻接矩阵：依次输入每条边依附的顶点和边的权值，确定两个顶点在图中的位置，
之后使相应的边赋予相应的权值，同时使其相对称的边赋予同样的权值。 
*/
void CreateUDN(AMGraph &G){
	printf("请输入总顶点数:");
	scanf("%d",&G.vexnum);
	printf("请输入总边数:");
	scanf("%d", &G.arcnum);
	for(int i=0;i<G.vexnum;++i){
		printf("请输入第%d个顶点的信息:", (i+1));
		cin>>G.vexs[i];
	}
		
	printf("\n");
	//初始化邻接矩阵 
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			G.arcs[i][j]=MaxInt;
		}
	}
	//构造邻接矩阵
	for(int k=0;k<G.arcnum;k++){
		printf("请输入第%d条边的信息(边的顶点和权值):\n", (k+1));
		printf("请输入边的第一个顶点:");
		VerTexType v1;
		//scanf("%c", &v1);
		cin>>v1; 
		printf("请输入边的第二个顶点:");
		VerTexType v2;
		//scanf("%c", &v2);
		cin>>v2;
		printf("请输入边的权重:");
		ArcType weight;
		scanf("%d", &weight);  
		//确定v1和v2在G中的位置，即顶点数组的下标
		int i=LocateVex(G, v1);
		printf("v1在图G中的位置:%d\n", i); 
		int j=LocateVex(G, v2);
		printf("v2在图G中的位置:%d\n", j); 
		G.arcs[i][j]=weight;
		G.arcs[j][i]=G.arcs[i][j];
	} 
} 

//输出图的邻接矩阵 
void PrintAM(AMGraph &G){
	printf("\n输出图的邻接矩阵:\n");
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			if(G.arcs[i][j]==MaxInt){
				G.arcs[i][j]=0;
				printf("%d ", G.arcs[i][j]);
			}else{
				printf("%d ", G.arcs[i][j]);
			}
		}
		printf("\n");
	}
}

//采用邻接矩阵表示图的广度优先遍历 
void BFS(AMGraph &G, int v, SQueue &Q){
	cout<<G.vexs[v];
	visited[v]=true;
	InitQueue(Q);
	EnQueue(Q, v);
	while(!IsEmptyQueue(Q)){
		int u;
		DeQueue(Q, u);
		for(int w=0;w<G.vexnum;w++){
			if(G.arcs[u][w]!=0 && !visited[w]){
				cout<<G.vexs[w];
				visited[w]=true;
				EnQueue(Q, w);
			}
		}
	} 
} 


int main(){
	AMGraph G;
	SQueue Q;
	CreateUDN(G);
	PrintAM(G);
	//初始化访问数组
	for(int i=0;i<MVNum; i++){
		visited[i]=false;
	} 
	BFS(G, 0, Q);
} 

对于下图运行结果如下：