文章目录

一、深度优先遍历（DFS）

二、邻接矩阵的深度优先递归算法与遍历操作

三、 领接表的深度优先递归算法与遍历操作

四、广度优先遍历（BFS）

五、邻接矩阵的广度遍历算法

六、 邻接表的广度遍历算法

大总结：ＤＦＳ和ＢＦＳ模板

一、深度优先遍历（DFS）

深度优先遍历也成为深度优先搜索，简称ＤＦＳ（Ｄｅｐｔｈ　Ｆｉｒｓｔ　Ｓｅａｒｃｈ） 从图中某个顶点ｖ出发，访问此顶点，然后从ｖ的未被访问的邻接点出发深度优先遍历图，直至图中所有和ｖ有路径相通的顶点都被访问到。

类似于一个树的前序遍历（栈或递归的过程）

二、邻接矩阵的深度优先递归算法与遍历操作：

typedef int Boolean;/*Boolean是布尔类型，其值是TRUE或FALSE*/
Boolean visited[MAX];/*访问标志的数组*/
/*邻接矩阵的深度优先递归算法*/
void DFS(MGraph G,int i)
{
   
	int j;
	visited[i]=TRUE;
	printf("%c",G.vexs[i]);/*打印顶点，也可以其他操作*/
	for(j=0;j<G.numVertexes;j++)
		if(G.arc[i][j]==1&&!visted[j])
			DFS(G,j);	/*对为访问的邻接顶点递归调用*/
}

三、邻接矩阵的深度遍历操作与遍历操作:

/*邻接矩阵的深度遍历操作*/
void DFSTraverse(MGraph G)
{
   
	int i;
	for(i=0;i<G.numVertexes;i++)
		visited[i]=FALSE;/*初始所有顶点状态都是未访问过状态*/
	for(i=0;i<G.numVertexes;i++)
		if(!visited[i])/*对未访问过的顶点调用DFS，若是连通图，只会访问一次*/
		DFS(G,i); 
}

四、广度优先遍历（ＢＦＳ）

广度优先遍历又称为广度优先搜索，简称ＢＦＳ

类似于树的层序遍历（队列渗透，之前写的队列层序建立二叉树）

/* 循环队列的顺序存储结构 */
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;
}

五、邻接矩阵的广度遍历算法 

/* 邻接矩阵的广度遍历算法 */
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);				/* 将找到的此顶点入队列 */
					} 
				} 
			}
		}
	}
}

六、 邻接表的广度遍历算法 

/* 邻接表的广度遍历算法 */
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;	/* 指针指向下一个邻接点 */
				}
			}
		}
	}
}

ＤＦＳ和ＢＦＳ模板

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#define maxn 10005
#define INF 0x3f3f3f3f
#define mm(a,x) memset(a,x,sizeof(a))
using namespace std;

int map[maxn][maxn],dfs_visited[maxn],bfs_visited[maxn];
int V,E;
void dfs(int i){
   
	dfs_visited[i]=1;
	cout<<" "<<i;
	for(int j=0;j<V;j++){
   
		if(map[i][j]&&!dfs_visited[j]){
   
			dfs(j);
		}
	}
}
void bfs(int i){
   
	queue<int> q;
	bfs_visited[i]=1;
	q.push(i);
	cout<<" "<<i;
	while(!q.empty()){
   
		int p=q.front();
		q.pop();
		for(int j=0;j<V;j++){
   
			if(map[p][j]&&!bfs_visited[j]){
   
				cout<<" "<<j;
				bfs_visited[j]=1;
				q.push(j);
			}
		}
	}
}
int main(){
   
	cin>>V>>E;
	for(int i=0;i<E;i++)
	{
   
		int c1,c2;
		cin>>c1>>c2;
		map[c1][c2]=map[c2][c1]=1;
	}
	for(int i=0;i<V;i++)
	{
   
		for(int j=0;j<V;j++)
	{
   
	cout<<map[i][j];	
	}
	puts("");
	}
	mm(dfs_visited,0);
	for(int i=0;i<V;i++)
	{
   
		if(!dfs_visited[i]){
   
			cout<<"{";
			dfs(i);
			cout<<" }"<<endl;
		}
	}
	mm(bfs_visited,0);
	for(int i=0;i<V;i++)
	{
   
		if(!bfs_visited[i]){
   
			cout<<"{";
			bfs(i);
			cout<<" }"<<endl;
		}
	}
	return 0;
}