图的邻接表与邻接矩阵相互转换

最新推荐文章于 2024-08-02 17:06:55 发布
最新推荐文章于 2024-08-02 17:06:55 发布
阅读量1.2k 收藏 4
点赞数 4
分类专栏： 图 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46127065/article/details/122212848
版权

如题 自用笔记 如有错误欢迎及时指正

两种存储结构的转换涉及以下数据：

        a.顶点数目与边数目

        b.顶点信息

        c.边信息

        d.为要转换的结构申请空间

        e.其他存储结构中保存的信息包括顶点度数，边权值等等

下面以无向带权图讨论该问题，有向图转换类似不再赘述。

存储结构定义

邻接表

*顶点表中带顶点度数域，边表中带权值域

/* ===预定义=== */
#define MAX_VEX_NUM 10
#define INF 2147483647

typedef int VertexType;            //顶点数据类型
typedef int EdgeType;               //边权值

/*===邻接表结构===*/
//边表结点
typedef struct ArcNode{
    int adjvex;     //以上一个顶点起始的边 所指向结尾顶点 在顶点表中的下标
    EdgeType weight;        //边权值
    struct ArcNode *nextarc;        //指向边表下一个结点
}ArcNode;
//顶点表结点
typedef struct VexNode{
    VertexType data;        //顶点的数据域
    int degree;     //度数
    ArcNode *firstarc;       //指向第一条出边 也就是指向第一个邻接顶点
} VexNode, AdjList[MAX_VEX_NUM];       //结构体数组    即为一个顺序存储的顶点表  用来保存顶点信息
//邻接表
typedef struct AdjacentList{
    AdjList List;       
    int vexnum;
    int edgenum;        
}ALGraph,*AdjListGraph;

/* ===建立邻接表=== */
void CreateGraph_AdjList(AdjListGraph &G){
    int numV, numE;     //要创建图的总顶点数与边数
    //建立初始结构
    printf("输入图的总顶点数与边数，使用空格隔开: ");
    scanf("%d%d", &numV, &numE);
    if(numV>MAX_VEX_NUM){
        printf("结点数超出限制！\n");
        return;
    }
    G = (ALGraph *)malloc(sizeof(ALGraph));
    G->vexnum = numV;
    G->edgenum = numE;
    printf("\n");
    
    int i, j;       //遍历控制器
    int start, end;     //一条弧的弧尾与弧头结点序号
    int w;      //弧权值
    
    //设置顶点表List 输入顶点信息存入list的data域并初始化firstarc指针域
    for (i = 0; i < G->vexnum; i++){
        printf("请输入第%d个结点的信息: ", i + 1);
        scanf("%d",&G->List[i].data);
        G->List[i].firstarc = NULL;     //初始化firstarc域
        G->List[i].degree = -1;
    }
    printf("\n");

    //创建边表数据
    for (i = 0; i < G->edgenum; i++){
        printf("依次输入第%d条边的'起始节点序号start','结束结点序号end','权值w',使用空格隔开(satrt与end在(1,...,n)取值)\n: ",i+1);
        scanf("%d%d%d", &start, &end, &w);
        printf("在无向图G中建立权值为%d的边(V%d,V%d)...\n", w, start, end);
        //注意无向图特性 邻接表中 边要记录两次
        //建立边<satrt,end>
        ArcNode *arc1 = (ArcNode *)malloc(sizeof(ArcNode));
        arc1->adjvex = end-1;      //边的结束结点下标为end-1
        arc1->weight = w;        //权值
        /* 采用头插法将边结点插入到顶点表表头结点之后 */
        arc1->nextarc = G->List[start-1].firstarc;
        G->List[start-1].firstarc = arc1;
        /* 采用头插法将边结点插入到顶点表表头结点之后 */
        //建立边<end,start>,若建立有向图,无此步
        ArcNode *arc2 = (ArcNode *)malloc(sizeof(ArcNode));
        arc2->adjvex = start-1;      //边的结束结点下标为start-1
        arc2->weight = w;          //权值
        /* 采用头插法将边结点插入到顶点表表头结点之后 */
        arc2->nextarc = G->List[end-1].firstarc;
        G->List[end - 1].firstarc = arc2;
        /* 采用头插法将边结点插入到顶点表表头结点之后 */
    }
}

/* ===输出图的邻接矩阵=== */
void PrintGraph_AdjList(AdjListGraph G){
    ArcNode *p; //工作指针
    int i, j;       //遍历控制器
    printf(" [顶点表]    [边表]  \n");
    for (int i = 0; i < G->vexnum; i++){
        //输出顶点表 第一个是下标 第二个是顶点信息
        printf("%d[ V%d |   ]->",i, G->List[i].data);     
        p = G->List[i].firstarc;
        while(p!=NULL){     //p不空
            //第一个是邻接点在顶点表中下标 第二个是边权值
            printf("[ %d | %d |   ]->", p->adjvex, p->weight);
            p = p->nextarc;
        }
        printf("[ ∞ | ∞ | ^ ]");
        printf("\n");
    }
}

邻接矩阵

*内含一个数组保存顶点度数

/* ===预定义=== */
#define MAX_VEX_NUM 10
#define INF 2147483647

typedef int VertexType;            //顶点数据类型
typedef int EdgeType;               //边权值

/* ===邻接矩阵结构=== */
typedef struct AdjacentMatrix{
    VertexType Vex[MAX_VEX_NUM];       //顶点表 保存顶点信息
    int Degree[MAX_VEX_NUM];        //存储顶点度数
    EdgeType Edge[MAX_VEX_NUM][MAX_VEX_NUM];      //边表  保存边信息
    int vexnum,edgenum;     //图当前顶点数与边数
} MGraph,*MatrixGraph;

/* ===创建图的邻接矩阵=== */
void CreateGraph_Matrix(MatrixGraph &G){
    int numV, numE;     //要创建图的总顶点数与边数
    printf("输入图的总顶点数与边数，使用空格隔开: ");
    scanf("%d%d", &numV, &numE);
    if(numV>MAX_VEX_NUM){
        printf("结点数超出限制！\n");
        return;
    }
    G = (MGraph *)malloc(sizeof(MGraph));
    G->vexnum = numV;
    G->edgenum = numE;
    memset(G->Degree, -1, MAX_VEX_NUM);
    printf("\n");

    int i, j;       //遍历控制器
    int start, end;     //一条弧的弧尾与弧头结点序号
    int w;      //弧权值

    //邻接矩阵即二维数组Edge初始化
    for (i = 0; i < G->vexnum;i++){
        for (j = 0; j < G->vexnum;j++){
            if(i==j){       //主对角线结点值为0
                G->Edge[i][j] = 0;
            }else{      //其他结点值为INF
                G->Edge[i][j] = INF;
            }//if
        }//for
    }//for

    //将顶点信息存入顶点表vex中
    for (i = 0; i < G->vexnum;i++){
        printf("请输入第%d个结点的信息: ", i + 1);
        scanf("%d", &G->Vex[i]);
    }
    printf("\n");

    //输入图的边信息
    for (i = 0; i < G->edgenum;i++){
        printf("依次输入第%d条边的'起始节点序号start','结尾结点序号end','权值w',使用空格隔开(satrt与end在(1,...,n)取值): ",i+1);
        scanf("%d %d %d", &start, &end, &w);
        G->Edge[start - 1][end - 1] = w;
        G->Edge[end - 1][start - 1] = w;        //无向图邻接矩阵对称性
        //若建立的是有向图 把这一句去掉即可
    }
}

/* ===输出图的邻接矩阵=== */
void PrintGraph_Matrix(MatrixGraph G){
	int i, j;
	printf("\n图的顶点为:");
	for (i = 0; i < G->vexnum; i++)
		printf("%d ", G->Vex[i]);
	printf("\n输出邻接矩阵:\n");
	printf("\t");
	for (i = 0; i < G->vexnum; i++)
		printf("\t%8d", G->Vex[i]);
		
	for (i = 0; i < G->vexnum; i++)
	{
		printf("\n\n%8d", G->Vex[i]);
		for (j = 0; j < G->vexnum; j++)
		{
			if (G->Edge[i][j] == INF)
				printf("\t%8s", "∞");
			else
				printf("\t%8d", G->Edge[i][j]);
		}
		printf("\n");
	}	
}

代码实现

邻接表转换邻接矩阵

/* ===邻接表转换为邻接矩阵=== */
void ListToMatrix(AdjListGraph ALG,MatrixGraph &MTG){
    MTG = (MGraph *)malloc(sizeof(MGraph));       //建立邻接矩阵结构
    MTG->vexnum = ALG->vexnum;          //矩阵图顶点数
    MTG->edgenum = ALG->edgenum;        //矩阵图边数
    memset(MTG->Degree, -1, MAX_VEX_NUM);
    int i, j;       //遍历控制器
    //邻接矩阵即二维数组Edge初始化
    for (i = 0; i < MTG->vexnum;i++){
        for (j = 0; j < MTG->vexnum;j++){
            if(i==j){       //主对角线结点值为0
                MTG->Edge[i][j] = 0;
            }else{      //其他结点值为INF
                MTG->Edge[i][j] = INF;
            }//if
        }//for
    }//for
    /* ===开始转换=== */
    //将顶点信息存入顶点表vex中
    for (int v = 0; v < MTG -> vexnum; v++){
        MTG->Vex[v] = ALG->List[v].data;        //MTG中顶点信息为ALG中顶点表信息
        MTG->Degree[v] = ALG->List[v].degree;
    }
    for (int v = 0; v < MTG -> edgenum; v++){
        for (ArcNode *p = ALG->List[v].firstarc; p != NULL;p=p->nextarc){     //p找到顶点信息
            MTG->Edge[v][p->adjvex] = p->weight;      //带权无向图 矩阵元素值为权值
            MTG->Edge[p->adjvex][v] = p->weight;      //由ALG中v到v的adjvex边建立MTG中对应元素
        }
    }
    printf("\n");
    /* ===开始转换=== */
}

邻接矩阵转换邻接表


/* ===邻接矩阵转换为邻接表=== */
void MatrixToList(MatrixGraph MTG,AdjListGraph &ALG){
    ALG = (ALGraph *)malloc(sizeof(ALGraph));     //建立邻接表结构
    ALG->vexnum = MTG->vexnum;      //设置顶点数与边数
    ALG->edgenum = MTG->edgenum;
    /* ===开始转换=== */
    //设置顶点表List 输入顶点信息存入list的data域并初始化firstarc指针域
    for (int v = 0; v < ALG->vexnum; v++){
        ALG->List[v].data = MTG->Vex[v];        //设置顶点信息
        ALG->List[v].firstarc = NULL;     //初始化firstarc域
        ALG->List[v].degree = MTG->Degree[v];
    }
    //设置边表
    //创建边表数据   遍历整个邻接矩阵
    for (int v = 0; v < ALG->vexnum; v++){      //遍历每个元素
        for (int w = 0; w <ALG->vexnum; w++){
            if(MTG->Edge[v][w]!=INF&&v!=w){       //v到w边存在 去除对角线元素
                ArcNode *p = (ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex = w;      //终点为w 起点为v的边 采用头插入插入到对应的顶点表之后
                p->weight = MTG->Edge[v][w];        //设置权值
                p->nextarc=ALG->List[v].firstarc;       //头插
                ALG->List[v].firstarc = p;
            }
        }
    }
    printf("\n");
    /* ===开始转换=== */
}

2021.12.29

11：30

以上

kollektor
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
图的存储：邻接表与邻接矩阵的相互转换
fakerth的博客
09-26 509
图的存储：邻接表与邻接矩阵的相互转换
数据结构学习--图的邻接矩阵和邻接表存储
06-25
1. 将给定的有向图从邻接矩阵转换为邻接表，反之亦然。 2. 设计程序，允许用户手动输入图的信息，然后将其转换为另一种存储方式。 在C语言实现中，`AdjMatrix`定义为一个二维整型数组，用于表示邻接矩阵。`AdjList`...
邻接表与邻接矩阵的相互转换
热门推荐
小L的博客
09-21 1万+
邻接矩阵与邻接表的相互转换
《经典图论算法》邻接矩阵转换
数据结构和算法
06-08 220
摘要：1，邻接矩阵转邻接表2，邻接矩阵转边集数组3，邻接矩阵转十字链表4，邻接矩阵转邻接多重表5，边集数组转邻接矩阵我们知道图的几种表示方式中邻接矩阵是最直观，也是最容易写的，所以有时候我们需要把邻接矩阵转化为其他表示方式。关于这几种表示方式的数据结构我们前面都已经介绍过，这里就不在重复介绍，我们只讲他们的代码实现。1，邻接矩阵转邻接表邻接表就是给每一个顶点创建一个列表，然后遍历邻接矩阵判断任意两...
C语言邻接矩阵和邻接表的相互转换算法讲解,邻接矩阵与邻接表的相互转换
weixin_36361600的博客
05-24 2179
编写一个程序，输出带权图的邻接矩阵，并能将该邻接矩阵转换成相应的邻接表，并输出该邻接表，带权图如下图所示。具体效果如下： 2.1.编写一个算法，实现由已知的邻接表产生对应的邻接矩阵，并输出。 具体效果如下：#include #include#define MAXV 100#define MaxSize 100#define INF 327676using namespace std;typede...
邻接矩阵和邻接表的相互转化
KK_2018的技术博客_程序员不止是程序员
12-24 2157
#include <iostream> #define MaxNum 100 using namespace std; //邻接矩阵 typedef struct{ int Vex[MaxNum]; //顶点 int edge[MaxNum][MaxNum]; //边 int arcnum,vexnum; //边和顶点个数 }MGraph; //邻接表 typedef struct ArcNode{ int adjvex; struct ArcNode *next; .
邻接矩阵与邻接表的相互转换
m0_45920074的博客
12-09 9941
编写一个程序，输出带权图的邻接矩阵，并能将该邻接矩阵转换成相应的邻接表，并输出该邻接表，带权图如下图所示。 具体效果如下： 2.1.编写一个算法，实现由已知的邻接表产生对应的邻接矩阵，并输出。 具体效果如下： #include <iostream> #include<bits/stdc++.h> #define MAXV 100 #define MaxSize 100 #define INF 327676 using namespace std; typedef char .
（有向图）邻接表与邻接矩阵的相互转化
weixin_50935546的博客
05-27 1361
1.邻接表->邻接矩阵 在这里插入图片描述 2.邻接矩阵->邻接表 #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<string> #include<vector> #include<stack> #include<bitset> #include<cstdlib> #i
邻接矩阵与邻接表的输出及其相互转换
weixin_72080540的博客
11-20 2280
对邻接表邻接矩阵的基本创建与画图及描述了邻接表邻接矩阵的相互转换
将无向图的邻接矩阵转化为邻接表
vener_的博客
09-25 5310
typedef struct { int vertex[max]; int arc[max][max]; int vexnum,aecnum; }MGraph; typedef struct ArcNode{ int adjvex; struct ArcNode *next; }ArcNode; typedef struct VNode { int data; ArcNode *first; }VNode,AdjList[max]; typedef struct { AdjList ver.
matlab实现图的邻接矩阵转化为邻接表
Alan_zf的博客
11-15 3533
这里写自定义目录标题调用函数graph一步搞定 调用函数graph一步搞定 %Create a graph using the adjacency matrix.'OmitSelfLoops’忽略对角线, %'upper’指明上三角（即无向图） G = graph(A,‘upper’,‘OmitSelfLoops’); %还可以作图 plot(G); %计算最短路 [Path,distance] ...
图的邻接矩阵和邻接表表示的各种算法
11-05
本文将详细探讨图的两种常见表示方法：邻接矩阵和邻接表，以及如何用它们实现迪杰斯特拉算法、普里姆算法和克鲁斯卡尔算法。这些算法主要用于解决最短路径和最小生成树问题。 1. **邻接矩阵**： - 邻接矩阵是表示...
adjacency matrix.zip_adjacency matrix_matlab 邻接表_matlab邻接表_邻接矩阵
07-14
在计算机科学和图论中，邻接矩阵和邻接表是两种常见的表示图的数据结构。本文将详细讨论这两种数据结构，以及如何在MATLAB中进行转换。我们将专注于标题和描述中提到的MATLAB程序，该程序能够将邻接表转换为邻接矩阵...
将一个无向图的邻接表转换为邻接矩阵算法.doc.doc
05-18
将一个无向图的邻接表转换为邻接矩阵算法.doc.doc
图的邻接表转邻接矩阵和深度遍历
12-24
### 图的邻接表转邻接矩阵与深度优先遍历 #### 一、引言 在计算机科学领域，图是一种非常重要的数据结构，用于表示实体之间的关系。在图的多种存储方式中，邻接表和邻接矩阵是最常见的两种。邻接表适合于存储稀疏...
数据结构与算法--栈
wumingzei的博客
08-02 1065
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。允许插入和删除运算的一端称为栈顶（top），不允许插入和删除的另一端称为栈底（bottom）。在栈顶进行的插入操作称为入栈或进栈(push),在栈顶进行的删除操作称为出栈或退栈(pop)特点：后进先出（LIFO, Last In First Out）。栈的后进先出特性。顺序栈和链栈的入栈、出栈操作。栈在中缀表达式转换为后缀表达式中的应用。
【数据结构】——链式二叉树
最新发布
2402_82668782的博客
08-02 962
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 320
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
图的邻接表转化成邻接矩阵
06-09
邻接表转化成邻接矩阵的步骤如下： 1. 统计节点数量，即图中顶点的个数n。 2. 创建一个n×n的邻接矩阵A，初始值都为0。 3. 对于邻接表中的每一个节点，将其边所连接的节点在邻接矩阵中标记为1。 4. 如果图是无向图，那么在邻接矩阵中对称标记，即A[i][j]=A[j][i]。 5. 邻接矩阵构建完成。 需要注意的是，邻接表中的节点编号可能不是从0到n-1连续的，因此在转换时需要进行编号的映射。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值