图之广度优先搜索（BFS）

我们先看下图的广度优先搜索的定义，然后可以感觉很熟悉，对的，那就是二叉树层次遍历里的方法，可以参考，我的文章，二叉树之层次遍历（二）

定义：

它的基本思想就是：首先访问起始顶点v，接着由v出发，依次访问v的各个未访问过的邻接顶点w1，w2，…，wi，然后再依次访问w1，w2，…，wi的所有未被访问过的邻接顶点；再从这些访问过的顶点出发，再访问它们所有未被访问过的邻接顶点……依次类推，直到图中所有顶点都被访问过为止。

广度优先搜索是一种分层的查找过程，每向前走一步可能访问一批顶点，不像深度优先搜索那样有往回退的情况，因此它不是一个递归的算法。为了实现逐层的访问，算法必须借助一个辅助队列，以记录正在访问的顶点的下一层顶点。

例子：

    第一层:A;

第二层：C,D,F;

第三层：B,G;

第四层：E;

代码：

#include<stdio.h>
#include<stdlib.h>
#include <malloc.h>
#include <string.h>
#define MAX 10
#define nLENGTH(a)  (sizeof(a)/sizeof(a[0]))
#define eLENGTH(a) ( sizeof(a) / sizeof(char) )/ ( sizeof(a[0]) / sizeof(char) )
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
}Graph, *PGraph; 
//创建队列节点
typedef struct node
{
	char data;
	struct node *next;
}linklist;

typedef struct list
{
	linklist *front,*rear;
	int num;
}link,*linkqueue;
//指向节点的位置
int point_node(PGraph g,char c)
{
	for(int i=0;i<g->vexnum;i++)
	{
		if(g->vexs[i]==c)
		{
			return i;
		}
	}
	return -1;
}
PGraph create_graph(char b[][2],char a[],int n,int e)
{
	char c1,c2; //边的2个顶点
	PGraph g; //矩阵
	g=(PGraph)malloc(sizeof(Graph));
	//memset()第一个参数 是地址，第二个参数是开辟空间的初始值，第三个参数是开辟空间的大小
	memset(g, 0, sizeof(Graph));
	printf("顶点个数:\n");//顶点数
	g->vexnum=n;
	printf("%d\n",g->vexnum);
	printf("边个数:\n");//边数
	g->edgnum=e;
	printf("%d\n",g->edgnum);
	//初始化顶点
	for(int j=0;j<g->vexnum;j++)
	{
		g->vexs[j]=a[j];
	}
	for(int i=0;i<g->edgnum;i++)
	{
		int p1,p2;
		c1=b[i][0];
		c2=b[i][1];
		p1=point_node(g, c1);
		p2=point_node(g, c2);
		if (p1==-1 || p2==-1)
        {
            printf("input error: invalid edge!\n");
            free(g);
            continue;
        }
		g->matrix[p1][p2]=1;
		g->matrix[p2][p1]=1;
		
	}
	return g;
}
//返回与v相邻的第一个顶点
int first_node(PGraph g,int v)
{
	int i;
	for(i=0;i<g->vexnum;i++)
	{
		if(g->matrix[v][i]!=0)
			return i;
	}
	return -1;
}
//返回与v相邻的下一个顶点
int next_node(PGraph g,int v,int w)
{
	int i;
	for(i=w+1;i<g->vexnum;i++)
	{
		if(g->matrix[v][i]!=0)
			return i;
	}
	return -1;

}

//初始化空队
void InitEmpty(linkqueue &q)
{
	q->front=q->rear=(linklist*)malloc(sizeof(linklist));
	q->front->next=NULL;
	q->rear->next=NULL;
}
//置空队
void SetEmptyQueue(linkqueue &q)
{
	q->front->next=NULL;
	q->front=q->rear;

}
//判断空队
int IsEmpty(linkqueue &q)
{
	if(q->front==q->rear)
	{
		return 1;
	}else{
		return 0;
	}
	//return ((q->front==q->rear)?1:0);
}
//元素入队
int InQueue(linkqueue &q,char e)
{
	q->rear->next=(linklist*)malloc(sizeof(linklist));;
	q->rear=q->rear->next;
	q->rear->data=e;
	q->rear->next=NULL;
	q->num++;
	return 0;
}
//元素出队
int OutQueue(linkqueue &q)
{
	int e;
	linklist *p;
	if(IsEmpty(q))
	{
		printf("空队！\n");
		return 0;
	}
	p=q->front;
	q->front=p->next;
	e=q->front->data;
	free(p);
	q->num--;
	return e;	
}
void BFS(PGraph g,char start)
{
		//指向链队列
	linkqueue m;
	m=(linkqueue)malloc(sizeof(link));
	InitEmpty(m);   //初始化队列，为队列分配内存
	SetEmptyQueue(m); //使队列为空队
	int visit[MAX]={0}; //标记顶点
	int i=point_node(g,start);
	if(!visit[i])
		{
			InQueue(m,g->vexs[i]);
			visit[i]=1;
		}
		while(!IsEmpty(m))
		{
			char b=OutQueue(m);
			int j=point_node(g,b);
			printf("%c\t",b);
			for(int w=first_node(g,j);w>=0;w=next_node(g,j,w))
			{
				if(!visit[w])
				{
					visit[w]=1;
					InQueue(m,g->vexs[w]);
				}
			}
		}
	
}

//测试
int main()
{
	int i,j;
	PGraph gp;
	//测试用例

	char a[]={'A', 'B', 'C', 'D', 'E', 'F', 'G'};
	char b[][2]={
        {'A', 'C'}, 
        {'A', 'D'}, 
        {'A', 'F'}, 
        {'B', 'C'}, 
        {'C', 'D'}, 
        {'E', 'G'}, 
        {'F', 'G'}}; 

	//测试用例

	int n=nLENGTH(a);
	int e=eLENGTH(b);
	gp=create_graph(b,a,n,e);

	//打印矩阵
	for (i = 0; i < gp->vexnum; i++)
    {
        for (j = 0; j < gp->vexnum; j++)
            printf("%d ", gp->matrix[i][j]);
        printf("\n");
    }
	//广度优先搜索图
	printf("广度优先搜索图:\n");
	BFS(gp,'A');
	return 0;

}