数据结构--图的邻接矩阵存储

最新推荐文章于 2022-05-30 20:03:29 发布
最新推荐文章于 2022-05-30 20:03:29 发布
阅读量453 收藏 7
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53786696/article/details/117123621
版权
这段代码展示了如何使用邻接矩阵存储有向图、无向图及其相关信息，并提供了插入、删除顶点和弧的操作。此外，还实现了广度优先遍历和深度优先遍历的算法。代码中包括了数据结构如队列的定义，以及创建有向图、无向图的函数。
摘要由CSDN通过智能技术生成

图的邻接矩阵存储

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
//#include "HeadFile.h"
#define INFINITY 65535
#define MAX_VERTEX_NUM 20
#define MAX_NAME 3
#define MAX_INFO 20
#define ERROR 0
#define OK 1
typedef int ElemType;
typedef int Status;
typedef int VRType;
typedef char InfoType;
typedef enum{DG,DN,AG,AN}GraphKind;
typedef char VertexType[MAX_NAME];
 //队列结构
typedef struct node    
{
	ElemType data;
	struct node *next;
}QueueNode;
typedef struct
{
	QueueNode *front;
	QueueNode *rear;
}LinkQueue;

typedef struct
{
	VRType adj;
	InfoType *info;
}AdjMatrixNode;
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];
	AdjMatrixNode arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
	int vexnum,arcnum;
	GraphKind kind;
}MGraph;

//求顶点位置
int LocateVex(MGraph G,VertexType u)
{
	int i;
	for(i=0;i<G.vexnum;++i)
		if(strcmp(u,G.vexs[i])==0)
			return i;
	return ERROR;
}

//求顶点信息
VertexType *GetVex(MGraph G,int v)
{
	if(v>=G.vexnum||v<0)
		return ERROR;
	return &G.vexs[v];
}

//对顶点赋新值
Status PutVex(MGraph *G,VertexType v,VertexType value)
{
	int k;
	k=LocateVex(*G,v);
	if(k<0)
		return ERROR;
	strcpy((*G).vexs[k],value);
	return 1;
}

//求顶点的第一个邻接顶点的序号
int FirstAdjVex(MGraph G, VertexType v)
{
	int i,j=0,k;
	k=LocateVex(G,v);
	if(G.kind==DN||G.kind==AN)
		j=INFINITY; 
	for(i=0;i<G.vexnum;i++)
		if(G.arcs[k][i].adj!=j)
			return i;
	return ERROR;
}


//求顶点v相对于某顶点w的下一个邻接顶点的序号
int NextAdjVex(MGraph G,VertexType v,VertexType w)
{
	int i,j=0,k1,k2;
	k1=LocateVex(G,v);
	k2=LocateVex(G,w);
	if(G.kind==DN||G.kind==AN)
		j=INFINITY;
	for(i=k2+1;i<G.vexnum;i++)
		if(G.arcs[k1][i].adj!=j)
			return i;
	return ERROR;
}

//插入新顶点
void InsertVex(MGraph *G,VertexType v)
{
	int i;
	strcpy((*G).vexs[(*G).vexnum],v);
	for(i=0;i<=(*G).vexnum;i++)
	{
		if((*G).kind%2)
		{
			(*G).arcs[(*G).vexnum][i].adj=INFINITY;
			(*G).arcs[i][(*G).vexnum].adj=INFINITY;
		}
		else
		{
			(*G).arcs[(*G).vexnum][i].adj=0;
			(*G).arcs[i][(*G).vexnum].adj=0;
		}
		(*G).arcs[(*G).vexnum][i].info=NULL;
		(*G).arcs[i][(*G).vexnum].info=NULL;
	}
	(*G).vexnum+=1;
}

//删除顶点
Status DeleteVex(MGraph *G,VertexType v)
{
	int i,j,k;
	VRType m=0;
	k=LocateVex(*G,v);
	if(k<0)
		return ERROR;
	if((*G).kind==DN||(*G).kind==AN)
		m=INFINITY;
	for(j=0;j<(*G).vexnum;j++)
		if((*G).arcs[j][k].adj!=m)
		{
			if((*G).arcs[j][k].info)
				free((*G).arcs[j][k].info);
			(*G).arcnum--;
		}
		if((*G).kind==DG||(*G).kind==DN)
			for(j=0;j<(*G).vexnum;j++)
				if((*G).arcs[k][j].adj!=m)
				{
					if((*G).arcs[k][j].info)
						free((*G).arcs[k][j].info);
					(*G).arcnum--;
				}
		for(j=k+1;j<(*G).vexnum;j++)
			strcpy((*G).vexs[j-1],(*G).vexs[j]);
		for(i=0;i<(*G).vexnum;i++)
			for(j=k+1;j<(*G).vexnum;j++)
				(*G).arcs[i][j-1]=(*G).arcs[i][j];
		for(i=0;i<(*G).vexnum;i++)
			for(j=k+1;j<(*G).vexnum;j++)
				(*G).arcs[j-1][i]=(*G).arcs[j][i];
		(*G).vexnum--;
		return OK;
}

//插入新弧
Status InsertArc(MGraph *G,VertexType v,VertexType w)
{
	int i,len,v1,w1;
	char *info,s[MAX_INFO];
	v1=LocateVex(*G,v);
	w1=LocateVex(*G,w);
	if(v1<0||w1<0)
		return ERROR;
	(*G).arcnum++;
	if((*G).kind%2)
	{
		printf("请输入此弧或边的权值：");
		scanf("%d",&(*G).arcs[v1][w1].adj);
	}
	else
		(*G).arcs[v1][w1].adj=1;
	printf("是否有该弧或边的相关信息(0:无 1:有)：");
	scanf("%d%*c",&i);
	if(i)
	{
		printf("请输入该弧或边的相关信息（<%d个字符):",MAX_INFO);
		gets(s);
		len=strlen(s);
		if(len)
		{
			info=(char*)malloc((len+1)*sizeof(char));
			strcpy(info,s);
			(*G).arcs[v1][w1].info=info;
		}
	}
	if((*G).kind>1)
	{
		(*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
		(*G).arcs[w1][v1].info=(*G).arcs[v1][w1].info;
	}
	return OK;
}

//删除弧
Status DeleteArc(MGraph *G,VertexType v,VertexType w)
{
	int v1,w1;
	v1=LocateVex(*G,v);
	w1=LocateVex(*G,w);
	if(v1<0||w1<0)
		return ERROR;
	if((*G).kind%2==0)
		(*G).arcs[v1][w1].adj=0;
	else
		(*G).arcs[v1][w1].adj=INFINITY;
	if((*G).arcs[v1][w1].info)
	{
		free((*G).arcs[v1][w1].info);
		(*G).arcs[v1][w1].info=NULL;
	}
	if((*G).kind>=2)
	{
		(*G).arcs[w1][v1].adj=(*G).arcs[v1][w1].adj;
		(*G).arcs[w1][v1].info=NULL;
	}
	(*G).arcnum--;
	return OK;
}

//构造有向图G的邻接矩阵
Status CreateDN(MGraph *G)
{
	int i,j,k,w,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;
	printf("请输入图的类型（有向图：0，有向网：1，无向图：2，无向网：3）:");
	scanf("%d",&(*G).kind);
	printf("请输入的顶点数、弧数、弧是否含其他信息(是:1,否:0):");
    scanf("%d %d %d",&(*G).vexnum,&(*G).arcnum,&IncInfo);
	printf("请输入%d个顶点的值(<%d个字符):",(*G).vexnum,MAX_NAME);
	for(i=0;i<(*G).vexnum;++i)
		scanf("%s",(*G).vexs[i]);
	for(i=0;i<(*G).vexnum;++i)
		for(j=0;j<(*G).vexnum;++j)
		{
			(*G).arcs[i][j].adj=INFINITY;
			(*G).arcs[i][j].info=NULL;
		}
	if((*G).kind==1||(*G).kind==3)
		printf("请顺序输入每条弧（边）的权值、弧尾和弧头（以空格作为间隔）:\n");
	else
		printf("请顺序输入每条弧（边）的弧尾和弧头（以空格作为间隔）:\n");
	for(k=0;k<(*G).arcnum;++k)
	{
		printf("第%d条弧",k+1);
		if((*G).kind==1||(*G).kind==3)
			scanf("%d%s%s",&w,va,vb);
		else
			scanf("%s%s",va,vb);
		i=LocateVex(*G,va);
		j=LocateVex(*G,vb);
		if((*G).kind==0)
			(*G).arcs[i][j].adj=1;
		if((*G).kind==1)
			(*G).arcs[i][j].adj=w;
		if((*G).kind==2)
		{
			(*G).arcs[i][j].adj=1;
			(*G).arcs[j][i].adj=1;
		}
		if((*G).kind==3)
		{
			(*G).arcs[i][j].adj=w;
			(*G).arcs[j][i].adj=w;
		}
		if(IncInfo)
		{
			printf("请输入该弧的相关信息(<%d个字符)：",MAX_INFO);
			gets(s);
			w=strlen(s);
			if(w)
			{
				info=(char*)malloc((w+1)*sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info=info;
			}
		}
	}
	printf("该图的邻接矩阵构造完成!");
	return OK;
}

//图的邻接矩阵存储结构的打印输出算法
void Display(MGraph G)
{
	int i,j;
	char s[7],s1[3];
	switch(G.kind)
	{
	case DG:
		strcpy(s,"有向图\0");
		strcpy(s1,"弧\0");
		break;
	case DN:
		strcpy(s,"有向网\0");
		strcpy(s1,"弧\0");
		break;
	case AG:
		strcpy(s,"无向图\0");
		strcpy(s1,"边\0");
		break;
	case AN:
		strcpy(s,"无向网\0");
		strcpy(s1,"边\0");
	}
	printf("%d个顶点%d条%s的%s\n",G.vexnum,G.arcnum,s1,s);
	for(i=0;i<G.vexnum;i++)
		printf("G.vexs[%d]=%s\n",i,G.vexs[i]);
	printf("G.arcs.adj:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
			printf("G.arc[%d][%d]=%d\n",i,j,G.arcs[i][j].adj);
		printf("\n");
	}
	printf("G.arcs.info:\n");
	for(i=0;i<G.vexnum;i++)
	{
		for(j=0;j<G.vexnum;j++)
			printf("%s\t",G.arcs[i][j].info);
		printf("\n");
	}
}

int InitQueue(LinkQueue *Q)               //链队列的初始化操作
{
	Q->front=(QueueNode *)malloc(sizeof(QueueNode));
	Q->front->next=NULL;
	Q->rear=Q->front;
	return OK;
}
int EnQueue(LinkQueue *Q,ElemType e)   //链队列的入操作
{
	QueueNode *p;
	p=(QueueNode *)malloc(sizeof(QueueNode));
	p->data=e;
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return OK;
}
int DeQueue(LinkQueue *Q,ElemType *e)        //链队列的出队操作
{
	QueueNode *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;
}
int QueueEmpty(LinkQueue Q)
{
	if(Q.front==Q.rear)
		return 0;
	else
		return 1;
}

/*Visit(MGraph G,int v)
{
	printf("%s",G.vexs[v]);
}*/
//邻接矩阵存储结构上的广度优先遍历算法
void BFSTraverse(MGraph G)
{
	int v,u,w;
	VertexType w1,u1;
	LinkQueue Q;
	int visited[MAX_VERTEX_NUM];
	for(v=0;v<G.vexnum;v++)
		visited[v]=-1;
	InitQueue(&Q);
	for(v=0;v<G.vexnum;v++)
		if(visited[v]==-1)
		{
			visited[v]=1;
			printf("%s ",G.vexs[v]);
			EnQueue(&Q,v);
			while(!QueueEmpty(Q))
			{
				DeQueue(&Q,&u);
				strcpy(u1,*GetVex(G,u));
				for(w=FirstAdjVex(G,u1);w>=0;)
				{
					if(visited[w]==-1)
					{
						visited[w]=1;
						printf("%s ",G.vexs[w]);
						EnQueue(&Q,w);
					}
					w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)));
				}
			}
		}
		printf("\n");
}

//邻接矩阵存储结构上的深度优先遍历的递归算法
/*VisitFunc(MGraph G,int v)
{
	printf("%s",G.vexs[v]);
}

int visited[MAX_VERTEX_NUM];
   // Status(*VisitFunc)(VertexType);
void DFS(MGraph G,int v)
{
	VertexType w1,v1;
	int w;
	visited[v]=1;
	VisitFunc(G,v);
	strcpy(v1,*GetVex(G,v));
	for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
		if(!visited[w])
			DFS(G,w);
}
void DFSTraverse(MGraph G)
{
	int visited[MAX_VERTEX_NUM];
	//VisitFunc=Visit;
	int v;
	for(v=0;v<G.vexnum;v++)
		visited[v]=0;
	for(v=0;v<G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);
	printf("\n");
}*/

void DFSTraverse(MGraph G,int v)
{
	int visited[MAX_VERTEX_NUM]={0};
	int S[MAX_VERTEX_NUM]={0};
	int top=-1;
	int j;
	printf("%s ",G.vexs[v]);
	visited[v]=1;
	S[++top]=v;
	while(top!=-1)
	{
		v=S[top];
		for(j=0;j<G.vexnum;j++)
		{
			if(G.arcs[v][j].adj==1 && visited[j]==0)
			{
				printf("%s ",G.vexs[j]);
				visited[j]=1;
				S[++top]=j;
				break;
			}
		}
		if(j==G.vexnum)
			top--;
	}
}



int main()
{
	int v1=1;
	MGraph myG;
	CreateDN(&myG);
	printf("打印图：\n");
	Display(myG);
	printf("图的广度优先遍历：");
	BFSTraverse(myG);
	printf("图的深度优先遍历：");
	DFSTraverse(myG,0);

}
大菜彩
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构（17.1）图之邻接矩阵存储
小姚的博客
07-12 1365
图的邻接矩阵存储方式
【数据结构】图的邻接矩阵存储实现
wenqian 'blog
07-29 8158
图的邻接表存储实现：http://blog.csdn.net/wenqian1991/article/details/24667287 图的邻接表DFS和BFS算法：http://blog.csdn.net/wenqian1991/article/details/24812393 这里则介绍图的另外一种存储方式：邻接矩阵。参考资料《大话数据结构》《C算法：卷二》 一、图的数据结构 图的邻接
数据结构：图的邻接矩阵存储
ml29895063的博客
04-01 1858
数据结构：图的邻接矩阵存储
【数据结构】图的存储结构之邻接矩阵（C语言）
xiangjunyes的博客
07-07 5665
定义 图的邻接矩阵（Adjacency Matrix）存储方式使用过两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。 我们来看一个实例，图1-1的左图就是一个无向图。 图1-1 我们设置两个数组，顶点数组为vertex[4]={v0,v1,}v2,v3} ，边数组arc[4][4]，如图1-1的右图这样的一个 ...
数据结构之图的邻接矩阵存储
AHuRui的博客
05-30 376
图的定义 图是由顶点的又穷非空集合和顶点之间边的集合组成的们通常表示为G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
数据结构学习--图的邻接矩阵和邻接表存储
06-25
在数据结构的学习中，图是一种非常重要的非线性数据结构，用于表示对象之间的关系。图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素...
数据结构-c语言-带main函数-图7.2-图的存储结构-图的邻接矩阵的创建-无向图。
06-24
数据结构-c语言-图的存储结构-图的邻接矩阵的创建-无向图 数据结构是计算机科学中最重要的概念之一，它是指计算机中组织、存储和管理数据的方式。图是一种常见的数据结构，代表着顶点和边之间的关系。图的存储结构...
数据结构-c语言-带main函数-图7.2-图的存储结构-图的邻接矩阵的创建-有向图。
06-24
### 数据结构-C语言-图的邻接矩阵创建详解 #### 一、引言 在计算机科学领域，数据结构是组织和存储数据的一种方式，能够高效地进行数据访问和修改。图作为复杂数据结构的一种，广泛应用于众多场景之中，如网络路由...
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
通过使用邻接矩阵存储图的结构，我们可以有效地表示顶点之间的关系。邻接矩阵对于稠密图来说尤其有效，因为它能够直接通过索引快速查找任意两个顶点之间的关系。然而，对于稀疏图来说，邻接矩阵会占用大量的空间，...
数据结构-c语言-带main函数-图7.3-图的遍历-深度优先搜索-递归方法-邻接矩阵-有向图。
06-24
在IT领域，数据结构是计算机科学中的核心概念之一，它涉及到如何有效地组织和存储数据，以便于高效地访问和操作。本示例中，我们关注的是图数据结构，特别是使用C语言实现的深度优先搜索（DFS）算法。DFS是一种遍历...
数据结构——实现图的邻接矩阵和邻接表储存
qq_52479948的博客
01-26 1771
#include<stdio.h> #include<malloc.h> #define INF 32767 //定义无穷 #define MAXV 100 //最大顶点个数 typedef char InfoType; //定义邻接矩阵类型 typedef struct { int no; //顶点编号 InfoType info; //顶点信息 }VertexType; //顶点类型 typedef struct { int e.
【数据结构】图-图的存储_邻接矩阵（图解、c++、java）
扑腾的江鱼复习仓库
03-08 1950
URLeisure的图的存储_邻接矩阵”完美“复习资料。
邻接矩阵存储图
知与谁i的博客
11-02 517
#include #include #define MAX_VERTEX_NUM 20 typedef int AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; typedef struct{ AdjMatrix arcs;//定义一个指向二维数组的变量 int vexnum,arcnum;//图当前的顶点数和边数 char vexs[MAX_VER
38. 数据结构笔记之三十八图的邻接矩阵存储实现
badman250的专栏
09-21 4226
38. 数据结构笔记之三十八图的邻接矩阵存储实现 “世界上有两种人，一种人，虚度年华；另一种人，过着有意义的生活。在第一种人的眼里，生活就是一场睡眠，如果在他看来，是睡在既温暖又柔和的床铺上，那他便十分心满意足了；在第二种人眼里，可以说，生活就是建立功绩......人就在完成这个功绩中享到自己的幸福。 --别林斯基”     来看下图的邻接存储实现。 1.  邻接矩阵存储原理 对于线性表来
（数据结构）图的储存（邻接表 邻接矩阵）
weixin_50935546的博客
05-31 315
1.图的邻接表储存（并实现找入度出度） #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<string> #include<vector> #include<stack> #include<bitset> #include<cstdlib> #include<cmath> #
图的邻接矩阵存储（简单代码实现）
qq_42552006的博客
11-13 8322
说起来邻接矩阵，对于学过线性代数的同学理解起来非常简单 其实就是一个数字组成方阵，每一个数字都能有有意义的代表一些信息。 下面来看一个例子 如上图所示的图，使用邻接矩阵存储的话应该是下面的情况 由此可见，邻接矩阵存储的无向图必定是对称的 如果是下面的有向图我们该如何表示呢 由行到列看，顶点1到3是连同的，路径的权值是10，而顶点3到1是不连通的所以用数学中的无穷大进行表示。 我相信大家也能够看出来有向图和无向图的区别了 下面用代码来实现带权值的无向图的的存储 存储结构 typedef struct { c
图的存储结构之邻接矩阵
weixin_51656756的博客
04-27 204
邻接矩阵   emmm,由于考虑到图是由顶点和弧两部分组成，合在一起比较困难，所以就考虑分到两个结构来分别存储，顶点不分大小，主次，所以用一个一维数组来存即可，而边或弧由于是顶点和顶点之间的关系，所以用二维数组来存.   二维数组存储数据的大小由什么来决定呢？ 由顶点数目来决定，顶点数是n，这个二维数组就是n*n的矩阵 我们先要来定义图的结构 typedef char VertexType; typedef enum { DG, UDG//有向图，无向图 }GraphType; typedef st.
图邻接矩阵存储代码实现（2）
qq_38130912的博客
01-26 738
图邻接矩阵：用两个数组来表示图。一个一维数组存储图的顶点，另外一个二维数组存储图中边或者弧的信息。 首先需要创建一个图，并在创建的过程记住每个元素的位置信息，这样有利于用easyx来画出更直观的图，便于观察。需要定义两个结构体： 元素即其位置结构体，图的结构体 用到的头文件如下： #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #include..
c语言实现一个邻接矩阵的存储（main函数没有打）
weixin_43316730的博客
05-11 244
#include<stdio.h> #include<stdlib.h> //初始化图 struct Gnode { int Nv; int Ne; int G[100][100]; char Data[100]; }; typedef struct Gnode* Graph; //初始化边 struct Enode { int v1,v2; int we...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大菜彩

家人们鼓励鼓励！

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

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

打赏作者

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

抵扣说明：

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

余额充值