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

C++数据结构之图的遍历——DFS和BFS（带有gif演示）

2023-06-07

int 顶点 bfs
1、介绍       图的遍历指的是从某一个顶点开始，访问图中的其余顶点，使得每个顶点被且仅被访问一次。本文着重介绍DFS和BFS的区别和过程，因此采用的是最简单的邻接矩阵来储存无向图并实现两种算法。下面是一个我在b站看到的一个较

1、介绍       

图的遍历指的是从某一个顶点开始，访问图中的其余顶点，使得每个顶点被且仅被访问一次。

本文着重介绍DFS和BFS的区别和过程，因此采用的是最简单的邻接矩阵来储存无向图并实现两种算法。

下面是一个我在b站看到的一个较浅显易懂的图遍历视频，大家可以用作参考： 

1.1DFS（深度优先搜索）和BFS(广度优先遍历）的区别

        我们可以用一个有趣的比喻来区别DFS和BFS，DFS和BFS都是在北极的冒险家，DFS是大胆且无畏的冒险家，而BFS是小心且谨慎的冒险家，当他们被困在由多块碎冰组成的一大块冰面上的时候，DFS优先选择朝着远离当前冰面的方向走去，直到不能走得更远了才回头来继续寻找其他的冰面直到全部冰面都走过一次，而BFS会优先选择先把当前冰面的相邻冰面都走一遍，当相邻的冰面走完了才会向前一步，然后继续走一边下一个冰面的相邻冰面，直到全部的冰面全部都走过一次。在这个比喻之后再读下面的内容我相信更加方便读者理解。

2、DFS（深度优先搜索）

        在对DFS进行了解之前，我们可以先对二叉树的遍历进行回顾，先根遍历为先访问根节点，再访问根节点的左子树，再访问根节点的右子树，而图的遍历算法DFS就是树的先根遍历（也叫先序遍历）的推广。

        由于在图中是极有可能存在回路的，并且图中的任意一个顶点都可能与其他的顶点相通，因此在访问完某一个顶点之后发现没有相邻的未访问的顶点了，这个时候就只能“走回头路”，返回上一个已经访问过的顶点，直到“有路可走”。

2.1算法思路

1）选择一个起点，对其进行访问

2）查询与当前顶点相邻的且未被访问过的顶点,如果存在多个相邻的且未被访问过的顶点，就按照一定的规则从中选择一个进行访问，例如可以按照序号的大小，从小到大进行依次访问。

3）当当前的顶点没有相邻的且未被访问过的顶点时，就访问上一个顶点，并检查该顶点的相邻顶点，找出还没有访问过的顶点，选择其中一个进行访问。若是相邻的顶点全部都被访问过了，就继续访问上一个节点，以此类推。（正是因为这个特点，DFS实际是一个可以利用递归实现的过程）

4）当所有的与起点相邻的顶点都被访问之后，就代表图已经遍历完毕了。

以下是图示：

1.首先这是一张无向图，各个顶点之间的连接关系如下所示

 2.我们选择一个起点进行访问，在这里我选择了0（访问过的点用黄色标出，正在访问的用红色箭头指出）

 3.检查顶点0的相邻节点，发现有1和4且都未被访问，然后我们按照一个先访问顶点序号较小的顶点的规则进行访问

4.在访问完2的时候我们对2进行检查，发现没有相邻的且未被访问过的顶点了，这样我们就返回上一个访问过的顶点1，并且对其相邻顶点进行检查。发现有未被访问过的就去访问，访问完毕之后继续检查，以此类推。最终的访问过程如下所示：

 最终的遍历路径为：0 1 2 3 5 6 4

2.2算法实现（递归版本）

由于在遍历的过程中涉及对顶点是否有被访问过的检查，因此很显然我们需要引入一个访问数组visited[maxsize],其中maxsize为最大顶点数，并且定义其类型为bool数组，这样一来，true就对应着已经被访问过，而false就是未被访问过。

1）由于我们对一个顶点进行访问之后，我们需要检查这个节点的相邻且未被访问过的节点，并且要优先访问序号较小的顶点去访问，我们就需要创建一个函数smallestadjvertex(int v)  (最小序号的邻接顶点)来进行操作,其中参数v为需要进行操作的顶点。

  1. int undigraph::smallestadjvertex(int v)//寻找最小邻接点，参数为顶点下标
  2. {
  3.     for (int i = 0; i < vertexnum; i++)
  4.     {
  5.         if (adjmatrix[v][i]==1)
  6.         {
  7.             return i;//因为i是从小到大递增的，因此第一个符合条件的顶点就是邻接点中序号最小的顶点
  8.         }
  9.         
  10.     }
  11.     return -1;//如果没有找到邻接点就返回-1
  12. }

2）由于该顶点很可能还有其他的邻接顶点，因此我们需要一个函数去寻找下一个邻接顶点,但是我们需要注意，如何确保自己找到的是“下一个”呢，因此我们需要把找到的第一个邻接顶点（也就是序号最小的顶点）的序号作为参数传入该函数中，又因为需要判断邻接关系，因此也需要引入当前顶点的序号，因此就产生了函数nextadjvertex(int v,int prev),其中v为当前顶点，prev为前一个找到的邻接顶点。

  1. int undigraph::nextadjvertex(int v,int prev)
  2. {
  3.     for (int i = prev+1; i < vertexnum; i++)
  4.     {
  5.         if (adjmatrix[v][i]==1)//这里需要注意一下，因为邻接矩阵是对称的，因此只需要判断“一边”就好
  6.         {
  7.             return i;//找到就返回该顶点的下标
  8.         }
  9.         
  10.     }
  11.     return -1;//未找到就返回-1
  12. }

在循环的判断条件中为什么i=prev+1呢，因为要访问下一个邻接顶点，那么我们就需要跳过前一个访问过的邻接顶点，所以需要加一。

3）在实现了两个基础的操作之后我们就可以利用递归，并且引入访问数组visited[]来进行DFS了

  1. void undigraph::DFS(int v)
  2. {
  3.     cout<<"顶点"<<v<<"被访问!"<<endl;
  4.     visited[v]=true;//将该顶点对应的访问数组的位置赋值为true
  5.     //下面一步的for循环内的判断语句需要好好理解，这个是DFS的关键
  6.     for (int prev = smallestadjvertex(v); prev>=0; prev=nextadjvertex(v,prev))
  7.     {
  8.         if (visited[prev]==false)//如果
  9.         {
  10.             DFS(prev);//递归调用
  11.         }
  12.         
  13.     }  
  14. }

4)最后我们只需要进行进行一个对全图的顶点进行遍历，对未被访问的顶点调用DFS即可

  1. void undigraph::DFStraverse()
  2. {
  3.     for (int i = 0; i < vertexnum; i++)//将访问数组初始化为false(即未被访问过的意思)
  4.     {
  5.         visited[i]=false;
  6.     }
  7.     for (int i = 0; i < vertexnum; i++)//遍历整个图找出未被访问过的顶点并调用DFS
  8.      {
  9.          if (visited[i]==false)
  10.          {
  11.              DFS(i);
  12.          }      
  13.     }   
  14. }

需要注意的是，如果该无向图是连通图的话上面代码块的第二个循环是没必要使用的，只需要选择一个起点对其调用DFS就可以对全图进行访问了，但是如果是非连通图的话我们就需要该循环。具体的连通图和非连通图的概念和区别可以看这个链接：连通图与非连通图的概念与区别

算法实现结果：

将上面动态演示的无向图导入该算法后得到的结果：

 我们可以看到访问的顺序是正确的。

最后我会贴出全部代码，包括DFS和BFS，以及图的创建和main函数

3.BFS(广度优先遍历）

正如他的名字一样，BFS就是以一种“广”的方式去访问。我们再对“递归”这个方法进行思考，一旦算法使用递归，其内部的数据就会以一种“往深处走”的方式进行访问，这显然与BFS的“广”的方式不同，因此下面仅使用非递归方法进行实现。

3.1算法思想

1）选择一个起点，并访问这个顶点

2）查询当前顶点的相邻顶点，并且以一定的规则依次将相邻且未被访问过的顶点全部访问一遍

3）然后从这些相邻顶点中选择一个顶点，查询该顶点的相邻顶点，同样以相同的规则将相邻顶点全部访问一遍

4）全部访问完毕之后就“切换”到下一个顶点，重复上述操作，直到所有的顶点都被访问。

以下是图示：

1.如图是一个无向图以及各个顶点之间的连接关系

 2.首先先选取一个起点并且对其进行访问，我选择的是0（访问过的点用黄色标出，正在访问的用红色箭头指出）

 3.检查当前顶点的相邻且未被访问过的顶点，我们可以发现1、2、4相邻且未被访问过，根据从小到大序号的访问顺序，我们依次对相邻的顶点进行访问，也就是1->2->4

 4.在对起点0相邻的且未被访问过的顶点（1、2、4）访问完毕之后，我们按照从小到大序号的排序方式，优先检查顶点1的相邻且未被访问过的顶点，并且对其进行升序访问（也就是从小到大访问7、3、8）

 

5.然后返回对顶点2进行检查，发现没有相邻的顶点，那么就对顶点4进行检查，发现有相邻的且未被访问过的顶点6，那么就对其进行访问，以此类推，在访问完顶点6之后，我们就要对顶点1的相邻顶点按照升序进行相邻顶点检查，也就是先检查顶点3再检查顶点7最后检查顶点8，发现顶点8有相邻且未被访问过的定点5，那么就对其访问，至此BFS就结束了

最终的遍历路径为： 0 1 2 4 3 7 8 6 5

3.2算法实现（非递归）

非递归版本的BFS相对于DFS来说比较简单，只需要不断地遍历得到邻接节点并且对其进行访问即可。但是其中需要用到的是队列这个数据结构，队列的作用是什么呢？

队列的作用：

队列的作用就是持续将当前顶点的邻接顶点入队，在对当前顶点的所有邻接顶点都进行访问之后就将其全部出队。

算法步骤：

1）选择一个起点

2）创建一个队列（这里我使用的是标准库中的queue，只需要在头文件导入<queue>即可）

3）首先先判断该顶点是否被访问过，如果未被访问过就对其进行访问。

4）将该顶点入队

5）循环判断队列是否为空，不为空队列就弹出，为空就跳出while循环，对下一个顶点进行BFS

6）然后进行邻接顶点的查找，查找到之后对其进行访问并且入队

最后利用一个BFStraverse对全图的顶点进行BFS即可

具体代码：

  1. void undigraph::BFStraverse()
  2. {
  3.     cout<<"进入BFStraverse"<<endl;
  4.     for (int i = 0; i < vertexnum; i++)
  5.     {
  6.         visited[i]=false;
  7.     }
  8.      for (int i = 0; i < vertexnum; i++)
  9.       {
  10.               BFS(i);    
  11.      }   
  12. }
  13.  
  14. void undigraph::BFS(int v)
  15. {
  16.     queue<int> q;
  17.     if (visited[v]==false)
  18.     {
  19.     cout<<"访问"<<v<<"顶点!"<<endl;
  20.     visited[v]=true;
  21.     }
  22.     q.push(v);
  23.     while (!q.empty())
  24.     {
  25.         q.pop();
  26.         
  27.         for (int i = 0; i < vertexnum; i++)
  28.         {
  29.             if (adjmatrix[v][i]==1&&visited[i]!=true)
  30.             {
  31.                 cout<<"访问"<<i<<"顶点!"<<endl;
  32.                 visited[i]=true;
  33.                 q.push(i);
  34.             }  
  35.         }     
  36.     }  
  37. }

算法执行结果：

 可以发现完全符合上面gif动图的演示过程。

3.3BFS算法出现的问题

我们将上图中的3、5两个顶点位置进行互换，再次将该图输入BFS算法之中试试：

                                                                原图                                                                         更改顶点后                                                  

执行结果：

首先我们先对BFS的思想进行具象化的表示：

 按照这种层级的访问思想，我们可以从图中看出3应该是最外层的，也就是应该是最后访问的，但是，从执行结果我们可以发现，竟然顶点3比顶点6先访问，这显然与我们所期待的BFS不同，并不符合那种一层一层遍历的思想，这是因为什么呢？

  1. void undigraph::BFStraverse()
  2. {
  3.     cout<<"进入BFStraverse"<<endl;
  4.     for (int i = 0; i < vertexnum; i++)
  5.     {
  6.         visited[i]=false;
  7.     }
  8.      for (int i = 0; i < vertexnum; i++)
  9.       {
  10.               BFS(i);    
  11.      }   
  12. }

观察这个代码段我们可以发现第二个循环，也就是循环执行BFS的那个循环，他的顺序是从i小到大依次进行BFS(i)的，也就是说，就算在图的逻辑上应该先访问6再访问3，但是由于你要循环由小到大执行BFS就导致了3会比6优先进入BFS，会产生这个问题主要还是因为我们并没有使用递归进行BFS的调用，而是人为的设置好了从小到大序号进行BFS。

3.4算法改进

        从上面产生的问题我们可以知道，该BFS算法没有按照我们预想的那样按“层级”的顺序去依次访问顶点，因此我们需要对算法进行一个改进。

        我们观察上面的BFS算法代码可以知道，每次产生的队列是基于当前顶点而产生的，也就是每往下一层，产生的队列就非常有可能会增加。

        如下图所示，第一层的0顶点产生了一个队列q0={1，2，4}，然后第二层的顶点1、2、4分别产生了三个队列q1={5,7,8},q2={},q4={0,6}，再往下会产生更多的队列。

         于是我们可以思考，能否将每一层产生的队列全部合并为一个队列呢，这样的话有n层就会产生n个队列，然后对每个队列中的元素依次进行BFS，这样就可以完美解决上面的BFS算法产生的问题。

        为了实现这个算法，我们依然需要用到标准库中的<queue>。本算法需要三个函数：

1.bfstraverse()：用于初始化访问数组和确定起点的

2.bfs():用于查找邻接且未被访问过的顶点，产生由这些顶点构成的队列并返回

3.mergequeue():用于合并队列（本算法的关键）

bfstraverse()：

  1. void undigraph::bfstraverse()
  2. {
  3.     for (int i = 0; i < vertexnum; i++)//初始化访问数组
  4.     {
  5.         visited[i]=false;
  6.     }  
  7.     cout<<"请输入起点:"<<endl;//得到起点
  8.     int start;
  9.     cin>>start;
  10.     cout<<"访问"<<start<<"顶点!"<<endl;
  11.     visited[start]=true;//并对起点进行访问
  12.     mergequeue(start);//把队列进行合并（关键操作）  
  13. }

bfs():

tips:由于之前想着使用指针，后面发现其实没有必要，因此队列名就变成了ptr

  1. queue<int> undigraph::bfs(int v)
  2. {
  3.     queue<int> ptr;//每对一个顶点进行bfs就产生一个队列用于储存邻接顶点
  4.         for (int i = 0; i < vertexnum; i++)
  5.         {
  6.             if (adjmatrix[v][i]==1&&visited[i]!=true)
  7.             {
  8.                 cout<<"访问"<<i<<"顶点!"<<endl;
  9.                 visited[i]=true;//每当查询到一个邻接且未被访问过的顶点，将其访问并推入队列中
  10.                 ptr.push(i);
  11.             }  
  12.         }
  13.     return ptr; //返回该队列              
  14. }

mergequeue():

        在阅读下面的代码前我们可以先思考一个问题，一个由n个顶点组成的图最多有多少层？很显然，n个顶点形成的图，层级最多的时候就是全部拉成一条线的时候，也就是有n层，因此我们只要知道有多少个顶点我们就可以知道要进行最多多少次的相对于层级而言的bfs。

队列合并步骤（图示）：

1.

 2.

 3.

  1. void undigraph::mergequeue(int start)//由起点进入
  2. {
  3.     int temp=start;
  4.     queue<int> tempqueue;//产生一个临时队列
  5.     tempqueue.push(start);//起点入队临时队列
  6.     int tempqueuesize=tempqueue.size();//得到临时队列的大小
  7.     queue<int> tempqueue1;//tempqueue1为一个中转临时队列，下面会用到
  8.     queue<int> tempqueuesum;//合并后的队列
  9.     for (int i = 0; i < vertexnum; i++)
  10.     {       
  11.         for(int i=0;i<tempqueuesize;i++)
  12.         {
  13.             //cout<<"对"<<tempqueue.front()<<"进行bfs"<<endl;                 
  14.             tempqueue1=bfs(tempqueue.front());
  15.             int tempqueue1size=tempqueue1.size();
  16.             for (int j = 0; j<tempqueue1size; j++)
  17.             {
  18.                 tempqueuesum.push(tempqueue1.front());
  19.                 tempqueue1.pop();
  20.             }  
  21.             tempqueue.pop();
  22.         }
  23.         temp=tempqueuesum.front();
  24.         tempqueue.swap(tempqueuesum);
  25.         tempqueuesize=tempqueue.size();
  26.     }
  27. }

3.5执行结果

 可以看到算法成功运行了并成功解决了上一个BFS所产生的问题。

4.全部代码

因为本人为了方便起见，不用每次测试都输入一遍图，就直接把邻接矩阵给初始化了，并且顶点数也初始化为9，如果想要调用createundigraph()来手动创建无向图的话，需要对下面的代码进行改动，也就是把顶点数量vertexnum改为0，然后邻接矩阵只定义而不具体赋值就好了。

  1. #include<stdio.h>
  2. #include<iostream>
  3. #include<queue>
  4. #define maxsize 100
  5. using namespace std;
  6.  
  7. class undigraph
  8. {
  9.     public:
  10.     bool visited[maxsize];//定义一个访问数组
  11.     int vertexnum=9;//无向图的顶点数目
  12.     int maxvertex=0;//用于储存最大顶点的序号
  13.     int data[maxsize];//用于储存每个顶点的数据
  14.     //定义邻接矩阵
  15.     int adjmatrix[maxsize][maxsize]={{0,1,1,0,1,0,0,0,0},
  16.     {1,   0,   0  , 0  , 0  , 1  , 0 ,  1  , 1},
  17.     {1  , 0 ,  0  , 0 ,  0  , 0  , 0  , 0 , 0},
  18.     {0  , 0  , 0  , 0  , 0  , 0  , 0 ,  0 , 1},
  19.     {1 ,  0  , 0  , 0 ,  0  , 0  , 1  , 0  , 0},
  20.     {0  , 1  , 0  , 0 ,  0  , 0   ,0  , 0  , 0},
  21.     {0 ,  0 ,  0 ,  0  , 1  ,0   ,0 ,  0  , 0},
  22.     {0  , 1 ,  0  , 0  , 0  , 0  , 0  , 0  , 0},
  23.     {0 ,  1  , 0 ,  1  , 0  , 0  , 0  , 0  , 0  }};
  24.     void createundigraph();//用于创建无向图
  25.     void printadjmatrix();//打印邻接矩阵
  26.     int smallestadjvertex(int v);
  27.     int nextadjvertex(int v,int prev);
  28.     void DFStraverse();//深度优先遍历
  29.     void DFS(int v);
  30.     void BFStraverse();//广度优先遍历
  31.     void bfstraverse();
  32.     void BFS(int v);
  33.     queue<int> bfs(int v);
  34.     void mergequeue(int tempqueuesize);
  35. };
  36.  
  37.  
  38. void undigraph::createundigraph()
  39. {   
  40.     int tempdata;
  41.     int adjvertex;
  42.     int i=0;
  43.     for(;;i++)
  44.     {
  45.         cout<<"请输入顶点"<<i<<"数据:"<<endl;
  46.         cin>>tempdata;
  47.         if (tempdata==-1)
  48.         {
  49.             break;
  50.         }
  51.         
  52.         data[i]=tempdata;
  53.         while (true)
  54.         {
  55.         cout<<"请输入顶点"<<i<<"的相邻顶点:(以-1结束)"<<endl;
  56.         cin>>adjvertex;
  57.         if (adjvertex==-1)
  58.         {
  59.             break;
  60.         }
  61.         
  62.         
  63.         if (adjvertex>=maxvertex)
  64.         {
  65.             maxvertex=adjvertex+1;
  66.         }
  67.         
  68.         adjmatrix[i][adjvertex]=1;
  69.         adjmatrix[adjvertex][i]=1;
  70.         }
  71.         
  72.         
  73.     }
  74.     vertexnum=i;
  75.     if (i>=maxvertex)
  76.     {
  77.         maxvertex=i;
  78.     }
  79.     
  80.     cout<<"共有"<<i<<"个顶点"<<endl;
  81.     cout<<"邻接矩阵构建完毕"<<endl;
  82.     
  83. }
  84.  
  85. void undigraph::printadjmatrix()
  86. {
  87.     for (int i = 0; i < maxvertex; i++)
  88.     {
  89.         for (int j = 0; j < maxvertex; j++)
  90.         {
  91.             cout<<adjmatrix[i][j]<<"   ";
  92.         }
  93.         cout<<endl;
  94.     }
  95.     
  96. }
  97.  
  98. void undigraph::DFStraverse()
  99. {
  100.     cout<<"进入DFStraverse"<<endl;
  101.     for (int i = 0; i < vertexnum; i++)
  102.     {
  103.         visited[i]=false;
  104.     }
  105.     for (int i = 0; i < vertexnum; i++)
  106.      {
  107.          if (visited[i]==false)
  108.          {
  109.              DFS(i);
  110.          }      
  111.     }   
  112. }
  113.  
  114. void undigraph::DFS(int v)
  115. {
  116.     cout<<"顶点"<<v<<"被访问!"<<endl;
  117.     visited[v]=true;
  118.     for (int prev = smallestadjvertex(v); prev>=0; prev=nextadjvertex(v,prev))
  119.     {
  120.         if (visited[prev]==false)
  121.         {
  122.             DFS(prev);
  123.         }
  124.         
  125.     }  
  126. }
  127.  
  128. void undigraph::BFStraverse()
  129. {
  130.     cout<<"进入BFStraverse"<<endl;
  131.     for (int i = 0; i < vertexnum; i++)
  132.     {
  133.         visited[i]=false;
  134.     }
  135.      for (int i = 0; i < vertexnum; i++)
  136.       {
  137.               BFS(i);    
  138.      }   
  139. }
  140.  
  141. void undigraph::BFS(int v)
  142. {
  143.     queue<int> q;
  144.     if (visited[v]==false)
  145.     {
  146.     cout<<"访问"<<v<<"顶点!"<<endl;
  147.     visited[v]=true;
  148.     }
  149.     //cout<<v<<"入队"<<endl;
  150.     q.push(v);
  151.     while (!q.empty())
  152.     {
  153.         //cout<<q.front()<<"出队"<<endl;
  154.         q.pop();
  155.         
  156.         for (int i = 0; i < vertexnum; i++)
  157.         {
  158.             if (adjmatrix[v][i]==1 && visited[i]!=true)
  159.             {
  160.                 cout<<"访问"<<i<<"顶点!"<<endl;
  161.                 visited[i]=true;
  162.                 //cout<<i<<"入队"<<endl;
  163.                 q.push(i);
  164.             }  
  165.         }     
  166.     }  
  167. }
  168.  
  169. void undigraph::bfstraverse()
  170. {
  171.     for (int i = 0; i < vertexnum; i++)
  172.     {
  173.         visited[i]=false;
  174.     }  
  175.     cout<<"请输入起点:"<<endl;
  176.     int start;
  177.     cin>>start;
  178.     cout<<"访问"<<start<<"顶点!"<<endl;
  179.     visited[start]=true;
  180.     mergequeue(start);   
  181. }
  182.  
  183. void undigraph::mergequeue(int start)
  184. {
  185.     int temp=start;
  186.     queue<int> tempqueue;
  187.     tempqueue.push(start);
  188.     int tempqueuesize=tempqueue.size(); 
  189.     queue<int> tempqueue1;
  190.     queue<int> tempqueuesum;
  191.     for (int i = 0; i < vertexnum; i++)
  192.     {       
  193.         for(int i=0;i<tempqueuesize;i++)
  194.         {
  195.             //cout<<"对"<<tempqueue.front()<<"进行bfs"<<endl;                 
  196.             tempqueue1=bfs(tempqueue.front());
  197.             int tempqueue1size=tempqueue1.size();
  198.             for (int j = 0; j<tempqueue1size; j++)
  199.             {
  200.                 tempqueuesum.push(tempqueue1.front());
  201.                 tempqueue1.pop();
  202.             }  
  203.             tempqueue.pop();
  204.         }
  205.         temp=tempqueuesum.front();
  206.         tempqueue.swap(tempqueuesum);
  207.         tempqueuesize=tempqueue.size();
  208.     }
  209. }
  210.  
  211. queue<int> undigraph::bfs(int v)
  212. {
  213.     //cout<<v<<"进入bfs"<<endl;
  214.     queue<int> ptr;
  215.         for (int i = 0; i < vertexnum; i++)
  216.         {
  217.             if (adjmatrix[v][i]==1&&visited[i]!=true)
  218.             {
  219.                 cout<<"访问"<<i<<"顶点!"<<endl;
  220.                 visited[i]=true;
  221.                 ptr.push(i);
  222.             }  
  223.         }
  224.     return ptr;                
  225. }
  226.  
  227. int undigraph::smallestadjvertex(int v)//寻找最小邻接点，参数为顶点下标
  228. {
  229.     for (int i = 0; i < vertexnum; i++)
  230.     {
  231.         if (adjmatrix[v][i]==1)
  232.         {
  233.             return i;//因为i是从小到大递增的，因此第一个符合条件的顶点就是邻接点中序号最小的顶点
  234.         }
  235.         
  236.     }
  237.     return -1;//如果没有找到邻接点就返回-1
  238. }
  239.  
  240. int undigraph::nextadjvertex(int v,int prev)
  241. {
  242.     for (int i = prev+1; i < vertexnum; i++)
  243.     {
  244.         if (adjmatrix[v][i]==1)//这里需要注意一下，因为邻接矩阵是对称的，因此只需要判断“一边”就好
  245.         {
  246.             return i;//找到就返回该顶点的下标
  247.         }
  248.         
  249.     }
  250.     return -1;//未找到就返回-1
  251. }
  252.  
  253. int main()
  254. {
  255.     undigraph ug;
  256.     // ug.createundigraph();   
  257.     ug.bfstraverse();
  258.     return 0;
  259. }

喜欢本文的话可以点点赞！

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