C语言数据结构与算法---图的遍历

一. 深度优先搜索（DFS）

1.概念及实现原理

首先从A开始，在没有碰到重复顶点的情况下，始终是想右手边走，于是到了B。根据右手通行原则到了C,D,E,F当继续走时发现回到了A，因为A处已经标记走过了，所以退回F，走右数第二条到G，发现B,D已经走过，于是到H，此时发现H的通道都已经走过了，但是结点还没有遍历完，所以在H处开始返回到G,在返回到E都已经走过了，在返回到D，发现I还没走，访问I，然后继续返回到顶点A。

深度优先遍历其实就是一个递归的过程

怎样避免重复访问？
设置辅助数组，用来标记每个被访问过的顶点。

2. 深度优先遍历的实现代码

1. 若图为邻接矩阵

bool visited[MAXWEX]; //标志访问过的数组
// i 为待访问结点的下标
void DFS(MGraph G, int i)
{
	int j;
	visited[i] = true;
	printf("%c",G.vesx[i]);
	for (j = 0; j < G.numv; j++)
	{
		if (G.arc[i][j] == 1 && visited[j] == false)
		{
			DFS(G,j);  //对为访问的邻接顶点递归调用
		}
	}
}

//邻接矩阵的深度优先遍历
void DFSTraverse(MGraph G)
{
	int i;
	//初始化所有结点为未访问状态
	for (i = 0; i < G.numv; i++)
	{
		visited[i] = false;
	}

	for (i = 0; i < G.numv; i++)
	{
		//对未访问过的顶点调用DFS，若是连通图，只调用一次
		if (visited[i] == false)
		{
			DFS(G,i);
		}
	}
}

2. 若图为邻接表

bool visited[MAXWEX]; //标志访问过的数组
// i 为待访问结点的下标
void DFS(GraphAdjList *G, int i)
{
	EdgeNode* p;
	visited[i] == true;
	printf("%c",G->adjList[i].data);
	p = G->adjList[i].firstedge;
	while (p)
	{
		if (visited[p->adjvex] == false)
		{
			DFS(G,p->adjvex);
		}
		p = p->next;
	}
}

//邻接矩阵的深度优先遍历
void DFSTraverse(GraphAdjList *G)
{
	int i;
	//初始化所有结点为未访问状态
	for (i = 0; i < G->numv; i++)
	{
		visited[i] = false;
	}

	for (i = 0; i < G->numv; i++)
	{
		//对未访问过的顶点调用DFS，若是连通图，只调用一次
		if (visited[i] == false)
		{
			DFS(G, i);
		}
	}
}

二. 广度优先搜索（BFS）

1. 概念及实现原理

类似于树的层序遍历

方法：从图的某一结点出发，首先依次访问该结点的所有邻接点，再按照这些顶点被访问的先后次序一次访问与他们相邻接的所有未被访问的顶点，重复此过程

2. 广度优先遍历的实现代码

/* 循环队列的顺序存储结构 */
typedef struct
{
	int data[MAXSIZE];
	int front;    	/* 头指针 */
	int rear;		/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}Queue;

/* 初始化一个空队列Q */
Status InitQueue(Queue *Q)
{
	Q->front=0;
	Q->rear=0;
	return  OK;
}

/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(Queue Q)
{ 
	if(Q.front==Q.rear) /* 队列空的标志 */
		return TRUE;
	else
		return FALSE;
}

/* 若队列未满，则插入元素e为Q新的队尾元素 */
Status EnQueue(Queue *Q,int e)
{
	if ((Q->rear+1)%MAXSIZE == Q->front)	/* 队列满的判断 */
		return ERROR;
	Q->data[Q->rear]=e;			/* 将元素e赋值给队尾 */
	Q->rear=(Q->rear+1)%MAXSIZE;/* rear指针向后移一位置， */
								/* 若到最后则转到数组头部 */
	return  OK;
}

/* 若队列不空，则删除Q中队头元素，用e返回其值 */
Status DeQueue(Queue *Q,int *e)
{
	if (Q->front == Q->rear)			/* 队列空的判断 */
		return ERROR;
	*e=Q->data[Q->front];				/* 将队头元素赋值给e */
	Q->front=(Q->front+1)%MAXSIZE;	/* front指针向后移一位置， */
									/* 若到最后则转到数组头部 */
	return  OK;
}

1. 若图为邻接矩阵

/* 邻接矩阵的广度遍历算法 */
void BFSTraverse(MGraph G)
{
	int i, j;
	Queue Q;
	for(i = 0; i < G.numv; i++)
       	visited[i] = FALSE;
    InitQueue(&Q);		/* 初始化一辅助用的队列 */
    for(i = 0; i < G.numv; 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.numv;j++) 
				{ 
					/* 判断其它顶点若与当前顶点存在边且未访问过  */
					if(G.arc[i][j] == 1 && !visited[j]) 
					{ 
 						visited[j]=TRUE;			/* 将找到的此顶点标记为已访问 */
						printf("%c ", G.vexs[j]);	/* 打印顶点 */
						EnQueue(&Q,j);				/* 将找到的此顶点入队列  */
					} 
				} 
			}
		}
	}
}

2. 若图为邻接表

/* 邻接表的广度遍历算法 */
void BFSTraverse(GraphAdjList *G)
{
	int i;
    EdgeNode *p;
	Queue Q;
	for(i = 0; i < G->numv; i++)
       	visited[i] = FALSE;
    InitQueue(&Q);
   	for(i = 0; i < G->numv; i++)
   	{
		if (!visited[i])
		{
			visited[i]=TRUE;
			printf("%c ",G->adjList[i].data);/* 打印顶点,也可以其它操作 */
			EnQueue(&Q,i);
			while(!QueueEmpty(Q))
			{
				DeQueue(&Q,&i);
				p = G->adjList[i].firstedge;	/* 找到当前顶点的边表链表头指针 */
				while(p)
				{
					if(!visited[p->adjvex])	/* 若此顶点未被访问 */
 					{
 						visited[p->adjvex]=TRUE;
						printf("%c ",G->adjList[p->adjvex].data);
						EnQueue(&Q,p->adjvex);	/* 将此顶点入队列 */
					}
					p = p->next;	/* 指针指向下一个邻接点 */
				}
			}
		}
	}
}