DFS和BFS(C++)

本文探讨了两种图算法——深度优先搜索(DFS)和宽度优先搜索(BFS)。DFS利用栈进行递归搜索,适用于解决全排列等问题,而BFS使用队列实现,擅长寻找最短路径,如在走迷宫问题中的应用。两者在空间复杂度上存在差异,DFS通常占用更少空间。
摘要由CSDN通过智能技术生成

深度优先搜索(Depth-First-Search):

事实上,深度优先搜索属于图算法的一种,英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次.

宽度优先搜索(Breadth First Search):

BFS,其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点,所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里,其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中(例如队列或是链表),而被检验过的节点则被放置在被称为 closed 的容器中。(open-closed表) 

DFS和BFS的区别:

  1. DFS 使用的数据结构是栈(stack),而BFS 使用的数据结构是队列(queue) 。
  2. 在空间上来说,DFS 使用的空间与搜索的高度有关,而BFS的空间是高度的指数,所以DFS比BFS用的空间小
  3. BFS 的好处是搜索最短路,而DFS 不具最短路。

DFS例题:

全排列

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 100010;
int n,path[N];
bool sta[N] ;
void dfs(int u)
{
	if(u == n)
	{
		for(int i=0;i<n;i++)cout << path[i] <<' ';
		cout<<endl;
		return;
	}
	
	for(int i=1;i<=n;i++)
		if(!sta[i])
		{
			path[u] = i ;
			sta[i] = true ;
			dfs(u+1);
			sta[i] = false ;
		}
}

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n;
	
	dfs(0);
	
	return 0;
}

 BFS例题

走迷宫

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int,int>PII;
const int N = 110;
int n,m,g[N][N],d[N][N];
PII q[N*N];  
int bfs()
{
	int hh = 0,tt = 0;
	q[0] = {0,0};
	memset(d,-1,sizeof d);
	d[0][0] = 0;
	int dx[4] = {-1,0,1,0},dy[4]= {0,1,0,-1};
	while(hh <= tt) 
	{
		auto t = q[hh ++ ];
		for(int i=0;i<4;i++)
		{
			int x = t.first + dx[i] ,y  = t.second + dy[i] ;
			if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1)
			{
				d[x][y] = d[t.first][t.second] + 1;
				q[++tt] = {x,y};
			}
		}
	}
	
	return d[n-1][m-1];
}

int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin >> n >> m;
	for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
			cin >> g[i][j]; 
	
	cout << bfs() << endl ;
	
	return 0;
}

题目来自AcWing

### 回答1: DFS(深度优先搜索)和BFS(广度优先搜索)算法论中常见的两种算法用于遍历或树的节点。以下是C++实现: DFS算法实现: ```c++ #include <iostream> #include <vector> #include <stack> using namespace std; void dfs(vector<vector<int>>& graph, vector<bool>& visited, int start) { stack<int> s; s.push(start); while (!s.empty()) { int node = s.top(); s.pop(); if (!visited[node]) { visited[node] = true; cout << node << " "; for (int i = graph[node].size() - 1; i >= 0; --i) { int next_node = graph[node][i]; if (!visited[next_node]) { s.push(next_node); } } } } } int main() { int n = 5; vector<vector<int>> graph(n); graph[0].push_back(1); graph[0].push_back(2); graph[1].push_back(3); graph[1].push_back(4); vector<bool> visited(n, false); dfs(graph, visited, 0); return 0; } ``` BFS算法实现: ```c++ #include <iostream> #include <vector> #include <queue> using namespace std; void bfs(vector<vector<int>>& graph, vector<bool>& visited, int start) { queue<int> q; q.push(start); while (!q.empty()) { int node = q.front(); q.pop(); if (!visited[node]) { visited[node] = true; cout << node << " "; for (int i = 0; i < graph[node].size(); ++i) { int next_node = graph[node][i]; if (!visited[next_node]) { q.push(next_node); } } } } } int main() { int n = 5; vector<vector<int>> graph(n); graph[0].push_back(1); graph[0].push_back(2); graph[1].push_back(3); graph[1].push_back(4); vector<bool> visited(n, false); bfs(graph, visited, 0); return 0; } ``` 这里我们以一个简单的无向为例,节点从0到4编号,的邻接表表示为: ``` 0: 1, 2 1: 0, 3, 4 2: 0 3: 1 4: 1 ``` DFS算法BFS算法的输出结果都是:0 2 1 4 3。 ### 回答2: DFS(深度优先搜索)和BFS(广度优先搜索)是两种常用的遍历算法,都可以用来实现C语言。 DFS算法通过递归或者栈的方式实现,可以从的某个顶点开始,沿着一条路径一直到达没有未探索的邻居节点为止,然后返回到前一个顶点继续探索其他未探索的邻居节点。可以用以下C语言代码实现DFS算法: ```c #include <stdio.h> #define SIZE 100 int visited[SIZE]; //用来标记节点是否访问过 int graph[SIZE][SIZE]; //的邻接矩阵表示 void dfs(int node) { printf("%d ", node); visited[node] = 1; for(int i = 0; i < SIZE; i++) { if(graph[node][i] && !visited[i]) { dfs(i); } } } int main() { //初始化visited和graph //调用dfs函数 dfs(0); //从节点0开始深度优先搜索 return 0; } ``` BFS算法通过队列的方式实现,可以从的某个顶点开始,将其加入队列,然后依次将队列中的节点访问并将其邻居节点加入队列,直到队列为空。可以用以下C语言代码实现BFS算法: ```c #include <stdio.h> #define SIZE 100 int visited[SIZE]; //用来标记节点是否访问过 int graph[SIZE][SIZE]; //的邻接矩阵表示 void bfs(int node) { int queue[SIZE]; int front = 0, rear = 0; queue[rear++] = node; visited[node] = 1; while(front < rear) { int curNode = queue[front++]; printf("%d ", curNode); for(int i = 0; i < SIZE; i++) { if(graph[curNode][i] && !visited[i]) { queue[rear++] = i; visited[i] = 1; } } } } int main() { //初始化visited和graph //调用bfs函数 bfs(0); //从节点0开始广度优先搜索 return 0; } ``` 以上就是用C语言实现DFSBFS算法的代码。在实际应用中,可以根据具体场景选择使用DFS还是BFS来进行的遍历。 ### 回答3: DFS(深度优先搜索)和BFS(广度优先搜索)算法都是用于的遍历的常见算法。它们在遍历的顺序、搜索方式和空间复杂度上有所差异。 DFS是一种先深入后回溯的搜索方法。它从起点开始,沿着的一条路径一直遍历到尽头,然后回溯到上一个节点,继续探索其他未遍历的路径,直到整个都被遍历完。DFS常用递归或栈的方式实现。 BFS是一种逐层扩展的搜索方法。它从起点开始,首先遍历起点的所有邻接节点,然后依次遍历邻接节点的邻接节点,以此类推,直到整个都被遍历完。BFS常用队列的方式实现,每次将待遍历节点加入队列,并在从队列中取出节点时,将其邻接节点加入队列。 在C语言中,实现DFSBFS算法可以借助的表示方式和遍历的数据结构。一种常见的的表示方式是邻接矩阵或邻接表,用于存储的顶点和边的关系。而在遍历过程中,可以借助一个访问标记数组,用于标记节点是否被访问过。 对于DFS算法的实现,可以通过递归函数实现,递归函数的参数包括当前遍历的节点、访问标记数组等。递归函数的主体部分可以按照DFS的逻辑进行实现。 而对于BFS算法的实现,可以通过队列来实现,首先将起点加入队列,然后循环取出队列中的节点,并将其邻接节点依次加入队列,直到队列为空。在每次取出节点时,可以将其标记为已经访问过。 总之,DFSBFS算法在C语言中的实现需要借助的表示方式,以及递归函数或队列等数据结构。具体实现的细节还可以根据具体问题的需求进行调整和优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值