DFS和BFS算法介绍_ros中dfs-CSDN博客

我根据看别人的帖子总结的。这篇文章合适对深度优先遍历和广度优先遍历原理有一定了解的同志阅读，深度和广度这两个概念大家都知道的：图通过邻接表存储，深度就是有多少层，广度就是有多宽，两者原理上的区别是DFS优先纵向访问，BFS优先横向访问。

上代码自己领悟了：

//BFS DFS
#include<iostream>
#include<list>
using namespace std;

//邻接表存储有向图：邻接表是图经常的存储方式。
class Graph{
 public:
    Graph(int V);
    void addEdge(int v,int w);//向图中添加一条边

    //BFS算法的实现
    void BFS();//BFS遍历

    //DFS算法的实现
    void DFS();//DFS遍历
private:
    int V;//顶点的数量
    list<int>*adj;//邻接表

    //BFS算法的实现
    void BFSUtil(int v,bool visited[]);//假设v可达所有顶点

    //DFS算法的实现
    void DFSUtil(int v,bool visited[]);//假设v可达所有顶点

};
//构造函数
Graph::Graph(int V)
{
    this->V=V;
    adj=new list<int>[V];//初始化V条链表
}
//添加边，构造邻接表
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w);
    //对于无向
    //adj[v].push_back(w);
    //adj[w].push_back(v);
}
//从顶点出发BFS
void Graph::BFSUtil(int v, bool visited[])
{
    //BFS辅助队列
    list<int>queue;
    //将当前节点标记为已访问并压入队列
    visited[v]=true;
    queue.push_back(v);
    list<int>::iterator ite;

    while(!queue.empty())
    {
        v=queue.front();
        cout<<v<<" ";
        queue.pop_front();
        //检测已出队的顶点s的所有邻接点
        //若存在尚未访问的邻接点，访问并压入队列
        for(ite=adj[v].begin();ite!=adj[v].end();ite++)
        {
            if(!visited[*ite])//如果未被访问，注意迭代器的用法，存的指针，指向下标
            {
                visited[*ite]=true;
                queue.push_back(*ite);
            }
        }
    }
}
//DFS实现
void Graph::DFSUtil(int v, bool visited[])
{
    visited[v]=true;
    cout<<v<<" ";
    list<int>::iterator ite;
    for(ite=adj[v].begin();ite!=adj[v].end();ite++)
    {
        if(!visited[*ite])
            DFSUtil(*ite,visited);//递归
    }
}

//BFS搜索实现
void Graph::BFS()
{
    //初始化访问标记数组
    bool *visited=new bool[V];
    for(int i=0;i<V;i++)
    {
        visited[i]=false;
    }
    //对每个连通分量调用一次BFSUtil
    for(int i=0;i<V;i++)
        if(!visited[i])
            BFSUtil(i,visited);
}
//DFS搜索实现
void Graph::DFS()
{
    //初始化访问标记数组
    bool *visited=new bool[V];
    for(int i=0;i<V;i++)
    {
        visited[i]=false;
    }
    //对每个连通分量调用一次BFSUtil
    for(int i=0;i<V;i++)
        if(!visited[i])
            DFSUtil(i,visited);
}

/* 测试 */
int main()
{
  // 创建图
  Graph g(4);
  g.addEdge(0, 1);
  g.addEdge(0, 2);
  g.addEdge(1, 2);
  g.addEdge(2, 0);
  g.addEdge(2, 3);
  g.addEdge(3, 3);

  cout << "Following is BFS Traversal (starting from vertex 2) \n";
  g.BFS();
  cout << endl;
  return 0;
}
/*BFS
 * 1 . 空间复杂度
无论是邻接表还是邻接矩阵的存储方式，BFS算法都需要借助一个辅助队列Q，n个顶点都需要入队一次，在最坏的情况下，空间复杂度为O(|V|)。
2 . 时间复杂度
当采用邻接表存储时，每个顶点均需搜索一次，故时间复杂度为O(|V|)，在搜索任一顶点的邻接点时，每条边至少访问一次，故时间复杂度为O(|E|)，算法总的时间复杂度为O(|V|+|E|)。
当采用邻接矩阵存储时，查找每个顶点的邻接点所需的时间为O(|V|)，故算法总的时间复杂度为O(|V|^2)。
*/

/*DFS
 * 1 . 空间复杂度
DFS算法是一个递归算法，需要借助一个递归工作栈，故它的空间复杂度为O(|V|)。
2 . 时间复杂度
当以邻接表存储时，时间复杂度为O(|V|+|E|)。
当以邻接矩阵存储时，时间复杂度为O(|V|^2)。
*/