数据结构-图的4种结构-邻接矩阵-邻接表-十字链表-邻接多重链表

最新推荐文章于 2022-11-05 19:56:17 发布
最新推荐文章于 2022-11-05 19:56:17 发布
阅读量329 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 指针 字符串 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39518639/article/details/106958398
版权

在这里插入图片描述
边节点数据结构：iver,ilink,jver,jlink
创建边节点时，查找iver,jver对应下标开始最后ilink,jlink为空时，把ilink或jlink指向当前所创建的节点。
顶点的edgefrist指针为空时表示创建的边节点为该顶点的第一条边。edgefirst直接指向该节点。

structfun.h

//数据结构函数头文件

#include <stdio.h>
#include <iostream>
#include<string>

using std::cout;
using std::cin;
using std::string;

#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define INFINITY 65535//无穷大
typedef string ElemType;
typedef string VertexType;//图顶点数据类型
typedef int EdgeType;//图边的数据类型

//数据结构-图-----------------------------------------------------------------------------

//1、邻接矩阵（Adjacency Martix）
	//设置一个顶点数组vertex[],设置一个边数组arc[][]
typedef struct
{
	//图顶点数组
	VertexType vertex[MAXSIZE];
	//图边数组
	EdgeType arc[MAXSIZE][MAXSIZE];	
	int vertexnum,arcnum;
}AdjMarGraph;

//2、邻接表（Adjacency List）
	//设置一个顶点数组vertex[],设置一个边的链表，顶点的next指向所对应的链表

typedef struct EdgeNode//边链表节点
{
	EdgeType arcVertex;
	int weight;//权值
	EdgeNode *next;
}EdgeNode;

typedef struct//顶点数组
{
	VertexType vertex;
	EdgeNode *firstEdge;
}VertexList[MAXSIZE];

typedef struct//图结构
{
	VertexList vlist;
	int numVertex,numArc;

}AdjListGraph;

//3、十字链表（Orthogonal->正交的 List）
	//设置一个顶点数组vertex[],设置一个边的链表，顶点的next指向所对应的链表

//链表节点 tailvex headvex headlink,taillink; 改成invex,outvex,outlink,inlink更好理解
                                                //入顶点，出顶点，出链接，入链接
typedef struct OrthogonalLinkNode
{
	EdgeType invex,outvex;
	OrthogonalLinkNode *outlink,*inlink;
	int weight;//边的权重
}OrthogonalLinkNode;

//数组顶点节点 vertex 顶点 edgein 入边 edgeout 出边
typedef struct
{
	VertexType vertex;
	OrthogonalLinkNode *edgein,*edgeout;
}OrthogonalEdgeNode[MAXSIZE];

//十字链表结构
typedef struct 
{
	OrthogonalEdgeNode vertexlist;
	int numvertex,numedge;
}OrthogonalListGraph;

//4、无向图 邻接多重表结构Adjacency Multiple Table（邻接多重表就是一个顶点的多条边用链表链接）
//ivex ilink jvex jlink (ivex jvex 边的两个顶点，ilink指向值与ivex相同的jvex的节点,jlink指向值与jvex相同的下一个节点。

typedef struct AMTEdgeNode//边链表节点
{
	EdgeType iver,jver;
	int weight;//权值
	AMTEdgeNode *ilink,*jlink;
}AMTEdgeNode;

typedef struct//顶点数组
{
	VertexType vertex;
	AMTEdgeNode *firstEdge;
}AMTVertexList[MAXSIZE];

typedef struct//图结构
{
	AMTVertexList vlist;
	int numVertex,numArc;

}AdjacencyMultipleTableGraph;

//1、邻接矩阵
	//无向图的邻接矩阵
int CreateAdjMaxGraph(AdjMarGraph *amg);

//2、邻接表
int CreateAdjListGraph(AdjListGraph *alg);

//3、十字链表
int CreateOrthogonalListGraph(OrthogonalListGraph *olg);

//4、邻接多重表结构
int CreateAdjacencyMultipleTableGraph(AdjacencyMultipleTableGraph *amtg);

structfun.cpp

#include<iostream>
#include<stdio.h>
#include<string>
#include<sstream>
#include"structfun.h"


using std::cout;
using std::cin;
using std::string;
using std::endl;
using std::ostringstream;

//图结构函数-----------------------------------------------
//1、邻接矩阵
	//图的邻接矩阵
int CreateAdjMaxGraph(AdjMarGraph *amg)
{
	int i=0;
	amg->vertexnum=0;
	amg->arcnum=0;

	while(1)//输入顶点;
	{
		printf("请输入顶点，结束用#号：");
	/*	scanf("%s",&amg->vertex[i]);*///string不能采用scanf,采用scanf必须先给字符串
		//预先分配空间，然后采用amg->vertex[i][0]scanf采用的是字符数组的形式存储字符串。
		//amg->vertex[i].resize(100);
		//scanf("%s",&amg->vertex[i][0]);
		cin>>amg->vertex[i];

		if(amg->vertex[i]=="#")
			break;
		amg->vertexnum++;
		i++;
		
	}
	for(i=0;i<amg->vertexnum;i++)//初始化边值为0
		for(int j=0;j<amg->vertexnum;j++)
		{
			if(i==j)
				amg->arc[i][j]=0;
			else
			amg->arc[i][j]=INFINITY;
		}
	//创建邻接矩阵图的边
	while(1)
	{
		int v1,v2,value;
		printf("请输入图的边的顶点下标（v1,v2,value）结束输入（0,0,0）：");
		scanf("%d,%d,%d",&v1,&v2,&value);
		amg->arc[v1][v2]=value;
		/*amg->arc[v2][v1]=value;*///无向图增加对等矩阵另外一边的值
		if(!v1&!v2&!value)
			break;
		amg->arcnum++;	
	}
	
	//输出图的邻接矩阵
	printf("图的邻接矩阵:\n");
	for(i=0;i<amg->vertexnum;i++)
	{
		printf("%s: ",amg->vertex[i].c_str());
		for(int j=0;j<amg->vertexnum;j++)
			{
				printf("%d  ",amg->arc[i][j]);
				if(j==amg->vertexnum-1)
					printf("\n");
			}
	}
return OK;
}

//2、邻接表
int CreateAdjListGraph(AdjListGraph *alg)
{
	int i=0;
	alg->numVertex=0;
	alg->numArc=0;
	while(1)//创建顶点
	{
		printf("请输入邻接表的顶点结束用#：");
		cin>>alg->vlist[i].vertex;
		if(alg->vlist[i].vertex=="#")
			break;
		alg->vlist[i].firstEdge=NULL;
		i++;
		alg->numVertex++;

	}
		while(1)//创建边链表
	{
		int v1=0,v2=0,w=0;
		EdgeNode *edgenode;
		printf("请输入邻接表的顶点对应的边（v1,v2,w）以(0,0,0)结束：");
		scanf("%d,%d,%d",&v1,&v2,&w);

		if(!v1&&!v2&&!w)//(0,0,0)结束
			break;

		edgenode = new EdgeNode();//创建边节点
		edgenode->arcVertex=v2;
		edgenode->weight=w;
		edgenode->next=NULL;

		if(alg->vlist[v1].firstEdge==NULL)//插入边节点
			alg->vlist[v1].firstEdge=edgenode;
		else
		{
			EdgeNode *temp;
			temp=alg->vlist[v1].firstEdge;

			while(temp->next!=NULL)
				temp=temp->next;
			temp->next=edgenode;
		}
		alg->numArc++;
	}
		return OK;
}

//3、十字链表(就是邻接表与逆邻接表合并)好处是方便同时具有图的出边和入边
int CreateOrthogonalListGraph(OrthogonalListGraph *olg)
{
	int i=0;
	olg->numvertex=0;
	olg->numedge=0;

	while(1)//输入顶点
	{
		printf("请输入图的顶点（以#结束）：");
		cin>>olg->vertexlist[i].vertex;
		if(olg->vertexlist[i].vertex=="#")
			break;
		olg->numvertex++;
		olg->vertexlist[i].edgein=NULL;
		olg->vertexlist[i].edgeout=NULL;
		i++;
	}

	while(1)//输入图的边
	{
		OrthogonalLinkNode *edge;
		edge=new OrthogonalLinkNode();
		edge->inlink=NULL;
		edge->outlink=NULL;
		int v1=0,v2=0,w=0;
		printf("请输入图的有向边（v1,v2,w）(0,0,0)结束：");
		scanf("%d,%d,%d",&v1,&v2,&w);
		if(!v1&&!v2&&!w)
			break;

		edge->outvex=v2;
		edge->invex=v1;//这一步是逆矩阵合并的步骤--edge->invex都等于链表的头顶点

		if(olg->vertexlist[v1].edgeout==NULL)
		{
			olg->vertexlist[v1].edgeout=edge;

		}else
		{
			OrthogonalLinkNode *temp;
			temp=new OrthogonalLinkNode(); 
			temp=olg->vertexlist[v1].edgeout;
			while(temp->outlink)
				temp=temp->outlink;
			temp->outlink=edge;
		}

		//最后处理图的入边与邻接表相比多了这个步骤，这个步骤是把逆邻接表串联起来，开头位置是edgein
		if(olg->vertexlist[v2].edgein==NULL)
		olg->vertexlist[v2].edgein=edge;
		else
		{
			OrthogonalLinkNode *temp;
			temp=new OrthogonalLinkNode(); 
			temp=olg->vertexlist[v2].edgein;
			while(temp->inlink)
				temp=temp->inlink;
			temp->inlink=edge;
		}

	}
	return OK;
}

//4、邻接多重表结构
int CreateAdjacencyMultipleTableGraph(AdjacencyMultipleTableGraph *amtg)
{
	int i=0;
	amtg->numVertex=0;
	amtg->numArc=0;

	while(1)//创建顶点
	{
		printf("请输入邻接表的顶点结束用#：");
		cin>>amtg->vlist[i].vertex;
		if(amtg->vlist[i].vertex=="#")
			break;
		amtg->vlist[i].firstEdge=NULL;
		i++;
		amtg->numVertex++;
	}

	while(1)//创建边
	{
		int v1,v2,w;
		AMTEdgeNode *node,*temp;
		node=new AMTEdgeNode();
		printf("请输入的边(v1,v2,w)用(0,0,0)结束：");
		scanf("%d,%d,%d",&v1,&v2,&w);
		if(!v1&&!v2&&!w)//(0,0,0)结束
		break;

		node->iver=v1;
		node->jver=v2;
		node->weight=w;
		node->ilink=NULL;
		node->jlink=NULL;


		if(!amtg->vlist[v1].firstEdge)//列表的firstEdge为空则指向节点
			amtg->vlist[v1].firstEdge=node;
		if(!amtg->vlist[v2].firstEdge)//列表的firstEdge为空则指向节点
			amtg->vlist[v2].firstEdge=node;

		if(amtg->vlist[v1].firstEdge!=node)
		{
			temp=new AMTEdgeNode();//处理v1的ilink和jlink
			temp=amtg->vlist[v1].firstEdge;
			while(temp)
			{
				if(temp->iver==v1)
				{
					if(!temp->ilink)//沿着链表找到ilink的最后为空，此时指针可以指向node
					{
						temp->ilink=node;
						break;
					}
					temp=temp->ilink;//否则继续下一个ilink节点
				}
				else 
				{
					if(!temp->jlink&&temp->jver==v1)
					{
						temp->jlink=node;
						break;
					}
					temp=temp->jlink;
				}
			}
		}

		if(amtg->vlist[v2].firstEdge!=node)
		{
			temp=new AMTEdgeNode();//处理v2的ilink和jlink
			temp=amtg->vlist[v2].firstEdge;
			while(temp)
			{
				if(temp->iver==v2)
				{
					if(!temp->ilink)
					{
						temp->ilink=node;
						break;
					}
					temp=temp->ilink;
				}
				else 
				{
					if(!temp->jlink&&temp->jver==v2)
					{
						temp->jlink=node;
						break;
					}
					temp=temp->jlink;
				}
			}
		}

		
		amtg->numArc++;
	}

	return OK;
}

main.cpp


#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<string>
#include"structfun.h"

using std::string;
using std::printf;
using std::scanf;
using std::endl;
using std::to_string;

void main()
{
//图的邻接矩阵
//AdjMarGraph amg;
//CreateAdjMaxGraph(&amg);

//图的邻接表
//AdjListGraph alg;
//CreateAdjListGraph(&alg);

//图的十字链表
//OrthogonalListGraph olg;
//CreateOrthogonalListGraph(&olg);

//图的邻接多重表
AdjacencyMultipleTableGraph amtg;
CreateAdjacencyMultipleTableGraph(&amtg);

system("pause");
}
weixin_39518639
关注
专栏目录
(王道408考研数据结构)第六章图-第二节1：图的存储结构（邻接矩阵、邻接表、十字链表和邻接多重表）
快乐江湖的博客
11-23 2055
文章目录一：邻接矩阵——适合存储稠密图（1）邻接矩阵定义（2）代码二：邻接表 一：邻接矩阵——适合存储稠密图 （1）邻接矩阵定义 图的邻接矩阵(Adjacency Matrix)：采用两个数组表示图。一个一维数组存储图中顶点信息；一个二维数组存储(邻接矩阵)图中边(无向图)或弧(有向图)的信息 对于无向图： 若某个元素值为1，代表两个顶点存在边 邻接矩阵是对称的，其中"1"的个数为图中总边数的2倍 矩阵中第iii行或第iii列元素之和为顶点iii的度 对于有向图： 若某个元素为1，代表从viv_{i
【数据结构笔记16】数据结构之图的四种存储结构（邻接矩阵、邻接表、十字链表、邻接多重表）
最新发布
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
12-22 815
邻接矩阵，其实就是利用一个二维数组来保存图G中的每一个顶点和顶点之间的关系，二维数组中的每一行或者每一列代表某个顶点V和其余顶点是否有边，大致如下图所示：邻接矩阵中的每一个单元格，表示两个顶点之间是否存在边，如果存在则设置为1，否则设置为0。如果图G是带权图，那么邻接矩阵中就可以保存对应边的权值，如果没有边，则保存无穷大，有时候，顶点自身到自身的单元格，也可以保存0。无向图的邻接矩阵中，如果要某个顶点的度，可以计算这个顶点对应的一行或者一列中，非0值个数，如果是带权图，那就统计非无穷大和非0的个数，最终
python两列数据生成邻接矩阵_python将邻接矩阵输出成图的实现
weixin_39524636的博客
12-03 1061
利用networkx，numpy，matplotlib，将邻接矩阵输出为图形。1，自身确定一个邻接矩阵，然后通过循环的方式添加变，然后输出图像import networkx as nximport matplotlib.pyplot as pltimport numpy as npG = nx.Graph()Matrix = np.array([[0, 1, 1, 1, 1, 1, 0, 0], ...
图的储存的四种形式（只有邻接矩阵没有）
蓝展展的博客
07-17 192
题目：https://acm.sdut.edu.cn/onlinejudge3/problems/3117 #include <iostream> #include <stdio.h> #include <string.h> #include <algorithm> #include <stdlib.h> #include <memory.h> #include <limits.h> #include <vector&
【数据结构】图的操作（邻接矩阵，邻接表，十字链表）
Bonstoppo
07-28 401
包含：邻接矩阵定义，邻接表的定义，十字链表的定义。
数据结构-图——以邻接矩阵、邻接表和十字链表实现
御承扬的博客
06-05 936
数据结构-图 对于上面这种有向图，现在分别以邻接矩阵、邻接表和十字链表的存储结构实现，并对前两种数据结构使用广度遍历和深度遍历。(在这里我只给出关键代码，详细代码，请通过文末的我的Github代码仓库的链接前往我的代码仓库查看！) 一、首先是以邻接矩阵的方式实现 #define MinInt 0 typedef char VerTexType; typedef int ArcType; cl...
数据结构20————图的五种存储结构
冰炭不投day的博客
01-19 2815
数据结构17————图的存储结构 一. 目录 数据结构17图的存储结构 一 目录 二 邻接矩阵 存储形式 图例 数据结构的结构体设计 实现有向图的存储并统计出度和入度 三 邻接表 存储形式 图例 数据结构的结构体设计 实现有向图的存储并统计出度和入 四 十字链表 存储形式 图例 数据结构的结构体设计 实现有向图的存储并统计出度和入 五邻接多重表 存储形式 图例 数据结构的
【数据结构】图的存储结构（邻接矩阵、邻接表、十字链表、邻接多重表）及实现（C语言）
weixin_51450101的博客
02-15 2751
邻接矩阵、邻接表、十字链表、邻接多重表是图的四种常用存储结构。图的邻接矩阵表示法（Adjacency Matrix）也称作数组表示法。它采用两个数组来表示图：一个是用于存储顶点信息的一维数组，另一个是用于存储图中顶点之间关联关系的二维数组，这个关联关系数组被称为邻接矩阵。 有向图的邻接矩阵可以指示弧的方向；无向图的邻接矩阵没有方向，所以是对称矩阵； 稀疏图不适于用邻接矩阵来存储，会造成空间浪费。 1.2 采用邻接矩
数据结构（廿四） -- C语言版 -- 图 - 图的存储结构 -- 十字链表、邻接多重表、 边集数组
青椒*^_^*凤爪爪的博客
09-05 7691
在图中任何两个顶点之间都可能存在联系，所以图的存储结构应该需要根据具体问题的要求来进行设计。从图的逻辑结构定义来看，图中任何一个顶点都可以看成是第一个顶点。常用的存储结构有邻接矩阵、邻接表（逆邻接表）、十字链表、邻接多重表、 边集数组。
图的存储结构（下）十字链表和邻接多重表，边集数组 数组和链表.pdf
04-18
十字链表是一种有向图的存储结构，它可以解决邻接表的出度问题。在十字链表中，每个顶点表后面接的是其出边表，每个出边表节点中含有头节点指针域（headlink）和尾节点指针域（taillink）。headlink指向的是下一个出...
Python处理已知网络关系数据为邻接矩阵
07-12
用Python将Excel网络关系（两列，id1,id2）转换为邻接矩阵。将数据更改为csv格式存储，通过遍历数据，输出邻接矩阵。经过实验，对网络节点关系数据进行重复处理，即1对应2节点，同样在数据中输入2对应1节点，以此可直接求出邻接矩阵，
文本处理，将交互组数据转化成邻接矩阵
徐赤赤的博客
05-29 2587
public static void main(String[] args) throws Exception { File file = new File("C:\\Users\\xuchichi\\Desktop\\method3\\123.txt"); List gene1 = readGeneName1(file); List gene2 = readGeneName2(fil
POJ 2003 Hire and Fire (多重链表 树结构 好题)
Tc的专栏
07-17 2289
POJ 2003 Hire and Fire (多重链表 树结构 好题)
2020-10-9 //严蔚敏《数据结构》 //图的存储结构：邻接多重表（适用于无向图、无向网）
weixin_45888287的博客
10-09 173
//严蔚敏《数据结构》 //图的存储结构：邻接多重表（适用于无向图、无向网） 邻接多重表的创建类似于有向图、网的十字链表的创建 //自学中，加油！ #include<iostream> #include<string> using namespace std; typedef enum{unvisited,visited} Visitif; #define InfoType double #define VertexType string const int MaxVertexNum
邻接多重表存储无向图以及有关操作
lovecontry
11-13 456
数据结构是编程里面最重要的一门基础课之一，所以学多少遍都不可以嫌多，算法的知识当然是融在其中，多练习，多思考，基础打好了，其他的东西学起来也就so easy了。 邻接多重表，是对用邻接表存储无向图的一种压缩存储，当然也是链式存储，邻接多重表的相关概念，可以百度、谷歌、或者看有关书籍。大部分书都没有详细介绍这个结构的应用(至少我目前还没看到有书上有写)，只是说 这个结构在对无向图的边进行操作的时候...
图的创建与遍历
子非鱼的博客
05-18 4029
图的存储结构可以用邻接矩阵或者邻接表来表示，对于n个顶点和e条边的无向网图，采用邻接矩阵创建时，其时间复杂度为O(n+n^2+e)，深度优先算法遍历时间复杂度为O(n^2)；采用邻接表创建时，其时间复杂度为O(n+e)，深度优先算法遍历时间复杂度为O(n+e)。以下是两种方式的代码实现。 #include<iostream> #define INF 65535 #define MAXVEX 100
数据结构之线性表、多重链表
weixin_73293671的博客
11-05 1458
本篇是对于学习到的数据结构线性表，广义表，多重链表的总结，内容有点小多。
数据结构 学习笔记（二）：线性结构：线性表（顺序表，链表，广义表，多重链表）
学愈进而愈惘
09-20 4859
前言请跟着上一讲http://blog.csdn.net/jurbo/article/details/52586981继续学习2.1 线性表及其实现2.1.1 引子：多项式表示【例】：一元多项式及其运算一元多项式： 主要运算：多项式相加、相减、相乘等【分析】如何表示多项式？多项式的关键数据： 多项式项数n 各项系数及指数 方法1：顺序存储结构直接表示方法2：顺序存储结构表示非零项方法3：链表结构存
Java多重链表_线性表、广义表、多重链表
weixin_35728286的博客
02-25 565
线性表、广义表、多重链表开始实习了，发现每天自我学习的时间好少好少，可能是自己懒吧，其实感觉有很多空闲时间自己可以学习只是自己没有好好把握，以前学数据结构没有好好学，现在补上吧！哈哈还是那句话欠的帐还是要还的。什么叫线性表？什么叫广义表？什么叫多重链表？呃....线性表借用MOOC上ZJU数据结构姥姥的例子：一元多项式 f(x)=4x5+3x3+2x^2+x节点：coef : 系数 ，expon ...
数据结构-十字链表详解
本文将深入探讨十字链表这一数据结构，它是有向图的一种链式存储方式，结合了邻接矩阵和邻接表的优势。在数据结构领域，十字链表的设计旨在高效地处理有向图中的节点连接。 首先，十字链表的构建基于两个主要节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值