图的深、广度优先遍历

/*
*图的深、广度优先搜索
*/
#include<stdio.h>//EOF(=^Z或F6),NULL 
#include<stdlib.h>
#include<string.h>

#define MAX_NAME 5//顶点字符串的最大长度+1
#define MAX_INFO 20//相关信息字符串的最大长度+1

typedef int VRType;
typedef char InfoType;
typedef char VertexType[MAX_NAME];
typedef int Boolean;//Boolean是布尔类型,其值是1或0

#define MAX_VEX_NUM 20


typedef struct 
{
	VRType adj;//顶点关系类型
	InfoType *info;//该弧相关信息的指针
}ArcCell,AdjMatrix[MAX_VEX_NUM][MAX_VEX_NUM];

typedef struct
{
	VertexType vexs[MAX_VEX_NUM];
	AdjMatrix arcs;
	int vexnum,arcnum;//当前顶点数和弧数
}MGraph;

typedef struct QNode
{
	VRType info;
	struct QNode *link;
}QNode,*QueuePtr;

typedef struct LinkQueue
{
	QueuePtr f;//队头、队尾指针
	QueuePtr r;
}*PLinkQueue;

/*构造一个空队列*/
PLinkQueue createEmptyQueue_link(void)
{
	PLinkQueue p_queue;

	p_queue=(PLinkQueue)malloc(sizeof(struct LinkQueue));

	if(NULL!=p_queue)
	{
		p_queue->f=NULL;
		p_queue->r=NULL;
	}
	else
		printf("Out of space!\n");
	return p_queue;
}
bool isEmptyQueue_link(PLinkQueue p_queue)
{
	return p_queue->f==NULL;
}
void enQueue_link(PLinkQueue p_queue,VRType vt)
{
	QueuePtr p;

	p=(QueuePtr)malloc(sizeof(struct QNode));

	if(NULL==p)
	{
		printf("Out of space!\n");
		exit(-1);
	}
	else
	{
		p->info=vt;//将元素写入数据域
		p->link=NULL;//填写新结点信息
		
		if(NULL==p_queue->f)
		{
			p_queue->f=p;
			p_queue->r=p;
		}
		else
		{
			p_queue->r->link=p;
			p_queue->r=p;
		}
	}
}
void deQueue_link(PLinkQueue p_queue)
{
	QueuePtr p;

	if(NULL==p_queue->f)
	{
		printf("EmptyQueue\n");
		exit(-1);
	}
	else
	{
		p=p_queue->f;
		if(p_queue->f==p_queue->r)
			p_queue->r=NULL;
		p_queue->f=p->link;
		free(p);
	}
}
VRType top_link(PLinkQueue p_queue)
{
	if(NULL==p_queue->f)
	{
		printf("EmptyQueue\n");
		exit(-1);
	}
	return p_queue->f->info;
		
} 
/* 初始条件:图G存在,u和G中顶点有相同特征 */
/* 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
int getLocateVex(MGraph G,VertexType u)
{
	int i;
	for(i=0;i<G.vexnum;++i)
	{
		if(strcmp(u,G.vexs[i])==0)
		{
			return  i;
		}
	}
	
	return -1;
}
/* 采用数组(邻接矩阵)表示法,构造无向图G */
int createUDG(MGraph *G)
{
	int i,j,k,l,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;

	printf("请输入无向图G的顶点数，边数，边是否含有其他信息(是:1,否:0)");
	scanf("%d%d%d",&(*G).vexnum,&(*G).arcnum,&IncInfo);

	printf("请输入%d个顶点的值(<%d个字符)",(*G).vexnum,MAX_NAME);
	for(i=0;i<(*G).vexnum;++i)//构造顶点向量
		scanf("%s",(*G).vexs[i]);

	for(i=0;i<(*G).vexnum;++i)
		for(j=0;j<(*G).vexnum;++j)
		{
			(*G).arcs[i][j].adj=0;
			(*G).arcs[i][j].info=NULL;
		}

	printf("请输入%d条边的顶点1 顶点2(以空格作为间隔):\n",(*G).arcnum);
	for(k=0;k<(*G).arcnum;++k)
	{
		scanf("%s%s",va,vb);
		i=getLocateVex(*G,va);
		j=getLocateVex(*G,vb);
		if(i<0||j<0)
		{
			printf("输入的节点不匹配!\n");
		}
		(*G).arcs[i][j].adj=(*G).arcs[j][i].adj=1;//无向图

		if(IncInfo)
		{
			printf("请输入该边的相关信息(<%d个字符):",MAX_INFO);
			gets(s);
			l=strlen(s);

			if(l)
			{
				info=(char *)malloc((l+1)*sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info=(*G).arcs[j][i].info=info;//无向图
			}
		}
	}

	return 1;
}

/* 初始条件: 图G存在,v是G中某个顶点 */
/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
int FirstAdjVex(MGraph G,VertexType v)
{
	int i,k;

	k=getLocateVex(G,v);
	for(i=0;i<G.vexnum;i++)//k为顶点v在图G中的序号 
	{
		if(G.arcs[k][i].adj!=0)
		{
			return i;
		}
				
	}
	
	return -1;
}
/* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号, */
/*           若w是v的最后一个邻接顶点,则返回-1 */
int NextAdjVex(MGraph G,VertexType v,VertexType w)
{
	int i=0,k1,k2;

	k1=getLocateVex(G,v);//k1为顶点v在图G中的序号 
	k2=getLocateVex(G,w);//k2为顶点w在图G中的序号

	for(i=k2+1;i<G.vexnum;i++)
	{
		if(G.arcs[k1][i].adj!=0)
		{
			return i;
		}					
	}
		
	return -1;
}
Boolean visited[MAX_VEX_NUM];//访问标志数组
int (*VisitFunc)(VertexType);//函数变量
/* 从第v个顶点出发递归地深度优先遍历图G*/
void DFS(MGraph G,int v)
{
	int w;
	visited[v]=1;//设访问标志为已访问
	VisitFunc(G.vexs[v]);//访问第v个顶点

	for(w=FirstAdjVex(G,G.vexs[v]);w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w]))
	{
		if(!visited[w])
		{
				DFS(G,w);
		}						
	}		
}

/* 初始条件: 图G存在,Visit是顶点的应用函数。*/
/* 操作结果: 从第1个顶点起,深度优先遍历图G,并对每个顶点调用函数Visit */
/*           一次且仅一次。一旦Visit()失败,则操作失败 */
void DFSTraverse(MGraph G,int(*Visit)(VertexType))
{
	int v;
	VisitFunc=Visit;//使用全局变量VisitFunc，使DFS不必设函数指针参数
	for(v=0;v<G.vexnum;v++)
		visited[v]=0;//访问数组初始化(未访问)
	for(v=0;v<G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);//对未访问的顶点调用DFS
	printf("\n\n");
}
/* 初始条件: 图G存在,Visit是顶点的应用函数。*/
/* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */
/*           Visit一次且仅一次。一旦Visit()失败,则操作失败。 */
/*           使用辅助队列Q和访问标志数组visited */
void BFSTraverse(MGraph G,int(*Visit)(VertexType))
{
	int v,u,w;
	PLinkQueue p_queue;

	for(v=0;v<G.vexnum;v++)
		visited[v]=0;//置出值
	p_queue=createEmptyQueue_link();//初始化辅助队列

	for(v=0;v<G.vexnum;v++)
	{
		if(!visited[v])//v尚未访问
		{
			visited[v]=1;//设访问标志为已访问
			Visit(G.vexs[v]);//访问第v个顶点

			enQueue_link(p_queue,v);	
			
			while(!isEmptyQueue_link(p_queue))
			{	
				u=top_link(p_queue);
				deQueue_link(p_queue);//队头元素出队并置为u
			
				for(w=FirstAdjVex(G,G.vexs[u]);w>=0;w=NextAdjVex(G,G.vexs[u],G.vexs[w]))
					if(!visited[w])//w为u的尚未访问的邻接顶点的序号 
					{
						visited[w]=1;
						Visit(G.vexs[w]);
						enQueue_link(p_queue,w);
					}
			}
		}
	}
	printf("\n\n");
}
int visit(VertexType v)
{
	printf("%s ",v);
	return 1;
}
/*输出邻接矩阵*/
void printGraph(MGraph G)
{
	int i,j;

	printf("%d个顶点%d条无向图的边\n",G.vexnum,G.arcnum);
	for(i=0;i<G.vexnum;++i)
		printf("G.vexs[%d]=%s\n",i,G.vexs[i]);

	printf("G.arcs.adj:\n"); /* 输出G.arcs.adj */
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
			printf("%6d",G.arcs[i][j].adj);
		printf("\n");
	}	
}
int main()
{
	MGraph G;

	createUDG(&G);
	printGraph(G);
	printf("\n\n");

	printf("图的深度优先搜索:");
	DFSTraverse(G,visit);
	printf("\n\n");

	printf("图的广度优先搜索:");
	BFSTraverse(G,visit);
	printf("\n\n");
	
	return 0;

}