C++深度优先和广度优先的实现

最新推荐文章于 2023-07-17 22:29:18 发布
最新推荐文章于 2023-07-17 22:29:18 发布
阅读量1.3k 收藏 8
点赞数 4
文章标签： c++ dfs bfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Howl_1/article/details/113246596
版权
本文介绍使用C++实现迷宫寻路的两种经典算法——深度优先搜索（DFS）和广度优先搜索（BFS）。文章详细展示了如何利用栈和队列数据结构来实现这两种算法，并通过图形库easyx直观呈现寻路过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++深度优先和广度优先的实现

前言

本篇文章为笔者的读书笔记，未经允许请勿转载。如果对你有帮助记得点个赞(●’◡’●)
本文主要讲的深度优先算法和广度优先算法的区别，其中深度优先有两种实现方式，一种是递归法，另一种是非递归（栈实现），而广度优先就是队列的实现；
后面还会以图形表述栈实现和队列实现；且用到了图形库easyx；

源码如下：

main

#include <iostream>
#include<vector>
#include<windows.h>
#include"Draw.h"
#include"DFS.h"
#include"BFS.h"
#include"Search.h"
using namespace std;
vector<vector<int>> map =
{
    {0,0,1,0,1,0,1},
    {1,0,0,0,0,0,1},
    {1,0,1,1,1,0,0},
    {1,0,0,0,1,1,1},
    {0,0,1,0,0,0,1},
    {1,0,1,0,1,0,0},
    {1,0,1,1,1,0,1},
};
//检查数据的合法性
bool check(int x, int y)
{
    //所走的路径不能越界，也不能走到地图为1的地方。
    if ((y < 0 ||  x<0) || y >= map.size() ||x>=map[y].size() || map[y][x] == 1)
    {
        return false;
    }
    return true;
}
//测试图形库是否能正常运行
void test()
{
    Draw draw(600, map);
    draw.updata();
}
//深度优先算法
void test1()
{
    DFS dfs(check);
    Draw draw(600, map);
    Pos start{ 0,0 };
    Pos end{ 1,6 };
    draw.level[end.y][end.x] = Draw::end;//设置终点位置
    draw.updata();
    const auto& path = dfs.recursive(start,end);//开始寻路，路径找完后用vector保存了
    for (const auto& e : path)
    {
        draw.level[e.y][e.x] = Draw::visit;//路径设置为visit。注意x，y不要写反了
        draw.updata();
        Sleep(500);
    }
}
//广度优先算法
void test2()
{
    BFS bfs(check);
    Draw draw(600, map);
    Pos start{ 1,1 };
    Pos end{ 3,0 };
    draw.level[end.y][end.x] = Draw::end;
    draw.updata();
    const auto& path = bfs.queue(start, end);
    for (const auto& e : path)
    {
        draw.level[e.y][e.x] = Draw::visit;
        draw.updata();
        Sleep(500);
    }

}
int main()
{
    //test();
    //test1();
    //test2();
    system("pause");
    return 0;
}

Draw.h

#pragma once
#include<vector>
#include<easyx.h>
#include<string>
#include<iostream>

//区别名
using vec2 = std::vector<std::vector<int>>;
//绘制地图的类
class Draw
{
public:
	Draw(int&& length, vec2& map) :length(length)
{
	this->level = map;
	this->size = length / level.size();
	initgraph(length, length, EW_SHOWCONSOLE);
}
	~Draw()
{
	closegraph();
}
	enum {
		road=0,//空地
		wall,//墙
		visit,//走过的路
		end,//终点
	};
	//绘制的地图。
	vec2 level;
	//游戏更新
	void updata()
{
	draw();
	test();
}
private:
	int length;				//宽度和高度
	int size;				//每个瓦片的大小
	//绘制地图
	void draw()
{
	BeginBatchDraw();//开始批量画图
	cleardevice();//把之前的先清除
	for (size_t i = 0; i < level.size(); i++)
	{
		for (size_t j = 0; j < level[i].size(); j++)
		{
			if (level[i][j] == road)
			{
				setfillcolor(RGB(0xdd, 0xdd, 0xdd));//设置路的颜色
			}
			else if (level[i][j] == wall)
			{
				setfillcolor(RGB(0x33, 0x33, 0xcc));
			}
			else if (level[i][j] == visit)
			{
				setfillcolor(RGB(0x33, 0xcc, 0x33));
			}
			else if (level[i][j] == end)
			{
				setfillcolor(RGB(0xff, 0x33, 0x33));
			}
			rect(j, i);//绘制瓦片，j代表x，i代表y。
			/*（0，0）----------▷ x的正方向
			      |
				  |
				  |
				  |
				 ▽ y的正方向
			图形库窗口的坐标*/
		}		  
	}		
	EndBatchDraw();
}				 			
	//绘制文本
	void test()
{
	system("cls");//清屏
	std::string str="";
	for (size_t i = 0; i < level.size(); i++)
	{
		for (size_t j = 0; j < level[i].size(); j++)
		{
			if (level[i][j] == road)
			{
				str += "  ";//设置路的标识符
			}
			else if (level[i][j] == wall)
			{
				str += "+ ";//墙
			}
			else if (level[i][j] == visit)
			{
				str += ". ";//走过的路
			}
			else if (level[i][j] == end)
			{
				str += "= ";//终点
			}
		}
		str += '\n';
	}
	std::cout << str << std::endl;
}	
	//绘制瓦片		
	void rect(int x, int y)
{
	fillrectangle(x * size, y * size, (x + 1) * size, (y + 1) * size);
		/* void fillrectangle(
		int left,
		int top,
		int right,
		int bottom
		); */

}
};

Search.h

#pragma once
#include<functional>
#include<vector>
struct Pos
{
	int x;
	int y;
	Pos(int x=0, int y=0) :x(x), y(y) {}
};
class Search
{	
protected:
	using Function = std::function<bool(int, int)>;
public:
	Search(Function fn) :fn(fn) {}
protected:
	
	//通过函数适配器调用外部规则，对数据进行判断；
	Function fn;
	//创建一个vector保存路径
	std::vector<Pos> path;
	//判断这条路是否走过
	bool isVisited(Pos pos)
	{
		for (const auto& e : path)
		{
			if (pos.x == e.x && pos.y == e.y)
			{
				return true;
			}
		}
		return false;
	}
	//判断下次移动是否合法
	bool isValid(Pos pos)
	{
		return fn(pos.x, pos.y) && !isVisited(pos);//fn调用外部规则check
	}
};

DFS.h

#pragma once
#include "Search.h"
//深度优先算法
class DFS : public Search
{
public:
	DFS(std::function<bool(int, int)> fn):Search(fn)//构造子类的时候，需要初始化父类。
{
    
}
	/*start 起点坐标
	  end   终点坐标*/
	//递归法
	std::vector<Pos> recursive(Pos start, Pos end)
{
    this->end = end;
    path.push_back(start);
    _recursive(start);
    return path;
}
	//非递归法（栈实现）
	std::vector<Pos> stack(Pos start, Pos end)
{
    static Pos dir[4] = {
        {0,1},//y+1向下
        {1,0},//x+1向右
        {-1,0},//x-1向左
        {0,-1},//y-1向上
    };
    std::stack<Pos> st;
    st.push(start);
    while (!st.empty())
    {
        auto now = st.top();
        st.pop();
        for (size_t i = 0; i < 4; i++)
        {
            //准备移动的路径
            Pos move(now.x + dir[i].x, now.y + dir[i].y);
            //判断是否能移动
            if (isValid(move))
            {
                st.push(move);
                path.push_back(move);
                //判断是否到达终点
                if (move.x == end.x && move.y == end.y)
                {
                    return path;
                }
            }
        }
    }
    return path;
}
private:
	bool is_end=false;//递归需要的标志位，默认位false
	Pos end;		  //保存终点坐标	
	void _recursive(Pos now)
{
    static Pos dir[4] = {
        {0,1},//y+1向下
        {1,0},//x+1向右
        {-1,0},//x-1向左
        {0,-1},//y-1向上
    };
    //判断是否到达终点
    if (now.x == end.x && now.y == end.y)
    {
        is_end = true;//找到终点标志位置1
        return;
    }
    //循环遍历下右左上4个方向
    for (int i = 0; i < 4; i++)
    {
        //准备移动的路径
        Pos move(now.x + dir[i].x, now.y + dir[i].y);
        //判断能否移动
            if (!is_end && isValid(move))
            {
                path.push_back(move);//保存走过的路径
                _recursive(move);
            }
    }
}
};

BFS.h

#pragma once
#include "Search.h"
class BFS :public Search
{
public:
	BFS(Function fn):Search(fn)
{
}
	std::vector<Pos> queue(Pos start, Pos end)
{
    static Pos dir[4] = {
       {0,1},//y+1向下
       {1,0},//x+1向右
       {-1,0},//x-1向左
       {0,-1},//y-1向上
    };
    std::queue<Pos> qu;
    qu.push(start);
    while (!qu.empty())
    {
        auto now = qu.front();
        qu.pop();
        for (size_t i = 0; i < 4; i++)
        {
            Pos move(now.x + dir[i].x, now.y + dir[i].y);
            if (isValid(move))
            {
                qu.push(move);
                path.push_back(move);
                if (move.x == end.x && move.y == end.y)
                {
                    return path;
                }
            }
        }
    }
    return path;
}
};

测试结果

递归实现：
在这里插入图片描述

深度优先（栈实现）：
在这里插入图片描述

广度优先（队列实现）
在这里插入图片描述

深度优先（栈实现）和广度优先（队列实现）图解

深度优先：
在这里插入图片描述
广度优先：
在这里插入图片描述

哈尔丫
关注
C++入门教程（23）深度优先，广度优先（连连看判断是否可以消除）
CV战士的日常
03-28 1191
最近看一个人实现连连看是否可以消除的核心代码，几分钟就写完了，手痒痒自己写了一遍 需求：实现一个函数，输入两个选中的块，判断是否可以消除 连连看规则，两个相同的块可以消除，但是需要满足以下条件， 两个块的连线上不能有其他块 连线的转折次数不能超过2 最边界的两个块可以绕出地图一个格子去连线 首先是实现连连看的地图，本例使用的是10X10的地图，边界都为0，真是的块只有8X8 int map[MaxLen][MaxHeight] = { 0,0,0,...
C++图遍历算法的实现：深度优先与广度优先
最新发布
**My Coding Family**
03-15 909
🏆本文收录于「编程与技术实战」专栏，此专栏涵盖了C/C++编程、人工智能、数据结构、机器学习等技术领域的内容，助你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
深度优先搜索和广度优先搜索（基础自学）（c++实现）
libertye的博客
11-21 2220
DFS与BFS对比 我们假设一个节点衍生出来的相邻节点平均的个数是N个，那么当起点开始搜索的时候，队列有一个节点，当起点拿出来后，把它相邻的节点放进去，那么队列就有N个节点，当下一层的搜索中再加入元素到队列的时候，节点数达到了N2，你可以想想，一旦N是一个比较大的数的时候，这个树的层次又比较深，那这个队列就得需要很大的内存空间了。 于是广度优先搜索的缺点出来了：在树的层次较深&子节点数较多的情况下，消耗内存十分严重。广度优先搜索适用于节点的子节点数量不多，并且树的层次不会太深的情况。 那么深度优先就
C++：【搜索】深度优先搜索与广度优先搜索
qq_73176808的博客
07-17 3003
简单来说，dfs就是从图的某一个点开始，沿着一条路走到黑，不撞南墙不回头。在走到尽头的时候，再返回搜索下一条路。举个简单的例子：这乍一看好像是一个树，但是其实大部分图都是错综复杂的，树只是一种特殊的图，因为举例子比较方便，所以就先用树状图举例子了。dfs从1号点开始，假设从最左边这条边开始搜索，那么要搜索到末端，也就是：然后就要回头了，那么回到哪里呢？回到离他最近的一个有岔路的点，并从那条岔路一直搜索到末端。也就是：以此类推，直到所有点都被搜索过，也就是出发点的所有出边都被搜索过了。
c++ 优先队列_数据结构与算法系列 - 深度优先和广度优先
weixin_39562327的博客
11-23 261
本文作者：何建辉(公众号：org_yijiaoqian)前言数据结构与算法系列(完成部分)：时间复杂度和空间复杂度分析数组的基本实现和特性链表和跳表的基本实现和特性栈、队列、优先队列、双端队列的实现与特性哈希表、映射、集合的实现与特性树、二叉树、二叉搜索树的实现与特性堆和二叉堆的实现和特性图的实现和特性递归的实现、特性以及思维要点分治、回溯的实现和特性深度优先搜索、广度优先搜索的实现和特性贪心算法...
广度优先搜索和深度优先搜索（c++）
m0_65690223的博客
04-20 2028
深度优先搜索（DFS）：从起点开始，沿着一条路径一直搜索到底，直到找到目标节点或者无法继续搜索为止。DFS一般使用递归或栈来实现。广度优先搜索（BFS）：从起点开始，按照距离逐层向外搜索，直到找到目标节点或搜索完所有节点。BFS一般使用队列来实现。广度优先搜索和深度优先搜索是两种常见的图搜索算法。
有向图深度优先与广度优先算法的C++实现
s1143671457的博客
08-29 859
#include #include #include #include #include using namespace std; void CreateGraph(vector > &Graph) { list tmp; string Content; Content = "V1"; tmp.push_back(Content); Content = "V2";
C++无向图深度优先和广度优先遍历（编译可运行）.rar
07-12
以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 注： 1.代码共182行。 2.代码经过多次编译运行，无错误。
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接矩阵存储和广度、深度优先遍历的方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式...
C/C++实现图的深度优先遍历和广度优先遍历
12-26
C/C++实现图的深度优先遍历和广度优先遍历
深度优先搜索算法和广度优先搜索算法
04-01
数据结构当中深度优先搜索算法和广度优先搜索算法的c语言算法
深度优先搜索算法C++实现
05-24
用C++编写的利用有界深度优先搜索算法解决8数码问题
深度优先搜索c++代码
12-15
最短路径问题是图论研究中的一个经典算法问题，旨在寻找图(由结点和路径组成的)中两结点之间的最短路径。最短路径分析广泛应用于事故抢修、交通指挥、GPS导航等行业应用中。算法具体的形式包括:确定起点的最短路径问题，即已知起始结点，求最短路径的问题。用于解决最短路径问题的算法被称做"最短路径算法"， 有时被简称作"路径算法"。
C++实现树的广度搜索和深度搜索完整代码
05-26
基本的数据结构——树，基本的的搜索算法——深搜和广搜，作为了解数据结构和搜索算法来说比较经典。大家一起学习，哈哈
C++ 图的邻接表表示
ChanJose的博客
03-20 1240
一、实现程序： 1.Graphlnk.h #ifndef Graphlnk_h #define Graphlnk_h #include <iostream> using namespace std; const int DefaultVertices = 30; template <class T, class E> struct Edge { // 边结点的定...
图的深度优先搜索和广度优先搜索算法、最小生成树两种算法 --C++实现
FreeeLinux's blog
08-18 3853
一：通用图结构 #ifndef _GRAPH_H #define _GRAPH_H #include #include #include #include using namespace::std; #define MAX_COST 0x7FFFFFFF //花费无限大设为整型最大值 ///////////////////////////////////////////////
图的深度优先遍历和广度优先遍历(C++实现)
weixin_45801057的博客
03-14 6240
深度优先遍历 理解 从图中某个顶点V出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发，深度优先搜索遍历图，直至图中所有和 V有路径相通且未被访问的的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点做起始点，重复上述过程，直至图中所有的顶点都被访问到。 代码实现(邻接表) #include <iostream> #include <vecto...
广度优先搜索BFS和深度优先搜索DFS查找最短路与最长路(C++实现)
言念君君子的博客
07-31 1936
文章目录1.广度优先搜索 Breadth First Search（BFS）1.图例2.c++实现代码2.深度优先搜索 Depth First Search（DFS）1.图例2.c++实现代码3.BFS与DFS的对比 1.广度优先搜索 Breadth First Search（BFS） 1.图例 举个例子，对于这张图： 我们想要知道从起点到终点最短需要多少步，采用广度优先搜索的方法： 1.将起点入队。 2.将队首元素向四周可拓展的点入队。如果没有可拓展的点，则说明该点是死路，该元素出队。 3.重复上述步
深度优先遍历和广度优先遍历(c++)
Echo_dia的博客
09-16 4246
深度优先遍历 定义：所谓深度优先遍历就是从某个节点出发，通过与其相连接的一个节点向下走，直到无法继续走下去。再遍历其余未走过的节点； 案例说明： 从A点出发，深度遍历结果应为：ABCDEFGHI —— 先沿ABCDEFGH走完第一条路，返回G，所有点都访问了；返回F，所有点都访问了… 直到返回到C点，发现I未被访问，访问I点； 具体代码实现： 图构建一个邻接矩阵 递归版本 刚开始构建一个fla...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值