个人笔记--图的构造及DFS和BFS遍历

最新推荐文章于 2023-02-07 23:01:11 发布
最新推荐文章于 2023-02-07 23:01:11 发布
阅读量369 收藏 2
点赞数 1
分类专栏： 数据结构实验 文章标签： 图论 bfs dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzh4792/article/details/111348072
版权

图的构造和两种遍历（DFS和BFS）

图的构造函数

Status LocateVex(MGraph G,VertexType u)//访问无向网图中该顶点所在位置
{
	int i;
	for(i=1;i<=G.vexnum;++i)
		if(G.vexs[i]==u)
			return i;
	return 0;
}
void CreateUDN(MGraph &G)//创建无向网图
{
	int i,j,k,w;
	VertexType v1,v2;
	char tmp;
	cout<<"请输入顶点数,边数和信息（无信息则输入0）"<<endl;
	cin>>G.vexnum>>G.arcnum>>G.IncInfo;
	cout<<"请输入这"<<G.vexnum<<"个顶点编号:";
	for(i=1;i<=G.vexnum;++i)
		cin>>G.vexs[i];
	for(i=1;i<=G.vexnum;++i)
	{
		for(j=1;j<=G.vexnum;++j)
			G.arcs[i][j].adj=0;
	}
	cout<<"请输入这"<<G.arcnum<<"条边:";	
	for(k=1;k<=G.arcnum;++k)
	{
		cin>>v1>>v2;
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		G.arcs[i][j].adj=1;
		if(G.IncInfo)
			cin>>G.arcs[i][j].info;
		G.arcs[j][i]=G.arcs[i][j];
	}
}

int FirstAdjVex(MGraph G,VertexType v)//访问v后的第一个连通结点
{
	int k,j,t;
	k=LocateVex(G,v);
	if(k)
	{
		t=INFINITY;
		for(j=1;j<=G.vexnum;j++)
			if(G.arcs[k][j].adj!=t)
				return j;
	}
	return 0;
}

int NextAdjVex(MGraph G,VertexType v,VertexType w)//访问v后的相对于w的第一个连通结点
{
	int k1,k2,j,t;
	k1=LocateVex(G,v);
	k2=LocateVex(G,w);
	if(k1 && k2)
	{
		t=INFINITY;
		for(j=k2+1;j<=G.vexnum;j++)
		{
			if(G.arcs[k1][j].adj!=t)
				return j;
		}
	}
	return 0;
}

void ShowMGraph(MGraph &G){//输出邻接矩阵
    for(int i=1;i<=G.vexnum;++i){
        for(int j=1;j<=G.vexnum;++j){
            cout<<G.arcs[i][j].adj<<" ";
        }
        cout<<endl;
    }
}

DFS（递归思想）

void DFS(MGraph G,int v)
{
	int w;
	visited[v]=TRUE;
	VisitFunc(G.vexs[v]);
	for(w=FirstAdjVex(G,G.vexs[v]);w;w=NextAdjVex(G,G.vexs[v],G.vexs[w]))
		if(!visited[w])
			DFS(G,w);		

}
void DFSTraverse(MGraph G,void(Visit)(VertexType))
{
	int v;
	VisitFunc=Visit;
	for(v=1;v<=G.vexnum;v++)//初始化
		visited[v]=FALSE;
	for(v=1;v<=G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);
}

BFS（借助队列）

void BFSTraverse(MGraph G,void(Visit)(VertexType))
{
	int v,w;
	LinkQueue q;
	QElemType e;
	for(v=1;v<=G.vexnum;v++)//初始化
		visited[v]=FALSE;
	InitQueue(q);
	
	for(v=1;v<=G.vexnum;v++)
	{
		if(!visited[v])
		{
			visited[v]=TRUE;
			Visit(G.vexs[v]);
			InsertQueue(q,v);
			while(!EmptyQueue(q))
			{
				DeleteQueue(q,e);
				for(w=FirstAdjVex(G,G.vexs[e]);w;w=NextAdjVex(G,G.vexs[e],G.vexs[w]))
				{
					if(!visited[w])
					{
						visited[w]=TRUE;
						Visit(G.vexs[w]);
						InsertQueue(q,w);
					}
				}
			}
		}
	}
}

完整代码：

#include<bits/stdc++.h>
using namespace std;
#define MAX 101
#define INF 0x3f3f3f3f
#define Listsize 100
#define INFINITY	INT_MAX
#define MAX_VERTEX_NUM	20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef char InfoType;
typedef int VRType;
typedef char VertexType;

typedef int QElemType;
typedef struct QNode{
	QElemType      data;
	struct QNode  *next;
}QNode, *QueuePtr;

typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

typedef struct ArcCell{
	VRType	adj;
	InfoType	* info;
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct{
	VertexType	vexs[MAX_VERTEX_NUM];
	AdjMatrix	arcs;
	int	vexnum,arcnum;
	int IncInfo;
}MGraph;
MGraph G;
Status visited[MAX_VERTEX_NUM+1];
void (*VisitFunc)(VertexType e);

Status InitQueue(LinkQueue &q)
{
    q.front=q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!q.front )
        exit(OVERFLOW);
    q.front->next=NULL;
    return OK;
}

Status DestroyQueue(LinkQueue &q){
    while(q.front){
        q.rear=q.front->next;
        free(q.front);
        q.front=q.rear;
    }
    return OK;
}

Status ClearQueue(LinkQueue &q)
{
	QueuePtr p1,p2;
	q.rear=q.front;
	p1=q.front->next;
	q.front->next=NULL;
	while(p1)
	{
		p2=p1;
		p1=p1->next;
		free(p2);	
 }
	return OK;
}

Status InsertQueue(LinkQueue &q,QElemType e){
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)
        exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    q.rear->next=p;
    q.rear=p;
    return OK;
}

Status DeleteQueue(LinkQueue &q,QElemType &e){
    QueuePtr p;
    if(q.front==q.rear)
        return ERROR;
    p=q.front->next;
    e=p->data;
    q.front->next=p->next;
    if(q.rear==p)
        q.rear=q.front;
    free(p);
    return OK;
}

Status EmptyQueue(LinkQueue &q)
{
	if(q.front->next==NULL)
		return 1;
	else
		return 0;
}

Status LengthQueue(LinkQueue &q)
{
	int len=0;
	QueuePtr p=q.front;
	while(q.rear!=p)
	{
		len++;
		p=p->next;
	}
	return len;
}

Status GetHead(LinkQueue q,QElemType &e)
{
		QueuePtr p;
		if(q.front==q.rear)
			return ERROR;
		p=q.front->next;
		e=p->data;
		return OK;
}

Status LocateVex(MGraph G,VertexType u)
{
	int i;
	for(i=1;i<=G.vexnum;++i)
		if(G.vexs[i]==u)
			return i;
	return 0;
}
void CreateUDN(MGraph &G)
{
	int i,j,k,w;
	VertexType v1,v2;
	char tmp;
	cout<<"请输入顶点数,边数和信息（无信息则输入0）"<<endl;
	cin>>G.vexnum>>G.arcnum>>G.IncInfo;
	cout<<"请输入这"<<G.vexnum<<"个顶点编号:";
	for(i=1;i<=G.vexnum;++i)
		cin>>G.vexs[i];
	for(i=1;i<=G.vexnum;++i)
	{
		for(j=1;j<=G.vexnum;++j)
			G.arcs[i][j].adj=0;
	}
	cout<<"请输入这"<<G.arcnum<<"条边:";	
	for(k=1;k<=G.arcnum;++k)
	{
		cin>>v1>>v2;
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		G.arcs[i][j].adj=1;
		if(G.IncInfo)
			cin>>G.arcs[i][j].info;
		G.arcs[j][i]=G.arcs[i][j];
	}
}

int FirstAdjVex(MGraph G,VertexType v)
{
	int k,j,t;
	k=LocateVex(G,v);
	if(k)
	{
		t=INFINITY;
		for(j=1;j<=G.vexnum;j++)
			if(G.arcs[k][j].adj!=t)
				return j;
	}
	return 0;
}

int NextAdjVex(MGraph G,VertexType v,VertexType w)
{
	int k1,k2,j,t;
	k1=LocateVex(G,v);
	k2=LocateVex(G,w);
	if(k1 && k2)
	{
		t=INFINITY;
		for(j=k2+1;j<=G.vexnum;j++)
		{
			if(G.arcs[k1][j].adj!=t)
				return j;
		}
	}
	return 0;
}

void ShowMGraph(MGraph &G){
    for(int i=1;i<=G.vexnum;++i){
        for(int j=1;j<=G.vexnum;++j){
            cout<<G.arcs[i][j].adj<<" ";
        }
        cout<<endl;
    }
}
void PrintElem(char c)
{
	cout<<c<<' ';
}
void DFS(MGraph G,int v)
{
	int w;
	visited[v]=TRUE;
	VisitFunc(G.vexs[v]);
	for(w=FirstAdjVex(G,G.vexs[v]);w;w=NextAdjVex(G,G.vexs[v],G.vexs[w]))
		if(!visited[w])
			DFS(G,w);		

}
void DFSTraverse(MGraph G,void(Visit)(VertexType))
{
	int v;
	VisitFunc=Visit;
	for(v=1;v<=G.vexnum;v++)
		visited[v]=FALSE;
	for(v=1;v<=G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);
}


void BFSTraverse(MGraph G,void(Visit)(VertexType))
{
	int v,w;
	LinkQueue q;
	QElemType e;
	for(v=1;v<=G.vexnum;v++)
		visited[v]=FALSE;
	InitQueue(q);
	
	for(v=1;v<=G.vexnum;v++)
	{
		if(!visited[v])
		{
			visited[v]=TRUE;
			Visit(G.vexs[v]);
			InsertQueue(q,v);
			while(!EmptyQueue(q))
			{
				DeleteQueue(q,e);
				for(w=FirstAdjVex(G,G.vexs[e]);w;w=NextAdjVex(G,G.vexs[e],G.vexs[w]))
				{
					if(!visited[w])
					{
						visited[w]=TRUE;
						Visit(G.vexs[w]);
						InsertQueue(q,w);
					}
				}
			}
		}
	}
}
void menu()
{
	cout<<"***********************************"<<endl;
	cout<<"************无向网图***************"<<endl;
	cout<<"***********************************"<<endl;
	cout<<"********   1.构建网图       *******"<<endl;
	cout<<"********   2.输出邻接矩阵   *******"<<endl;
	cout<<"********   3.深度优先遍历   *******"<<endl;
	cout<<"********   4.广度优先遍历   *******"<<endl;
	cout<<"********   5.退出           *******"<<endl;
	cout<<"***********************************"<<endl;
}

int main()
{
	int v,e;
	menu();
	int order;
	do
	{
		cout<<"请输入选择： " ;
		cin>>order;
		switch(order)
		{
			case 1:
				v=0,e=0;
				CreateUDN(G);
				cout<<"创建成功"<<endl;
				break;
			case 2:
				cout<<"邻接矩阵为："<<endl;
				ShowMGraph(G);
				break;
			case 3:
				cout<<"深度优先遍历为：";
				DFSTraverse(G,PrintElem);
				cout<<endl;
				break;
			case 4:
				cout<<"广度优先遍历为：";
				BFSTraverse(G,PrintElem);
				cout<<endl;
				break;
			case 5:
				cout<<"程序已退出"<<endl;
				break;
			default:
				cout<<"输入指令错误"<<endl;
				break;
		}	
	}while(order!=5);
	return 0;
}

如图：
在这里插入图片描述
邻接矩阵为
0 1 0 0 0 1
1 0 1 1 0 0
0 1 0 1 1 0
0 1 1 0 1 0
0 0 1 1 0 1
1 0 0 0 1 0

在这里插入图片描述
在这里插入图片描述
并非最终版本，如有错误，请指出

Henu_敖丙
关注
专栏目录
(王道408考研数据结构)第六章图-第三节：图的遍历(DFS和BFS)
快乐江湖的博客
11-24 1955
文章目录一：图的深度优先遍历(DFS)（1）回溯算法和DFSA：回溯算法的本质B：回溯算法的框架C：全排列（2）图的DFSA：DFS思想B：动画演示C：代码二：图的广度优先遍历(BFS) 一：图的深度优先遍历(DFS) （1）回溯算法和DFS 图的深度优先遍历其本质就是回溯算法，所以这里我们先介绍回溯算法 原创声明 本人在学习回溯算法时也感觉比较困惑，但是有幸看到一本非常好的算法书籍，也算是解决了我很多疑惑，我发现有些东西不是我智商不够，而是缺乏训练，尤其是有目的，有逻辑的训练。 本文皆是我在阅读它的书后所
理解数据结构——图的DFS和BFS
weixin_44522586的博客
11-03 4571
理解数据结构——图的DFS和BFS 在图算法和搜索算法中，dfs和bfs是常见的两种遍历方式。且二者常常千变万化，出现于各类题型，如最短路径、树形dp中，那么我们该如何理解这两种算法思想呢。 1.DFS 深度优先搜索 顾名思义，即当我们对某个树or图进行搜索时，一条道走到黑，“不撞南墙不回头”。dfs总是沿着某个最深的方向来进行搜索，直到无路可走。 假设有下面这么一个树形结构（此处用树型结构，是为...
图的BFS遍历和DFS遍历（广度优先和深度优先）
一个吃水不忘挖井人的博客。希望能帮助到你
02-17 478
遍历使用链表构成的图点击打开链接这样一张图修改了原理的Graph类方便添加节点和权值public class Graph { public HashMap&lt;Integer,Node&gt; nodes;//所有的节点，和节点编号。 public HashSet&lt;Edge&gt; edges;//所有的边 public Graph() { nodes = new HashMa...
图的创建和遍历(BFS/DFS)
06-23 194
图的表示方法主要有邻接矩阵和邻接表。其中邻接表最为常用，因此这里便以邻接表为例介绍一下图的创建及遍历方法。 创建图用到的结构有两种：顶点及弧 struct ArcNode { int vertexIndex; //该弧指向的顶点位置 struct ArcNode* next; //...
数据结构—图的遍历（BFS、DFS）
m0_51769031的博客
06-18 1033
图的遍历算法可以用来判断图的连通性。对于无向图来说，访问图中所有顶点所需调用BFS/DFS的次数就是连通分量数。但是对于有向图来说，具体问题需要具体分析，对于强连通图，只需调用一次，但是对于非强连通图就要具体分析。 图的广度优先遍历算法思想和二叉树的层次遍历算法思想几乎是相同的，需要一个辅助队列实现。 时间复杂度：邻接表：O(|V|+|E|)；邻接矩阵：O(|V|^2)；空间复杂度为：O(|V|)；主要来自于辅助队列由广度优先遍历得到的遍历树称为：广度优先遍生成树。对于非连通图的广度优先遍历可得到广度优
图的遍历 —— DFS、BFS
一个很懒的人
08-29 5328
0.概要 本文主要从以下三个方面介绍图的遍历： 图的广度优先遍历（BFS） 图的深度优先遍历（DFS） 两种遍历一般性实现代码（C++） 1.图的广度优先遍历（BFS） （1）树 (层次遍历) VS 图 (BFS——广度优先遍历) （2）算法要点——BFS 连通图 非连通图 （3）遍历序列可变性 （4）空间复杂度 （5）时间复杂度 （6）广度优先生成树 对⾮连通图的⼴度优先遍历，可得到⼴度优先⽣成森林 1.图的广度优先遍历（BFS） （1）算法要点 （2）遍历序列可.
图的基本介绍与创建 dfs与bfs遍历
Azadoo的博客
05-17 294
为什么要有图 1)线性表局限于一个直接前驱和一个直接后继的关系 2)树也只能有一个直接前驱也就是父节点 3)当我们 需要表示多对多的关系时，这里我们就用到了图 图的举例说明 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结占也可以称为顶点。如图。 图的常用概念 1)顶点(vertex) 2)边(edge) 3) 路径 4)无向图(右图) 无向图:顶点之间的连接没有方向，比如A-B,即可以是A->B也可以B->A. 路径:比如从D-> C的路径有 D-
DFS和BFS笔记
01-20
如上图所示，我们选取A点为父结点，则接下来应当遍历与A节点直接相邻的B, C节点，我们按顺序将节点记录在python列表中：[A, B, C]（注：假设先看的B节点），至此A节点处理完毕，我们按顺序处理B节点，发现B节点直接...
【数据结构笔记21】图的遍历，DFS与BFS，连通图
记录学习痕迹的公众号：Piper蛋窝
10-14 644
图的最基本操作思想。
图知识点整理(创建与DFS，BFS)
weixin_44267007的博客
08-11 225
图 ​ 在线性表中，数据元素之间是被串起来的，仅有线性关系，每个数据元素只有一个直接前驱和直接后继。在树形结构中，数据元素之间有着明显的层次关系，并且每一层上的数据元素可能和下一层中多个元素相关，单只能和上一层中一个元素相关，这个一对父母可以有多个孩子，但是每个孩子只能由一对父母相对应。 ​ 但是在处理复杂关系的时候，例如人与人之间的关系，这个并不能简单的使用一对一或一对多的形式来进行表示，而是要考虑多对多的一些情况。故这里引入图结构。 文章目录图图的定义图的存储结构邻接矩阵邻接表图的遍历深度优先遍历DFS
图的创建、DFS和BFS
weixin_53754024的博客
05-08 485
图的基本概念 1.图是一种数据结构，其中结点可以具有零个或者多个相邻的元素，两个结点之间的连接称为边。结点可以称为顶点。 2. 顶点： 边： 路径： 3.无向图： 有向图： 带权图： 4.图的两种表示方式：一个是二维数组来表示（邻接矩阵）；另一种即链表表示（邻接表）。 邻接矩阵：1表示两个顶点之间是连通的；0表示两个顶点之间不可以连通。（自己规定的） 缺点：需要为每一个顶点分配n个边的空间，二很多边是不存在的，造成空间的浪费。 邻接表：只关心存在的边，因此没有空间的浪费，邻接表是由
图的概念和构造方法（Java）
TYPFOON的博客
03-20 697
图 一、基本概念： 图中的节点可以有0个或多个前驱和后继节点（相邻元素）， 两个节点之间的连线称为边，节点也可以成为顶点。 二、基本属性： 顶点、边、路径、无向图 有向图、带权图 三、表示方式： 邻接矩阵（用数组写） 表示图形中顶点之间相邻关系的矩阵。 邻接表（大多数情况直接用链表写，也可以用链表和数组写） 对比邻接矩阵（每个节点都要分配n条边的空间），邻接表只关心存在的边...
图示构造函数的析构顺序（默认构造函数、拷贝构造函数和赋值运算符重载函数）
乐行僧的博客
05-29 474
示例代码： #include&lt;iostream&gt; using namespace std; class Test { public: Test(int a=10,int b=20) { _a = a; _b = b; cout &lt;&lt; this &lt;&lt; " "; cout &lt...
数据结构:图的代码
weixin_34387468的博客
08-26 260
直接上代码：代码里面有注释#pragmaonce #include<assert.h> #include<queue> #include"Heap.hpp" #include"UnionFindSet.hpp" // //临接矩阵表示无向图&有向图 // template<classV,classW> cla...
构造函数原型图
HWSss的博客
10-29 321
用C语言代码实现图的建立
最新发布
weixin_42598278的博客
02-07 94
如果你想用 C 语言来建立图的话，需要使用图的存储结构。 常见的存储结构有邻接矩阵和邻接表。 邻接矩阵是用一个二维数组来存储图的结构的方法。例如，对于一张有 5 个结点的无向图，可以使用如下的代码来存储： #define MaxSize 100 typedef char VertexType; typedef int EdgeType; typedef struct { VertexTy...
图的存储、构造、遍历、应用（代码+注释+图片说明）
bigBbug的博客
01-24 854
图的存储（邻接矩阵、邻接表）、构造、遍历（BFS、DFS）、应用（最小生成树Prim-Kruscal、最短路径BFS-Dijkstra-Floyd、拓扑排序、关键路径）
【数据结构-图】1.图的构造和遍历（基本理论+代码）
为了远大的理想，冲锋！
02-01 4348
一、图的基本概念 **图：**图G是一个有序二元组(V,E)，其中V称为顶集(Vertices Set)，E称为边集(Edges set)，E与V不相交。它们亦可写成V(G)和E(G)。其中，顶集的元素被称为顶点(Vertex)，边集的元素被称为边(edge)。 有向图： 若E是有向边（也称弧）的有限集合时，则图G为有向图。弧是顶点的有序对，记为 <v,w><v,w><v,w> ，称为从顶点v到顶点w的弧。如上图中（a）：G1=(V1,E1)∣∣V1={1,2,3}∣∣
深度优先搜索DFS代码实现
guangjie2333的博客
01-21 446
Init.h文件 #ifndef INIT #include<stdio.h> #include<stdlib.h> constexpr auto MaxVertexNum = 100; typedef int Ver; //顶点下标 typedef int WeigthType; //边的权值 typedef int DataType; //顶点的数据类型 /...
C++与数据结构复习笔记：面试必备
接着，讨论了二叉树的基本概念，包括哈夫曼树的构建和广度优先搜索(BFS)和深度优先搜索(DFS)这两种在树和图遍历中的重要算法。此外，还涉及了图的相关内容，比如Dijkstra算法，这是一个用于求解单源最短路径问题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值