考研数据结构代码：图(邻接矩阵实现)的深度优先搜索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	//邻接矩阵 
{
	char Vex[MaxSize];	//顶点表
	int Edge[MaxSize][MaxSize];	//邻接矩阵，边表
	int vexnum, arcnum;			//图当前的定点数和边数
}Graph;
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)
{
	for(int i = 0; i < G.vexnum; i++)
	{
		if(G.Edge[v][i] == 1 && visited[i] == 0) 
		{
			return i;
		}
	}
	return -1;
} 
int NexNeighbor(Graph G,int v,int w)
{
	for(int i = w+1, i < G.vexnum; i++)
	{
		if(G.Vex[v][i] == 1 && visited[i] == 0)
		{
			return i;
		}
	}
	return -1;
}
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);
		}
}