图的深度优先遍历和广度优先遍历

图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问且只访问一次。

深度优先遍历：

算法描述：

（1）访问结点v。

（2）找到v的第一个邻接点w。

（3）如果邻接点w存在且未被访问，则从w出发深度优先遍历图；否则，结束。

（4）找顶点v关于w的下一个邻接点，转(3)。

完整代码：

#include "stdio.h"
#include "stdlib.h"
#define  N 5
 struct node            /*图顶点结构*/
{
	int peak;              //邻接顶点数据
	struct node *next;
};
 typedef struct node *graph;        //图结构
 struct node head[N];
 int visited[N];
 void Dfs(int peak);
 void Create(int peak1, int peak2)
 {
	 graph p, q;
	 q = (graph)malloc(sizeof(struct node));
	 if (q!=NULL)
	 {
		 q->peak = peak2;
		 q->next = NULL;
		 p = &(head[peak1]);
		 while (p->next!=NULL)
		 {
			 p = p->next;
		 }
		 p->next = q;
	 }
 }
 void visit(int peak)
 {
	 int i;
	 for (i = 0; i < N; i++)
	 {
		 visited[i] = 0;
	 }
	 for (i = 0; i < N;i++)
	 {
		 if (visited[i]== 0)
		 {
			 Dfs(peak);
		 }
	 }
 }
 void Dfs(int peak)
 {
	 graph p;
	 printf("%d访问", peak);                          //访问顶点peak
	 visited[peak] = 1;
	 p = head[peak].next;                 //找第一个邻接点
	 while (p != NULL)
	 {
		 if (visited[p->peak]==0)
		 {
			 Dfs(p->peak);
		 }
		 p = p->next;
	 }
 }
 void Show(struct node *head)
 {
	 graph p;
	 p = head->next;
	 while (p!=NULL)
	 {
		 printf(" [%d] ", p->peak);
		 p = p->next;
	 }
	 printf("\n");
 }
 int main()
 {
	 int node[8][2]=
	 {
		 {1,2},{1,3},{2,1},{2,4},{3,1},{3,4},{4,2},{4,3}
	 };
	 int i;
	 for (i = 0; i < 8;i++)
	 {
		 Create(node[i][0], node[i][1]);
	 }
	 printf("图的邻接表存储为:\n");
	 for (i = 1; i < N;i++)
	 {
		 printf("[%d] ", i);
		 Show(&head[i]);
	 }
	 printf("图的深度优先遍历结果\n");
	 visit(1);
	 printf("结束\n");
	 return 0;
 }

广度优先遍历：

算法描述：

（1）设图G的初态是所有顶点未被访问，设置辅助队列Q，队列Q为空。

（2）任选一个未被访问过的顶点v作为遍历起点。

（3）访问v，并将v入队列，将v标为已访问。

（4）若队列Q不空，取出一个顶点v。

（5）查找v的所有未被访问的邻接点vi并对其访问，并入队列，转（4），直到队列为空。

（6）若此时还有未被访问过的结点，转（2），否则结束。

完整代码：

#include "stdio.h"
#include "stdlib.h"
#define  N 5
typedef struct queue                                 //队的存储结构
{
	int data;
	struct queue *next;
}Queue;
typedef struct
{
	Queue *front;
	Queue *rear;
}qnode;
struct node            /*图顶点结构*/
{
	int peak;              //邻接顶点数据
	struct node *next;
};
typedef struct node *graph;        //图结构
struct node head[N];
int visited[N];

void Create(int peak1,int peak2);
void Show(struct node *head);
void BFS(int peak);
void Visit(int peak);
void InitQueue(qnode *p);
void In(qnode *p,int x);
int Empty(qnode *p);
int Out(qnode *p);

void InitQueue(qnode *p)                               //队的初始化
{
	p->front = p->rear = NULL;
}

void In(qnode *p,int x)                                //入队
{
	Queue *q;
	q = (Queue*)malloc(sizeof(Queue));
	if (q!=NULL)
	{
		q->data = x;
		q->next = NULL;
	}
	if (Empty(p)==1)
	{
	/*	p->front->data = p->rear->data = x;*/
		p->front = p->rear = q;
	}
	else
	{
		p->rear->next = q;
		p->rear = q;
	}
}
int Empty(qnode *p)                                           //判断队是否为空
{
	return((p->front == NULL) && (p->rear == NULL));
}
int Out(qnode *p)
{
	int x;
	Queue *q;
	if (Empty(p) == 0)
	q = p->front;
	x = q->data;
	p->front = q->next;
	if (p->rear == q)                    //如果出队后为空队
	{
		p->rear = NULL;
	}
	free(q);
	return x;
}
void Create(int peak1, int peak2)
{
	graph p, q;
	q = (graph)malloc(sizeof(struct node));
	if (q != NULL)
	{
		q->peak = peak2;
		q->next = NULL;
		p = &(head[peak1]);
		while (p->next != NULL)
		{
			p = p->next;
		}
		p->next = q;
	}
}
void Show(struct node *head)
{
	graph p;
	p = head->next;
	while (p!=NULL)
	{
		printf("[%d]", p->peak);
		p = p->next;
	}
	printf("\n");
}
void Visit(int peak)
{
	int i;
	for (i = 0; i < N;i++)
	{
		visited[i] = 0;
	}
	for (i = 0; i < N; i++)
	{
		if (visited[i] == 0)
		{
			BFS(peak);
		}
	}
}
void BFS(int peak)
{
	graph p;
	qnode Q;
	InitQueue(&Q);
	printf("[%d]访问", peak);
	visited[peak] = 1;
	In(&Q, peak);
	int v, k;
	while (!Empty(&Q))
	{
		v = Out(&Q);
		p = head[v].next;
		while (p != NULL)
		{
			k = p->peak;
			if (visited[k] == 0)
			{
				printf("[%d]访问", k);
				In(&Q, k);
				visited[k] = 1;
			}
			p = p->next;
		}
	}
}
int main()
{
	int node[8][2] =
	{
		{ 1,2 },{ 1,3 },{ 2,1 },{ 2,4 },{ 3,1 },{ 3,4 },{ 4,2 },{ 4,3 }
	};
	int i;
	for (i = 0; i < 8; i++)
	{
		Create(node[i][0], node[i][1]);
	}
	printf("图的邻接表存储为:\n");
	for (i = 1; i < N; i++)
	{
		printf("[%d] ", i);
		Show(&head[i]);
	}
	printf("图的广度优先遍历结果\n");
	Visit(1);
	printf("结束\n");
	return 0;
}