图的基本操作（邻接矩阵）

已于 2023-02-20 16:34:39 修改
阅读量1k 收藏 7
点赞数 4
文章标签： 算法 图论 c++
于 2023-02-16 16:45:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63343322/article/details/129063399
版权

图是比较常用的一种数据结构，我针对期末考试对其进行了大概整理，形成了本文。

声明

#include<iostream>
#include<fstream>
#include<queue>
#include<stack>
using namespace std;
#define MAX_V 20 // 最大顶点数目
#define READMODE 2//文件内容格式，1是完整的矩阵，2是读入边
typedef char ElemType;//元素类型
typedef int GraphKind;//图形类型
typedef struct
{
	ElemType info; // 顶点其它信息
}VertexType; // 顶点类型定义
class MGraph
{
private:
	int arcs[MAX_V][MAX_V]; // 邻接矩阵
	int num1, num2; // 图包含的顶点数以及边数
	VertexType vexs[MAX_V]; // 存放顶点信息
	GraphKind type;//如果提供的数据区分不了，默认是无向图,十位数为一代表网，没有数代表图，个位数为一代表无向，为二代表有向
public:
	MGraph();
	void BFS();//广度遍历输出图
	void DFS();//深度遍历输出图
	void dfs(bool* f, int i);//深度遍历辅助函数
	void print();//输出图的邻接矩阵
	void DJ(int b);//迪杰斯特拉（Dijkstra）算法求最短路径
	void prim();//普里姆（Prim）算法求最小生成树，输出其邻接矩阵
	void DPauxiliary(int b, int* f, bool* v, int* pre);//迪杰斯特拉算法和普里姆算法的辅助函数
};

图的建立

整体上是基于文件进行图的建立，有两种文件内容格式，READMODE ==1时，是读入顶点个数，顶点信息以及邻接矩阵，READMODE ==2时，是读入顶点个数，顶点信息，边的个数，边的信息，样例如下：
READMODE ==1
READMODE ==2
两种读入形成的邻接矩阵都是从1开始存，0不存数据。

READMODE ==1

if (READMODE == 1)
	{
		for (i = 1; i <= num1; i++)
		{
			for (int j = 1; j <= num1; j++)
			{
				file >> arcs[i][j];
				if (arcs[i][j] != 0 && i != j)
					num2++;
				if (arcs[i][j] > 1)
					type += 10;//网
			}
		}
		i = 0;
		if (num2 % 2 == 0)
		{
			type += 1;//无向
			num2 /= 2;//提前去掉重复统计的边
			for (int i = 1; i <= num1; i++)
			{
				for (int j = 1; j <= i; j++)
				{
					if (arcs[i][j] != arcs[j][i])
					{
						num2 *= 2;//还原边
						type += 1;//有向
						break;
					}
				}
				if (type % 10 == 2)
					break;
			}
		}
	}

READMODE==2

if (READMODE == 2)//默认是无向
	{
		file >> num2;
		for (int i = 1; i <= num1; i++)
		{
			for (int j = 1; j <= num1; j++)
			{
				if (i != j)
					arcs[i][j] = 0;
				else
					arcs[i][j] = 1;
			}
		}
		type += 1;
		for (i = 1; i <= num2; i++)
		{
			int x, y, l;
			file >> x >> y >> l;
			arcs[x][y] = arcs[y][x] = l;
			if (l > 1)
				type += 10;
		}
		
	}

遍历

无论是广度遍历还是深度遍历，其目的都是将所有点的信息进行遍历输出，不能有遗落，只不过BFS是广度优先，DFS是深度优先。

广度遍历（BFS）

广度优先的字面意思很好理解，其思想也差不多，我理解的就是一层一层访问，以最开始访问的顶点作为基准，记其层数为0，其他点几条线与之相连就是第几层，每一层的访问顺序由其上层（指的是最开始的分支层）的标号大小决定，编号小的先访问，上层完全相同的，比较本身编号大小，编号小的先访问。对于非连通图来讲，将图分成几个连通的子图，按照标号顺序访问整个子图。
这个只是个人思路，仅供参考，但是代码思路还是很清晰的：
1.先将起点入队
2.出队输出，并将与出队点直接相连的所有点入队
3.反复执行第二步
4.遍历，将所有未入队过的点从第1步开始执行，直至所有点都入队过
5.反复出队输出，直至队空

void MGraph::BFS()
{
	queue<int> q;
	bool* f = new bool[num1 + 1];
	fill(f, f + num1 + 1, 0);
	cout << "广度遍历结果为：";
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == 1)
			continue;
		q.push(i);
		f[i] = 1;
		for (int j = 1; j <= num1; j++)
		{
			if (arcs[i][j] == 0 || f[j] == 1 || j == i)//两点之间没有边，该点已经访问过，该点与先行点是一个的情况排除
				continue;
			q.push(j);//压入队列
			f[j] = 1;
		}
		cout << vexs[q.front()].info << ' ';
		q.pop();
	}
	while (!q.empty())
	{
		cout << vexs[q.front()].info << ' ';
		f[q.front()] = 1;
		q.pop();
	}
	cout << endl;
}

深度遍历（DFS)

同样的，广度优先的字面意思也很好理解，我的解释是，一条线一条线的遍历，出现分支的话，先进入编号小的一边，访问到头后，回到分支点，访问其他分支，同样的，对于非连通图来讲，将图分成几个连通的子图，按照标号顺序访问整个子图。 代码思路就是递归，首先一个大循环防止是非连通图导致访问不全。然后就是一条线一条线的进行访问，到头就返回。

void MGraph::DFS()
{
	bool* f = new bool[num1 + 1];
	fill(f, f + num1 + 1, 0);
	cout << "深度遍历结果为：";
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == 1)
			continue;
		dfs(f, i);
	}
	cout << endl;
}
void MGraph::dfs(bool* f, int i)
{
	cout << vexs[i].info << ' ';
	f[i] = 1;
	for (int j = 1; j <= num1; j++)
	{
		if (i == j || arcs[i][j] == 0 || f[j] == 1)
			continue;
		dfs(f, j);
	}
}

最短路径和最小生成树（迪杰斯特拉算法和普里姆算法）

迪杰斯特拉算法和普里姆算法很像，**都是以一个点为基准，反复从未接入过的点中选出与之最近的点，接入图中，然后更新与新接入点直接相连的点到基准点的最短路径长度，只不过迪杰斯特拉算法说的最短针对的是起点，而普里姆算法的最短针对的是新的图。**但是思想还是差不多的。
另外我写的代码是针对无向的，有向没试，但应该不行。

迪杰斯特拉算法

找最短路径就是一个大循环内嵌两个循环，大循环是为了遍历到所有的点，第一个小循环是为了寻找未接入过的点中选出与基准点最近的点，第二个小循环就是最短路径长度和前驱点的更新。

void MGraph::DJ(int b)
{
	if (type % 10 == 2)
	{
		cout << "有向图不行" << endl;
		return;
	}
	int* f;
	bool* v;
	int* pre;
	v = new bool[num1 + 1];//标记是否经过
	f = new int[num1 + 1];//记录最短距离
	pre = new int[num1 + 1];//记录最短路径的上一节点
	fill(f, f + num1 + 1, INT_MAX);
	fill(v, v + num1 + 1, false);
	for (int i = 1; i <= num1; i++)
		pre[i] = i;
	f[b] = 0;
	for (int i = 1; i <= num1; i++)
	{
		int near = -1;
		int min = INT_MAX;
		for (int j = 1; j <= num1; j++)//每次寻找到的点，都是未选过的，距离起点最近的点
		{
			if (v[j] == false && f[j] < min)
			{
				near = j;
				min = f[j];
			}
		}
		if (near == -1)
			break;
		v[near] = 1;
		for (int j = 1; j <= num1; j++)
		{
			if (arcs[near][j] != 0 && j != near && v[j] == false)
			{
				if (min + arcs[near][j] < f[j]) {
					f[j] = min + arcs[near][j];
					pre[j] = near;//pre保存当前结点的上一个节点，以便输出最短路线
				}
			}
		}
	}
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == INT_MAX)
		{
			cout << b << "和" << i << "不连通" << endl;
			continue;
		}
		if (i == b)
			continue;
		stack<int>path;
		int j = i;
		while (j != b)
		{
			path.push(j);
			j = pre[j];
		}
		cout << b << "-";
		while (!path.empty())
		{
			if (path.top() != b)
				cout << path.top();
			path.pop();
			if (!path.empty())
				cout << '-';
		}
		cout <<"        " << "最短距离是" << f[i] << endl;
	}
}

最小生成树

我是直接输出构成最小生成树的边了，找边跟最短路径差不多

void MGraph::prim()
{
	bool* f = new bool[num1 + 1];//是否接入新图
	int* linknode = new int[num1 + 1];//与新的图的连接点
	int *k = new int[num1 + 1];//与新的图的最小长度
	fill(f, f + num1 + 1, false);
	for (int i = 2; i <= num1; i++)
	{
		k[i] = arcs[i][1];
		if (k[i] == 0)
		{
			k[i] = 999;
			linknode[i] = 0;
		}
		else
			linknode[i] = 1;
	}
	k[1] = 0;
	f[1] = 1;
	for (int i = 2; i <= num1; i++)
	{
		int min = 999;
		int minnode = 0;
		for (int j = 2; j<= num1; j++)
		{
			if (f[j])
				continue;
			if (k[j] < min)
			{
				min = k[j];
				minnode = j;
			}
		}
		if (min == 999)
			break;
		f[minnode] = 1;
		cout << linknode[minnode] << ' ' << minnode << ' ' << k[minnode] << endl;
		for (int j = 2; j <= num1; j++)//更新
		{
			if (f[j])
				continue;
			if (arcs[j][minnode] != 0 && k[j] > arcs[j][minnode])
			{
				k[j] = arcs[j][minnode];
				linknode[j] = minnode;
			}
		}
	}
}

源代码

#include<iostream>
#include<fstream>
#include<queue>
#include<stack>
using namespace std;
#define MAX_V 20 // 最大顶点数目
#define READMODE 2//文件内容格式，1是完整的矩阵，2是读入边
typedef char ElemType;//元素类型
typedef int GraphKind;//图形类型
typedef struct
{
	ElemType info; // 顶点其它信息
}VertexType; // 顶点类型定义
class MGraph
{
private:
	int arcs[MAX_V][MAX_V]; // 邻接矩阵
	int num1, num2; // 图包含的顶点数以及边数
	VertexType vexs[MAX_V]; // 存放顶点信息
	GraphKind type;//如果提供的数据区分不了，默认是无向图,十位数为一代表网，没有数代表图，个位数为一代表无向，为二代表有向
public:
	MGraph();
	void BFS();
	void DFS();
	void dfs(bool* f, int i);
	void print();
	void DJ(int b);
	void prim();
	void DPauxiliary(int b, int* f, bool* v, int* pre);
};
int main()
{
	MGraph G;
	G.print();
	G.DFS();
	G.BFS();
	G.DJ(1);
	G.prim();
}
MGraph::MGraph()
{
	type = 0;
	num2 = 0;
	fstream file("data1.txt", ios::in);
	file >> num1;
	int j = 1, i = 1;
	while (i <= num1)
		file >> vexs[i++].info;
	if (READMODE == 1)
	{
		for (i = 1; i <= num1; i++)
		{
			for (int j = 1; j <= num1; j++)
			{
				file >> arcs[i][j];
				if (arcs[i][j] != 0 && i != j)
					num2++;
				if (arcs[i][j] > 1)
					type += 10;//网
			}
		}
		i = 0;
		if (num2 % 2 == 0)
		{
			type += 1;//无向
			num2 /= 2;//提前去掉重复统计的边
			for (int i = 1; i <= num1; i++)
			{
				for (int j = 1; j <= i; j++)
				{
					if (arcs[i][j] != arcs[j][i])
					{
						num2 *= 2;//还原边
						type += 1;//有向
						break;
					}
				}
				if (type % 10 == 2)
					break;
			}
		}
	}
	if (READMODE == 2)//默认是无向
	{
		file >> num2;
		for (int i = 1; i <= num1; i++)
		{
			for (int j = 1; j <= num1; j++)
			{
				if (i != j)
					arcs[i][j] = 0;
				else
					arcs[i][j] = 1;
			}
		}
		type += 1;
		for (i = 1; i <= num2; i++)
		{
			int x, y, l;
			file >> x >> y >> l;
			arcs[x][y] = arcs[y][x] = l;
			if (l > 1)
				type += 10;
		}
		
	}
	else
		type += 2;//有向
	cout << "这是一个" << num1 << "个顶点" << num2 << "条边" << "的";
	if (type % 10 == 2)
		cout << "有向";
	else
		cout << "无向";
	if (type / 10 > 0)
		cout << "网" << endl;
	else
		cout << "图" << endl;
}
void MGraph::BFS()
{
	queue<int> q;
	bool* f = new bool[num1 + 1];
	fill(f, f + num1 + 1, 0);
	cout << "广度遍历结果为：";
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == 1)
			continue;
		q.push(i);
		f[i] = 1;
		for (int j = 1; j <= num1; j++)
		{
			if (arcs[i][j] == 0 || f[j] == 1 || j == i)//两点之间没有边，该点已经访问过，该点与先行点是一个的情况排除
				continue;
			q.push(j);//压入队列
			f[j] = 1;
		}
		cout << vexs[q.front()].info << ' ';
		q.pop();
	}
	while (!q.empty())
	{
		cout << vexs[q.front()].info << ' ';
		f[q.front()] = 1;
		q.pop();
	}
	cout << endl;
}
void MGraph::dfs(bool* f, int i)
{
	cout << vexs[i].info << ' ';
	f[i] = 1;
	for (int j = 1; j <= num1; j++)
	{
		if (i == j || arcs[i][j] == 0 || f[j] == 1)
			continue;
		dfs(f, j);
	}
}
void MGraph::DFS()
{
	bool* f = new bool[num1 + 1];
	fill(f, f + num1 + 1, 0);
	cout << "深度遍历结果为：";
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == 1)
			continue;
		dfs(f, i);
	}
	cout << endl;
}
void MGraph::print()
{
	for (int i = 1; i <= num1; i++)
	{
		for (int j = 1; j <= num1; j++)
			cout << arcs[i][j] << ' ';
		cout << endl;
	}
}
void MGraph::DJ(int b)
{
	if (type % 10 == 2)
	{
		cout << "有向图不行" << endl;
		return;
	}
	int* f;
	bool* v;
	int* pre;
	v = new bool[num1 + 1];//标记是否经过
	f = new int[num1 + 1];//记录最短距离
	pre = new int[num1 + 1];//记录最短路径的上一节点
	fill(f, f + num1 + 1, INT_MAX);
	fill(v, v + num1 + 1, false);
	for (int i = 1; i <= num1; i++)
		pre[i] = i;
	f[b] = 0;
	for (int i = 1; i <= num1; i++)
	{
		int near = -1;
		int min = INT_MAX;
		for (int j = 1; j <= num1; j++)//每次寻找到的点，都是未选过的，距离起点最近的点
		{
			if (v[j] == false && f[j] < min)
			{
				near = j;
				min = f[j];
			}
		}
		if (near == -1)
			break;
		v[near] = 1;
		for (int j = 1; j <= num1; j++)
		{
			if (arcs[near][j] != 0 && j != near && v[j] == false)
			{
				if (min + arcs[near][j] < f[j]) {
					f[j] = min + arcs[near][j];
					pre[j] = near;//pre保存当前结点的上一个节点，以便输出最短路线
				}
			}
		}
	}
	for (int i = 1; i <= num1; i++)
	{
		if (f[i] == INT_MAX)
		{
			cout << b << "和" << i << "不连通" << endl;
			continue;
		}
		if (i == b)
			continue;
		stack<int>path;
		int j = i;
		while (j != b)
		{
			path.push(j);
			j = pre[j];
		}
		cout << b << "-";
		while (!path.empty())
		{
			if (path.top() != b)
				cout << path.top();
			path.pop();
			if (!path.empty())
				cout << '-';
		}
		cout <<"        " << "最短距离是" << f[i] << endl;
	}
}
void MGraph::prim()
{
	bool* f = new bool[num1 + 1];
	int* linknode = new int[num1 + 1];
	int *k = new int[num1 + 1];
	fill(f, f + num1 + 1, false);
	for (int i = 2; i <= num1; i++)
	{
		k[i] = arcs[i][1];
		if (k[i] == 0)
		{
			k[i] = 999;
			linknode[i] = 0;
		}
		else
			linknode[i] = 1;
	}
	k[1] = 0;
	f[1] = 1;
	for (int i = 2; i <= num1; i++)
	{
		int min = 999;
		int minnode = 0;
		for (int j = 2; j<= num1; j++)
		{
			if (f[j])
				continue;
			if (k[j] < min)
			{
				min = k[j];
				minnode = j;
			}
		}
		if (min == 999)
			break;
		f[minnode] = 1;
		cout << linknode[minnode] << ' ' << minnode << ' ' << k[minnode] << endl;
		for (int j = 2; j <= num1; j++)
		{
			if (f[j])
				continue;
			if (arcs[j][minnode] != 0 && k[j] > arcs[j][minnode])
			{
				k[j] = arcs[j][minnode];
				linknode[j] = minnode;
			}
		}
	}
}
青耕_
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图——邻接矩阵
zhuziyuzzy的博客
05-02 4016
*图的储存*///点的数量//定义点集合数组v[i]=j;第i个结点的编号是jstruct edges{//单条边结构体int from;//该条边的左顶点int to;//该条边的右顶点double w;//边的长度//边集合int cnt=1;//当前在读入第cnt条边//记录第cnt条边的左顶点是u//记录第cnt条边的右顶点是ve[cnt].w=w;////记录第cnt条边的权值cnt++;//换下一条边去读/*邻接矩阵*///
数据结构之以邻接矩阵实现图的基本操作(一)
超级超级的博客
02-18 3366
1.图的基本定义 此处使用了字符作为顶点表存储的数据类型，整型作为边表 数据类型 typedef struct{ VertexType Vex[MaxVertexNum]; //顶点表 EdgeType Edge[MaxVertexNum][MaxVertexNum]; //邻接矩阵，边表 int vexnum,arcnum; //当前顶点数和弧数 }MGraph; 2....
图的建立——邻接矩阵
ZQYnn's blog
05-14 1万+
通过邻接矩阵的方式建立图 邻接矩阵(Adjacency Matrix)的存储结构就是通过一维数组存储图中顶点的信息，用矩阵表示图中各个顶点的的临界关系，而矩阵通过一个二维数组表示。 图的分类 在矩阵中的表示方法 在无向图中矩阵的表示 无向网中矩阵的表示 存储顶点信息的结构 存储图的信息时，要通过结构体来定义数据类型，以无向网为例定义如下： #define MAX_VEX 100...
【图】（一）图的建立 - 邻接矩阵与邻接表 - C语言
最新发布
友人帐_的博客
10-28 2975
使用C语言的文件操作，以邻接矩阵和邻接表两种方式建立图，并给出两种方式的转换函数。
数据结构实验：C++实现邻接矩阵创建无向图以及BFS和DFS遍历
qq_45050714的博客
01-02 3046
数据结构实验四：利用邻接矩阵创建无向图，并实现BFS和DFS遍历 1.实验目的 采用邻接矩阵或邻接表进行图的存储 分别完成图的深度优先和宽度优先搜索 2.无向图类 #ifndef graph_h #define graph_h #include<iostream> #include<queue> #include<stack> #include<map> using namespace std; //利用邻接矩阵构造无向图，实现BFS和DFS遍历 clas
有向图邻接矩阵c++运算操作
07-19
有向图邻接矩阵c++运算操作 基本操作 邻接矩阵 c++实现
Python根据已知邻接矩阵绘制无向图操作示例
09-20
本篇将详细介绍如何利用Python的`networkx`库和`matplotlib`库根据已知的邻接矩阵来绘制无向图。 首先，邻接矩阵是一种二维数组，用于表示图中各个节点间的连接关系。在无向图中，邻接矩阵是对称的，因为边没有方向...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
这些函数的实现涉及到动态内存分配、遍历矩阵和链表等基本操作。 在实际编程中，需要注意内存管理，确保在创建链表后正确释放内存。同时，为了提高用户体验，可以考虑添加错误检查和用户友好的输入提示，以处理无效...
图之邻接矩阵详解（C语言版）.rar
04-24
下面是一些使用C语言操作邻接矩阵的基本操作： 1. 初始化：创建一个n×n的二维数组，并将其所有元素初始化为0，表示图中没有任何边。 ```c int adj_matrix[N][N] = {0}; // N为顶点数量 ``` 2. 插入边：在矩阵中...
C++通过邻接矩阵实现图.zip
05-08
本篇将深入探讨如何利用C++通过邻接矩阵实现图，并涵盖图的一些基本操作，如添加和删除顶点、添加和删除边，以及两种常用的图遍历算法——深度优先搜索（DFS）和广度优先搜索（BFS）。此外，还将涉及单源最短路径...
求最短路径（选路算法）
12-13
该.exe文件是基于VC下得MFC而开发的，可以求地图上两个节点之间的最短路径。该地图参考图是云南大学呈贡校区的一部分。
数据结构课程设计报告(校园导游图）
05-29
数据结构课程设计报告(校园导游图），全面的数据结构，共大家使用！
邻接矩阵—图的存储结构
wmy0217_的博客
02-15 1万+
文章目录邻接矩阵1、邻接矩阵表示法2、无向图的邻接矩阵表示法3、有向图的邻接矩阵表示法4、网（有权图）的邻接矩阵表示法5、邻接矩阵的存储表示6、采用邻接矩阵表示法创建无向网7、邻接矩阵优点和缺点 图没有顺序存储结构，但可以借助二维数组来表示元素之间的关系，即邻接矩阵表示法 图的链式存储结构有多种，邻接表、十字链表、邻接多重表 邻接矩阵、邻接表是我们重点要研究的 邻接矩阵 1、邻接矩阵表示法 建立...
图的邻接表和邻接矩阵
juryoo的专栏
05-05 7705
邻接表 一、邻接表 邻接表是图的一种链式存储结构。 邻接表中，对图中每个顶点建立一个单链表，第i个单链表中的结点表示依附于顶点Vi的边（对有向图是以顶点Vi为尾的弧）。 邻接表中的表结点和头结点结构： 表 结 点 adjvex nextarc
图论（六）图的两种表示方法
saltriver的专栏
01-17 2万+
如果要用图来解决问题，首先我们必须采用某种数据结构来存储和表示“图”。相对于数组、链表等来说，图的存储结构就复杂的多了。 首先，图上的任何一个顶点都可以被看作是第一个顶点，任意顶点的邻接顶点之间也不存在次序关系。还记得在《图论（一）基本概念》中的“同构图”吧，图的形状可以千变万化的。因此也就无法以数据元素在内存中的物理位置来表示元素之间的关系，也就是说，图不可能用数组这样简单的顺序存储结构来表示。
图的邻接矩阵（C语言）
热门推荐
一串代码的博客
08-18 4万+
邻接矩阵 无向图和有向图在邻接矩阵中的表示方法： 无向图和有向图大同小异，在这里只以无向图为例，代码部分通过简单调整即可对应编译有向图邻接矩阵数据类型定义#define MaxVertices 100 //定义最大容量 typedef struct{ //包含权的邻接矩阵的的定义 int Vertices[MaxVertices]; //顶点信息的数组 int Edge[Max
数据结构--图的创建(邻接矩阵)
ledou2的博客
08-20 1万+
数据结构–图的创建(邻接矩阵) 顶点数组: 边数组: #include &lt;stdio.h&gt; #define MAXVEX 20 //最大顶点数 #define FINITY 100 //代表 ∞ typedef char VertexType; ...
图的邻接矩阵表示方法以及遍历
喜爱兰兰
05-10 2784
下面的程序可以用来创建有向图，有向网，无向图，无向网。对于图来说如果来个顶点之间存在边，则在矩阵中用1表示，无边则用0表示。在网络中，边是对应权值的。 图的遍历可以分为深度优先遍历和广度优先遍历。 深度优先遍历的思想是，选择某个未被访问的顶点并访问，然后从该顶点出发，选择第一个和该顶点邻接的未被访问的顶点进行访问。在该过程中可以设置一个标识数组flags[]来标识各个顶点是否被访问到。 广度
C++数据结构_图的理论学习笔记（1）_基本概念、存储结构
lgc0208的博客
05-25 560
1.1 基本概念 1.1.1 图的定义         图G由两个集合V和E构成，记作G（V, E），其中，V代表图中顶点的集合，E代表顶点之间的关系。E可以是空集，表示图只有顶点而没有边。         （v1，v2）表示v1和v2之间有一条边（无方向）；<v1，v2>表示v1和v2之间有一条弧（有方向）。图的表示方法示例如下图：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值