VS+opencv表示图的深度优先和广度优先遍历算法实现

最新推荐文章于 2023-06-30 18:20:57 发布
最新推荐文章于 2023-06-30 18:20:57 发布
阅读量337 收藏
点赞数
分类专栏： opencv  C语言 文章标签： opencv   C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheZzie/article/details/90378356
版权

题目要求：分别以邻接矩阵和邻接表数据结构来表示和存储一个图（要求同时支持无向图和有向图），分别求解器其深度优先（堆栈）和广度优先（队列）遍历结果，共四个遍历函数（邻接矩阵+深度优先遍历，邻接表+深度优先遍历，邻接矩阵+广度优先遍历，邻接表+广度优先遍历）。在此基础上，借助OpenCV画出原来的图（顶点以数据域中的三个整数数值画相应颜色的圆，边以黑色的线条来表示），以红色的线条来取代黑色的线条表示得到的生成树上的边。

下图为个人数据（仅供参考）:上图为"a.txt"文本的数据，下图为"b.txt"文本的数据
在这里插入图片描述

在这里插入图片描述
下面为个人的代码（已经注释清楚，如果不清楚可以评论私聊）：
代码函数中的12时因为个人数据有12个点，可以在全局中#define N来表示你的数据个数，可以变通 ；

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include "opencv2/imgproc/imgproc.hpp"
#include<core/core.hpp>
#include<highgui/highgui.hpp>
#include "cv.h"  
#include "highgui.h"
using namespace cv;
using namespace std;

struct color
{
	int R;
	int G;
	int B;
}co[12];    //存储各个结点的颜色

struct node
{
	int number;    
	struct node *next;   
}s[12];     //创建邻接表的节点

struct node1
{
	int x;
	int y;

}nd[12];   //各个节点的坐标

int matrix[12][12] = { 0 };      //邻接矩阵
int visited[12] = { 0 };   //判断节点是否被输出
int k = 0;        //统计已记录节点

void readtxt();    //读取全部文本
void drawpicture(Mat image);
void DFSchart(struct node *p,Mat image1);       //邻接表深度搜索遍历
void BFSchart(Mat image1);      //邻接表广度搜索遍历
void DFSmatrix(int i, Mat image1);       //邻接矩阵深度搜索遍历
void BFSmatrix(Mat image1);      //邻接矩阵广度搜索遍历

int main()
{
	Mat image(400, 800, CV_8UC3, Scalar(255, 255, 255));
	Mat image1, image2, image3, image4;
	int i;

	readtxt();
	drawpicture(image);
	namedWindow("lena", 1);
	imshow("lena", image);
	waitKey();
	//邻接表深度搜索遍历
	visited[12] = { 0 }; 
	image1 = image.clone();    //复制原图，下面同理
	for (i = 0; i < 12; i++)    //此处循环是为面对该图为不连通图的情况，如果有多条独立的路径的话，即可通过循环判断所有点是否已经都被搜索了
	{
		k = 1;
			if (visited[i] == 0)
				DFSchart(&s[i],image1);   //对该点进行深度搜索，下同理
			if (k == 12)
				break;
	}
	imshow("lena", image1);
	waitKey();
	imwrite("邻接表深入搜索遍历.jpg", image1);

	//邻接表广度搜索遍历
	for(i = 0; i < 12;i++)    //将各点状态重新调味0，下同理
		visited[i] = 0;
	image2 = image.clone();
	BFSchart(image2);    //进行邻接表广度搜索
	imshow("lena", image2);
	waitKey();
	imwrite("邻接表广度搜索遍历.jpg", image2);

	//邻接矩阵深度搜索遍历
	for (i = 0; i < 12; i++)
		visited[i] = 0;
	image3 = image.clone();
	for (i = 0; i < 12; i++)    //循环与邻接表深度搜索原因一致
	{
		k = 0;
		if (visited[i] == 0)
			DFSmatrix(i, image3);   //深度搜索开始
		if (k == 12)
			break;
	}
	imshow("lena", image3);
	waitKey();
	imwrite("邻接矩阵深度搜索遍历.jpg", image3);

	//邻接矩阵广度搜索遍历
	//大部分道理与邻接表光度搜索道理一致
	for (i = 0; i < 12; i++)
		visited[i] = 0;
	image4= image.clone();
	BFSmatrix(image4);   //广度搜索开始
	imshow("lena", image4);
	waitKey();
	imwrite("邻接矩阵广度搜索遍历.jpg", image4);

	return 0;
}

void readtxt()   //读取2个文本的原始数据来获得各节点颜色和坐标，同时创建邻接矩阵和邻接表
{
	FILE *fp;
	int i, j, row, col;
	struct node *p,*q;
	fp = fopen("a.txt", "r");          //"a.txt"内存储各节点颜色及坐标
	for (i = 0; i < 12; i++)
		fscanf_s(fp, "%d:(%d,%d,%d,%d,%d)",&row, &co[i].R, &co[i].G, &co[i].B, &nd[i].x, &nd[i].y);       //读取各节点颜色和坐标
	fclose(fp);
	fp = fopen("b.txt", "r");         //"b.txt"存储各条路
	while (!feof(fp))
	{
		fscanf_s(fp, "(%d,%d)\n", &row, &col);           //row为起点，col为路的终点
		matrix[row][col] = 1;       //将此路用矩阵表示
	}
	fclose(fp);
	for (i = 0; i < 12; i++)
	{
		s[i].number = i;
		p = &s[i];
		//通过矩阵0.1属性来创建各个结点的邻接表
		for (j = 0; j < 12; j++)
		{
			if (matrix[i][j] == 1)     //如果二维矩阵此处为1，则代表i的邻接表内有j
			{
				q = (struct node *)malloc(sizeof(struct node));      
				q->number = j;
				p->next = q;
				p = q;
			}
		}
		p->next = NULL;
	}
}        

void drawpicture(Mat image)    //通过颜色及坐标及各点连接关系画出原图
{
	int i;
	char zm[3];
	zm[1] = '\0';
	zm[2] = '\0';
	struct node *p, *q;
	for (i = 0; i < 12; i++)
	{
		zm[0] = '0' + i;     //zm数组用于putText函数用于在图片上输出文本
		if (i > 9)
		{
			zm[0] = i / 10+'0';
			zm[1] = i % 10 + '0';
		}
		circle(image, Point(nd[i].x, nd[i].y), 20, Scalar(co[i].B, co[i].G, co[i].R), -1);      //画出各节点
		putText(image, zm, Point(nd[i].x, nd[i].y), FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(255, 2, 2));     //在圆上标记此点的值
	}
	for (i = 0; i < 12; i++)
	{
		p = &s[i];
		while (p->next!= NULL)
		{
			line(image, Point(nd[i].x, nd[i].y), Point(nd[p->next->number].x, nd[p->next->number].y), Scalar(0, 0, 0));   //在图上连接有关系的结点，即为路径
			p = p->next;
		}
	}
}

void DFSchart(struct node *p,Mat image1)         //邻接表深度搜索遍历
{
	visited[0] = 1;
	struct node *q=p->next;
	while (q != NULL)
	{
		if (visited[q->number] == 0)   //如果该点未被搜索到的话，就对其进行操作搜索
		{
			visited[q->number] = 1;
			k += 1;
			line(image1, Point(nd[p->number].x, nd[p->number].y), Point(nd[q->number].x, nd[q->number].y), Scalar(0, 0, 255));   //将该条搜索经过的路径改为红色
			if (k == 12)        //如果已经搜完所有结点，就直接return退出函数循环
				return;
			DFSchart(&s[q->number],image1);     //通过递归对该点进行深度搜索
		}
		q = q->next;
	}

}  //

void BFSchart(Mat image1)         //邻接表广度搜索遍历
{
	int b[12];
	int i=0, j=0,z;
	struct node *p,*q;
	b[0] = 0;
	for (z = 0; z < 12; z++)    //此处循环用以面对出现多条独立路径的情况
	{
		if (visited[z] == 0)
		{
			b[j] = z;
			j++;
			for (i; i < j; i++)   //此处用循环不用堆栈的原因是因为每次搜索新的一个点时，j都会大于i，j可以当作堆栈的尾，i可以当作堆栈的头，对我而言可以等效使用，因为循环用惯了，此处可以多看几遍理解一下，不是很困难
			{
				visited[b[i]] = 1;   //将搜索过的点状态调为1
				p = &s[i];
				q = p->next;
				while (q != NULL)
				{
					if (visited[q->number] == 0)    //如果此点未被搜索过，则对其进行操作
					{
						visited[q->number] = 1;
						b[j] = q->number;   //将搜索点加入b数组，可以当作正常使用的栈
						j += 1;
						line(image1, Point(nd[p->number].x, nd[p->number].y), Point(nd[q->number].x, nd[q->number].y), Scalar(0, 0, 255));   //将搜索过的路径描红
					}
					q = q->next;
				}
			}
		}
		if (j == 12)   //如果j等于点的总数时则代表已经搜索完全可以退出函数了
			return;
	}

}

void DFSmatrix(int i, Mat image1)    //邻接矩阵深度搜索遍历
{
	visited[i] = 1;
	k += 1;
	int j;
	if (k == 12)    //如果已经搜完所有结点，就直接return退出函数循环
		return;
	for (j = 0; j < 12; j++)
	{
		if (matrix[i][j] == 1)   //矩阵值为1时则代表i，j两点有路即可进行搜索判断
		{
			if (visited[j] == 0)       //如果该点未被搜索到的话，就对其进行操作搜索
			{
				line(image1, Point(nd[i].x, nd[i].y), Point(nd[j].x, nd[j].y), Scalar(0, 0, 255));       //将该条搜索经过的路径改为红色
				DFSmatrix(j, image1);         //通过递归对该点进行深度搜索
				if (k == 12)    //如果已经搜完所有结点，就直接return退出函数循环
					return;
			}
		}
	}
}

void BFSmatrix(Mat image1)      //邻接矩阵广度搜索遍历
{
	int b[12];
	int i = 0, j = 0, z,i1;

	for (z = 0; z < 12; z++)     //此处循环用以面对出现多条独立路径的情况
	{
		if (visited[z] == 0)
		{
			b[j] = z;
			j++;
			for (i; i < j; i++)         //此处循环与上面广度搜索不用真正的堆栈同理
			{
				visited[b[i]] = 1;      //此处用于帮起始点状态改变
				for (i1 = 0; i1 < 12; i1++)       
				{
					if (matrix[b[i]][i1] == 1)
					{
						if (visited[i1] == 0)       //如果此点未被搜索过，则对其进行操作
						{
							visited[i1] = 1;
							b[j] = i1;        //将搜索点加入b数组，可以当作正常使用的栈
							j++;
							line(image1, Point(nd[b[i]].x, nd[b[i]].y), Point(nd[i1].x, nd[i1].y), Scalar(0, 0, 255));      //将搜索过的路径描红
						}
					}
				}
				if (j == 12)         //如果j等于点的总数时则代表已经搜索完全可以退出函数了
					return;

			}


		}
	}
}
The Zzie
关注
专栏目录
C++构造无向图，邻接矩阵，深度优先遍历，广度优先遍历
qq_44757691的博客
12-14 6087
define MVNum 100 //最大顶点数//定义无向图邻接矩阵{//顶点表//邻接矩阵//图的当前定点数和边数};
733.图像渲染（深度优先遍历）
qq_42199845的博客
01-17 181
力扣733
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
图（二）---------图的深度优先遍历算法和广度优先遍历算法
SmilingCobra
05-16 1196
今天我来介绍一些图的深度优先遍历算法和广度优先遍历算法。在展示我的代码之前我想先对这两种算法进行一些讲述首先是深度优先遍历算法。大家来看这个图，深度优先遍历就是以一个顶点为起点，找到它的第一个邻接顶点并将这个顶点设置为已经访问过的，然后递归之前的方法，直到所有的顶点的第一个邻接点都被访问过了。然后向上回溯，查找其他的邻接顶点重复之前的方法查找其他的邻接顶点的第一个邻接顶点是否被访问。以我这个图为例...
图的深度优先和广度优先遍历算法
有梦不难
08-08 240
1.说明 图的广度优先算法，需要一个队列来记录节点的访问顺序 2.代码实现 1.图 package Graph; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; public class Graph { private ArrayList<String> VertexList; // 顶点的集合 private int[][] Edges_Relation;
图的实现及其深度优先、广度优先遍历
makerjack001的博客
11-03 391
图 图的概念我就不赘述了传送门讲的比我清楚 代码也很简单 int visited[10] = { 0 };//这个是为了之后访问时候用的，存储访问信息容器 class MGraph { private: int vertex[10]; int arc[10][10] = { 0 }; int vertexnum, arcnum; public: MGraph(int a[], int n, int e); ~MGraph() {}; void DFSTraverse(int v); void
深度优先搜索算法（DFS）详解及与广度优先搜索算法（BFS）的比较
lemonxiaoxiao的博客
09-19 1457
参考：http://data.biancheng.net/view/39.html 一、深度优先搜索算法概述 深度优先搜索属于图算法的一种，英文缩写为DFS（Depth First Search）。 深度优先搜索的过程类似于树的先序遍历，首先从例子中体会深度优先搜索。 例如图 1 是一个无向图，采用深度优先算法遍历这个图的过程为： 图1 （1）首先任意找一个未被遍历过的顶点，例如从 V1 开始，由于 V1 率先访问过了，所以，需要标记 V.
用opencv+vs2013做的迷宫求解程序，能自动标记迷宫的最佳路线，附图。opencv的环境需自己配置
11-11
在迷宫求解算法中，通常会采用深度优先搜索（DFS）或广度优先搜索（BFS）。DFS是一种递归策略，从起点开始，尽可能深地探索迷宫的分支，直到找到一条路径或者所有可能的路径都被尝试过。BFS则是利用队列数据结构，先...
C# OpenCvSharp 实现迷宫解密.rar
最新发布
10-07
4. **路径搜索算法**：迷宫解密的核心是实现一种路径搜索算法，如深度优先搜索(DFS)、广度优先搜索(BFS)或A*算法。这些算法通过递归或队列数据结构遍历所有可能的路径，寻找从起点到终点的解决方案。 5. **坐标转换...
DBSCAN聚类算法C++代码实现
03-22
在C++实现中，可以使用STL库（如`std::vector`，`std::unordered_set`等）来存储点和邻接关系，利用`std::pair`表示点和其邻居，使用`std::queue`或`std::stack`进行广度优先搜索或深度优先搜索。测试数据和输出结果...
暑假训练总结
sdau20163940的博客
08-25 290
转眼之间，暑假一个月的时间就飞逝了。其实回过头来，你会发现时间过得真的很快，时间是抓不住的，关键是你如何利用时间，使有限的时间发挥最大的效率，提高时间的利用率。回过头，总结一下一个暑假的工作成果，其实也是一种收获。 首先，一进入假期我们就把精力投入到了DP上面，DP在ACM中非常重要的，同时又是竞赛中的难点，因为该算法时间效率高，代码量少，多元性很强，主要考察自己的思维能力和建模的抽象能力以及自
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_图的遍历-深度优先和广度优先...
weixin_39536630的博客
11-22 4041
0.深度优先遍历图的遍历：就是依次访问所有的结点，且不能重复访问某个结点，且要避免死循环，所以应该把访问过的结点加上标记。1.邻接矩阵深度优先遍历所以上图中，以结点的右手原则遍历得到以下结果：右手原则遍历但是还没有访问到所有的结点，所以现在应该原路返回如果遇到还没有访问过的结点，则继续访问，比如I结点：遇到I结点还没有访问过，就访问I结点在邻接矩阵实现深度优先遍历顶点数组其邻接矩阵为：邻接矩阵深度...
玩转图论算法（2）图的深度优先遍历【Java实现】
mike_jun的博客
04-24 718
3-1 图的两种形式遍历 所谓图的遍历（graph traversal），也称为搜索（search），就是从图中某个顶点出发，沿着一些边访遍图中所有的顶点，且使 每个顶点仅被访问一次。遍历可以采取两种方法进行：深度优先搜索（DFS，depth first search） 和广度优先搜索（BFS，breadth first search）。 3-2 图的深度优先...
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_数据结构与算法学习笔记：图...
weixin_39663378的博客
11-21 1931
图：图结构区别于线性结构和树型结构，区别可见下图逻辑上的图(graph)结构由顶点(vertex)和边(edge)组成。一个图结构G包含顶点集合V和边集合E，任何两个顶点之间可以有一个边表示两者的关系。对于一个存在的G，V不可以为空集，E可以为空集。左中右分别都是图结构与图相关的概念：有向图：边都具有方向的图结构就是有向图结构。边的方向表示访问的方向。有向无环图：对于一个有向图，如果对于任意一个节...
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_数据结构–图（深度优先遍历和广度优先遍历）（Java）...
weixin_39823459的博客
11-22 2045
数据结构–图（深度优先遍历和广度优先遍历）（Java） 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ 图的常用概念 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。 顶点(vertex) 边(edge) 路径 无向图 有向图 带权图 图的表示方式 图的表...
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_从零开始学习数据结构>图的遍历...
weixin_39812577的博客
11-21 1405
图的存储结构：邻接矩阵、邻接表，那么对于不同的存储结构必然存在着不同的访问方式，拿到具体数据的过程就是图的遍历。1、遍历图的遍历与树的很相似，遍历满足：(1)、对每一个顶点都得进行一次访问；(2)、对其不能进行重复的访问，只能是一次；对上次的一个补充: 当父类是模板类时，子类继承后，要是想调用父类的方法/数据，必须加上模板的作用域限定符，例 : Grapth::maxVertices;方...
邻接表按深度优先遍历和按广度优先遍历的序列
naozibuok的博客
06-30 3735
深度优先：按深度优先遍历时会有类似"跳转"的操作，比如例1中顶点v1→边v2后，会直接跳转到顶点v2去，再重新从顶点v2→边v1，由于v1访问过，所以变为v2→边v5，再跳转到顶点v5去，直到每个顶点都被访问过。抽象理解为"跳转"，实际上是递归。那么例1按深度优先遍历的序列如下：广度优先：按广度优先遍历实际上就是一条路走到黑， 比如例1中顶点v1→边v2→边v3→边v4，此时，再从顶点v2开始，顶点v2→边v1(访问过)→边v5，再从顶点v3开始，再从顶点v4开始......直到每个顶点都被访问过。实际上里
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_C语言：数据结构-图的广度优先搜索遍历...
weixin_39982537的博客
11-24 1589
广度优先搜索遍历(1)广度优先搜索遍历的定义广度优先搜索遍历类似于树的按层遍历，其遍历过程如下：1.访问初始点vi，并将其标记已访问过，访问vi的所有未被访问过的邻接点(次序可任意)，假定依次为vi1、vi2、…、vit，并均标记已访问过。2.然后按邻接点访问的先后次序，依次访问V11,V22,……Vit所有未被访问的邻接点，直至所有顶点访问完。 (2)广度优先搜索遍历的过程下面结合图7-10所示...
深度优先遍历和广度优先遍历_漫画算法：深度优先遍历 和 广度优先遍历
weixin_39997311的博客
11-23 265
专注于Java领域优质技术，欢迎关注来自： 程序员小灰————— 第二天 —————————————————什么是 深度/广度 优先遍历？深度优先遍历简称DFS(Depth First Search)，广度优先遍历简称BFS(Breadth First Search)，它们是遍历图当中所有顶点的两种方式。这两种遍历方式有什么不同呢？我们来举个栗子：我们来到一个游乐场，游乐场里有11个景点。我们从景...
Python+OpenCV实现批量图片水平翻转
在本文档中，我们将探讨如何使用Python和OpenCV库实现批量图片镜像的功能。OpenCV是一个强大的计算机视觉库，常用于图像处理和计算机视觉应用，而Python作为其主要的编程接口，提供了丰富的工具来简化操作。在这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值