广度优先搜索

广度优先搜索类似于树的层次遍历。从图中的某一顶点出发，遍历每一个顶点时，依次遍历其所有的邻接点，然后再从这些邻接点出发，同样依次访问它们的邻接点。按照此过程，直到图中所有被访问过的顶点的邻接点都被访问到。

最后还需要做的操作就是查看图中是否存在尚未被访问的顶点，若有，则以该顶点为起始点，重复上述遍历的过程。

还拿图 1 中的无向图为例，假设 V1 作为起始点，遍历其所有的邻接点 V2 和 V3 ，以 V2 为起始点，访问邻接点 V4 和 V5 ，以 V3 为起始点，访问邻接点 V6 、 V7 ，以 V4 为起始点访问 V8 ，以 V5 为起始点，由于 V5 所有的起始点已经全部被访问，所有直接略过， V6 和 V7 也是如此。
以 V1 为起始点的遍历过程结束后，判断图中是否还有未被访问的点，由于图 1 中没有了，所以整个图遍历结束。遍历顶点的顺序为：

V1 -> V2 -> v3 -> V4 -> V5 -> V6 -> V7 -> V8

#include<stdio.h>
#include<stdlib.h>
#define MAX_NUM 20    //顶点的最大个数 
#define VRtype int    //表示顶点之间关系的变量类型 
#define infoType char //存储弧或者边额外信息的指针变量类型 
#define vertexType int  //图中顶的数据类型
typedef struct{
	VRtype adj; //顶点之间关系
	infoType * info;//额外信息 
}Adj[MAX_NUM][MAX_NUM];

typedef struct{
	vertexType vexs[MAX_NUM];//顶点表 
	Adj arcs;               //边表 
	int vexnum,arcnum;     //图当前顶点数和弧数 
}MGraph; 
//***********************构建图*********************************
int locatevex(MGraph *G,vertexType v){
	int i;
	for(i=0;i<G->vexnum;i++){
		if(G->vexs[i]==v){
			break;
		}
	}
	
	if(i>G->vexnum){
		printf("no such vertex.\n ");
		return -1;
	}
	return i;
}

void CreateDG(MGraph *G){
	printf("input the vex num:\n");
	scanf("%d",&(G->vexnum));
	printf("input the arc num:\n");
	scanf("%d",&(G->arcnum));
	
	printf("input the data that the vex should have? ");
	for(int i=0;i<G->vexnum;i++){
		scanf("%d",&(G->vexs[i]));
	}
   
   for(int i=0;i<G->vexnum;i++){
   	  for(int j=0;j<G->vexnum;j++){
   	  	  G->arcs[i][j].adj=0;
   	  	  G->arcs[i][j].info=NULL;
		 }
   }	
   
   printf("add the arc num:\n"); //这里是看两个顶点在数组中有木有 
   for(int i=0;i<G->arcnum;i++){
   	  int v1,v2;
	  printf("v1 value:");
	  scanf("%d",&v1);
	  printf("v2 value:");
	  scanf("%d",&v2); 
   	  
   	  int n=locatevex(G,v1);
   	  int m=locatevex(G,v2);
   	  
   	  if(m==-1||n==-1){
   	    printf("no this vertex\n");
		return; 	
	  }
   	  
   	  G->arcs[n][m].adj=1;
	  printf("输入成功|\n"); 
   }	
}
//***********************构建图*********************************
void PrintGrapth(MGraph G){
	printf("开始打印\n");
	printf("   ");
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("%d\t",i);
	}
	printf("\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("%d  ", i);
		
		for (int j = 0; j < G.vexnum; j++)
		{
			printf("%d\t", G.arcs[i][j].adj);
		}
		//getchar();
		printf("\n");
	}
	return ;
}

//*******************广度优先搜索*************** 
bool visited[MAX_NUM];

int FirstNeighbor(MGraph G,int v){
//查找与数组下标为v的顶点之间有边的顶点，返回它在数组中的下标
    for(int i = 0; i<G.vexnum; i++){
        if( G.arcs[v][i].adj ){
            return i;
        }
    }
    return -1;
}

int NextNeighbor(MGraph G,int v,int w){
//从前一个访问位置w的下一个位置开始，查找之间有边的顶点
    for(int i = w+1; i<G.vexnum; i++){
        if(G.arcs[v][i].adj){
            return i;
        }
    }
    return -1;
}

void visit(int v){
  	printf("%d\n",v);  //v=G.vex[i]
}

typedef struct{
	int data[50];
	int front,rear;
}queue;

void iniqueue(queue &q){
	q.front=q.rear=0;
}

bool isempty(queue q){
    if(q.front==q.rear) return true;
    else return false;
}

void enqueue(queue &q,int x){
	if((q.rear+1)%50==q.front) return;
	q.data[q.rear]=x;
	q.rear=(q.rear+1)%50;
}

void dequeue(queue &q,int x){
	if((q.rear+1)%50==q.front) return;
	x=q.data[q.front];
	q.front=(q.front+1)%50;
}

void BFS(MGraph G,int v,queue q){
	//从顶点出发，广度优先搜索，算法借助一个辅助队列Q 
	visit(v);             //访问初始顶点V 
	visited[v]=true;      //对V做已访问标记 
	enqueue(q,v);         //顶点V入队列 
	while(!isempty(q)){    
		dequeue(q,v);     //顶点V出队列 
		for(int w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w))//检测V所有邻接点
		if(!visited[w]){  //w尚未访问 
			visit(w);    //访问顶点W 
			visited[w]=true;//对W做访问标记
			enqueue(q,w); 
		} //if
	}//while
}

void BFStraverse(MGraph G){
   for(int i=0;i<G.vexnum;++i)
     visited[i]=false;
   queue q;  
   iniqueue(q);
   for(int i=0;i<G.vexnum;++i)
      if(!visited[i]) 	
	      BFS(G,i,q);
}
//*******************广度优先搜索*************** 
int main() {
	system("title");
	MGraph G;
	CreateDG(&G);
	PrintGrapth(G);
	printf("广度优先搜索：\n");
	BFStraverse(G);
	system("pause");
}