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

已于 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
    评论
【数据结构】图的存储结构—邻接矩阵
四季轮换叶，一路招摇胜
06-15 2万+
考虑图的定义，图是由顶点和边组成的。图常用的存储结构有邻接矩阵、邻接表、十字链表和邻接多重表。这里我们今天主要详细介绍一下图存储结构 — 邻接矩阵
图的存储 —— 邻接矩阵
谢谢你们的关注
09-29 1万+
图的存储 —— 邻接矩阵
邻接矩阵（图论）
bsjshhs的博客
05-17 686
图的结构比较复杂，是非线性结构，任意两点都可能存在联系，相对来说存储方法较多。目前主要有：邻接矩阵表示法邻接表表示法邻接多重表表示法十字链表表示法无论上述哪种存储方式，我们都要存储顶点和边的信息，在本系列文章中，我们介绍1,2两种表示法。邻接矩阵就是利用二维矩阵表示图中各顶点之间的关系，对于有n个顶点的图来说，用n阶方阵来表示该图，其中矩阵元素表示从顶点到之间的边，的大小表示边的权值。如果顶点到没有边，则可以将设置为0或者。
数据结构之图(二)——邻接矩阵
热门推荐
daocaoren_的博客
08-06 6万+
图的逻辑结构为多对多，图没有顺序存储结构，但可以借助二维数组来表示元素间的关系，即数组表示法(邻接矩阵)。图的链式存储结构可以用多重链表来描述，如邻接表，邻接多重表以及十字链表等。 邻接矩阵 数组(邻接矩阵)表示法： 建立一个邻接表(记录各个顶点信息)和一个邻接矩阵(表示各个顶点间的关系)。 1.设图A=(V,E)有n个顶点，则有顶点表Vexs[n]如下， i 0 1 2 ⋯\cdot...
【数据结构】 图的邻接矩阵
zgsdlr的博客
11-12 5319
在图的存储方法中，邻接矩阵通过数组对图的信息进行存储。 基本思路 使用邻接矩阵前，需要开一个一维数组数组，以存储各个顶点的数据（数组的编号与邻接矩阵中顶点的编号一一对应）；同时，还需要一个标记顶点是否被访问的一维数组，用来表示图中顶点是否被访问。【其中，标记顶点是否被访问的数组使用全局变量】 邻接矩阵为n*n方阵（二维数组），用来表示图中顶点间的连通关系（两顶点连通，数组值为1；两顶点不连通，数组值为0）。因此邻接矩阵edge数组的大小取决于图中顶点的数量。 邻接矩阵构造前，需要对标记数组、邻接矩阵edge
图的邻接矩阵与邻接表
Brant_zero的博客
08-27 3372
C++实现图。图的概念与相关名词，使用邻接矩阵、邻接表存储图结构。
图的基本操作（无向带权图邻接矩阵）
ReidSC的博客
03-09 8356
代码任意输入数字进行测试，注意点从1开始输入#include&lt;iostream&gt; #include&lt;queue&gt; #include&lt;cstdlib&gt; using namespace std; #define inf 99999 #define maxsize 10 queue&lt;int&gt; seq; int edge[maxsize][maxsiz...
【总结】邻接矩阵 图的基本操作
玲玲的专栏
10-08 3509
#include #include #define MaxVertexNum 100 typedef int VertexType ; //由用户定义顶点类型 typedef int EdgeType; //由用户定义边上的权值类型 typedef
有向图邻接矩阵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. 插入边：在矩阵中...
邻接矩阵存储方式实现_邻接表_邻接矩阵_数据结构_
09-29
其中，邻接矩阵和邻接表是两种常见的图存储方式。 **邻接矩阵** 邻接矩阵是一种二维数组，用于存储图中节点之间的连接关系。对于无向图，邻接矩阵是对称的，即矩阵的第i行第j列元素与第j行第i列元素相等，表示节点...
图之邻接矩阵详解（C语言版）
qq_44075108的博客
04-24 9850
图之邻接矩阵详解（C语言版）
图的邻接矩阵存储法详解与C++实现
m0_68805093的博客
07-22 1920
邻接矩阵法存储图，以及对图的基本操作的C/C++代码实现
数据结构学习笔记——图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）
小宇y的博客
08-14 1万+
图的常用存储结构有邻接矩阵和邻接表，另外还有十字链表、邻接多重表等等。//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;100//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;.........
图的邻接矩阵
banhu_LongjinG的博客
07-11 4321
图 邻接矩阵
图的存储结构——邻接矩阵
ker的博客
01-28 5688
图的存储结构邻接矩阵表示法存储表示采用邻接矩阵表示法创建无向网用代码实现无向网 若有n个顶点，就是n*n的方阵，与边数无关 对称矩阵：从矩阵的左上角到右上角的主对角线为轴，右上角的元与左下角对应的元全都是相等的 邻接矩阵表示法 有向图、无向图的邻接矩阵表示法 如： 无向图 总结： 无向图的邻接矩阵是对称的； 顶点i的度=第i行（列）中1的个数； 特别的：完全图的邻接矩阵中，对角元素为0，其余为...
[Leetcode 136][Easy]-只出现一次的数字
最新发布
2201_75413354的博客
07-03 184
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
邻接矩阵设计基本操作演示
05-31
邻接矩阵的设计基本操作包括创建图、添加节点、添加边、删除节点、删除边、查找节点和遍历图等操作。下面我演示一下这些基本操作的实现过程： 1. 创建图 创建图需要确定节点个数和边的数量，可以通过二维数组来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值