考研数据结构代码：图(邻接表实现)的深度优先搜索DFS，广度优先搜索BFS

图的DFS,BFS

邻接表存储

BFS(!需要借助队列Q ):

1. G进入BFSTraverse():初始化标记数组visited[]，初始化对列Q，for循环if(结点v未访问)，则进入BFS()
2. G,v进入BFS():访问v,更新visited[]，v入队Q
3. while(Q非空)，则for() 循环遍历v的每一个邻接结点，若结点i未访问，则对其访问，更新状态并入队Q.

DFS:

1. G进入DFSTraverse(): 初始化标记数组visited[]，for循环if(结点v未访问)，则进入DFS()
2. G,v进入DFS():访问v,更新visited[]
3. for() 循环遍历v的每一个邻接结点，若结点i未访问，则对G，i进入DFS().

// 图（邻接表实现）
// 图 (邻接矩阵实现） 
//BFS(!需要借助队列Q):
//①G进入BFSTraverse():初始化标记数组visited[]，初始化对列Q，for循环if(结点v未访问)，则进入BFS 
//②G,v进入BFS():访问v,更新visited[]，v入队Q
//③while(Q非空)，则for()循环遍历v的每一个邻接结点，若结点i未访问，则对其访问，更新状态并入队Q. 
//DFS:
//①G进入DFSTraverse(): 初始化标记数组visited[]，for循环if(结点v未访问)，则进入DFS
//②G,v进入DFS():访问v,更新visited[]
//③for()循环遍历v的每一个邻接结点，若结点i未访问，则对G，i进入DFS().
#include <stdio.h> 
#define MaxSize 100		//顶点数目的最大值 
// 边： 
typedef struct ArcNode{			//边表结点 
	int adjvex;					//该弧指向的顶点的位置
	struct ArcNode *next;		//指向下一条弧的指针
}ArcNode;
// 点： 
typedef struct VNode{			//顶点表结点	
	char data;			//顶点信息
	ArcNode *first;				//指向第一条依附该顶点的弧的指针
}VNode;
// 邻接表： 
typedef struct{					
	VNode vertices[MaxSize];			//邻接表
	int vexnum, arcnum;			//图的顶点数和弧数
}Graph;						//ALGraph是以邻接表存储的图类型


bool visit();	//访问当前结点 
void BFSTraverse(Graph G);	//BFS遍历 
void BFS(Graph G,int i);	//访问当前节点并对第i个结点的邻接结点进行遍历 
int FirstNeighbor(Graph G,int v);	//得到第v个结点邻接的第一个未遍历结点 
int NexNeighbor(Graph G,int v,int w);	//得到第v个结点邻接的第w个结点后的第一个未遍历结点 
int main()
{
	Graph G;
	BFSTraverse(G); 
}
int FirstNeighbor(Graph G,int v)
{
	if(G.vertices[v].first != NULL)
	{
		return G.vertices[v].first.adjvex;
	}
	return -1;
} 
int NexNeighbor(Graph G,int v,int w)
{
	ArcNode *p = G.vertices[v].first;
	while(p->adjvex != w && p->next != NULL)
	{
		p = p->next;
	}
	if(p->next == NULL)
		return -1;
	else
		return p->next->adjvex;
}
void BFSTraverse(Graph G)	//BFS
{
	int visited[MaxSize] = {0};	//访问标记数组	
	int i;
	InitQueue(Q);				//初始化辅助队列Q
	for(i = 0; i < G.vexnum; i++)	//从0号顶点开始遍历 
	{
		if(!visited[i])			//对每个连通分量调用一次BFS
		{
			BFS(G,i);			//vi未访问过，从vi开始BFS
		}
	}
}
void BFS(Graph G, int v){		//从顶点v出发，广度优先遍历图G 
	visit(v);
	visited[v]=1;			//对v做以访问标记
	EnQueue(Q,v);				//顶点v入队Q
	while(!isEmpty(Q))
	{
		DeQueue(Q,v);
		for(w = FirstNeighbor(G,v); w >= 0; w = NexNeighbor(G,v,w))
		{
				visit(w);
				visited[w] = 1;
				EnQueue(Q,w);
		}
	}
}

void DFSTraverse(Graph G){		//对图G进行深度优先遍历
	int visited[G.vexnum] = {0};
	for(v = 0; v < G.vexnum; v++)
	{
		if(!visited[v])			//只要未被访问过就执行DFS
		{
			DFS(G,v);
		}
	}	
}
void DFS(Graph G, int v){		//从顶点v出发，深度优先遍历图G
	visit(v);
	visited[v] = 1;
	for(w = FirstNeighbor(G,v); w >= 0; w = NextNeighbor(G,v,w))
		if(!visited[w])	//若w未被访问，则执行DFS
		{		
			DFS(G,w);
		}
}