BFS 和 DFS

最新推荐文章于 2022-06-02 16:44:10 发布
最新推荐文章于 2022-06-02 16:44:10 发布
阅读量199 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wchzh2015/article/details/89215146
版权

文中的代码和部分图参考了 Graph and its representations

目录

图的表示的方法：

DFS，参考：Depth First Search or DFS for a Graph

 访问存在孤立点的图

下面也是一种写法：参考 算法录 之 BFS和DFS

DFS的非递归写法

BFS（广度优先搜索）参考：Breadth First Search or BFS for a Graph

对上面的图进行BFS遍历的话：结果为 2，0，3，1。

访问存在孤立点的图

下面的写法类似：参考 算法录 之 BFS和DFS

 应用：

参考文献

  • 图的表示的方法：

  • 邻接矩阵

直接开一个N×N的二维数组E，然后 E[i][j] 为1的时候表示 i 和 j 之间有一条边，0的时候就没有。

　　    这样很方便简单，但是也有缺点，

                  1、首先是效率问题，超过1000个点一般不管是空间还是时间都不允许了。

                  2、然后就是如果两个顶点之间有两条边的话，就没法表示了。。。

　　    所以现在一般很少用这种方法，当然不排除某些时候还是可以使用的。

Adjacency Matrix Representation
上面的无向图的邻接矩阵的表示方法 
int E[5][5];

E[1][2]=1;
E[4][2]=0;

 

  • 邻接表

使用链表的方式保存一个顶点的所有相连接的边，每个顶点表示为这个链表的起始的根节点。

当然，每个顶点都要维护一个链表，这个时候可以使用 vector 数组比较方便。

Adjacency List Representation of Graph
上面的无向图的邻接表的表示方法 
vector <int> E[5];

E[4].push_back(1) // 有一条从4到1的边。
  •  使用邻接表建立无向图的一个例子：
// A simple representation of graph using STL 
#include<bits/stdc++.h> 
using namespace std; 

// A utility function to add an edge in an 
// undirected graph. 
void addEdge(vector<int> adj[], int u, int v) 
{ 
	adj[u].push_back(v); 
	adj[v].push_back(u); 
} 

// A utility function to print the adjacency list 
// representation of graph 
void printGraph(vector<int> adj[], int V) 
{ 
	for (int v = 0; v < V; ++v) 
	{ 
		cout << "\n Adjacency list of vertex "
			<< v << "\n head "; 
		for (auto x : adj[v]) 
		cout << "-> " << x; 
		printf("\n"); 
	} 
} 

// Driver code 
int main() 
{ 
	int V = 5; 
	vector<int> adj[V]; 
	addEdge(adj, 0, 1); 
	addEdge(adj, 0, 4); 
	addEdge(adj, 1, 2); 
	addEdge(adj, 1, 3); 
	addEdge(adj, 1, 4); 
	addEdge(adj, 2, 3); 
	addEdge(adj, 3, 4); 
	printGraph(adj, V); 
	return 0; 
}

 

先上图：需要一个栈，因为每次都是搜到之后不停的往下搜，符合先进先出。但是一般来说不用栈，而是直接通过函数的递归就行了。

如图所示，由于存在环，所以需要设置 bool 类型的数组，防止有的节点会重复遍历，导致进入无休止的循环遍历状态。

先从2开始搜索，然后0与2连接，所以搜索0,再从0开始搜索，由于有一条指向2的路线，但是2一开始就已经访问过了，所以选择与0相连接的另一条没有被访问过节点1。此时从1开始搜索，1只有一条指向2的路线，但是2已经遍历过，所以回退到上一个连接点0，与0向连接的节点都已经被访问过了，所以再回退到2，此时还有与2连接的节点3没有访问过，此时访问3，至此，DFS遍历结束。 

 

// C++ program to print DFS traversal from 
// a given vertex in a given graph 
#include<iostream> 
#include<list> 
using namespace std; 

// Graph class represents a directed graph 
// using adjacency list representation 
class Graph 
{ 
	int V; // No. of vertices 

	// Pointer to an array containing 
	// adjacency lists 
	list<int> *adj; 

	// A recursive function used by DFS 
	void DFSUtil(int v, bool visited[]); 
public: 
	Graph(int V); // Constructor 

	// function to add an edge to graph 
	void addEdge(int v, int w); 

	// DFS traversal of the vertices 
	// reachable from v 
	void DFS(int v); 
}; 

Graph::Graph(int V) 
{ 
	this->V = V; 
	adj = new list<int>[V]; 
} 

void Graph::addEdge(int v, int w) 
{ 
	adj[v].push_back(w); // Add w to v’s list. 
} 

void Graph::DFSUtil(int v, bool visited[]) 
{ 
	// Mark the current node as visited and 
	// print it 
	visited[v] = true; 
	cout << v << " "; 

	// Recur for all the vertices adjacent 
	// to this vertex 
	list<int>::iterator i; 
	for (i = adj[v].begin(); i != adj[v].end(); ++i) 
		if (!visited[*i]) 
			DFSUtil(*i, visited); 
} 

// DFS traversal of the vertices reachable from v. 
// It uses recursive DFSUtil() 
void Graph::DFS(int v) 
{ 
	// Mark all the vertices as not visited 
	bool *visited = new bool[V]; 
	for (int i = 0; i < V; i++) 
		visited[i] = false; 

	// Call the recursive helper function 
	// to print DFS traversal 
	DFSUtil(v, visited); 
} 

int main() 
{ 
	// Create a graph given in the above diagram 
	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 Depth First Traversal"
			" (starting from vertex 2) \n"; 
	g.DFS(2); 

	return 0; 
}

 

​

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

  •  访问存在孤立点的图

上面是从一个指定的源点DFS访问节点，但是如果图中有孤立的点，则不能保证图中所有的点都能被访问到。所以，改变遍历的方式，改为不指定源点，将每一个节点都设置为源点，只要在从源点开始DFS遍历前，判断一下是否已经访问过就可以了。代码改动如下：


#include <iostream>
#include <cstdio>
#include <cstring>
#include <list>
#include <bits/stdc++.h>
using namespace std;


// C++ program to print DFS traversal from
// a given vertex in a given graph

// Graph class represents a directed graph
// using adjacency list representation
class Graph
{
	int V; // No. of vertices

	// Pointer to an array containing
	// adjacency lists
	list<int> *adj;

	// A recursive function used by DFS
	void DFSUtil(int v, bool visited[]);
public:
	Graph(int V); // Constructor

	// function to add an edge to graph
	void addEdge(int v, int w);

	// DFS traversal of the vertices
	// reachable from v
	void DFS(); // ---------------------------
};

Graph::Graph(int V)
{
	this->V = V;
	adj = new list<int>[V];
}

void Graph::addEdge(int v, int w)
{
	adj[v].push_back(w); // Add w to v’s list.
}

void Graph::DFSUtil(int v, bool visited[])
{
	// Mark the current node as visited and
	// print it
	visited[v] = true;
	cout << v << " ";

	// Recur for all the vertices adjacent
	// to this vertex
	list<int>::iterator i;
	for (i = adj[v].begin(); i != adj[v].end(); ++i)
		if (!visited[*i])
			DFSUtil(*i, visited);
}

// DFS traversal of the vertices reachable from v.
// It uses recursive DFSUtil()
void Graph::DFS()  // ------------------------
{
	// Mark all the vertices as not visited
	bool *visited = new bool[V];
	for (int i = 0; i < V; i++)
		visited[i] = false;

	// Call the recursive helper function
	// to print DFS traversal
	for(int i=0; i<V; i++)  // ------------------
	{
	    if(!visited[i])
            DFSUtil(i, visited); // --------------------
	}

}

int main()
{
	// Create a graph given in the above diagram
	Graph g(7);
	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 Depth First Traversal"
			" (starting from vertex 2) \n";
	g.DFS(); // ---------------------

	return 0;
}

 

bool vis[110];
int N;

void DFS(int u)
{
    int len;

    vis[u]=1;
    len=E[u].size();

    for(int i=0;i<len;++i)
        if(vis[E[u][i]]==0)
            DFS(E[u][i]);
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

 

  • DFS的非递归写法

  • 比如建立如下的一个图，

  • 代码如下：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <list>
#include <bits/stdc++.h>
using namespace std;

// C++ program to print DFS traversal from
// a given vertex in a given graph

// Graph class represents a directed graph
// using adjacency list representation
class Graph
{
	int V; // No. of vertices

	// Pointer to an array containing
	// adjacency lists
	list<int> *adj;
    stack<int>st;

	// A recursive function used by DFS
	void DFSUtil(int v, bool visited[], stack<int>st);
public:
	Graph(int V); // Constructor

	// function to add an edge to graph
	void addEdge(int v, int w);

	// DFS traversal of the vertices
	// reachable from v
	void DFS();
};

Graph::Graph(int V)
{
	this->V = V;
	adj = new list<int>[V];
}

void Graph::addEdge(int v, int w)
{
	adj[v].push_back(w); // Add w to v¡¯s list.
}

void Graph::DFSUtil(int v, bool visited[], stack<int> st)
{
	// Mark the current node as visited and
	// print it
	visited[v] = true; // 遍历每个源点，如果没有访问，就打印输出，并入栈
	cout << v << " ";
	st.push(v);
	while(!st.empty()) // 如果栈不为空
    {
        int head = st.top();
        list<int>::iterator it = adj[head].begin();
        bool flag = false; // 设置标记，如果当前节点没有邻接点或者邻接点都已经被访问过，则将当前栈中的一个元素出队
        for(it = adj[head].begin(); it!=adj[head].end(); it++) // 开始遍历当前节点的邻接点
        {
            if(!visited[*it]) //  如果邻接点没有访问过
            {
                cout<< *it <<" ";
                st.push(*it);
                visited[*it] = true; //设置邻接点已经访问过
                flag = true; // 设置标记为 true，代表当前节点存在一个没有被访问过的邻接点
                break;
            }
        }
        if(flag == false) // 如果当前节点没有邻接点或者邻接点都已经被访问过,则栈不为空时出栈一个元素。
        {
            if(!st.empty())
                st.pop();
        }
    }

}


void Graph::DFS()
{

    bool *visited = new bool[V];
    for(int i=0; i<V; i++)
        visited[i] = false;

    for(int i=0; i<V; i++) //依次以每个结点为源点
    {
        if(!visited[i])
            DFSUtil(i, visited, st);
    }
}
int main()
{
	// Create a graph given in the above diagram
	Graph g(10);
	g.addEdge(0, 1);
	g.addEdge(3, 3);
	g.addEdge(2, 4);
	g.addEdge(2, 5);

	cout << "Following is Depth First Traversal"
			" (starting from vertex 2) \n";
	g.DFS();

	return 0;
}

 

广度优先搜索，顾名思义，就是先搜索完同一层次的所有节点，然后到下一层，继续搜索下一层的所有节点。以此类推，搜索完所有的节点。

这种遍历的方式类似于遍历一个队列，如同我把每层的节点从左到右放入队列中，所有的层从上到下遍历完。所以，我们可以借助辅助队列，来进行广度优先搜索。

​

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

对上面的图进行BFS遍历的话：结果为 2，0，3，1。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <list>
#include <bits/stdc++.h>
using namespace std;


// 新建一个 Graph 类，使用邻接表表示一个有向图，
class Graph
{
private:
    int V; // 表示有向图中节点的数量
    list<int> *adj; // 使用STL中的 list 容器，定义链表数组，数组中的每一个元素表示一个链表
public:
    Graph(int V); //构造函数初始化
    void addEdge(int v, int w); // 向图添加一条边
    void BFS(int s); //从节点 s 开始，BFS 遍历图。

};

Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w);// 把 w 添加到v的链表中。
}

void Graph::BFS(int s)
{

    bool *visit = new bool[V];
    for(int i=0; i<V; i++)
        visit[i] = false;

    list<int>queue;// list 是一个双向链表，所以在两头都可以执行插入删除操作，
                   // 所以直接使用 list 来模拟队列
    visit[s] = true; //标记当前顶点已经被访问标记过，并入队列
    queue.push_back(s);

    list<int>::iterator it; // 初始化迭代器，用于遍历容器，这里是用作遍历当前节点的邻接点

    while(!queue.empty())
    {
        s = queue.front();
        cout << s << " ";
        queue.pop_front();

        for(it = adj[s].begin(); it!=adj[s].end(); it++)
        {
            if(!visit[*it]) // 如果已经访问过，则继续遍历下一个没有访问过得邻接点
            {
                visit[*it] = true; //没有访问过，则先标记已经访问过了，防止重复遍历
                queue.push_back(*it);
            }
        }
    }
}
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 Breadth First Traversal "
         << "(starting from vertex 2) \n";
    g.BFS(2);//从 2 开始进行BFS遍历
    return 0;
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

 

​

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

  • 访问存在孤立点的图

上面的写法如果是在图中存在孤立点的时候，也会不能遍历到，所以，应该以每个结点为源点，进行BFS遍历，具体的写法可以参看上面 DFS中的访问图中存在孤立点的写法

bool vis[110];            // 记录已经走过的点，防止重复访问。

void BFS(int root,int N)        // N个点的图，从root点开始搜索。
{
    queue <int> que;

    memset(vis,0,sizeof(vis));    // 初始化。
    vis[root]=1;
    que.push(root);

    int u,len;

    while(!que.empty())
    {
        u=que.front();
        que.pop();

        len=E[u].size();
        for(int i=0;i<len;++i)        // 找到和u相连的所有点，存在一个vector里面。
            if(vis[E[u][i]]==0)
            {
                vis[E[u][i]]=1;
                que.push(E[u][i]);
            }
    }
}
wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

 

  •  应用：

  1. BFS算法求解单源最短路劲问题
  2.  

  • 参考文献

  1. Graph and its representations
  2. Breadth First Search or BFS for a Graph
  3. Depth First Search or DFS for a Graph
  4. 算法录 之 BFS和DFS
wchzh2015
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于python模拟bfs和dfs代码实例
01-19
BFS # @Time : 2020/11/8 # @Author : Jimou Chen # 广搜 def bfs(graph, start): queue = [start] # 先把起点入队列 visited = set() # 访问国的点加入 visited.add(start) while len(queue): vertex = ...
MFC树控件BFS和DFS示例
09-24
MFC自带树控件CTreeCtrl的搜索遍历示例，代码包括对指定节点及子节点进行勾选操作、从指定节点开始搜索操作、按层次打印树节点，涉及BFS和DFS算法。
Build graph（Java）
weixin_46943250的博客
07-15 595
Build the graph as shown in the above figure using the adjacency list. Implement the BFS & DFS algorithm and traverse the graph starting from Vertex A. 1 procedure DFS-iterative(G,v): 2 let S be a stack 3 S.push(v) 4 while S is not emp.
图的DFS和BFS算法
Gerald_Jones的博客
05-02 8404
前言 文章主要介绍数据结构知识板块中图的两种不同存储结构下（邻接表和邻接矩阵）BFS和DFS遍历算法。BFS和DFS应用领域不再说明，深搜和广搜的遍历算法十分重要。 DFS 原理：深度优先搜索，顾名思义即为一条道走到黑的搜索策略，行不通退回来换另外一条道再走到黑，依次直到搜索完成。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。...
BFS&DFS
Gin077的专栏
01-08 379
BFS:http://www.jb51.net/article/53730.htm
【霍罗维兹数据结构】GRAPH 图 | 基本图运算 DFS&BFS | 最小代价生成树
⚡ 柠檬叶子团队
06-02 1677
概念：最早可追溯到1736年，欧拉用图论解决了经典的七桥问题。欧拉证明，如果要从图中的一个节点除法，经图中所有边一次且仅一次，最后回到出发的节点，那么当且仅当图中所有节点的度都是偶数。为了纪念欧拉的发现，我们称之为欧拉回路。图是使用最广泛的数学结构，可应用于电路分析、寻找最短路径、项目规划、化合物鉴定、网络流程设计、基因/蛋白质相互作用等……一个图由两个集合构成： ：有限的、非空的顶点集合， ：有限的、可能是空的边缘集合。我们可以将其写作 .An undirected graph：each edg
查找算法—BFS宽度优先遍历算法
hahachenchen789的博客
10-15 203
BFS属于一种盲目搜寻法，也就是说彻底的搜索整张图，并不考虑结果的可能位置。列出所有结果。   实际应用：BFS在求解最短或者最长路径或者最短最长步数上有很多应用。比如迷宫。   例子：在一个n*n的矩阵中，从原点(0,0)走到终点(n-1.n-1),只能上下左右走，求最短步数，n*n是01矩阵，0表示该格子没有障碍，1表示有障碍。   int mazeArr[maxn][maxn]...
二叉树的BFS和DFS
01-21
1. ⼆叉树的直径 leetcode 543 / lintcode 1181 描述 给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。...
BFS和DFS算法可视化（js实现）
01-17
这是山东大学可视化课程项目，用js实现的BFS和DFS，详细的展示了BFS和DFS的运行过程，网页可交互。
搜索入门——BFS和DFS
12-18
从最基础的迷宫问题看深搜和宽搜的内涵，理解最基础的穷举搜索。
算法导论—无向图的遍历(BFS+DFS，MATLAB)
热门推荐
掉下个小石头
08-22 1万+
华电北风吹 天津大学认知计算与应用重点实验室 最后修改日期：2015/8/22无向图的存储方式有邻接矩阵，邻接链表，稀疏矩阵等。无向图主要包含两方面内容，图的遍历和寻找联通分量。一、无向图的遍历 无向图的遍历有两种方式—广度优先搜索(BFS)和深度优先搜索(DFS)。广度优先搜索在遍历一个顶点的所有节点时，先把当前节点所有相邻节点遍历了，然后遍历当前节点第一个相邻的节点的所有相邻节点，广度优先
POJ 3411 Paid Roads (DFS多次访问节点）
10-02 2146
题意：n座城市由m条公路连接，每两座城市间可能有多条公路。这些公路都是需要收费的，并且有两种付费方式。例如从a到b：方式一在b处付费 r ；方式二在a之前（可能包含a)付费p，但是用方式二付费要求路径必须经过c点。要求从1到n得最小费用。 题解：题目只要求最小费用，由于有重边的
算法导论--图的遍历（DFS与BFS）
开始的地方
08-05 2011
转载于 勿在浮沙筑高台http://blog.csdn.net/luoshixian099/article/details/51897538 图的遍历就是从图中的某个顶点出发，按某种方法对图中的所有顶点访问且仅访问一次。为了保证图中的顶点在遍历过程中仅访问一次，要为每一个顶点设置一个访问标志。通常有两种方法：深度优先搜索(DFS)和广度优先搜索(BFS).这两种算法对有向图与无向图均适用。  以...
深入浅出BFS/DFS(3)—孤立点的处理
peinishangrichu的博客
11-24 778
图的表示方法： 参考： 1. 邻接矩阵 直接开一个N×N的二维数组E，然后 E[i][j] 为1的时候表示 i 和 j 之间有一条边，0的时候就没有。 这样很方便简单，但是也有缺点， 1 首先是效率问题，超过1000个点一般不管是空间还是时间都不允许了。 2 然后就是如果两个顶点之间有两条边的话，就没法表示了。 所以现在一般很少用这种方法，当然不排除某些时候还是可以使用的。 2. 邻接表 使用链表的方式保存一个顶点的所有相连接的边，每个顶点表示为这个链表的起始的节点。 当然，每个顶点都要维护一个链表，这个
简单的BFS对图的连通性检测（不带权值）
jelly的博客
03-17 559
#include&amp;lt;iostream&amp;gt; #include&amp;lt;queue&amp;gt; #include&amp;lt;algorithm&amp;gt; #include&amp;lt;vector&amp;gt; using namespace std; //利用bfs检测图的连通性 //利用邻接表存储图 //不带权值 const int maxn=100; int N; vector
stringstream 用法
wchzh2015的博客
06-19 1658
在使用C++编程的时候，有时会输入一段英文句子，如果使用Python原因的话，那么直接使用 split() 函数就好了。那么使用C++有没有方便的方法呢？这就不得不提到stringstream。 stringstream 这里参考大佬的博客，自己就不再重述了 c++ stringstream（老好用了） stringstream的简单用法 当然如果将一个字符串表示的整数转换为in...
GeeksforGeeks 智力题
wchzh2015的博客
04-16 1583
博客中整理了学习GeeksforGeeks 站点的智力题。作为自己的学习历程。会在学习中不断的更新。 目录 Puzzle 1 | (How to Measure 45 minutes using two identical wires?) Puzzle 2 | (Find ages of daughters) Puzzle 3 | (Calculate total distance tra...
快速幂，矩阵快速幂，使用矩阵快速幂求斐波那契数列
wchzh2015的博客
04-16 650
学习 矩阵的乘法和快速幂的一些理解（适用初学者） 快速幂讲解 【算法竞赛进阶指南】 0x01 位运算 学习笔记 练习 a^b 64位整数乘法
72.编辑距离
wchzh2015的博客
05-18 570
学习博客： 详解编辑距离(Edit Distance)及其代码实现 应用：编辑距离 题目描述： 给定两个单词word1和word2，计算出将word1转换成word2所使用的最少操作数。 你可以对一个单词进行如下三种操作： 插入一个字符 删除一个字符 替换一个字符 示例1: 输入: word1 = "horse", word2 = "ros" 输出: 3...
BFS和DFS C++算法
最新发布
09-04
BFS和DFS都是常用的图搜索算法。它们的区别在于搜索的策略和复杂度。引用中提到，对于给定的问题，BFS是较佳的算法。 BFS（广度优先搜索）是一种逐层扩展搜索的算法。它从起始节点开始，逐层遍历邻接节点，直到找到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值