数据结构—邻接矩阵存储法代码实现

已于 2022-01-27 15:46:44 修改
阅读量2.4k 收藏 45
点赞数 6
分类专栏： 计算机技术 文章标签： 数据结构 算法 邻接矩阵存储法 图 c语言
于 2021-09-05 08:22:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/120098025
版权

邻接矩阵法

  • 图的邻接矩阵(adjacency matrix)是一种采用邻接矩阵数组表示顶点之间相邻关系的存储结构。设G=(V,E)是含有n(n>0)个顶点的图，各顶点的编号为0~(n-1)，则G的邻接矩阵数组A是n阶方阵，其定义如下：

  • 如果G是不带权无向图，则：
    A [ i ] [ j ] = { 1          若 ( i , j ) ∈ E ( G ) 0          其 他 A[i][j]=\begin{cases} 1\;\;\;\;若(i,j)∈E(G) \\ 0\;\;\;\;其他 \\ \end{cases} A[i][j]={1若(i,j)∈E(G)0其他​
    在这里插入图片描述

  • 如果G是不带权有向图，则：
    A [ i ] [ j ] = { 1          若 < i , j > ∈ E ( G ) 0          其 他 A[i][j]=\begin{cases} 1\;\;\;\;若<i,j>∈E(G) \\ 0\;\;\;\;其他 \\ \end{cases} A[i][j]={1若<i,j>∈E(G)0其他​
    在这里插入图片描述

  • 如果G是带权无向图，则：
    A [ i ] [ j ] = { w i j          若 i ≠ j 且 ( i , j ) ∈ E ( G ) ， 该 边 的 权 为 w i j 0          i = j ∞          其 他 A[i][j]=\begin{cases} w_{ij}\;\;\;\;若i≠j且(i,j)∈E(G)，该边的权为w_{ij} \\ 0\;\;\;\;i=j \\ ∞\;\;\;\;其他 \\ \end{cases} A[i][j]=⎩⎪⎨⎪⎧​wij​若i​=j且(i,j)∈E(G)，该边的权为wij​0i=j∞其他​
    在这里插入图片描述

  • 如果G是带权有向图，则：
    A [ i ] [ j ] = { w i j          若 i ≠ j 且 < i , j > ∈ E ( G ) ， 该 边 的 权 为 w i j 0          i = j ∞          其 他 A[i][j]=\begin{cases} w_{ij}\;\;\;\;若i≠j且<i,j>∈E(G)，该边的权为w_{ij} \\ 0\;\;\;\;i=j \\ ∞\;\;\;\;其他 \\ \end{cases} A[i][j]=⎩⎪⎨⎪⎧​wij​若i​=j且<i,j>∈E(G)，该边的权为wij​0i=j∞其他​
    在这里插入图片描述

邻接矩阵类型的声明

#define MaxVertenNum 100 //顶点数目的最大值
typedef char VertexType; //顶点的数据类型
typedef int EdgeType; //存放顶点信息
typedef struct
{
	VertexType Vex[MaxVertenNum]; //顶点表
	EdgeType Edge[MaxVertenNum][MaxVertenNum]; //邻接矩阵
	int vexnum, arcnum; //图的当前顶点数和弧数
}MGraph;

邻接矩阵类型的特点

  1. 图的邻接矩阵表示是唯一的。
  2. 对于含有n个顶点的图，当采用邻接矩阵存储时，无论是有向图还是无向图，也无论边的数目是多少，其存储空间都为 O ( n 2 ) O(n^2) O(n2)，所以邻接矩阵适合于存储边的数目较多的稠密图。
  3. 无向图的邻接矩阵数组一定是一个对称矩阵，因此可以采用压缩存储的思想，在存放邻接矩阵数组时只需存放上(或下)三角部分的元素即可。
  4. 对于无向图，邻接矩阵数组的第i行或第j列非零元素、非∞元素的个数正好是顶点i的度。
  5. 对于有向图，邻接矩阵数组的第i行(或第i列)非零元素、非∞元素的个数正好是顶点i的出度(或入度)。
  6. 在邻接矩阵中，判断图中两个顶点之间是否有边或者求两个顶点之间边的权的执行时间为O(1)。所以在需要提取边权值的算法中通常采用邻接矩阵存储结构。

不带权无向图基本操作的代码实现

#include<stdio.h>
#define MaxVertenNum 100 //顶点数目的最大值
#define NodeNum 6 //顶点个数
typedef char VertexType; //顶点的数据类型
typedef int EdgeType; //存放顶点信息
typedef struct
{
	VertexType Vex[MaxVertenNum]; //顶点表
	EdgeType Edge[MaxVertenNum][MaxVertenNum]; //邻接矩阵
	int vexnum, edgenum; //图的当前顶点数和边数
}MGraph;

void InitG(MGraph& g) //初始化
{
	int i, j;
	for (i = 0; i < MaxVertenNum; i++) g.Vex[i] = '\0';
	for (i = 0; i < MaxVertenNum; i++)
		for (j = 0; j < MaxVertenNum; j++)
			g.Edge[i][j] = 0;
	g.vexnum = 0;
	g.edgenum = 0;
}

void CreateVex(MGraph& g) //创建顶点信息
{
	int i = 0, count = 0;
	printf("输入图的顶点：");
	VertexType ch= getchar();
	while (ch != '#')
	{
		g.Vex[i++] = ch;
		ch = getchar();
		count++; //统计顶点个数
	}
	g.vexnum = count;
}

void CreateEdge(MGraph& g) //创建邻接矩阵信息
{
	EdgeType b;
	printf("输入邻接矩阵信息：\n");
	for (int i = 0; i < g.vexnum; i++)
		for (int j = 0; j < g.vexnum; j++)
		{
			scanf("%d", &b);
			g.Edge[i][j] = b;
		}
}

void Info(MGraph& g) //图的顶点数和边数
{
	int count = 0;
	for (int i = 0; i < g.vexnum; i++)
		for (int j = 0; j < g.vexnum; j++)
			if (g.Edge[i][j] == 1) count++;
	g.edgenum = count / 2;
}

int CountDegree(MGraph g, VertexType point) //统计每个顶点的度
{
	int j, count = 0;
	for (int i = 0; i < g.vexnum; i++)
		if (g.Vex[i] == point) j = i;
	for (int k = 0; k < g.vexnum; k++) if (g.Edge[j][k] == 1) count++;
	return count;
}

void PrintG(MGraph g) //输出各顶点的连接情况
{
	int i, j;
	for (i = 0; i < g.vexnum; i++)
	{
		for (j = 0; j < g.vexnum; j++)
			if (g.Edge[i][j] == 1) printf("%c->%c		", g.Vex[i], g.Vex[j]);
		printf("\n");
	}
}

bool Adjacent(MGraph g, VertexType x, VertexType y) //判断图G是否存在边(x,y)
{
	int i, j, k;
	for (i = 0; i < g.vexnum; i++)
	{
		if (g.Vex[i] == x) j = i;
		if (g.Vex[i] == y) k = i;
	}
	if (g.Edge[j][k] == 1) return true;
	else return false;
}

void Neighbors(MGraph g, VertexType x) //列出图G中与结点x邻接的边
{
	int i, j;
	for (i = 0; i < g.vexnum; i++)
		if (g.Vex[i] == x) j = i;
	for (i = 0; i < g.vexnum; i++)
		if (g.Edge[j][i] == 1)
			printf("%c ", g.Vex[i]);
}

bool InsertVertex(MGraph& g, VertexType x) //在图G中插入顶点x
{
	for (int i = 0; i < g.vexnum; i++)
		if (x == g.Vex[i]) return false; //与图G中原有顶点值相同
	g.Vex[g.vexnum] = x;
	g.vexnum++;
	return true;
}

bool DeleteVertex(MGraph& g, VertexType x) //从图G中删除顶点x
{
	int i, j, k;
	for (i = 0; i < g.vexnum; i++)
		if (x == g.Vex[i]) k = i;
	if (k < g.vexnum)
	{
		for (j = k; j < g.vexnum - 1; j++) //处理顶点表中的值
			g.Vex[j] = g.Vex[j + 1];

		//处理邻接矩阵中的值
		for (i = 0; i < k; i++) //处理矩阵右上元素
			for (j = k; j < g.vexnum - 1; j++)
				g.Edge[i][j] = g.Edge[i][j + 1];

		for (i = k; i < g.vexnum - 1; i++)  //处理矩阵左上元素
			for (j = 0; j < k; j++)
				g.Edge[i][j] = g.Edge[i + 1][j];

		for (i = k; i < g.vexnum - 1; i++)  //处理矩阵右下元素
			for (j = k; j < g.vexnum - 1; j++)
				g.Edge[i][j] = g.Edge[i + 1][j + 1];
		g.vexnum--;
		return true;
	}
	return false;
}

void PrintMatrix(MGraph g) //输出邻接矩阵
{
	int i, j;
	printf("输出邻接矩阵：\n");
	for (i = 0; i < g.vexnum; i++)
		printf("\t%c", g.Vex[i]);
	printf("\n");

	for (i = 0; i < g.vexnum; i++)
	{
		printf("%c", g.Vex[i]);
		for (j = 0; j < g.vexnum; j++)
			printf("\t%d", g.Edge[i][j]);
		printf("\n");
	}
	printf("\n");
}

bool AddEdge(MGraph& g, VertexType x, VertexType y) //若无向边(x, y)不存在，则向图G中添加该边
{
	int i, j, k;
	for (i = 0; i < g.vexnum; i++)
	{
		if (g.Vex[i] == x) j = i;
		if (g.Vex[i] == y) k = i;
	}
	if (j >= g.vexnum || k >= g.vexnum) return false; //不存在顶点x或顶点y
	else
	{
		if (g.Edge[j][k] == 0)
		{
			g.Edge[j][k] = 1;
			g.Edge[k][j] = 1;
			return true;
		}
		else return false; //该边已存在
	}
}

bool RemoveEdge(MGraph& g, VertexType x, VertexType y) //若无向边(x, y)存在，则在图G中删除该边
{
	int i, j, k;
	for (i = 0; i < g.vexnum; i++)
	{
		if (g.Vex[i] == x) j = i;
		if (g.Vex[i] == y) k = i;
	}
	if (j >= g.vexnum || k >= g.vexnum) return false; //不存在顶点x或顶点y
	else
	{
		if (g.Edge[j][k] == 1)
		{
			g.Edge[j][k] = 0;
			g.Edge[k][j] = 0;
			return true;
		}
		else return false; //该边不存在
	}
}

int FirstNeighbor(MGraph g, VertexType x) //求图G中顶点x的第一个邻接点，若有则返回顶点号。若x没有邻接点或图中不存在x，则返回-1。
{
	int i, j;
	for (i = 0; i < g.vexnum; i++)
		if (x == g.Vex[i]) j = i;
	if (j >= g.vexnum) return -1; //图中不存在值为x的顶点
	else
	{
		for (i = 0; i < g.vexnum; i++)
			if (g.Edge[j][i] == 1) return i; //返回顶点号
		if (i >= g.vexnum) return -1; //x没有邻接点
	}
}

int NextNeighbor(MGraph g, VertexType x, VertexType y)
//假设图G中顶点y是顶点x的一个邻接点，返回除y外顶点x的下一个邻接点的顶点号，若y是x的最后一个邻接点，则返回-1
{
	int i, j, k;
	for (i = 0; i < g.vexnum; i++)
	{
		if (g.Vex[i] == x) j = i;
		if (g.Vex[i] == y) k = i;
	}
	if (j >= g.vexnum || k >= g.vexnum) return false; //不存在顶点x或顶点y
	else
	{
		for (i = k + 1; i < g.vexnum; i++)
		{
			if (g.Edge[j][i] == 1) return i; //返回顶点号
		}
		if (i >= g.vexnum) return -1; //x没有邻接点
	}
}

int main()
{
	MGraph g;
	VertexType Vex[MaxVertenNum];
	EdgeType Edge[MaxVertenNum][MaxVertenNum];
	InitG(g);
	CreateVex(g);
	CreateEdge(g);

	Info(g);
	printf("\n无向图G中共有：%d个顶点，%d条边\n", g.vexnum, g.edgenum);

	PrintMatrix(g);

	printf("输出无向图G中各顶点的连接情况：\n");
	PrintG(g);

	int sumdegree = 0, i;
	for (i = 0; i < g.vexnum; i++)
	{
		int degree;
		degree = CountDegree(g, g.Vex[i]);
		printf("顶点%c的度为：%d\n", g.Vex[i], degree);
		sumdegree = sumdegree + degree;
	}
	printf("无向图G中所有顶点的度之和为：%d\n", sumdegree);

	/*VertexType x, y;
	printf("\n-----判断图G是否存在边(x,y)-----\n");
	x = 'C', y = 'F';
	printf("顶点%c和顶点%c之间存在边吗？(1表示存在，0表示不存在)— %d", x, y, Adjacent(g, x, y));
	x = 'A', y = 'D';
	printf("\n顶点%c和顶点%c之间存在边吗？(1表示存在，0表示不存在)— %d\n", x, y, Adjacent(g, x, y));*/

	/*printf("\n-----列出图G中与结点x邻接的边-----\n");
	x = 'B';
	printf("与顶点%c连接的边有：", x);
	Neighbors(g, x);
	printf("\n");*/

	/*printf("\n-----在图G中插入顶点x-----\n");
	x = 'G';
	printf("插入顶点%c", x);
	printf("插入成功了吗？— %d(1表示成功，0表示失败)\n", InsertVertex(g, x));
	PrintG(g);
	Info(g);
	printf("无向图G中共有：%d个顶点，%d条边\n", g.vexnum, g.edgenum);
	PrintMatrix(g);*/

	/*printf("\n-----在图G中删除顶点x-----\n");
	x = 'C';
	printf("删除顶点%c\n", x);
	printf("删除成功了吗？(1表示成功，0表示失败)— %d\n", DeleteVertex(g, x));
	printf("输出无向图G中各顶点的连接情况：\n");
	PrintG(g);
	printf("\n");
	Info(g);
	printf("\n无向图G中共有：%d个顶点，%d条边\n", g.vexnum, g.edgenum);
	PrintMatrix(g);*/

	/*printf("\n-----图G中添加无向边(x, y)-----\n");
	x = 'E', y = 'F';
	printf("在顶点%c与顶点%c之间添加一条无向边\n", x, y);
	printf("添加成功了吗？— %d(1代表成功，原图中没有边(x, y)，0代表失败，原图中已存在该边或者顶点x/顶点y不存在)\n", AddEdge(g, x, y));
	printf("\n");
	PrintMatrix(g);

	printf("输出无向图G中各顶点的连接情况：\n");
	PrintG(g);
	printf("\n");*/

	/*printf("\n-----删除图G中无向边(x, y)-----\n");
	x = 'B', y = 'F';
	printf("删除(若存在)顶点%c与顶点%c之间的一条无向边\n", x, y);
	printf("删除成功了吗？— %d(1代表成功，原图中有边(x, y)，0代表失败，原图中不存在该边或者顶点x/顶点y不存在)\n", RemoveEdge(g, x, y));
	printf("\n");
	PrintMatrix(g);

	printf("输出无向图G中各顶点的连接情况：\n");
	PrintG(g);
	printf("\n");*/

	/*printf("\n-----求图G中顶点x的第一个邻接点-----\n");
	x = 'E';
	printf("图G中顶点%c的第一个邻接点的顶点号为：%d(-1代表x没有邻接点或图中不存在x)\n", x,FirstNeighbor(g,x));*/

	/*printf("\n-----求图G中除y之外顶点x的下一个邻接点的顶点号-----\n");
	x = 'B', y = 'E';
	printf("图G中除顶点%c之外顶点%c的下一个邻接点的顶点号为：%d(-1代表x没有邻接点或图中不存在x)\n", x, y, NextNeighbor(g, x, y));*/
	return 0;
}

在这里插入图片描述

  • ①Adjacent(G,x,y)：判断图G是否存在边(x,y)。
    在这里插入图片描述
  • ②Neighbors(G,x)：列出图G中与结点x邻接的边。
    在这里插入图片描述
  • ③InsertVertex(G,x)：在图G中插入顶点x。
    在这里插入图片描述
  • ④DeleteVertex(G,x)：从图G中删除顶点x。
    在这里插入图片描述
  • ⑤Addedge(G,x,y)：若无向边(x,y)不存在，则向图G中添加该边。
    在这里插入图片描述
  • ⑥RemoveEdge(G,x,y)：若无向边(x,y)存在，则从图G中删除该边。
    在这里插入图片描述
  • ⑦FirstNeighbor(G,x)：求图G中顶点x的第一个邻接点，若有则返回顶点号。若x没有邻接点或图中不存在x，则返回-1。
    在这里插入图片描述
  • ⑧NextNeighbor(G,x,y)：假设图G中顶点y是顶点x的一个邻接点，返回除y外顶点x的下一个邻接点的顶点号，若y是x的最后一个邻接点，则返回-1。
    在这里插入图片描述

邻接矩阵法的性质

  • 设图G的邻接矩阵为A(矩阵元素为0/1)，则 A n A^n An的元素 A n [ i ] [ j ] A^n[i][j] An[i][j]等于由顶点i到顶点j的长度为n的路径的数目。
    在这里插入图片描述
    在这里插入图片描述

A 2 [ 1 ] [ 1 ] = 1 A^2[1][1]=1 A2[1][1]=1：表示A-A长度为2的路径有1条， A 2 [ 2 ] [ 2 ] = 3 A^2[2][2]=3 A2[2][2]=3：表示B-B长度为2的路径有3条， A 2 [ 3 ] [ 3 ] = 2 A^2[3][3]=2 A2[3][3]=2：表示C-C长度为2的路径有2条…
在这里插入图片描述
A 3 [ 1 ] [ 2 ] = 3 A^3[1][2]=3 A3[1][2]=3：表示A-B长度为3的路径有3条， A 3 [ 2 ] [ 4 ] = 4 A^3[2][4]=4 A3[2][4]=4表示B-D长度为2的路径有4条， A 3 [ 3 ] [ 1 ] = 1 A^3[3][1]=1 A3[3][1]=1表示C-A长度为3的路径有1条， A 3 [ 4 ] [ 4 ] = 2 A^3[4][4]=2 A3[4][4]=2表示D-D长度为2的路径有2条…

—Miss. Z—
关注
  • 6
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言利用图的邻接矩阵的存储方式实现有向图和无向图的深度优先搜索（DFS）
Xenoverse的博客
11-20 9029
C语言利用图的邻接矩阵的存储方式实现有向图和无向图的深度优先搜索（DFS） Description 图采用邻接矩阵存储，图中顶点数为n(0&lt;n&lt;20)，顶点信息为整数，依次为0,1,..,n-1。 编写函数，输入图的类型，0：无向图，1：有向图；输入图的顶点数、边数、边的偶对，建立邻接矩阵； 编写函数，实现图的深度优先搜索，输出深度优先搜索序列。 调用上述函数，从0号顶点出发...
基于邻接数组法的无向图实现
凛_Lin~~的博客
01-21 1978
本文章对不带权的无向图作出实现（结点间的关系采用邻接数组 / 邻接矩阵表示），新人菜鸟写文章，难免有一些疏漏或者错误，如有发现，欢迎评论区指出，在此感谢各位看官老爷。 具体代码可以在主页获取。 一.工具 以C/C++语言实现数据结构，编程环境Code::Blocks 17.12 ，使用C++提供标准容器queue和string ，整体使用c语言，但因为c语言的string需要采用char数组模拟，所以采用c++的string类型，为了实现方便，同时直接采用c++标准的队列，使代码更简洁，无需做一些
数据结构与算法实验:图型数据结构及其应用
qq_33991272的博客
06-26 1019
实验题目： 设图结点的元素类型为char，建立一个不少于8个顶点的带权无向图G，实现以下图的各种基本操作的程序： ①用邻接矩阵作为储结构存储图G并输出该邻接矩阵； ② 用邻接链表作为储结构存储图G并输出该邻接链表； ③按DFS算法输出图G中顶点的遍历序列； ④ 按BFS算法输出图G中顶点的遍历序列； ⑤按Prime算法从某个指定的顶点出发输出图G的最小生成树； ⑥ 主函数通过函数调用实现以上各项操作。 不多说，直接上代码： #include<bits/stdc++.h> using name.
图的表示与基础操作：邻接矩阵与邻接表的C语言实现
最新发布
Mrluo386的博客
05-30 834
图由顶点集和边集构成，边可以是有向或无向的，且可带有权重。根据图的特性选择合适的存储结构至关重要，这直接影响到图的各种操作（如遍历、查找最短路径等）的效率。本文只对于代码做简单分享，不对代码的逻辑做深层解释，如果读者想知道代码的实现逻辑，请详细阅读代码中的注释部分。
图：邻接矩阵表示法创建无向图并深度优先搜索遍历
双鱼座boyy的博客
05-16 6085
无向图表示： 代码： #include<iostream> using namespace std; #define pointMax 100 #define MaxInt 32767 struct AMgroup { char VTchart[pointMax]; //顶点表 int AMchart[pointMax][pointMax]; //邻接矩阵 int point, vert; ...
邻接表实现无向图存储
qq_57525683的博客
11-26 674
【代码】邻接表实现无向图存储。
邻接矩阵法实现图C代码
02-27
以上就是使用邻接矩阵法实现图的基本思路和操作。这种实现方式适合于处理稠密图，即节点间连接较多的情况。对于稀疏图（节点间连接少），更推荐使用邻接表法，因为邻接表可以节省大量的内存空间。在实际应用中，应...
邻接矩阵-无向图.rar
04-23
无向图是一种图论概念，其中的边连接两个顶点，且没有方向之分。...通过理解和实现这些代码，你可以深入理解无向图的邻接矩阵表示法以及图的遍历算法。同时，这也是提升编程能力和算法基础的好机会。
数据结构C语言实现代码.zip
10-22
3. **图数据结构**：图是由顶点和边组成的，可以表示各种复杂关系，如邻接矩阵和邻接表是两种常见的图表示方式。图的遍历算法，如深度优先搜索（DFS）和广度优先搜索（BFS），在很多问题中都有应用。 4. **散列表...
《数据结构》的全部代码实现C语言.zip
06-18
下面将详细探讨这些代码实现所涵盖的数据结构及其相关知识点。 1. **线性数据结构**： - **数组**：是最基本的数据结构，C语言中通过动态内存分配可以实现大小可变的数组。数组提供了随机访问元素的能力，但插入和...
湖南大学数据结构实验5邻接矩阵.zip
03-08
在本实验“湖南大学数据结构实验5邻接矩阵”中，我们将专注于一种特定的数据结构——邻接矩阵，它是图理论的一个关键概念。在图论中，图是由顶点（节点）和连接这些顶点的边组成的结构。邻接矩阵是表示图的一种二维...
图的邻接矩阵存储代码
12-03
图邻接矩阵的存储代码 是我话了一个晚上编写的，足够全面
图深度优先遍历
qq_24624539的博客
12-03 3371
编写程序对给定的有向图（不一定连通）进行深度优先遍历，图中包含n个顶点，编号为0至n-1。本题限定在深度优先遍历过程中，如果同时出现多个待访问的顶点，则优先选择编号最小的一个进行访问，以顶点0为遍历起点。 输入格式: 输入第一行为两个整数n和e，分别表示图的顶点数和边数，其中n不超过20000，e不超过50。接下来e行表示每条边的信息，每行为两个整数a、b，表示该边的端点编号，但各边并非按端点编号顺序排列。 输出格式: 输出为一行整数，每个整数后一个空格，即该有向图的深度优先遍历结点序列。 输入样
数据结构——图（邻接矩阵建立无向图）
qq_59708493的博客
02-08 3117
邻接矩阵 介绍 邻接矩阵存储结构就每个顶点用一个最大值为n的一维数组存储边的信息,这样所有点合起来就是用矩阵表示图中各顶点之间的邻接关系。所谓矩阵其实就是N*N的二维数组。 对于有 n个顶点的图 G=(v,t) 来说,我们可以用一个 n×n 的矩阵 A来表示 G 中各顶点的相邻关系,如果 点v1和 点vj​之间存在边(或弧),则 A[i][j]=1,否则 A [ i][ j ]=A【j】【i】=0。” 优点 无向图邻接矩阵的第i行（或第i列）非零元素的个数正好是第i个顶点的度。 有向图邻接矩阵中第i
数据结构无向图的操作（C语言）
多低调的博客
12-02 4198
目录 //1、含邻接矩阵的图结构 //2、创建邻接矩阵 //3、打印邻接矩阵 //4、邻接表的图结构 //5、创建邻接表 //6、打印邻接表 //7、深度优先搜索 //8、广度优先搜索 //9、带主函数完整测试源码 //1、含邻接矩阵的图结构 用邻接矩阵来表示图： //定义邻接矩阵的图结构 typedef struct graph { elemtype data[N + 1];//存放顶点，不使用data[0]存放 int side[N + 1][N + 1];//邻接矩阵，同
邻接矩阵实现代码
q18108398942的博客
08-21 2279
邻接矩阵，是用来存储图的，也是对称矩阵，通过邻接矩阵，可以很容易的知道图中的信息。下面给出邻接矩阵的创建代码。 typedef char VertexType; /*顶点类型，可以自定义*/ typedef int EdgeType; /*边权值类型*/ #define MAXVEX 100 /*最大定点数*/ #define INFINITY 65535 /
【数据结构】图的存储结构之邻接矩阵（C语言）
xiangjunyes的博客
07-07 5653
定义 图的邻接矩阵（Adjacency Matrix）存储方式使用过两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。 我们来看一个实例，图1-1的左图就是一个无向图。 图1-1 我们设置两个数组，顶点数组为vertex[4]={v0,v1,}v2,v3} ，边数组arc[4][4]，如图1-1的右图这样的一个 ...
数据结构——邻接矩阵法（C语言实现）
qq_27846147的博客
06-02 1286
数据结构——邻接矩阵法（C语言实现） 直接上代码： //邻接矩阵法 #include <stdio.h> #define max 100 #define Elemtype char typedef struct{ Elemtype vex[max]; int edge[max][max]; int vexnum,arcnum; //图的当前顶点数和弧数 int mbool; }MGraph; int main() { MGraph mgraph; printf("输入顶点个数
C语言实现邻接矩阵（无向图的顺序表示）
Arithmetic-logic
08-06 2450
有向/无向不带权图 带权图 定义图的结构体 #define Default_Vertex_Size 10 #define T char typedef struct GraphMtx { int MaxVertices;//最大顶点容量 int NumVertices;//图中顶点个数 int NumEdges;//图中边的条数 T *VerticesList;//指向存有顶点的空间的指针 int **Edge;//指向存矩阵的空间的指针 }GraphMtx; 初始化 void
邻接矩阵A2怎么计算
07-27
邻接矩阵A2的计算可以通过将邻接矩阵A与自身相乘得到。根据引用\[1\]中的规律，假设邻接矩阵A的每一个点的坐标是(i,k)，那么邻接矩阵A2的每一个点的坐标是(k,j)，并且每一个点的意义均为两个定点之间是否有边。所以，如果邻接矩阵A中的(i,k)为1，邻接矩阵A中的(k,j)也为1，那么最后计算得到的邻接矩阵A2中的结果也为1，表示从i到j有边。换句话说，邻接矩阵A2中的每一个元素表示从i到j有多少条长度为2的可行路径。因此，可以通过将邻接矩阵A与自身相乘来计算邻接矩阵A2。 #### 引用[.reference_title] - *1* *2* [【数据结构】探究邻接矩阵A^2的意义](https://blog.csdn.net/qq_45879198/article/details/126808563)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值