图广度优先遍历

一、实验目的1．掌握图的各种存储结构，特别要熟练掌握邻接矩阵和邻接表存储结构；2．遍历是图各种应用的算法的基础，要熟练掌握图的深度优先遍历和宽度优先遍历算法，复习栈和队列的应用；3．掌握图的各种应用的算法：图的连通性、连通分量和最小生成树、拓扑排序、关键路径。

二、实验内容实验内容1**图的遍历[问题描述]许多涉及图上操作的算法都是以图的遍历为基础的。

写一个程序，演示在连通无向图上遍历全部顶点。

[基本要求]建立图的邻接表的存储结构，实现无向图的深度优先遍历和广度优先遍历。

以用户指定的顶点为起点，分别输出每种遍历下的顶点访问序列。

[实现提示]设图的顶点不超过30个，每个顶点用一个编号表示（如果一个图有N个顶点，则它们的编号分别为1，2，…，N）。

通过输入图的全部边输入一个图，每条边是两个顶点编号对，可以对边依附顶点编号的输入顺序作出限制（例如从小到大）。

[编程思路]首先图的创建，采用邻接表建立，逆向插入到单链表中，特别注意无向是对称插入结点，且要把输入的字符在顶点数组中定位（LocateVex(Graph G,char *name)，以便后来的遍历操作，深度遍历算法采用递归调用，其中最主要的是NextAdjVex(Graph G, int v, int w)；FirstAdjVex （）函数的书写，依次递归下去，广度遍历用队列的辅助。

[程序代码]头文件：#include<stdio.h>#include<stdlib.h>#define MAX_VERTEX_NUM 30#define MAX_QUEUE_NUMBER 30#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;typedef int InfoType;typedef int Status;/* 定义弧的结构*/typedef struct ArcNode{int adjvex; /*该边所指向的顶点的位置*/ struct ArcNode *nextarc; /*指向下一条边的指针*/ InfoType info; /*该弧相关信息的指针*/}ArcNode;/*定义顶点的结构*/typedef struct VNode{char data[40]; /*顶点信息*/ArcNode *firstarc; /*指向第一条依附该顶点的弧的指针*/}VNode,AdjList[MAX_VERTEX_NUM];/*定义图的结构*/typedef struct {AdjList vertices;int vexnum,arcnum; /*图的当前顶点数和弧数*/int kind; /*图的类型标志*/}Graph;/*定义队列的结构*/typedef struct{int *elem;int front, rear;}Queue;/*功能选择*/void MenuSelect(int w);/*顶点定位*/int LocateVex(Graph G,char *name);/*创建无向图*/void CreateGraph(Graph &G);/*求第一个顶点*/int FirstAdjVex(Graph G, int v);/*求下一个顶点*/int NextAdjVex(Graph G, int v, int w);/*深度递归*/void DFS(Graph G, int v) ;/*深度遍历*/void DFSTravel(Graph G,int v);/*广度遍历*/void BFSTraverse(Graph G,char *name);/*初始化队列*/Status InitQueue(Queue &Q);/*判空*/Status EmptyQueue(Queue Q);/*进队*/Status EnQueue(Queue &Q, int e);/*出队*/Status DeQueue(Queue &Q, int &e);实现文件：#include <stdio.h>#include"malloc.h"#include "tuhead.h"#include "stdlib.h"#include "string.h"bool visited[MAX_VERTEX_NUM];/************************************************************ 顶点定位************************************************************/int LocateVex(Graph G,char *name){int i;for(i=1;i<=G.vexnum;i++) //从1号位置开始存储if(strcmp(name,G.vertices[i].data)==0) //相等则找到，返回位序return i;return -1;}/************************************************************ 创建无向图************************************************************/void CreateGraph(Graph &G){ArcNode *p;char name1[10],name2[10];int i,j,k;printf(" 请输入顶点数,按回车键结束：");scanf("%d",&G.vexnum);printf(" 请输入弧数,按回车键结束：");scanf("%d",&G.arcnum);printf(" 请依次输入顶点名（用空格分开且字符小于10）,按回车键结束：\n");printf(" ");for(i=1;i<=G.vexnum;i++) //从1号位置开始存储{scanf("%s",G.vertices[i].data); //从一号位置开始初始化G.vertices[i].firstarc=NULL;}printf("\n\n\n\n");printf(" ………………………………………输入小提示………………………………………\n");printf(" &&&&1 为避免输入遗漏，最好从选择任意一点，输入所有相邻边\n");printf(" &&&&2 输入边时格式(用空格分开，即格式为顶点（空格）顶点（空格)）\n");printf(" ………………………………………输入小提示………………………………………\n\n\n\n");for(k=0;k<G.arcnum;k++){printf("请输入相邻的两个顶点,按回车键结束：");scanf("%s%s",name1,name2);i=LocateVex(G,name1); //返回位序j=LocateVex(G,name2);p=(ArcNode *)malloc(sizeof(ArcNode)); //申请边节点p->adjvex=j; //插入到邻接表中，注意此处为逆向插入到单链表中p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;//无向图，注意是对称插入结点p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=i;p->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p;}}/************************************************************ 求第一个顶点************************************************************/int FirstAdjVex(Graph G, int v){ArcNode *p;if(v>=1 && v<=G.vexnum){p=G.vertices[v].firstarc;if(p->nextarc==NULL)return 0;elsereturn (p->nextarc->adjvex); //返回第一个顶点字符}return -1;}/************************************************************ 求下一个顶点************************************************************/int NextAdjVex(Graph G, int v, int w){ //在图G中寻找第v个顶点的相对于w的下一个邻接顶点ArcNode *p;if(v>=1 && v<=G.vexnum && w>=1 && w<=G.vexnum){p=G.vertices[v].firstarc;while(p->adjvex!=w)p=p->nextarc; //在顶点v的弧链中找到顶点wif(p->nextarc!=NULL)return 0; //若已是最后一个顶点，返回0 elsereturn(p->nextarc->adjvex); //返回下一个邻接顶点的序号}return -1;}/************************************************************ 深度递归************************************************************/void DFS(Graph G, int v){int w;ArcNode *p;visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点p=G.vertices[v].firstarc; //p为依附顶点的第一条边while (p!=NULL){w=p->adjvex;if(visited[w]==0)DFS(G,w);p=p->nextarc; //下移指针}}/************************************************************ 深度遍历************************************************************/void DFSTravel(Graph G,int v){for(int i=1;i<=G.vexnum;i++)visited[i]=0;int w;ArcNode *p;visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点p=G.vertices[v].firstarc;while (p!=NULL){w=p->adjvex;if(visited[w]==0)DFS(G,w);p=p->nextarc;}}/************************************************************ 初始化队列************************************************************/Status InitQueue(Queue &Q){Q.elem = new int[MAX_QUEUE_NUMBER];Q.front = Q.rear = 0;return OK；}Status EmptyQueue(Queue Q){if(Q.front==Q.rear)return 0;elsereturn 1;}/*********************************************************** * 进队列* ***********************************************************/ Status EnQueue(Queue &Q, int e){if((Q.rear + 1)%MAX_QUEUE_NUMBER != Q.front)Q.elem[Q.rear ] = e;else ;Q.rear = (Q.rear + 1)%MAX_QUEUE_NUMBER;return OK；}/*********************************************************** * 出队列* ***********************************************************/ Status DeQueue(Queue &Q, int &e){if(Q.rear != Q.front)e = Q.elem[Q.front];else ;Q.front = (Q.front+1)%MAX_QUEUE_NUMBER;return OK；}/*********************************************************** * 广度遍历************************************************************/void BFSTraverse(Graph G,char *name){ArcNode *p;int v,w,u,k=0;Queue Q;int visited[20];for(v=1;v<=G.vexnum;v++) //初始化visited[v]=0;InitQueue(Q);for(v=LocateVex(G,name);k!=2;v=(v+1)%(G.vexnum-1)) //v为输入的字符转化的位序{if(v+1==LocateVex(G,name)) //从v开始走完图的所有顶点k++;if(visited[v]==0){visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点EnQueue(Q,v); // 进队while(EmptyQueue(Q)!=0){DeQueue(Q,u); //出队p=G.vertices[u].firstarc;while(p!=NULL){w=p->adjvex; //p边的下一个顶点if(visited[w]==0){printf("%s ",G.vertices[w].data);visited[w]=1;EnQueue(Q,w);}p=p->nextarc; //下移指针}}}}}主文件：#include <stdio.h>#include"malloc.h"#include "tuhead.h"#include "stdlib.h"#include "string.h"/************************************************************ 界面控制************************************************************/void main(){printf("\n################################# 图的遍历#################################\n");printf("\n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n");printf("\n");printf(" 1 ------- 图的创建\n");printf(" 2 ------- 图的深度优先遍历\n");printf(" 3 ------- 图的广度优先遍历\n");printf(" 0 ------- 退出\n");printf("\n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n");printf("\n");printf("请输入选择的操作代码（0-3）按回车键结束\n");MenuSelect(1);}/************************************************************ 功能选择************************************************************/void MenuSelect(int w){int select,done;int v;Graph G; char name[10];while (done) {printf("input the operating code : ");scanf("%d",&select);switch(select){case 1: printf("根据要求创建图:\n ");CreateGraph(G);break;case 2: printf("请输入深度优先遍历开始点的名：");scanf("%s",name);v=LocateVex(G,name); //将输入字符找到在顶点数组name对应的序号Vprintf("深度优先遍历：");DFSTravel(G,v);printf("\n");break;case 3: printf("请输入广度优先遍历开始点的名：");scanf("%s",name);printf("广度优先遍历：");BFSTraverse(G,name);printf("\n");break;case 0: done=0; break;default: printf(" ERROR\n");}printf("\n");}}[实验数据与结果]测试数据：实验结果。

广度优先遍历非递归算法
广度优先遍历（BFS）是一种图的遍历算法，用来遍历图中所有的节点。

以下是广度优先遍历的非递归算法：
1. 创建一个队列，用来存放待访问的节点。

2. 将起始节点放入队列中。

3. 创建一个集合，用来存放已经访问过的节点。

4. 将起始节点加入到已访问节点的集合中。

5. 循环执行以下步骤，直到队列为空为止：
5.1. 从队列中取出一个节点。

5.2. 访问该节点。

5.3. 获取该节点的所有相邻节点。

5.4. 对于每个相邻节点，如果它没有被访问过，则将其加入到队列和已访问节点的集合中。

通过以上步骤，可以按广度优先的顺序遍历整个图。

这种非递归算法利用队列的先进先出（FIFO）特性，保证了相邻节点的访问顺序是按照它们与起始节点的距离逐渐增加的顺序进行的，从而实现了广度优先遍历。

深度优先搜索和⼴度优先搜索 深度优先搜索和⼴度优先搜索都是图的遍历算法。

⼀、深度优先搜索（Depth First Search） 1、介绍 深度优先搜索（DFS），顾名思义，在进⾏遍历或者说搜索的时候，选择⼀个没有被搜过的结点（⼀般选择顶点），按照深度优先，⼀直往该结点的后续路径结点进⾏访问，直到该路径的最后⼀个结点，然后再从未被访问的邻结点进⾏深度优先搜索，重复以上过程，直⾄所有点都被访问，遍历结束。

⼀般步骤：（1）访问顶点v；（2）依次从v的未被访问的邻接点出发，对图进⾏深度优先遍历；直⾄图中和v有路径相通的顶点都被访问；（3）若此时图中尚有顶点未被访问，则从⼀个未被访问的顶点出发，重新进⾏深度优先遍历，直到图中所有顶点均被访问过为⽌。

可以看出，深度优先算法使⽤递归即可实现。

2、⽆向图的深度优先搜索 下⾯以⽆向图为例，进⾏深度优先搜索遍历： 遍历过程： 所以遍历结果是：A→C→B→D→F→G→E。

3、有向图的深度优先搜索 下⾯以有向图为例，进⾏深度优先遍历： 遍历过程： 所以遍历结果为：A→B→C→E→D→F→G。

⼆、⼴度优先搜索（Breadth First Search） 1、介绍 ⼴度优先搜索（BFS）是图的另⼀种遍历⽅式，与DFS相对，是以⼴度优先进⾏搜索。

简⾔之就是先访问图的顶点，然后⼴度优先访问其邻接点，然后再依次进⾏被访问点的邻接点，⼀层⼀层访问，直⾄访问完所有点，遍历结束。

2、⽆向图的⼴度优先搜索 下⾯是⽆向图的⼴度优先搜索过程： 所以遍历结果为：A→C→D→F→B→G→E。

3、有向图的⼴度优先搜索 下⾯是有向图的⼴度优先搜索过程： 所以遍历结果为：A→B→C→E→F→D→G。

三、两者实现⽅式对⽐ 深度优先搜索⽤栈（stack）来实现，整个过程可以想象成⼀个倒⽴的树形：把根节点压⼊栈中。

每次从栈中弹出⼀个元素，搜索所有在它下⼀级的元素，把这些元素压⼊栈中。

并把这个元素记为它下⼀级元素的前驱。

数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。

功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。

按照惯例，先上代码，注释超详细：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#pragma warning(disable:4996)#define Max 20//定义数组元素最⼤个数（顶点最⼤个数）typedef struct node//边表结点{int adjvex;//该边所指向结点对应的下标struct node* next;//该边所指向下⼀个结点的指针}eNode;typedef struct headnode//顶点表结点{int in;//顶点⼊度char vertex;//顶点数据eNode* firstedge;//指向第⼀条边的指针，边表头指针}hNode;typedef struct//邻接表（图）{hNode adjlist[Max];//以数组的形式存储int n, e;//顶点数，边数}linkG;//以邻接表的存储结构创建图linkG* creat(linkG* g){int i, k;eNode* s;//边表结点int n1, e1;char ch;g = (linkG*)malloc(sizeof(linkG));//申请结点空间printf("请输⼊顶点数和边数：");scanf("%d%d", &n1, &e1);g->n = n1;g->e = e1;printf("顶点数：%d 边数：%d\n", g->n, g->e);printf("请输⼊顶点信息（字母）：");getchar();//因为接下来要输⼊字符串，所以getchar⽤于承接上⼀条命令的结束符for (i = 0; i < n1; i++){scanf("%c", &ch);g->adjlist[i].vertex = ch;//获得该顶点数据g->adjlist[i].firstedge = NULL;//第⼀条边设为空}printf("\n打印顶点下标及顶点数据：\n");for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据{printf("顶点下标：%d 顶点数据：%c\n", i, g->adjlist[i].vertex);}getchar();int i1, j1;//相连接的两个顶点序号for (k = 0; k < e1; k++)//建⽴边表{printf("请输⼊对<i,j>（空格分隔）：");scanf("%d%d", &i1, &j1);s = (eNode*)malloc(sizeof(eNode));//申请边结点空间s->adjvex = j1;//边所指向结点的位置，下标为j1s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s}return g;//返回指针g}int visited[Max];//标记是否访问void DFS(linkG* g, int i)//深度优先遍历{eNode* p;printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已访问过的顶点visited值改为1p = g->adjlist[i].firstedge;//p指向顶点i的第⼀条边while (p)//p不为NULL时（边存在）{if (visited[p->adjvex] != 1)//如果没有被访问DFS(g, p->adjvex);//递归}p = p->next;//p指向下⼀个结点}}void DFSTravel(linkG* g)//遍历⾮连通图{int i;printf("深度优先遍历;\n");//printf("%d\n",g->n);for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问{DFS(g, i);//调⽤DFS函数}}}void BFS(linkG* g, int i)//⼴度优先遍历{int j;eNode* p;int q[Max], front = 0, rear = 0;//建⽴顺序队列⽤来存储，并初始化printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已经访问过的改成1rear = (rear + 1) % Max;//普通顺序队列的话，这⾥是rear++q[rear] = i;//当前顶点（下标）队尾进队while (front != rear)//队列⾮空{front = (front + 1) % Max;//循环队列，顶点出队j = q[front];p = g->adjlist[j].firstedge;//p指向出队顶点j的第⼀条边while (p != NULL){if (visited[p->adjvex] == 0)//如果未被访问{printf("%c ", g->adjlist[p->adjvex].vertex);visited[p->adjvex] = 1;//将该顶点标记数组值改为1rear = (rear + 1) % Max;//循环队列q[rear] = p->adjvex;//该顶点进队}p = p->next;//指向下⼀个结点}}}void BFSTravel(linkG* g)//遍历⾮连通图{int i;printf("⼴度优先遍历：\n");for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问过{BFS(g, i);//调⽤BFS函数}}}//因为拓扑排序要求⼊度为0，所以需要先求出每个顶点的⼊度void inDegree(linkG* g)//求图顶点⼊度{eNode* p;int i;for (i = 0; i < g->n; i++)//循环将顶点⼊度初始化为0{g->adjlist[i].in = 0;}for (i = 0; i < g->n; i++)//循环每个顶点{p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针while (p != NULL)///当p不为空（边存在）{g->adjlist[p->adjvex].in++;//该边终点结点⼊度+1p = p->next;//p指向下⼀个边结点}printf("顶点%c的⼊度为：%d\n", g->adjlist[i].vertex, g->adjlist[i].in);}void topo_sort(linkG *g)//拓扑排序{eNode* p;int i, k, gettop;int top = 0;//⽤于栈指针的下标索引int count = 0;//⽤于统计输出顶点的个数int* stack=(int *)malloc(g->n*sizeof(int));//⽤于存储⼊度为0的顶点for (i=0;i<g->n;i++)//第⼀次搜索⼊度为0的顶点{if (g->adjlist[i].in==0){stack[++top] = i;//将⼊度为0的顶点进栈}}while (top!=0)//当栈不为空时{gettop = stack[top--];//出栈,并保存栈顶元素（下标）printf("%c ",g->adjlist[gettop].vertex);count++;//统计顶点//接下来是将邻接点的⼊度减⼀，并判断该点⼊度是否为0p = g->adjlist[gettop].firstedge;//p指向该顶点的第⼀条边的指针while (p)//当p不为空时{k = p->adjvex;//相连接的顶点（下标）g->adjlist[k].in--;//该顶点⼊度减⼀if (g->adjlist[k].in==0){stack[++top] = k;//如果⼊度为0，则进栈}p = p->next;//指向下⼀条边}}if (count<g->n)//如果输出的顶点数少于总顶点数，则表⽰有环{printf("\n有回路！\n");}free(stack);//释放空间}void menu()//菜单{system("cls");//清屏函数printf("************************************************\n");printf("* 1.建⽴图 *\n");printf("* 2.深度优先遍历 *\n");printf("* 3.⼴度优先遍历 *\n");printf("* 4.求出顶点⼊度 *\n");printf("* 5.拓扑排序 *\n");printf("* 6.退出 *\n");printf("************************************************\n");}int main(){linkG* g = NULL;int c;while (1){menu();printf("请选择：");scanf("%d", &c);switch (c){case1:g = creat(g); system("pause");break;case2:DFSTravel(g); system("pause");break;case3:BFSTravel(g); system("pause");break;case4:inDegree(g); system("pause");break;case5:topo_sort(g); system("pause");break;case6:exit(0);break;}}return0;}实验⽤图:运⾏结果：关于深度优先遍历 a.从图中某个顶点v 出发，访问v 。

图的遍历技巧
图的遍历是指按照一定的规则，从图的某个顶点出发，沿着边遍历图中的所有顶点，使得每个顶点都被访问一次且仅一次的过程。

常用的图的遍历技巧有以下两种：
1. 深度优先遍历（Depth First Search, DFS）：从图的某个顶点出发，先访问该顶点，然后依次访问与该顶点相邻的未被访问过的顶点，并以此递归地进行遍历。

当不存在未被访问的相邻顶点时，回溯到上一个顶点，继续遍历其他未被访问的相邻顶点，直至所有顶点都被访问完。

2. 广度优先遍历（Breadth First Search, BFS）：从图的某个顶点出发，先访问该顶点，然后依次访问与该顶点相邻的未被访问过的顶点，并将这些顶点按照入队的顺序加入队列中。

接下来再从队列中取出一个顶点，重复前述操作，直至队列为空。

这两种遍历技巧可以分别应用于不同场景的图问题。

深度优先遍历一般适用于需要探索整个图中某一支路径的问题，而广度优先遍历一般适用于需要确定最短路径或者按层遍历的问题。

算法设计：深度优先遍历和广度优先遍历实现深度优先遍历过程1、图的遍历和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。

它是许多图的算法的基础。

深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。

它们对无向图和有向图均适用。

注意：以下假定遍历过程中访问顶点的操作是简单地输出顶点。

2、布尔向量visited[0．．n-1]的设置图中任一顶点都可能和其它顶点相邻接。

在访问了某顶点之后，又可能顺着某条回路又回到了该顶点。

为了避免重复访问同一个顶点，必须记住每个已访问的顶点。

为此，可设一布尔向量visited[0．．n-1]，其初值为假，一旦访问了顶点Vi之后，便将visited[i]置为真。

--------------------------深度优先遍历(Depth-First Traversal)1．图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。

在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。

若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。

若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。

图的深度优先遍历类似于树的前序遍历。

采用的搜索方法的特点是尽可能先对纵深方向进行搜索。

这种搜索方法称为深度优先搜索(Depth-First Search)。

相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。

2、深度优先搜索的过程设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。

若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。

【算法】⼴度优先算法和深度优先算法⼴度（BFS）和深度（DFS）优先算法这俩个算法是图论⾥⾯⾮常重要的两个遍历的⽅法。

下⾯⼀个例⼦迷宫计算，如下图解释：所谓⼴度，就是⼀层⼀层的，向下遍历，层层堵截，看下⾯这幅图，我们如果要是⼴度优先遍历的话，我们的结果是V1 V2 V3 V4 V5 V6 V7 V8。

⼴度优先搜索的思想： ①访问顶点vi ； ②访问vi 的所有未被访问的邻接点w1 ,w2 , …wk ； ③依次从这些邻接点（在步骤②中访问的顶点）出发，访问它们的所有未被访问的邻接点; 依此类推，直到图中所有访问过的顶点的邻接点都被访问； 说明： 为实现③，需要保存在步骤②中访问的顶点，⽽且访问这些顶点的邻接点的顺序为：先保存的顶点，其邻接点先被访问。

这⾥我们就想到了⽤标准模板库中的queue队列来实现这种先进现出的服务。

步骤：　 1.将V1加⼊队列，取出V1，并标记为true(即已经访问)，将其邻接点加进⼊队列，则 <—[V2 V3]　 2.取出V2，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[V3 V4 V5]3.取出V3，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[V4 V5 V6 V7]4.取出V4，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[V5 V6 V7 V8]5.取出V5，并标记为true(即已经访问)，因为其邻接点已经加⼊队列，则 <—[V6 V7 V8]6.取出V6，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[V7 V8]7.取出V7，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[V8]8.取出V8，并标记为true(即已经访问)，将其未访问过的邻接点加进⼊队列，则 <—[]区别：深度优先遍历：对每⼀个可能的分⽀路径深⼊到不能再深⼊为⽌，⽽且每个结点只能访问⼀次。

浅析深度优先和⼴度优先遍历实现过程、区别及使⽤场景⼀、什么是深度/⼴度优先遍历？ 深度优先遍历简称DFS（Depth First Search），⼴度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种⽅式。

这两种遍历⽅式有什么不同呢？我们来举个栗⼦： 我们来到⼀个游乐场，游乐场⾥有11个景点。

我们从景点0开始，要玩遍游乐场的所有景点，可以有什么样的游玩次序呢？1、深度优先遍历 第⼀种是⼀头扎到底的玩法。

我们选择⼀条⽀路，尽可能不断地深⼊，如果遇到死路就往回退，回退过程中如果遇到没探索过的⽀路，就进⼊该⽀路继续深⼊。

在图中，我们⾸先选择景点1的这条路，继续深⼊到景点7、景点8，终于发现⾛不动了： 于是，我们退回到景点7，然后探索景点10，⼜⾛到了死胡同。

于是，退回到景点1，探索景点9： 按照这个思路，我们再退回到景点0，后续依次探索景点2、3、5、4、发现相邻的都玩过了，再回退到3，再接着玩6，终于玩遍了整个游乐场： 具体次序如下图，景点旁边的数字代表探索次序。

当然还可以有别的排法。

像这样先深⼊探索，⾛到头再回退寻找其他出路的遍历⽅式，就叫做深度优先遍历（DFS）。

这⽅式看起来很像⼆叉树的前序遍历。

没错，其实⼆叉树的前序、中序、后序遍历，本质上也可以认为是深度优先遍历。

2、⼴度优先遍历 除了像深度优先遍历这样⼀头扎到底的玩法以外，我们还有另⼀种玩法：⾸先把起点相邻的⼏个景点玩遍，然后去玩距离起点稍远⼀些（隔⼀层）的景点，然后再去玩距离起点更远⼀些（隔两层）的景点… 在图中，我们⾸先探索景点0的相邻景点1、2、3、4： 接着，我们探索与景点0相隔⼀层的景点7、9、5、6： 最后，我们探索与景点0相隔两层的景点8、10： 像这样⼀层⼀层由内⽽外的遍历⽅式，就叫做⼴度优先遍历（BFS）。

这⽅式看起来很像⼆叉树的层序遍历。

没错，其实⼆叉树的层序遍历，本质上也可以认为是⼴度优先遍历。

图的遍历算法实验报告
《图的遍历算法实验报告》
在计算机科学领域，图的遍历算法是一种重要的算法，它用于在图数据结构中
访问每个顶点和边。

图的遍历算法有两种常见的方法：深度优先搜索（DFS）
和广度优先搜索（BFS）。

在本实验中，我们将对这两种算法进行实验，并比较
它们的性能和应用场景。

首先，我们使用深度优先搜索算法对一个简单的无向图进行遍历。

通过实验结
果可以看出，DFS算法会首先访问一个顶点的所有邻居，然后再递归地访问每
个邻居的邻居，直到图中所有的顶点都被访问到。

这种算法在一些应用场景中
非常有效，比如寻找图中的连通分量或者寻找图中的环路。

接下来，我们使用广度优先搜索算法对同样的无向图进行遍历。

通过实验结果
可以看出，BFS算法会首先访问一个顶点的所有邻居，然后再按照距离递增的
顺序访问每个邻居的邻居。

这种算法在一些应用场景中也非常有效，比如寻找
图中的最短路径或者寻找图中的最小生成树。

通过对比实验结果，我们可以发现DFS和BFS算法各自的优势和劣势。

DFS算
法适合用于寻找图中的连通分量和环路，而BFS算法适合用于寻找最短路径和
最小生成树。

因此，在实际应用中，我们需要根据具体的需求来选择合适的算法。

总的来说，图的遍历算法是计算机科学中非常重要的算法之一，它在许多领域
都有着广泛的应用。

通过本次实验，我们对DFS和BFS算法有了更深入的了解，并且对它们的性能和应用场景有了更清晰的认识。

希望通过这篇实验报告，读
者们也能对图的遍历算法有更深入的理解和认识。

天津理工大学实验报告学院（系）名称：计算机与通信工程学院姓名学号专业计算机科学与技术班级2009级1班实验项目实验四图的深度优先与广度优先遍历课程名称数据结构与算法课程代码实验时间2011年5月12日第5-8节实验地点7号楼215 批改意见成绩教师签字：实验四图的深度优先与广度优先遍历实验时间：2011年5月12日，12:50 -15:50（地点：7-215）实验目的：理解图的逻辑特点；掌握理解图的两种主要存储结构（邻接矩阵和邻接表），掌握图的构造、深度优先遍历、广度优先遍历算法。

具体实验题目：（任课教师根据实验大纲自己指定）每位同学按下述要求实现相应算法：根据从键盘输入的数据创建图（图的存储结构可采用邻接矩阵或邻接表），并对图进行深度优先搜索和广度优先搜索1）问题描述：在主程序中提供下列菜单：1…图的建立2…深度优先遍历图3…广度优先遍历图0…结束2）实验要求：图的存储可采用邻接表或邻接矩阵；定义下列过程：CreateGraph(): 按从键盘的数据建立图DFSGrahp()：深度优先遍历图BFSGrahp()：广度优先遍历图实验报告格式及要求：按学校印刷的实验报告模版书写。

（具体要求见四）实验思路：首先，定义邻接矩阵和图的类型，定义循环队列来存储，本程序中只给出了有向图的两种遍历，定义深度优先搜索和广度优先搜索的函数，和一些必要的函数，下面的程序中会有说明，然后是函数及运行结果！#include<iostream>#include<cstdlib>using namespace std;#define MAX_VERTEX_NUM 20//最大顶点数#define MaxSize 100bool visited[MAX_VERTEX_NUM];enum GraphKind{AG,AN,DG,DN};//图的种类，无向图，无向网络，有向图，有向网络struct ArcNode{int adjvex;ArcNode * nextarc;};struct VNode{int data;ArcNode * firstarc;};struct Graph{VNode vertex[MAX_VERTEX_NUM];int vexnum,arcnum;//顶点数，弧数GraphKind kind;//图的类型};struct SeqQueue{int *base;int front,rear;SeqQueue InitQueue(){//循环队列初始化SeqQueue Q;Q.base = new int;Q.front=0;Q.rear=0;return Q;}void DeQueue(SeqQueue &Q,int &u){//出队操作u = *(Q.base+Q.front);Q.front = (Q.front+1)%MaxSize;}int QueueFull(SeqQueue Q){//判断循环队列是否满return (Q.front==(Q.rear+1)%MaxSize)?1:0;}void EnQueue(SeqQueue &Q,int x){//入队操作if(QueueFull(Q)){cout<<"队满，入队操作失败！"<<endl;exit(0);}*(Q.base+Q.rear) = x;Q.rear = (Q.rear+1)%MaxSize;void CreateDG(Graph & G,int n,int e){//初始化邻接表头结点int j;for(int i=0;i<n;++i){G.vertex[i].data=i;G.vertex[i].firstarc=NULL;}for(i=0;i<e;++i){cin>>i>>j;//输入边的信息ArcNode* s;s= new ArcNode;s->adjvex = j;s->nextarc = G.vertex[i].firstarc;G.vertex[i].firstarc = s;}}void Visit(Graph G,int u){cout<<G.vertex[u].data<<" ";}int FirstAdjVex(Graph G,int v){if(G.vertex[v].firstarc)return G.vertex[v].firstarc->adjvex;elsereturn -1;}int NextAdjVex(Graph G,int v,int w){ArcNode* p = G.vertex[v].firstarc;while(p->adjvex!=w)p = p->nextarc;if(p->nextarc)return p->nextarc->adjvex;elsereturn -1;}void DFSGrahp(Graph G,int v){visited[v]=true;Visit(G,v);//访问顶点V，对从未访问过的邻接点w递归调用DFS for(int w=FirstAdjVex(G,v);w!=0;w=NextAdjVex(G,v,w))if(!visited[w]) DFSGrahp(G,w);}void DFSTraverse(Graph G){//对图G做深度优先搜索for(int v=0;v<G.vexnum;++v)visited[v]=false;//初始化访问标志数组visitedfor(v=0;v<G.vexnum;++v)if(!visited[v]) DFSGrahp(G,v);//对尚未访问的顶点v调用DFS }void BFSGrahp(Graph G){//图的广度优先搜索SeqQueue Q;Q=InitQueue();int u;for(int v=0;v<G.vexnum;++v)if(!visited[G,v]){EnQueue(Q,v);//v入队列while(!((Q.front==Q.rear)?1:0)){DeQueue(Q,u);//对首元素出队，赋给uvisited[u]=true;Visit(G,u);for(int w=FirstAdjVex(G,u);w!=0;w=NextAdjVex(G,u,w)) //u的未访问过的邻接点w入队列if(!visited[w])EnQueue(Q,w);}}}int main(){Graph p;int n,e;cout<<"输入图的顶点及边数："<<endl;cin>>n>>e;cout<<"创建图："<<endl;CreateDG(p,n,e);cout<<"图的优先深度结果为："<<endl;DFSTraverse(p);cout<<"图的广度优先结果为："<<endl;BFSGrahp(p);printf("结果如上所示!\n");return 0;}。

实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。

2、熟练掌握图的存储结构。

3、熟练掌握图的两种遍历算法。

二、实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。

[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。

【测试数据】由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握图的相关概念。

2、掌握图的逻辑结构和存储结构。

3、掌握图的两种遍历算法的实现。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果，对程序进行分析。

编程思路：深度优先算法：计算机程序的一种编制原理，就是在一个问题出现多种可以实现的方法和技术的时候，应该优先选择哪个更合适的，也是一种普遍的逻辑思想，此种思想在运算的过程中，用到计算机程序的一种递归的思想。

度优先搜索算法：又称广度优先搜索，是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。

Dijkstra单源最短路径算法和Prim 最小生成树算法都采用了和宽度优先搜索类似的思想。

其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。

换句话说，它并不考虑结果的可能位址，彻底地搜索整张图，直到找到结果为止。

以临接链表作为存储结构，结合其存储特点和上面两种算法思想，给出两种遍历步骤：（1）既然图中没有确定的开始顶点，那么可从图中任一顶点出发，不妨按编号的顺序，先从编号小的顶点开始。

（2）要遍历到图中所有顶点，只需多次调用从某一顶点出发遍历图的算法。

所以，下面只考虑从某一顶点出发遍历图的问题。

（3）为了在遍历过程中便于区分顶点是否已经被访问，设置一个访问标志数组visited[n]，n为图中顶点的个数，其初值为0，当被访问过后，其值被置为1。

（4）这就是遍历次序的问题，图的遍历通常有深度优先遍历和广度优先遍历两种方式，这两种遍历次序对无向图和有向图都适用。

深度优先遍历算法和广度优先遍历算法实验小结一、引言在计算机科学领域，图的遍历是一种基本的算法操作。

深度优先遍历算法（Depth First Search，DFS）和广度优先遍历算法（Breadth First Search，BFS）是两种常用的图遍历算法。

它们在解决图的连通性和可达性等问题上具有重要的应用价值。

本文将从理论基础、算法原理、实验设计和实验结果等方面对深度优先遍历算法和广度优先遍历算法进行实验小结。

二、深度优先遍历算法深度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历，沿着一条路径一直向前直到不能再继续前进为止，然后退回到上一个节点，尝试下一个节点，直到遍历完整个图。

深度优先遍历算法通常使用栈来实现。

以下是深度优先遍历算法的伪代码：1. 创建一个栈并将起始节点压入栈中2. 将起始节点标记为已访问3. 当栈不为空时，执行以下步骤：a. 弹出栈顶节点，并访问该节点b. 将该节点尚未访问的邻居节点压入栈中，并标记为已访问4. 重复步骤3，直到栈为空三、广度优先遍历算法广度优先遍历算法是一种用于遍历或搜索树或图的算法。

该算法从图的某个顶点开始遍历，先访问起始节点的所有相邻节点，然后再依次访问这些相邻节点的相邻节点，依次类推，直到遍历完整个图。

广度优先遍历算法通常使用队列来实现。

以下是广度优先遍历算法的伪代码：1. 创建一个队列并将起始节点入队2. 将起始节点标记为已访问3. 当队列不为空时，执行以下步骤：a. 出队一个节点，并访问该节点b. 将该节点尚未访问的邻居节点入队，并标记为已访问4. 重复步骤3，直到队列为空四、实验设计本次实验旨在通过编程实现深度优先遍历算法和广度优先遍历算法，并通过对比它们在不同图结构下的遍历效果，验证其算法的正确性和有效性。

具体实验设计如下：1. 实验工具：使用Python编程语言实现深度优先遍历算法和广度优先遍历算法2. 实验数据：设计多组图结构数据，包括树、稠密图、稀疏图等3. 实验环境：在相同的硬件环境下运行实验程序，确保实验结果的可比性4. 实验步骤：编写程序实现深度优先遍历算法和广度优先遍历算法，进行多次实验并记录实验结果5. 实验指标：记录每种算法的遍历路径、遍历时间和空间复杂度等指标，进行对比分析五、实验结果在不同图结构下，经过多次实验，分别记录了深度优先遍历算法和广度优先遍历算法的实验结果。

深度优先算法与⼴度优先算法深度优先搜索和⼴度优先搜索，都是图形搜索算法，它两相似，⼜却不同，在应⽤上也被⽤到不同的地⽅。

这⾥拿⼀起讨论，⽅便⽐较。

⼀、深度优先搜索深度优先搜索属于图算法的⼀种，是⼀个针对图和树的遍历算法，英⽂缩写为DFS即Depth First Search。

深度优先搜索是图论中的经典算法，利⽤深度优先搜索算法可以产⽣⽬标图的相应拓扑排序表，利⽤拓扑排序表可以⽅便的解决很多相关的图论问题，如最⼤路径问题等等。

⼀般⽤堆数据结构来辅助实现DFS算法。

其过程简要来说是对每⼀个可能的分⽀路径深⼊到不能再深⼊为⽌，⽽且每个节点只能访问⼀次。

基本步奏（1）对于下⾯的树⽽⾔，DFS⽅法⾸先从根节点1开始，其搜索节点顺序是1,2,3,4,5,6,7,8（假定左分枝和右分枝中优先选择左分枝）。

（2）从stack中访问栈顶的点；（3）找出与此点邻接的且尚未遍历的点，进⾏标记，然后放⼊stack中，依次进⾏；（4）如果此点没有尚未遍历的邻接点，则将此点从stack中弹出，再按照（3）依次进⾏；（5）直到遍历完整个树，stack⾥的元素都将弹出，最后栈为空，DFS遍历完成。

⼆、⼴度优先搜索⼴度优先搜索（也称宽度优先搜索，缩写BFS，以下采⽤⼴度来描述）是连通图的⼀种遍历算法这⼀算法也是很多重要的图的算法的原型。

Dijkstra单源最短路径算法和Prim最⼩⽣成树算法都采⽤了和宽度优先搜索类似的思想。

其别名⼜叫BFS，属于⼀种盲⽬搜寻法，⽬的是系统地展开并检查图中的所有节点，以找寻结果。

换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为⽌。

基本过程，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。

如果所有节点均被访问，则算法中⽌。

⼀般⽤队列数据结构来辅助实现BFS算法。

基本步奏（1）给出⼀连通图，如图，初始化全是⽩⾊（未访问）；（2）搜索起点V1（灰⾊）；（3）已搜索V1（⿊⾊），即将搜索V2，V3，V4（标灰）；（4）对V2，V3，V4重复以上操作；（5）直到终点V7被染灰，终⽌；（6）最短路径为V1，V4，V7.作者：安然若知链接：https:///p/bff70b786bb6来源：简书简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

深度优先算法与广度优先算法
深度优先算法和广度优先算法是两种常用的图遍历算法。

它们都是基
于图的遍历来搜索图中的所有节点，并且都是基于图中节点之间的关
联性来进行搜索操作的。

首先来说深度优先算法。

深度优先算法即从一条边开始遍历，如果遇
到死路则返回上一个节点，继续从它的下一条边继续遍历。

整个搜索
的过程是以深度为优先，直到遍历所有的节点为止。

深度优先算法使
用的是栈数据结构，先访问的节点会被后访问的节点所覆盖，直到遍
历到最深处，然后回死路走回上一个节点，继续访问它的下一个节点。

深度优先算法一般用于寻找迷宫或图中的某条路径等应用场景。

接下来是广度优先算法。

广度优先算法即在图中按照一层一层的方式
遍历所有的节点，直到遍历完为止。

广度优先算法使用的是队列数据
结构，先访问的节点会先被访问到，后访问的节点会被后访问的节点
所覆盖，确保按层次进行遍历。

广度优先算法一般用于求出图中所有
节点的最短路径等应用场景。

总结起来，深度优先算法和广度优先算法都有各自的优点和应用场景。

深度优先算法主要是在有解的情况下寻找具体的解，而广度优先算法
则是在寻找最短路径的情况下使用。

在具体应用时，可以根据实际情
况选择使用哪一种算法，或者结合两种算法的优点进行优化，以达到更好的搜索效果。

因此，深度优先算法和广度优先算法都是图遍历中经典而又经典的算法，能够应用于很多具体的场景中，为寻找路径和搜索解决方案等问题提供了很好的方法和实现手段。