图的存储方式——邻接矩阵与邻接表

最新推荐文章于 2024-08-02 21:53:32 发布
最新推荐文章于 2024-08-02 21:53:32 发布
阅读量1.9k 收藏 32
点赞数 47
文章标签： 算法 数据结构 c++ c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g262773728277/article/details/134858377
版权

新人第一次发，可能有错，请大佬们多多包涵

一、邻接矩阵（Adjacency Matrix)

1.基本介绍

言简意赅，邻接矩阵时就是表示顶点间相邻关系的矩阵！

我认为，邻接矩阵可以分为三种：

1.无向无权邻接矩阵   A[i][j]=    1(若i,j相邻)并且A[j][i]=1   or    0(不相邻）

2.有向无权邻接矩阵    A[i][j]=    1(若i,j相邻)   or    0(不相邻）

3.有向有权邻接矩阵。 A[i][j]=    权值(若i,j相邻)   or    0(不相邻）

2.代码解释——注意在这里我们构建的是无向无边邻接矩阵

1.邻接矩阵类型的结构体建立

在这里，我们定义了 ADJ_MATRIX

1.邻接矩阵的 顶点数量(vexnum)，边(弧)的数量(arcnum)。

2.顶点的内容——构建了一个内容数组(vexs[ ])。

3.展现弧关系的矩阵——构建了一个弧关系二维数组arcs[ ][ ]。

const int MAXLEN=100;
typedef char VEXTYPE;
typedef int ARCTYPE;

//构建邻接矩阵
struct ADJ_MATRIX
{
	int vexnum,arcnum;				//点数和弧数
	VEXTYPE vexs[MAXLEN];			//顶点内容 的数组(这里是字符型)
	ARCTYPE arcs[MAXLEN][MAXLEN];	//表示弧关系的矩阵
};

2.定义构造邻接矩阵 的函数

第一步：为表示邻接矩阵类型的结构体分配空间。

第二步：输入顶点数(vexnum)和弧数(arcnum)。

第三步：给顶点数组赋值(顶点的内容是什么)，注意这里是字符型的。

第四步：初始化弧关系二维数组，让他们的值都为零。

第五步：输入边(i,j)——确定顶点之间的关系。

//直接创建邻接矩阵
ADJ_MATRIX* Create_Matrix()
{
	ADJ_MATRIX* matrix_graph;
	
	//1.分配空间
	matrix_graph = new ADJ_MATRIX;
	
	//2.输入顶点数vexnum,弧数arcnum
	cin>>matrix_graph->vexnum>>matrix_graph->arcnum;
	
	//!!!!!3.为顶点内容(vexs[i])赋值
	for(int i=0;i<matrix_graph->vexnum;i++)
		cin>>matrix_graph->vexs[i];//char
	/*
	vexs[i]   a b c d e
	下标      0 1 2 3 4
	*/
	
	//4.初始化邻接矩阵
	for(int i=0;i<matrix_graph->vexnum;i++)
		for(int j=0;j<matrix_graph->vexnum;j++)
			matrix_graph->arcs[i][j]=0;
	
	//5.输入弧——确定顶点之间的关系
	for(int i=0;i<matrix_graph->arcnum;i++)
	{
		int x,y;
		cin>>x>>y;//输入有联系顶点的下标
		matrix_graph->arcs[x][y]=1;
		matrix_graph->arcs[y][x]=1;
	}
	
	return matrix_graph;
}

3.邻接矩阵的输出——不多说，直接上代码

//输出邻接矩阵
void Print_ADJ_Matrix(ADJ_MATRIX* matrix_graph)
{
	//在最上方展示顶点内容
	cout<<"  ";
	for(int i=0;i<matrix_graph->vexnum;i++)
		cout<<char(matrix_graph->vexs[i])<<" ";
	cout<<endl;
	
	for(int i=0;i<matrix_graph->vexnum;i++)
	{
		cout<<matrix_graph->vexs[i]<<" ";//在最左侧展示顶点内容
		for(int j=0;j<matrix_graph->vexnum;j++)
			cout<<matrix_graph->arcs[i][j]<<" ";
		cout<<endl;
	}
}

 4.(展示)main函数运行与运行案例

int main()
{						
	ADJ_MATRIX* M_g;		//定义一个ADJ_MATRIX的指针对象——M_g
	
	M_g=Create_Matrix();	//2.创建
	
	Print_ADJ_Matrix(M_g);	//3.打印
	
	return 0;				//注意习惯
}

**********************************************运行——输入*************************************************

5 5
a b c d e
0 1
1 2
2 3   
3 4
1 4 

**********************************************运行——输出*************************************************

二、邻接表  (Adjacency List) 

1.基本介绍

一种链式存储方法，对于图中每个顶点vi建立一个单链表，将与vi相连的顶点放在这个链表中。二每一个单链表有边节点和表头结点组成。

表头结点
vex_datafirstarc
边结点
vex_datainfonextarc

2.代码解释——在这里我们构建的是无向无权邻接表

1.邻接矩阵类型(无向图)的结构体建立

我们定义了 ADJ_LIST

1.邻接表的 顶点数量(vexnum)，边(弧)的数量(arcnum)。

2.邻接表 adjlist[ ]     (每个顶点相连关系的链表）

        (1) VEXNODE

                [1] vex_data——数据域

                [2] firstarc——链域

        (2)  ARCNODE

                [1] vex_data——临界点域

                [2] info——数据域 在这里，我们默认为0。

                [3] nextarc——链域

const int MAXLEN=100;
typedef char VEXTYPE; 
typedef int ARCTYPE;

//邻(lin)接表的边结点
struct ARCNODE
{
	VEXTYPE vex_data;					//顶点的值
	int info;							//与边相关的信息，如权值
	ARCNODE* nextarc;					
};

//邻接表的表头结点
struct VEXNODE
{
	VEXTYPE vex_data;
	ARCNODE* firstarc;
};

//构建邻接表
struct ADJ_LIST
{
	int vexnum,arcnum;
	VEXNODE adjlist[MAXLEN];		//每个点的邻接链表构成的数组adjlist
}

2.定义构造邻接表 的函数

第一步：为表示邻接表类型的结构体分配空间。

第二步：输入顶点数(vexnum)和弧数(arcnum)。

第三步：给顶点数组赋值(顶点的内容是什么)，注意这里是字符型的。

第四步：输入边(i,j)——确定顶点之间的关系。由于这里是无向图，所有要操作两次

ADJ_LIST* Create_List()
{
	ADJ_LIST* list_graph;
	ARCNODE* p;
	
	//1.list_graph开辟空间
	list_graph=new ADJ_LIST;
	
	//2.输入点数，边数
	cin>>list_graph->vexnum>>list_graph->arcnum;
	
	//3.为顶点内容赋值(adjlist[i].vex_data)并进行初始化
	for(int i=0;i<list_graph->vexnum;i++)
	{
		cin>>list_graph->adjlist[i].vex_data;
		list_graph->adjlist[i].firstarc=NULL;
	}
	//4.根据边的关系建表
	for(int i=0;i<list_graph->arcnum;i++)
	{
		int x,y;
		cin>>x>>y;
		
		//(1)在下标x的链表上插入y的内容
		p=new ARCNODE;
		p->vex_data=list_graph->adjlist[y].vex_data;
		p->nextarc=list_graph->adjlist[x].firstarc;
		list_graph->adjlist[x].firstarc=p;
		
		//(2)在下标y的链表上插入x的内容
		p=new ARCNODE;
		p->vex_data=list_graph->adjlist[x].vex_data;
		p->nextarc=list_graph->adjlist[y].firstarc;
		list_graph->adjlist[y].firstarc=p;
	}
	return list_graph;
}

3.邻接表的输出——不多说，直接上代码

void Print_ADJ_List(ADJ_LIST *list_graph)
{
	ARCNODE* p;
	for(int i=0;i<list_graph->vexnum;i++)
	{
		cout<<"<"<<i<<"> "<<list_graph->adjlist[i].vex_data;
		p=list_graph->adjlist[i].firstarc;
		while(p)
		{
			cout<<"->"<<p->vex_data;
			p=p->nextarc;
		}
		cout<<"->^"<<endl;
	}
}

4.(展示)main函数运行与运行案例

int main()
{
	ADJ_LIST* L_graph;			//定义ADJ_LIST
	
	L_graph=Create_List();		//创建
	
	Print_ADJ_List(L_graph);	//输出
	return 0;
}

**********************************************运行——输入*************************************************

5 5
a b c d e
0 1
1 2
2 3   
3 4
1 4 

**********************************************运行——输出*************************************************

细心的同学应该观察到这就是有上面矩阵的案例转变而来的

3.邻接矩阵转邻接表

//邻接矩阵转邻接表
ADJ_LIST* Matrix_To_List(ADJ_MATRIX* matrix_graph) {
	ADJ_LIST* list_graph;
	ARCNODE *p;

	//1.分配空间
	list_graph = new ADJ_LIST;

	//2.给邻接表赋顶点数vexnum,弧数arcnum
	list_graph->vexnum = matrix_graph->vexnum;
	list_graph->arcnum = matrix_graph->arcnum;

	//3.构建邻接表(邻接链表的数组)
	for (int i = 0; i < list_graph->vexnum; i++) {
		//初始化顶点i的一支单链表
		list_graph->adjlist[i].vex_data = matrix_graph->vexs[i];
		list_graph->adjlist[i].firstarc = NULL;

		//对于除了i的顶点进行遍历.
		for (int j = 0; j < list_graph->vexnum; j++) {
			//注意：是头插法！！！
			if (matrix_graph->arcs[i][j]) {	//若有i和j联系(matrix_graph[i][j])则插入j
				p = new ARCNODE;
				p->vex_data = matrix_graph->vexs[j];
				p->nextarc = list_graph->adjlist[i].firstarc;
				list_graph->adjlist[i].firstarc = p;
			}
		}
	}
	return list_graph;
}

（展示）main函数运行与运行案例

int main() {
	ADJ_MATRIX* M_g;
	ADJ_LIST* L_g;

	M_g =Create_Matrix();
	Print_ADJ_Matrix(M_g);

	L_g=Matrix_To_List(M_g);
	Print_ADJ_List(L_g);
	return 0;
}

**********************************************运行——输入*************************************************

5 5
a b c d e
0 1
1 2
2 3   
3 4
1 4 

**********************************************运行——输出*************************************************

三.最后给大家一个最终的源代码内容，可以在电脑上试着自己运行

#include<iostream>
using namespace std;

const int MAXLEN = 100;
typedef char VEXTYPE;
typedef int ARCTYPE;

//构建邻接矩阵
struct ADJ_MATRIX {
	int vexnum, arcnum;				//点数和弧数
	VEXTYPE vexs[MAXLEN];			//顶点内容 的数组(这里是字符型)
	ARCTYPE arcs[MAXLEN][MAXLEN];	//表示弧关系的矩阵
};

//邻(lin)接表的边结点
struct ARCNODE {
	VEXTYPE vex_data;					//顶点的值
	int info = 0;							//与边相关的信息，如权值
	ARCNODE* nextarc;
};

//邻接表的表头结点
struct VEXNODE {
	VEXTYPE vex_data;
	ARCNODE* firstarc;
};

//构建邻接表
struct ADJ_LIST {
	int vexnum, arcnum;
	VEXNODE adjlist[MAXLEN];		//每个点的邻接链表构成的数组adjlist
};

//直接创建邻接矩阵
ADJ_MATRIX* Create_Matrix() {
	ADJ_MATRIX* matrix_graph;

	//1.分配空间
	matrix_graph = new ADJ_MATRIX;

	//2.输入顶点数vexnum,弧数arcnum
	cin >> matrix_graph->vexnum >> matrix_graph->arcnum;

	//!!!!!3.为顶点内容(vexs[i])赋值
	for (int i = 0; i < matrix_graph->vexnum; i++)
		cin >> matrix_graph->vexs[i]; //char
	/*
	vexs[i]   a b c d e
	下标      0 1 2 3 4
	*/

	//4.初始化邻接矩阵
	for (int i = 0; i < matrix_graph->vexnum; i++)
		for (int j = 0; j < matrix_graph->vexnum; j++)
			matrix_graph->arcs[i][j] = 0;

	//5.输入弧——确定顶点之间的关系
	for (int i = 0; i < matrix_graph->arcnum; i++) {
		int x, y;
		cin >> x >> y; //输入有联系顶点的下标
		matrix_graph->arcs[x][y] = 1;
		matrix_graph->arcs[y][x] = 1;
	}

	return matrix_graph;
}

//直接创建邻接表
ADJ_LIST* Create_List() {
	ADJ_LIST* list_graph;
	ARCNODE* p;

	//1.list_graph开辟空间
	list_graph = new ADJ_LIST;

	//2.输入点数，边数
	cin >> list_graph->vexnum >> list_graph->arcnum;

	//3.为顶点内容赋值(adjlist[i].vex_data)并进行初始化
	for (int i = 0; i < list_graph->vexnum; i++) {
		cin >> list_graph->adjlist[i].vex_data;
		list_graph->adjlist[i].firstarc = NULL;
	}
	//4.根据边的关系建表
	for (int i = 0; i < list_graph->arcnum; i++) {
		int x, y;
		cin >> x >> y;

		//(1)在下标x的链表上插入y的内容
		p = new ARCNODE;
		p->vex_data = list_graph->adjlist[y].vex_data;
		p->nextarc = list_graph->adjlist[x].firstarc;
		list_graph->adjlist[x].firstarc = p;

		//(2)在下标y的链表上插入x的内容
		p = new ARCNODE;
		p->vex_data = list_graph->adjlist[x].vex_data;
		p->nextarc = list_graph->adjlist[y].firstarc;
		list_graph->adjlist[y].firstarc = p;
	}
	return list_graph;
}

//输出邻接矩阵
void Print_ADJ_Matrix(ADJ_MATRIX* matrix_graph)
{
	//在最上方展示顶点内容
	cout<<"  ";
	for(int i=0;i<matrix_graph->vexnum;i++)
		cout<<char(matrix_graph->vexs[i])<<" ";
	cout<<endl;
	
	for(int i=0;i<matrix_graph->vexnum;i++)
	{
		cout<<char(matrix_graph->vexs[i])<<" ";//在最左侧展示顶点内容
		for(int j=0;j<matrix_graph->vexnum;j++)
			cout<<matrix_graph->arcs[i][j]<<" ";
		cout<<endl;
	}
}

//输出邻接表
void Print_ADJ_List(ADJ_LIST *list_graph) {
	ARCNODE* p;
	for (int i = 0; i < list_graph->vexnum; i++) {
		cout << "<" << i << "> " << list_graph->adjlist[i].vex_data;
		p = list_graph->adjlist[i].firstarc;
		while (p) {
			cout << "->" << p->vex_data;
			p = p->nextarc;
		}
		cout << "->^" << endl;
	}
}

//邻接矩阵转邻接表
ADJ_LIST* Matrix_To_List(ADJ_MATRIX* matrix_graph) {
	ADJ_LIST* list_graph;
	ARCNODE *p;

	//1.分配空间
	list_graph = new ADJ_LIST;

	//2.给邻接表赋顶点数vexnum,弧数arcnum
	list_graph->vexnum = matrix_graph->vexnum;
	list_graph->arcnum = matrix_graph->arcnum;

	//3.构建邻接表(邻接链表的数组)
	for (int i = 0; i < list_graph->vexnum; i++) {
		//初始化顶点i的一支单链表
		list_graph->adjlist[i].vex_data = matrix_graph->vexs[i];
		list_graph->adjlist[i].firstarc = NULL;

		//对于除了i的顶点进行遍历.
		for (int j = 0; j < list_graph->vexnum; j++) {
			//注意：是头插法！！！
			if (matrix_graph->arcs[i][j]) {	//若有i和j联系(matrix_graph[i][j])则插入j
				p = new ARCNODE;
				p->vex_data = matrix_graph->vexs[j];
				p->nextarc = list_graph->adjlist[i].firstarc;
				list_graph->adjlist[i].firstarc = p;
			}
		}
	}
	return list_graph;
}

小 range
关注
  • 47
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
数据结构学习--图的邻接矩阵和邻接表存储
06-25
任意给出个图（本实验中使用有向图）的存储方式，试设计一个程序，在计算机中完成 该图的当前存储方式到另外一种存储方式的转换。
插入删除节点和边——邻接表和矩阵存储结构
01-31
本文将深入探讨两种常用的图存储结构：邻接表和邻接矩阵，并介绍如何在这两种结构上进行节点和边的插入与删除操作。 ### 邻接表 邻接表是一种节省空间的图存储方式，特别适合于稀疏图（边的数量远小于节点数量的...
图的邻接矩阵和邻接表实现
11-26
本文将详细探讨图的两种常见存储方式——邻接矩阵和邻接表，以及基于这两种数据结构的深度搜索（DFS）、广度搜索（BFS）和Dijkstra最短路径算法。 首先，邻接矩阵是一种二维数组，用于表示图中所有节点之间的连接...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
有向图的邻接矩阵转化为邻接表并存储顶点大于50的值
06-11
一次上机练习——有向图的邻接矩阵转化为邻接表并存储顶点大于50的值 小渣渣写的和大家一起学习进步
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 1011
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
【算法】浅析网络流算法
Young_Pro的博客
08-02 926
网络流算法（Network Flow Algorithms）是指在给定的网络中，寻找一种从源点到汇点的流量分配方式，使得某个目标函数达到最优，同时满足网络中的容量约束。网络流算法作为一种优化工具，在实际应用中具有广泛的意义。通过本文的介绍，相信大家对网络流算法的原理、使用和意义有了更深入的了解。在实际问题求解过程中，我们可以根据问题的特点，灵活运用网络流算法，提高问题求解的效率。
dp专题（二）
2301_80718054的博客
08-02 595
地上有一排格子，共 nn 个位置。机器猫站在第一个格子上，需要取第 nn 个格子里的东西。机器猫当然不愿意自己跑过去，所以机器猫从口袋里掏出了一个机器人！问机器人最少需要多少次跳跃，才能到达 nn 号格子。
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 238
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
【Hot100】LeetCode—31. 下一个排列
weixin_44382896的博客
08-02 208
技巧题，分为以下几个步骤。
算法板子：BFS(广度优先搜索)——迷宫问题，求从迷宫的起点到终点的最短路径； 八数码问题，求从初始布局到最终布局x最少移动多少次
m0_67839004的博客
08-01 335
【代码】算法板子：BFS(广度优先搜索)——迷宫问题，求从迷宫的起点到终点的最短路径。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3468
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
【算法】退火算法 Simulated Annealing
藓类少女的博客
07-25 1465
退火算法（Simulated Annealing, SA）是一种基于热力学模拟的优化算法，用于求解全局优化问题。它通过模拟物理退火过程来寻找全局最优解。
算法 —— 暴力枚举
fen_0108的博客
07-25 4012
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
【C++】指针
weixin_60546365的博客
07-30 283
int a = 10;int * p;p = &a;//指针p记录a的地址。
C语言作业二
最新发布
weixin_47702917的博客
08-02 173
三角形判断（牛客）
算法【N皇后问题位运算实现】
W_O_Z的博客
08-02 115
其中，ans表示个数，row表示进行到第几行，col、left、right表示分别从竖直、右上到左下、左上到右下三个方向上哪些列不能被放置，1为不能，0为能。遍历找到可放置的列，place中1的位数代表当前行皇后放在哪列。3.int right: 0..i-1行皇后放置的位置因为右下方向延伸的原因，哪些列不能再放皇后。2.int left: 0..i-1行皇后放置的位置因为左下方向延伸的原因，哪些列不能再放皇后。1.int col: 0..i-1行皇后放置的位置因为正下方向延伸的原因，哪些列不能再放皇后。
算法通关：014_1：用栈实现队列
m0_75257168的博客
08-02 137
时间复杂度平均下来每个方式是O(1)
力扣：3128. 直角三角形（Java）
jungleirim的博客
08-02 160
如果 grid 中 3 个元素满足：一个元素与另一个元素在 同一行，同时与第三个元素在 同一列 ，那么这 3 个元素称为一个 直角三角形。这 3 个元素互相之间不需要相邻。请你返回使用 grid 中的 3 个元素可以构建的 直角三角形 数目，且满足 3 个元素值 都 为 1。输入：grid = [[0,1,0],[0,1,1],[0,1,0]]给你一个二维 boolean 矩阵 grid。有 2 个直角三角形。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小 range

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值