邻接矩阵存储图的深度优先遍历 邻接表存储图的广度优先遍历 详解

练习6.1 邻接矩阵存储图的深度优先遍历 (20分)（DFS）

邻接矩阵存储图的深度优先遍历

试实现邻接矩阵存储图的深度优先遍历。

函数接口定义：

void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) );

其中MGraph是邻接矩阵存储的图，定义如下：

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};

typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */
函数DFS应从第V个顶点出发递归地深度优先遍历图Graph，遍历时用裁判定义的函数Visit访问每个顶点。当访问邻接点时，要求按序号递增的顺序。题目保证V是图中的合法顶点。

裁判测试程序样例：

#include <stdio.h>

typedef enum {false, true} bool;
#define MaxVertexNum 10  /* 最大顶点数设为10 */
#define INFINITY 65535   /* ∞设为双字节无符号整数的最大值65535*/
typedef int Vertex;      /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;  /* 边的权值设为整型 */

typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */
bool Visited[MaxVertexNum]; /* 顶点的访问标记 */

MGraph CreateGraph(); /* 创建图并且将Visited初始化为false；裁判实现，细节不表 */

void Visit( Vertex V )
{
    printf(" %d", V);
}

void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) );


int main()
{
    MGraph G;
    Vertex V;

    G = CreateGraph();
    scanf("%d", &V);
    printf("DFS from %d:", V);
    DFS(G, V, Visit);

    return 0;
}

/* 你的代码将被嵌在这里 */
输入样例：给定图如下

5

输出样例：

DFS from 5: 5 1 3 0 2 4 6

先看一下百度百科对DFS的解释：

深度优先遍历图的方法是，从图中某顶点v出发：
（1）访问顶点v；
（2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
（3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。当然，当人们刚刚掌握深度优先搜索的时候常常用它来走迷宫.事实上我们还有别的方法，那就是广度优先搜索(BFS).

然后我来模拟一下题目的过程：

1、从5开始搜索，按从小到大的顺序搜索：首先搜索到1，标记，然后递归从1搜索；
2、节点1遍历到3，3被标记，开始搜索，然后依次访问到0和2，标记；
3、与2相连的还有3和5，但是3和5已经被标记过了，回溯到0，继续访问4，标记；
4、4节点和5相连，但是5已经被标记过了，不再访问，依次回溯到0->3->1->5节点；
5、与5相连的还有2和4,2和4已被访问，于是访问6，标记；
6、6没有与其他节点相连，回溯至5，遍历结束。

DFS伪代码：

DFS(当前被访问的节点pos)
{
	pos被标记访问过
	
	遍历与pos相连的节点（有边相连）
		如果这个节点没有被访问过
		搜索（DFS）当前节点
}

DFS题目代码

void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) )//Graph表示邻接矩阵存储的图，V表示当前访问的节点。第三个参数为输出节点的函数
{
	int w;
	Visit(V);//访问到V，输出
	Visited[V]=true;//标记V被访问过，此后不再访问
	for(w=0;w<Graph->Nv;w++){ //数据是0到Graph->Nv（顶点数点数），访问每个节点
		if(Graph->G[V][w]<INFINITY&&Visited[w]==false){//如果当前节点V与遍历的节点w有边相连，且w没有被访问过
			DFS(Graph,w,Visit);//从w开始搜索访问
		}
	}				
}

练习6.2 邻接表存储图的广度优先遍历 (20分)（BFS）

邻接表存储图的广度优先遍历

试实现邻接表存储图的广度优先遍历。

函数接口定义：

void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) );

其中LGraph是邻接表存储的图，定义如下：

/* 邻接点的定义 */

typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 邻接点下标 */
    PtrToAdjVNode Next; /* 指向下一个邻接点的指针 */
};

/* 顶点表头结点的定义 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge; /* 边表头指针 */
} AdjList[MaxVertexNum];     /* AdjList是邻接表类型 */

/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 顶点数 */
    int Ne;     /* 边数   */
    AdjList G;  /* 邻接表 */
};

typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
函数BFS应从第S个顶点出发对邻接表存储的图Graph进行广度优先搜索，遍历时用裁判定义的函数Visit访问每个顶点。当访问邻接点时，要求按邻接表顺序访问。题目保证S是图中的合法顶点。

裁判测试程序样例：

#include <stdio.h>

typedef enum {false, true} bool;
#define MaxVertexNum 10   /* 最大顶点数设为10 */
typedef int Vertex;       /* 用顶点下标表示顶点,为整型 */

/* 邻接点的定义 */
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 邻接点下标 */
    PtrToAdjVNode Next; /* 指向下一个邻接点的指针 */
};

/* 顶点表头结点的定义 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge; /* 边表头指针 */
} AdjList[MaxVertexNum];     /* AdjList是邻接表类型 */

/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 顶点数 */
    int Ne;     /* 边数   */
    AdjList G;  /* 邻接表 */
};
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */

bool Visited[MaxVertexNum]; /* 顶点的访问标记 */

LGraph CreateGraph(); /* 创建图并且将Visited初始化为false；裁判实现，细节不表 */

void Visit( Vertex V )
{
    printf(" %d", V);
}

void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) );

int main()
{
    LGraph G;
    Vertex S;

    G = CreateGraph();
    scanf("%d", &S);
    printf("BFS from %d:", S);
    BFS(G, S, Visit);

    return 0;
}

/* 你的代码将被嵌在这里 */
输入样例：给定图如下

2

输出样例：

BFS from 2: 2 0 3 5 4 1 6

百度百科中解释BFS的实现：
广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。

我来模拟一下题目的过程：

1、首先把第一个访问的节点2加入队列，标记被访问过；
2、与2相连的节点有0,3,5，加入队列并标记访问过；
3、与2相连的有2,3,4，但是2和3已经被标记了，于是访问4，标记；
4、与4相连的还有5，5也被标记过了，不再访问，
5、此时队列中还有3和5,由3访问到1,5访问到6，程序结束。

BFS伪代码：

BFS（需要访问的节点S）
{
	定义队列
	队列中加入S
	S被标记访问过
	
	当队列不为空时
		取出队首的元素pos
		输出pos，表示访问到pos
		遍历与pos相连的节点（有边与pos相连）
			如果当前节点没有被访问过
				标记当前节点被访问过
				加入队列
				
}

BFS题目代码

void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) )//Graph表示邻接矩阵存储的图，V表示当前访问的节点。第三个参数为输出节点的函数
{
	int queue[100],front=0,rear=0;//用数组表示队列，front表示队列首，rear表示队列尾
	queue[++rear]=S;//队列存入访问的第一个节点S
    Visited[S]=true;//标记S被访问过，以后不再访问
	while(front!=rear){//当队列不为空时（首部没有到达尾部）
		int pos=queue[++front];//取出队列首部节点
	    Visit(pos);//输出取出的节点
        PtrToAdjVNode w;//定义邻接点w（题面中给出定义）
		for(w=Graph->G[pos].FirstEdge;w!=NULL;w=w->Next){//依次访问与pos相连的节点
			if(Visited[w->AdjV]==false){//如果这个节点没有被访问过
	        	Visited[w->AdjV]=true;//标记这个节点被访问
				queue[++rear]=w->AdjV;//把这个节点加入到队列中
			}
		}
	}
}

最初写的代码，实现正规的队列：

#include<stdlib.h> 
int maxsize=100;
typedef struct node *queue;
struct node{
	int *data,front,rear,maxsize;
};
void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) )
{
	queue q=(queue)malloc(sizeof(struct node));
	q->data=(int *)malloc(sizeof(int)*maxsize);
	q->front=q->rear=0;
//	add[q , S];	q->rear=(q->rear+1)%q->maxsize;
	q->data[++q->rear]=S;	
	Visited[S]=true;	
	PtrToAdjVNode w;
	while(q->front!=q->rear){		
		int v=q->data[++q->front];	
		Visit(v);	
		for(w=Graph->G[v].FirstEdge;w;w=w->Next){
			if(!Visited[w->AdjV]){
				q->data[++q->rear]=w->AdjV;	
				Visited[w->AdjV]=true;
			}
		}
	}
}

DFS和BFS是数据结构的图论中最基础最重要的算法，图论中很多算法都是基于BFS和DFS实现的，因此应该好好理解和掌握这两种算法。