邻接矩阵深度优先和广度优先遍历（DFS和BFS）

深度优先遍历

深度优先遍历(DepthFirstSearch)，也有称为深度优先搜索，简称为DFS。

约定右手原则：在没有碰到重复顶点的情况下，分叉路口始终是向右手边走，每路过一个顶点就做一个记号。

如果再细心观察，你会发现整个遍历过程就像是一棵树的前序遍历！

广度优先遍历

广度优先遍历（BreadthFirstSearch），又称为广度优先搜索，简称BFS。

代码：

<span style="font-family:Microsoft YaHei;font-size:14px;">/*邻接矩阵的广度遍历算法*/
#include "stdio.h"
#include "stdlib.h"

#define OK 1
#define ERROR 1
#define FALSE 0
#define TRUE 1

typedef int Status; //Status是函数的类型，其值是函数结果状态代码
typedef int Boolean;//Boolean是布尔类型，其值是TRUE或FALSE

//图的邻接矩阵存储结构
typedef char VertexType;//顶点类型应由用户定义
typedef int EdgeType;//边上的权值类型应由用户定义
#define MAXVEX 100  //最大顶点数，应由用户定义

typedef struct 
{
	VertexType  vexs[MAXVEX];//顶点表
	EdgeType arc[MAXVEX][MAXVEX];//邻接矩阵，可看做边表
	int numVertexes,numEdge;//图中当前的顶点数和边数
}MGraph;

//***********用到的队列结构与函数***********

//链队列的结构
typedef int QElemType;//这里QElemType的类型假设为int

typedef struct QNode //结点结构
{
	QElemType  data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct //队列的链表结构
{
	QueuePtr front,rear;//队头、队尾指针
}LinkQueue;

//初始化队列：
Status initQueue(LinkQueue *q)
{
	q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
	if(!q->front)
		return ERROR;
	q->front->next = NULL;

	return OK;
}

//入队：插入元素e为q的新的队尾元素
Status EnQueue(LinkQueue *q,QElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if(!s)//存储分配失败
		return ERROR;
	s->data = e;
	s->next = NULL;
	q->rear->next = s;
	q->rear = s;

	return OK;
}

//出队
//若队列不为空，删除q的队头元素，用e返回其值，并返回OK，否则返回ERROR
Status DeQueue(LinkQueue *q,QElemType *e)
{
	
	QueuePtr p;

	if(q->front==q->rear)
		return ERROR;
	p = q->front->next;
	*e = p->data;
	q->front->next = p->next;

	if(q->rear==p)//若队头是队尾，则删除后将rear指向头结点
		q->rear = q->front;
	free(p);
	return OK;
}

//判断是否为空队列,若为空队列则返回1，否则返回0
Status QueueEmpty(LinkQueue q)
{
	if(q.front == q.rear)
		return 1;
	return 0;
}

//******************************************************

//建立无向图的邻接矩阵表示
void CreatMGraph(MGraph *G)
{

	int i,j,k;
	printf("输入顶点数和边数：\n");
	scanf("%d,%d",&G->numVertexes,&G->numEdge);//输入顶点数和边数
	getchar();

	printf("输入顶点字符：\n");
	for(i=0;i<G->numVertexes;i++) //读入顶点信息，建立顶点表
		scanf("%c",&G->vexs[i]);

	for(i=0;i<G->numVertexes;i++)
		for(j=0;j<G->numVertexes;j++)
			G->arc[i][j] =0;//邻接矩阵初始化

	for(k=0;k<G->numEdge;k++)//读入numEdges条边，建立邻接矩阵
	{
		printf("输入边（vi,vj）上的下标i，下标j：\n");
		scanf("%d,%d",&i,&j);
		G->arc[i][j]=1;
		G->arc[j][i]=G->arc[i][j];//因为是无向图，矩阵对称
	}
}

Boolean visited[MAXVEX];//访问标记的数组

//邻接矩阵的深度优先递归算法
void DFS(MGraph G,int i)
{
	int j;
	visited[i] = TRUE;
	printf("%c ",G.vexs[i]);
	for(j=0;j<G.numVertexes;j++)
		if(G.arc[i][j]==1 && !visited[j])
			DFS(G,j);//对未访问的邻接顶点递归调用
}

//邻接矩阵的深度遍历算法
void DFSTraverse(MGraph G)
{
	int i;
	for(i=0;i<G.numVertexes;i++)
		visited[i]=FALSE;//初始所有顶点状态都是未被访问过
	for(i=0;i<G.numVertexes;i++)
		if(!visited[i])
			DFS(G,i);
}

//邻接矩阵的广度遍历算法
void BFSTraverse(MGraph G)
{
	int i,j;
	LinkQueue Q;

	for(i=0;i<G.numVertexes;i++)
	{
		visited[i] = FALSE;
	}

	initQueue(&Q);				//初始化一辅助用的队列

	for(i=0;i<G.numVertexes;i++)//对每一个顶点做循环
	{
		if(!visited[i])			//若是未被访问过就处理
		{
			visited[i] = TRUE;	//设置当前顶点访问过
			printf("%c ",G.vexs[i]);//打印顶点
			EnQueue(&Q,i);		//将此顶点入队列

			while(!QueueEmpty(Q))//若当前顶点不为空
			{
				DeQueue(&Q,&i);	 //将队中元素出队列，赋值给i
				for(j=0;j<G.numVertexes;j++)
				{
					//判断其他顶点若与当前顶点存在边且未被访问过
					if(G.arc[i][j] ==1 && !visited[j])
					{
						visited[j] = TRUE;//将找到的此顶点标记为已访问
						printf("%c ",G.vexs[j]);//打印此顶点
						EnQueue(&Q,j);//将找到的此顶点入队列
					}
				}
			}
		}
	}
}
	
int main()
{
	MGraph G;
	CreatMGraph(&G);
	printf("\n深度遍历：");
	DFSTraverse(G);
	printf("\n广度遍历：");
	BFSTraverse(G);

	return 0;
}</span>