深圳幻海软件技术有限公司 欢迎您！
更多

图的遍历（深度优先遍历DFS，广度优先遍历BFS）以及Ｃ语言的实现

2023-06-05

int head 顶点
遍历的定义：从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算．一:深度优先遍历（ＤＦＳ）１，在访问图中某一起始顶点Ｖ后，由Ｖ出发，访问它的任一邻接顶点Ｗ１２，再从Ｗ１出发，访问与Ｗ１邻接但还未被访问过的顶点Ｗ２；３，然后再从Ｗ２出

遍历的定义：

从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算．

一:深度优先遍历（ＤＦＳ）

１，在访问图中某一起始顶点Ｖ后，由Ｖ出发，访问它的任一邻接顶点Ｗ１

２，再从Ｗ１出发，访问与Ｗ１邻接但还未被访问过的顶点Ｗ２；

３，然后再从Ｗ２出发，进行类似的访问．．．．．．

４，如此进行下去，直至到达所有的邻接顶点都被访问过的顶点Ｕ为止．

５，接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问过的邻接点

６，如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问；

７，如果没有，就再退回一步进行搜索．重复上述过程，直到连通图中所有顶点都被访问过为止．

１，使用邻接矩阵表示的无向图深度优先遍历的实现

 

 以上图为例，以邻结矩阵创建无向图，并且深度优先遍历

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MAXSIZE 100 //最大顶点数
  4. #define MAX_INT 32767//设置最大值
  5. typedef struct{
  6.     char vexs[MAXSIZE];//这里的数据类型根据实际情况而定
  7.     int arcs[MAXSIZE][MAXSIZE];//这里的数据类型根据实际情况而定
  8.     int vexnum, arcnum;//图的当前顶点数和边数
  9. }Graph;
  10. int get_index(char* arr,char m)
  11. {
  12.     int i = 0;
  13.     for(i = 0; i < MAXSIZE; i++)
  14.     {
  15.         if(arr[i] == m)return i;
  16.     }
  17.     return -1;
  18. }
  19.  
  20. void CreatGraph(Graph* G)
  21. {
  22.     int i,j = 0;
  23.     printf("请输入顶点和边的数量:>");
  24.     scanf("%d%d",&G->vexnum,&G->arcnum);//把输入的值保存到图结构体中
  25.     for(i = 0; i < G->vexnum; i++)//初始化邻接矩阵
  26.     {
  27.         for(j = 0; j < G->vexnum; j++)
  28.             {
  29.                 G->arcs[i][j] = 0;
  30.             }
  31.  
  32.     }
  33.  
  34.     for(i = 0; i < G->vexnum; i++)
  35.     {
  36.         printf("请输入每个顶点的值:>");
  37.         getchar();//清除键盘缓存区的回车键
  38.         scanf("%c", &G->vexs[i]);//把输入的值保存到顶点数组当中
  39.     }
  40.     for(i = 0; i < G->arcnum; i++)//有几条边，循环几次
  41.     {
  42.         char m,n;//用来接收两个顶点
  43.         int j,k;//接收顶点的下标
  44.         printf("请依次输入每一条边，格式为:ab >");
  45.         getchar();
  46.         scanf("%c%c",&m,&n);
  47.         j = get_index(G->vexs,m);//得到输入的m的值，在顶点数组中的下标
  48.         k = get_index(G->vexs,n);//得到输入的n的值，在顶点数组中的下标
  49.         G->arcs[j][k] = 1;//给邻接矩阵对应的位置赋权值
  50.         G->arcs[k][j] = 1;//因为是无向网，所以是对称的，给对称点赋相同值
  51.     }
  52.  
  53.  
  54. }
  55. //深度遍历创建的无向图
  56. void DepthSearch(Graph G, int v, int*visited)//参数为创建的图，输入的值在数组中的下标，判断是否被访问过的数组
  57. {
  58.     int i = 0;
  59.     visited[v] = 1;
  60.     printf("%c", G.vexs[v]);
  61.     for(i = 0; i < G.vexnum; i++)//遍历二维数组v行的每一列
  62.     {
  63.         if((G.arcs[v][i] == 1)&&(visited[i]!=1))//如果有边相连，而且该顶点还没有被访问过
  64.             DepthSearch(G, i,visited);//递归搜索该顶点
  65.     }
  66. }
  67. int main()
  68. {
  69.     Graph G;
  70.     CreatGraph(&G);
  71.     char input;
  72.     int visited[MAXSIZE] = {0};//创建数组，用来判断某一个顶点是否被访问过
  73.     printf("请输入搜索的起始点:>");
  74.     getchar();
  75.     scanf("%c",&input);
  76.     DepthSearch(G, get_index(G.vexs, input),visited);
  77.     return 0;
  78.  
  79. }

 ２，使用邻接表表示的无向图深度优先遍历的实现

 同样以这个无向图为例：创建一个visited[]数组，用来判断某个顶点是否已经被访问过

代码与上面邻接矩阵也差不多，只是在条件判断时有所不同，这里不需要判断表结点是不是顶点的边，只需要判断表结点是不是空．具体代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MAXSIZE 100 //最大顶点数
  4. #define MAX_INT 32767//设置最大值
  5. typedef struct TableNode{//表结点
  6.     int index;//结点在数组中的下标
  7.     struct TableNode* nextarc;
  8.     int info;//权值
  9.  
  10. }TNode;
  11.  
  12. typedef struct{//头结点
  13.     char data;
  14.     TNode* firstarc;
  15. }HNode;
  16.  
  17. typedef struct{//整个无向网的结构体
  18.     HNode* head;
  19.     int vexnum,arcnum;
  20. }Gragh;
  21. int get_index(HNode* arr,char m)
  22. {
  23.     int i = 0;
  24.     for(i = 0; i < MAXSIZE; i++)
  25.     {
  26.         if(arr[i].data == m)return i;
  27.     }
  28.     return -1;
  29. }
  30.  
  31. void CreatGraph(Gragh* G)
  32. {
  33.     int i = 0;
  34.     printf("请输入顶点和边的数量:>");
  35.     scanf("%d%d",&G->vexnum,&G->arcnum);//把输入的值保存到图结构体中
  36.  
  37.  
  38.     for(i = 0; i < G->vexnum; i++)
  39.     {
  40.         printf("请输入每个顶点的值:>");
  41.         getchar();//清除键盘缓存区的回车键
  42.         scanf("%c", &G->head[i].data);//把输入的值保存到顶点数组当中
  43.         G->head[i].firstarc = NULL;
  44.     }
  45.     for(i = 0; i < G->arcnum; i++)//有几条边，循环几次
  46.     {
  47.         char m,n;//用来接收两个顶点
  48.         int j,k;//接收顶点的下标
  49.         printf("请依次输入每一条边，格式为:ab >");
  50.         getchar();
  51.         scanf("%c%c",&m,&n);
  52.         j = get_index(G->head,m);//得到输入的m的值，在顶点数组中的下标
  53.         k = get_index(G->head,n);//得到输入的n的值，在顶点数组中的下标
  54.         TNode* P1 = malloc(sizeof(TNode));
  55.         P1->index = k;
  56.         P1->nextarc = G->head[j].firstarc;
  57.         G->head[j].firstarc = P1;
  58.         //因为是无向图，所以还要建立一条反向的边
  59.         TNode* P2 = malloc(sizeof(TNode));
  60.         P2->index = j;
  61.         P2->nextarc = G->head[k].firstarc;
  62.         G->head[k].firstarc = P2;
  63.     }
  64.  
  65.  
  66. }
  67. //深度遍历创建的无向图
  68. void DepthSearch(Gragh G, int v, int*visited)//参数为创建的图，输入的值在数组中的下标，判断是否被访问过的数组
  69. {
  70.     visited[v] = 1;
  71.     printf("%c", G.head[v].data);
  72.     TNode* P = G.head[v].firstarc;
  73.     while(P)
  74.     {
  75.         if(!visited[P->index])DepthSearch(G, P->index, visited);//如果表结点不为空且判断数组值不为１，则递归搜索该结点
  76.         P = P->nextarc;//指针指向该结点的下一个结点
  77.     }
  78.  
  79. }
  80. int main()
  81. {
  82.     Gragh G;
  83.     CreatGraph(&G);
  84.     char input;
  85.     int visited[MAXSIZE] = {0};//创建数组，用来判断某一个顶点是否被访问过
  86.     printf("请输入搜索的起始点:>");
  87.     getchar();
  88.     scanf("%c",&input);
  89.     DepthSearch(G, get_index(G.head, input),visited);
  90.     return 0;
  91.  
  92. }

二:广度优先遍历（ＢＦＳ） 

方法：从图的某一结点出发，首先依次访问该结点的所有邻接点，再按这些顶点被访问的先后次序依次访问与他们相邻接的所有未被访问的顶点，重复此过程，直至所有顶点均被访问为止．

根据广度优先的特点，和以前树的层次遍历比较相似，这里我们也采用队列的方式，把要访问的顶点先入队，访问完后，再出队，这样不停的循环，直到队列为空，就表示遍历完成了．

１，使用邻接矩阵表示的无向图广度优先遍历的实现

这里为了代码的简洁和可读性，我把常用的一些代码，创建无向图和队列，都放到头文件中去了

如果有需要，可以私信．创建无向图和队列的代码在前面的文章里都有．这里只是重点讲广度优先遍历的算法

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MAXSIZE 10 //最大顶点数
  4. #include "gragh.h"
  5. //广度优先遍历创建的无向图
  6. void BreadthSearch(Gragh G, int v, int*visited, SQ* Q)//参数为创建的图，输入的值在数组中的下标，判断是否被访问过的数组，以及队列
  7. {
  8.     visited[v] = 1;//把传入的起点，设置为１
  9.     push_sq(Q, G.head[v]);//把传入的顶点入队
  10.  
  11.     while(Q->back != Q->front)//如果队不为空，则循环
  12.     {
  13.         printf("%c", Q->arr[Q->front].data);//访问队列最前面的数据
  14.         TNode* P = Q->arr[Q->front].firstarc;//把指针指向顶点对应的第一个表结点
  15.         while(P)//只要表结点不为空就循环
  16.         {
  17.             if(!visited[P->index])push_sq(Q, G.head[P->index]);//把没有访问过的顶点入队列
  18.             visited[P->index] = 1;//把入了队列的顶点，在visited数组中设置为１
  19.             P = P->nextarc;//指针指向下一条边
  20.         }
  21.         pop_sq(Q);
  22.     }
  23. }
  24. int main()
  25. {
  26.     SQ Q;//队列类型变量
  27.     Gragh G;//图类型变量
  28.     CreatGraph(&G);//创建一个无向图
  29.     InitSQ(&Q);//创建并初始化一个顺序队列
  30.     char input;
  31.     int visited[MAXSIZE] = {0};//创建数组，用来判断某一个顶点是否被访问过
  32.     printf("请输入搜索的起始点:>");
  33.     getchar();
  34.     scanf("%c",&input);
  35.     BreadthSearch(G, get_index(G.head, input),visited,&Q);//广度优先遍历无向图
  36.     return 0;
  37.  
  38. }

邻接表不唯一，根据你创建算法，头插法，尾插法不同，而不同

邻接矩阵是唯一的，所以用邻接矩阵创建的图，遍历出来的结果都一样． 

邻接矩阵的广度遍历，和邻接表的差不多，这里就不详细说了！

_____________________________________

最近老是有人问我上面代码里.h和.c文件的内容，我现在发出来

gragh.h:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MAXSIZE 10 //最大顶点数
  4. typedef struct TableNode{//表结点
  5.     int index;//结点在数组中的下标
  6.     struct TableNode* nextarc;
  7.     int info;//权值
  8. }TNode;
  9.  
  10. typedef struct{//头结点
  11.     char data;
  12.     TNode* firstarc;
  13. }HNode;
  14.  
  15. typedef struct{//整个无向网的结构体
  16.     HNode* head;
  17.     int vexnum,arcnum;
  18. }Gragh;
  19. typedef struct SequenceQueue//定义一个队列类型结构体
  20. {
  21.     HNode* arr;//定义一个数组，类型自己决定
  22.     int front;//队列头指针（下标）
  23.     int back;//队列尾指针（下标）
  24. }SQ;
  25. int get_index(HNode* arr,char m);
  26. void CreatGraph(Gragh* G);
  27. void InitSQ(SQ* Q);//创建并初始化一个队列
  28. void push_sq(SQ* Q, HNode e);//插入规则，从队尾插入
  29. void pop_sq(SQ* Q);//删除规则，从队头删除
  30. int length_sq(SQ* Q);

gragh.c:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MAXSIZE 10 //最大顶点数
  4. #define MAX_INT 32767//设置最大值
  5. #include "gragh.h"
  6. int get_index(HNode* arr,char m)
  7. {
  8.     int i = 0;
  9.     for(i = 0; i < MAXSIZE; i++)
  10.     {
  11.         if(arr[i].data == m)return i;
  12.     }
  13.     return -1;
  14. }
  15.  
  16. void CreatGraph(Gragh* G)
  17. {
  18.     int i = 0;
  19.     printf("请输入顶点和边的数量:>");
  20.     scanf("%d%d",&G->vexnum,&G->arcnum);//把输入的值保存到图结构体中
  21.  
  22.  
  23.     for(i = 0; i < G->vexnum; i++)
  24.     {
  25.         printf("请输入每个顶点的值:>");
  26.         getchar();//清除键盘缓存区的回车键
  27.         scanf("%c", &G->head[i].data);//把输入的值保存到顶点数组当中
  28.         G->head[i].firstarc = NULL;
  29.     }
  30.     for(i = 0; i < G->arcnum; i++)//有几条边，循环几次
  31.     {
  32.         char m,n;//用来接收两个顶点
  33.         int j,k;//接收顶点的下标
  34.         printf("请依次输入每一条边，格式为:ab >");
  35.         getchar();
  36.         scanf("%c%c",&m,&n);
  37.         j = get_index(G->head,m);//得到输入的m的值，在顶点数组中的下标
  38.         k = get_index(G->head,n);//得到输入的n的值，在顶点数组中的下标
  39.         TNode* P1 = malloc(sizeof(TNode));
  40.         P1->index = k;
  41.         P1->nextarc = G->head[j].firstarc;
  42.         G->head[j].firstarc = P1;
  43.         //因为是无向图，所以还要建立一条反向的边
  44.         TNode* P2 = malloc(sizeof(TNode));
  45.         P2->index = j;
  46.         P2->nextarc = G->head[k].firstarc;
  47.         G->head[k].firstarc = P2;
  48.     }
  49. }
  50.  
  51.  
  52.  
  53. void InitSQ(SQ* Q)//创建并初始化一个队列
  54. {
  55.     Q->arr = (TNode*)malloc(sizeof(TNode)*MAXSIZE);//定义一个10个整型大小空间的数组
  56.     Q->front = Q->back = 0;//队列置空
  57.  
  58. }
  59. void push_sq(SQ* Q, HNode e)//插入规则，从队尾插入
  60. {
  61.     if((Q->back+1)%MAXSIZE == Q->front)//判断队列是否满
  62.     {
  63.         printf("error!,队列已经满了！");
  64.     }
  65.     else
  66.     {
  67.         Q->arr[Q->back] = e;
  68.         Q->back = (Q->back + 1)%MAXSIZE;
  69.     }
  70. }
  71. void pop_sq(SQ* Q)//删除规则，从队头删除
  72. {
  73.     if(Q->front == Q->back)//判断队列是否空
  74.     {
  75.         printf("error!,队列已经空了！");
  76.     }
  77.     else
  78.     {
  79.         HNode tmp = Q->arr[Q->front];
  80.         Q->front = (Q->front + 1)%MAXSIZE;
  81.         return;
  82.     }
  83. }
  84. int length_sq(SQ* Q)
  85. {
  86.     return (Q->back - Q->front + MAXSIZE)%MAXSIZE;
  87. }
  88.  
  89.

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览47639 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪