图的深度优先搜索DFS和广度优先搜索BFS

riba2534
234 阅读5分钟

原贴链接： 【经典算法】图的深度优先搜索和广度优先搜索

下面的两种搜索算法都是基于 图的邻接表存储 。

深度优先搜索（DFS）

深度优先搜索（depth-first search）是对先序遍历（preorder traversal）的推广。我们从某个顶点 v 开始处理 v，然后递归地遍历所有与 v 邻接的顶点。

实现思想：\

在深度优先搜索中，对于最新发现的顶点，如果它还有以此为起点而未探测到的边，就沿此边继续探测下去，当节点 v 的所有边都已被探寻过，探索将回溯到发现节点 v 有那条边的始节点，这一过程一直进行到已发现从源节点可达的所有节点位置。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个过程反复进行直到所有节点都被发现为止。

                                                          

结合上图说明：左图是邻接表形式，按照上面的实现思想，假定我们首先发现顶点0，然后发现它还有以此为顶点而未探测到的边(0,1),(0,4)，探测完毕后，就回溯到始节点，然后到下一个节点1，(1,0)已探测过(无向图) ，则直接探测(1,4)，然后以此类推。                                    \

为避免图中的圈造成的无限循环，当我们访问一个顶点 v 的时候，由于我们已经到达了该点处，因此需要将该点标记为已访问，对于未被标记的所有邻接顶点递归调用深度优先搜索。

[cpp]  view plain  copy print ?

  1. #include <iostream>  
  2. #include <list>  
  3.   
  4. using namespace std;  
  5.   
  6. class graph  
  7. {  
  8. public:  
  9.     graph(int v) :vertex(v){  
  10.         adj = new list<int>[v];  
  11.     }  
  12.   
  13.     void addEdge(int v, int w);  
  14.     void DFS();  
  15.     void DFS(int v);  
  16.       
  17. private:  
  18.     int vertex;  
  19.     list<int> *adj;  
  20.     void DFSUtil(int v, bool visited[]);  
  21. };  
  22.   
  23. //v:边的首顶点；w：边的尾顶点  
  24. void graph::addEdge(int v, int w)  
  25. {  
  26.     adj[v].push_back(w);  
  27. }  
  28.   
  29. void graph::DFSUtil(int v, bool visited[])  
  30. {  
  31.     visited[v] = true;//置位  
  32.     cout << v << " ";  
  33.   
  34.     list<int>::iterator iter;  
  35.     for (iter = adj[v].begin(); iter != adj[v].end(); ++iter)  
  36.     {  
  37.         if (!visited[*iter])//表明未被访问过  
  38.             DFSUtil(*iter, visited);//跳转到*iter  
  39.     }  
  40. }  
  41.   
  42. //vStart:搜索的起始顶点  
  43. //指定的起始顶点必须位于图内可达到的顶点  
  44. //如果图不连通，有可能访问不到某些节点  
  45. void graph::DFS(int vStart)  
  46. {  
  47.     bool *visited = new bool[vertex];  
  48.     memset(visited, false, vertex);  
  49.   
  50.     DFSUtil(vStart, visited);  
  51. }  
  52.   
  53. //不需要指定起始顶点  
  54. //不管图的结构如何，都可以搜索到所有节点  
  55. void graph::DFS()  
  56. {  
  57.     bool *visited = new bool[vertex];  
  58.     memset(visited, false, vertex);  
  59.   
  60.     //从V0开始深度优先遍历，Vk-1是最后一次深度优先遍历开始的顶点  
  61.     for (int i = 0; i < vertex; ++i)  
  62.     {  
  63.         if (!visited[i])  
  64.             DFSUtil(i, visited);  
  65.     }  
  66. }  
  67. int main()  
  68. {  
  69.     graph g(5);  
  70.     g.addEdge(0, 1);//生成无向图  
  71.     g.addEdge(0, 4);  
  72.     g.addEdge(1, 0);  
  73.     g.addEdge(1, 4);  
  74.     g.addEdge(1, 2);  
  75.     g.addEdge(1, 3);  
  76.     g.addEdge(2, 1);  
  77.     g.addEdge(2, 3);  
  78.     g.addEdge(3, 1);  
  79.     g.addEdge(3, 4);  
  80.     g.addEdge(3, 2);  
  81.     g.addEdge(4, 3);  
  82.     g.addEdge(4, 0);  
  83.     g.addEdge(4, 1);  
  84.   
  85.     g.DFS();  
  86.   
  87.     return 0;  
  88. }  

布尔型数组 visited[ ] 初始化为 false。通过只对那些尚未被访问的节点递归调用该函数，我们保证不会陷入无限的循环。如果图是无向的且不连通，或是有向的但非强连通的，这种方法可能会访问不到某些节点（DFS(int v)）。此时我们搜索一个未被标记的节点，然后应用深度优先遍历，并继续这个过程直到不存在未标记的节点为止（DFS()）。因为该方法保证每条边只访问一次，所以只要使用邻接表，则执行遍历的总时间就是O(|E|+|V|)。
\

广度优先搜索（BFS）

该方法按层处理顶点：距开始点最近的那些顶点首先被访问，而最远的那些顶点最后被访问。这很像对树的层序遍历。

为方便后面的介绍，重新贴一下邻接表的存储方式图：

                                                  \

我们以上图的邻接表存储方式为例对广度优先搜索进行说明：按照前面BFS的定义，我们首先访问所有与开始顶点最近的顶点，然后访问所有距离递增的顶点，最远的顶点则是最后被访问。假定开始顶点为1，与顶点1最近的顶点有四个：0、4、2、3。邻接表存储有个好处就是，所有最近且距离相等的顶点都位于该顶点位置的链表中。首先我们访问完所有与开始顶点1最近的顶点（0、4、2、3），很容易得知，与开始顶点次近（距离增1）的顶点恰好是最近顶点的最近顶点，也就是与（0、4、2、3）顶点最近的顶点。前面可理解为不断的替换开始顶点，已经访问过的顶点坐标记，保证不会被重复访问，否则进入无限循环。这样依次推进，直至访问完所有顶点。

[cpp]  view plain  copy print ?

  1. //vStart:搜索的起始顶点  
  2. //指定的起始顶点必须位于图内可达到的顶点  
  3. void graph::BFS(int vStart)  
  4. {  
  5.     bool *visited = new bool[vertex];  
  6.     memset(visited, false, vertex);  
  7.   
  8.     list<int> queue;//利用链表构建一个队列  
  9.   
  10.     visited[vStart] = true;//表示开始访问  
  11.     queue.push_back(vStart);//开始顶点入队  
  12.   
  13.     list<int>::iterator iter;  
  14.   
  15.     while (!queue.empty())  
  16.     {  
  17.         vStart = queue.front();//这里有个优先级，邻接表中链表的头节点优先级最高，依次降低  
  18.         cout << vStart << " ";  
  19.         queue.pop_front();//已访问顶点出队  
  20.   
  21.         //将与开始顶点最近的顶点，也就是链表中的顶点依次入队  
  22.         for (iter = adj[vStart].begin(); iter != adj[vStart].end(); ++iter)  
  23.         {  
  24.             if (!visited[*iter])  
  25.             {  
  26.                 visited[*iter] = true;//标记即将访问，事实上，进入队列了就是要访问的  
  27.                 queue.push_back(*iter);//从链表头节点到尾节点依次入队  
  28.             }  
  29.         }  
  30.     }  
  31. }  

同样，如果图不是强连通，比如存在孤立的顶点，BFS就不能够访问图中所有的点，这可参考前面的DFS版本，进行修改以便对于任何图结构都能够访问所有顶点。BFS同DFS，只要使用邻接表，运行时间就是O(|E|+|V|)。\

\

深度优先搜索与广度优先搜索的区别：

深度优先搜索是按照一定的顺序先查找完一个分支，再查找另一个分支，直到找到目标，或是访问完所有节点（连通）；广度优先搜索是从初始状态一层一层向下找，直到找到目标，或是访问完所有节点（连通）。

\

深度优先搜索通过栈来实现，而广度优先搜索通过队列来实现。

\

通常深度优先搜索不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。
广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些。

\

上面说的通俗点就是：广度优先搜索是从中心点层层向外推进，走完最里层房间，然后走第二层的所有房间，直到第二层的所有房间全部走完，再走第三层的房间（这里不同的是同一层的所有房间之间是可以跳转的）。而深度优先搜索则是走死胡同，从中心点开始走，一路走，直到最后无路可走，然后退回来一层，再进入下一层的一间房间（只有同层的房间可以跳转，不同层的房间需要退回来），再走其余房间。

\

\

avatar
文章
阅读
粉丝