邻接表转换成邻接矩阵
计算机专业基础综合数据结构图历年真题试卷汇编4_真题无答案
计算机专业基础综合数据结构(图)历年真题试卷汇编4(总分58, 做题时间90分钟)6. 综合题1.已知一图如下图所示:(1)写出全部拓扑排序;(2)以V1为源点,以V8为终点,给出所有事件允许发生的最早时间和最晚时间,并给出关键路径;(3)求V1结点到各点的最短距离。
【北京邮电大学2000五(15分)】SSS_TEXT_QUSTI2.(1)对于有向无环图,叙述求拓扑有序序列的步骤;(2)对于以下的图,写出它的四个不同的拓扑有序序列。
【南开大学1998二(12分)】SSS_TEXT_QUSTI3.有向图的拓扑排序能否用图的深度搜索模式来查找?若能,请简述方法;若不能,请简述原因。
【西北大学2000二、8(5分)】SSS_TEXT_QUSTI4.下图是带权的有向图G的邻接表表示法,求:(1)以结点V1出发深度遍历图G 所得的结点序列;(2)以结点V1出发广度遍历图G所得的结点序列;(3)从结点V1到结点V8的最短路径;(4)从结点V1到结点V8的关键路径。
【中国海洋大学1999四(10分)】SSS_TEXT_QUSTI5.下表给出了某工程各工序之间的优先关系和各工序所需时间。
(1)画出相应的AOE网; (2)列出各事件的最早发生时间,最迟发生时间;(3)找出关键路径并指明完成该工程所需最短时间。
【山东大学2002七(15分)】【北京交通大学1995六(15分)】SSS_TEXT_QUSTI6.请写出应填入下列叙述中( )内的正确答案。
某一工程作业的网络图如图所示,其中箭头表示作业,箭头边的数字表示完成作业所需的天数。
箭头前后的圆圈表示事件,圆圈中的数字表示事件的编号。
用事件编号的序列(例如0一2—7—9一11)表示进行作业的路径。
完成此工程的关键路径是(A),完成此工程所需的最少天数为(B)天,此工程中具有最大充裕天数的事件是(C),充裕天数是(D)。
关键路径上的事件的充裕天数是(E)。
【上海大学2002三(10分)】SSS_TEXT_QUSTI7.求出下面AOE网中的关键路径(要求给出各个顶点的最早发生时间和最迟发生时间,并画出关键路径)。
图的邻接矩阵和邻接表相互转换
图的邻接矩阵和邻接表相互转换图的邻接矩阵存储方法具有如下几个特征:1)无向图的邻接矩阵一定是一个对称矩阵。
2)对于无向图的邻接矩阵的第i 行非零元素的个数正好是第i 个顶点的度()i v TD 。
3)对于有向图,邻接矩阵的第i 行非零元素的个数正好是第i 个顶点的出度()i v OD (或入度()i v ID )。
4)用邻接矩阵方法存储图,很容易确定图中任意两个顶点之间是否有边相连;但是,要确定图中有多少条边,则必须按行、按列对每个元素进行检测,所发费得时间代价大。
邻接表是图的一种顺序存储与链式存储相结合的存储方法。
若无向图中有n 个顶点、e 条边,则它的邻接表需n 个头结点和2e 个表结点。
显然,在边稀疏的情况下,用邻接表表示图比邻接矩阵存储空间。
在无向图的邻接表中,顶点i v 的度恰好是第i 个链表中的结点数,而在有向图中,第i 个链表中结点个数是顶点i v 的出度。
在建立邻接表或邻逆接表时,若输入的顶点信息即为顶点的编号,则建立临接表的时间复杂度是)(e n O +;否则,需要通过查找才能得到顶点在图中位置,则时间复杂度为)*(e n O 。
在邻接表上容易找到任意一顶点的第一个邻接点和下一个邻接点,但要判断任意两个顶点之间是否有边或弧,则需要搜索第i 个或第j 个链表,因此,不及邻接矩阵方便。
邻接矩阵和邻接表相互转换程序代码如下:#include<iostream.h>#define MAX 20//图的邻接表存储表示typedef struct ArcNode{int adjvex; //弧的邻接定点 char info; //邻接点值struct ArcNode *nextarc; //指向下一条弧的指针}ArcNode;typedef struct Vnode{ //节点信息char data;ArcNode *link;}Vnode,AdjList[MAX];typedef struct{AdjList vertices;int vexnum; //节点数int arcnum; //边数}ALGraph;//图的邻接矩阵存储表示typedef struct{int n; //顶点个数char vexs[MAX]; //定点信息int arcs[MAX][MAX]; //边信息矩阵}AdjMatrix;/***_____________________________________________________***///函数名:AdjListToMatrix(AdjList g1,AdjListMatrix &gm,int n)//参数:(传入)AdjList g1图的邻接表,(传入)int n顶点个数,(传出)AdjMatrix gm图的邻接矩阵//功能:把图的邻接表表示转换成图的邻接矩阵表示void AdjListToAdjMatrix(ALGraph gl,AdjMatrix &gm){int i,j,k;ArcNode *p;gm.n=gl.vexnum;for(k=0;k<gl.vexnum;k++)gm.vexs[k]=gl.vertices[k].data;for(i=0;i<MAX;i++)for(j=0;j<MAX;j++)gm.arcs[i][j]=0;for(i=0;i<gl.vexnum;i++){p=gl.vertices[i].link; //取第一个邻接顶点while(p!=NULL){ //取下一个邻接顶点gm.arcs[i][p->adjvex]=1;p=p->nextarc;}}}/***________________________________________________***///函数名:AdjMatrixToAdjListvoid AdjMatrixToAdjList(AdjMatrix gm,ALGraph &gl){int i,j,k,choice;ArcNode *p;k=0;gl.vexnum=gm.n;cout<<"请选择所建立的图形是无向图或是有向图:";cin>>choice;for(i=0;i<gm.n;i++){gl.vertices[i].data=gm.vexs[i];gl.vertices[i].link=NULL;}for(i=0;i<gm.n;i++)for(j=0;j<gm.n;j++)if(gm.arcs[i][j]==1){k++;p=new ArcNode;p->adjvex=j;p->info=gm.vexs[j];p->nextarc=gl.vertices[i].link;gl.vertices[i].link=p;}if(choice==1)k=k/2;gl.arcnum=k;}void CreateAdjList(ALGraph &G){int i,s,d,choice;ArcNode *p;cout<<"请选择所建立的图形是有向图或是无向图:";cin>>choice;cout<<"请输入节点数和边数:"<<endl;cin>>G.vexnum>>G.arcnum;for(i=0;i<G.vexnum;i++){cout<<"第"<<i<<"个节点的信息:";cin>>G.vertices[i].data;G.vertices[i].link=NULL;}if(choice==1){for(i=0;i<2*(G.vexnum);i++){cout<<"边----起点序号,终点序号:";cin>>s>>d;p=new ArcNode;p->adjvex=d;p->info=G.vertices[d].data;p->nextarc=G.vertices[s].link;G.vertices[s].link=p;}}else{for(i=0;i<G.vexnum;i++){cout<<"边----起点序号,终点序号:";cin>>s>>d;p=new ArcNode;p->adjvex=d;p->info=G.vertices[d].data;p->nextarc=G.vertices[s].link;G.vertices[s].link=p;}}}void CreateAdjMatrix(AdjMatrix &M){int i,j,k,choice;cout<<"请输入顶点个数:";cin>>M.n;cout<<"请输入如顶点信息:"<<endl;for(k=0;k<M.n;k++)cin>>M.vexs[k];cout<<"请选择所建立的图形是无向图或是有向图:";cin>>choice;cout<<"请输入边信息:"<<endl;for(i=0;i<M.n;i++)for(j=0;j<M.n;j++)M.arcs[i][j]=0;switch(choice){case 1:{for(k=0;k<M.n;k++){cin>>i>>j;M.arcs[i][j]=M.arcs[j][i]=1;}};break;case 2:{for(k=0;k<M.n;k++){cin>>i>>j;M.arcs[i][j]=1;}};break;}}void OutPutAdjList(ALGraph &G){int i;ArcNode *p;cout<<"图的邻接表如下:"<<endl;for(i=0;i<G.vexnum;i++){cout<<G.vertices[i].data;p=G.vertices[i].link;while(p!=NULL){cout<<"---->("<<p->adjvex<<" "<<p->info<<")";p=p->nextarc;}cout<<endl;}}void OutPutAdjMatrix(AdjMatrix gm){cout<<"图的邻接矩阵如下:"<<endl;for(int i=0;i<gm.n;i++){。
计算机学科专业基础综合数据结构-图(二)_真题-无答案
计算机学科专业基础综合数据结构-图(二)(总分100,考试时间90分钟)一、单项选择题(下列每题给出的4个选项中,只有一个最符合试题要求)1. 具有6个顶点的无向图至少应有______条边才能确保是一个连通图。
A.5 B.6 C.7 D.82. 设G是一个非连通无向图,有15条边,则该图至少有______个顶点。
A.5 B.6 C.7 D.83. 下列关于无向连通图特性的叙述中,正确的是______。
①所有顶点的度之和为偶数②边数大于顶点个数减1③至少有一个顶点的度为1A.只有① B.只有② C.①和② D.①和③4. 对于具有n(n>1)个顶点的强连通图,其有向边的条数至少是______。
A.n+1B.nC.n-1D.n-25. 下列有关图的说法中正确的是______。
A.在图结构中,顶点不可以没有任何前驱和后继 B.具有n个顶点的无向图最多有n(n-1)条边,最少有n-1条边 C.在无向图中,边的条数是结点度数之和 D.在有向图中,各顶点的入度之和等于各顶点的出度之和6. 对于一个具有n个顶点和e条边的无向图,若采用邻接矩阵表示,则该矩阵大小是______,矩阵中非零元素的个数是2e。
A.n B.(n-1)2 C.n-1 D.n27. 无向图的邻接矩阵是一个______。
A.对称矩阵 B.零矩阵 C.上三角矩阵 D.对角矩阵8. 从邻接矩阵可知,该图共有______个顶点。
如果是有向图,该图共有4条有向边;如果是无向图,则共有2条边。
A.9 B.3 C.6 D.1 E.5 F.4 G.2 H.09. 下列说法中正确的是______。
A.一个图的邻接矩阵表示是唯一的,邻接表表示也唯一 B.一个图的邻接矩阵表示是唯一的,邻接表表示不唯一 C.一个图的邻接矩阵表示不唯一,邻接表表示唯一 D.一个图的邻接矩阵表示不唯一,邻接表表示也不唯一10. 用邻接表存储图所用的空间大小______。
A.与图的顶点数和边数都有关 B.只与图的边数有关 C.只与图的顶点数有关 D.与边数的二次方有关11. 采用邻接表存储的图的深度优先搜索算法类似于二叉树的______,广度优先搜索算法类似于二叉树的层次序遍历。
2002年哈工大计算机科学与技术专业854考研真题
2002年哈工大计算机科学与技术专业854考研真题I.数据结构一、填空题1.具有n个顶点的开放树,边的总数有(1)条。
2.由三个结点组成的二元树共有(2)各不同的结构形态。
3.N个元素的线性表,采用顺序存储结构,插入一个元素要平均移动表中(3-1)个元素,删除一个元素最坏情况下要移动(3-2)个元素。
4.一个二元树第5层结点最多有(4)个。
5.若在一个表中共有625个元素,且查找每个元素的概率相同,那么在采用分块查找时,每块的最佳长度为(5-1),此时的平均查找长度为(5-2)。
6.具有n个叶结点的哈夫曼(Huffman)树中,其结点总数为(6)。
7.在折半查找中,要求被查找元素必须采用(7-1)存储结构,且(7)。
8.堆分类(heap sort)的时间复杂性为(8-1)。
基数分类的的时间复杂性为(8-2)。
9.一个无向图有n个顶点,e条边,则所有顶点的度数之和为(9)。
10.设F是一个森林,B是由F按自然对应关系转换而得到的二元树,F中有n个非终结结点,则B中右子树为空的结点有(10)个。
二、选择题1.下三角矩阵A m*n按行优先顺序压缩存储在数组Sa[(n+1)*n/2]中,若非零元素a ij(0<=i,j<n)存放在Sa[k]中则i,j和k之间的关系为(1)。
A.k=i*n+jB.k=j*n/2+iC.k=(i+1)*i/2+jD.k=(j-1)*n/2+i-12.将一株有100个结点的完全二元树从上到下,从左到右依次进行编号,根结点的编号为1,则编号为49的结点的右孩子编号为(2)。
A.98B.99C.50D.没有右孩子3.数据在计算机中存储器内表示时,物理地址和逻辑地址相同并且是连续的,称之为(3)。
A.逻辑结构B.顺序存储结构C.链式存储结构D.以上都对4.一株非空二元树的所有叶结点在先根、中根和后根遍历序列中的相对顺序(4)。
A.发生改变B.不发生改变C.不能确定D.以上都不对5.对于一个具有n个顶点e条边的无向图,若采用邻接表表示,则表向量(顶点表)的大小为(5-1),所有关于顶点的邻接表(边表)的结点总数为(5-2)。
gml转邻接矩阵和邻接表
(2015-04-13 22:22:57)[编辑][删除]转载▼标签:教育文化复杂网络研究中gml格式数据转换成邻接矩阵的方法1.首先到Newman的主页/~mejn/netdata/下载Gephi软件,这个需要java环境。
图1.Newman主页上的Gephi图2.点击Newman主页Gephi后的页面2.然后打开安装好的Gephi软件图3. 安装好的Gephi软件图4. 打开后的软件界面3.然后点击:文件-----打开-----选中一个gml格式的文件------打开-----确定图5.选择文件图6.打开文件的选择图7.打开文件后的界面4.点击:数据资料(图7左上角红圈内)-----边-----输出表格图8.数据资料界面图9.输出表格界面5.只选择Source和Target-----点击确定-----保存到桌面。
此时在桌面你会发现一个电子表格(格式是csv),双击打开它。
删除有汉字的第一行。
这样就得到了这个网络的邻接表。
图10.保存到桌面的输出文件图11.打开后的界面6.打开matlab-----新建一个文件重命名为b-----复制电子表格中的邻接表到新建的文件b中(图12)图12.复制邻接表到b中7.新建函数,代码如下function b=ainc2adj(x)% 邻接表生成邻接矩阵if min(x)==0;x=x+1;endd=length(x);a=max(max(x));b=zeros(a,a);for i=1:dif x(i,1)==x(i,2);b(x(i,1),x(i,2))=0;elseb(x(i,1),x(i,2))=1;b(x(i,2),x(i,1))=1;endend8.在Command Window 中运行函数a=ainc2adj(b); 最后就输出邻接矩阵a了。
图13.运行函数图14.得到的邻接矩阵a提示:1.这是自己捉摸出来的笨方法,如果有大神看到这篇博文,请指点个比较简单的方法方便大家科研。
图基本算法图的表示方法邻接矩阵邻接表
图基本算法图的表⽰⽅法邻接矩阵邻接表 要表⽰⼀个图G=(V,E),有两种标准的表⽰⽅法,即邻接表和邻接矩阵。
这两种表⽰法既可⽤于有向图,也可⽤于⽆向图。
通常采⽤邻接表表⽰法,因为⽤这种⽅法表⽰稀疏图(图中边数远⼩于点个数)⽐较紧凑。
但当遇到稠密图(|E|接近于|V|^2)或必须很快判别两个给定顶点⼿否存在连接边时,通常采⽤邻接矩阵表⽰法,例如求最短路径算法中,就采⽤邻接矩阵表⽰。
图G=<V,E>的邻接表表⽰是由⼀个包含|V|个列表的数组Adj所组成,其中每个列表对应于V中的⼀个顶点。
对于每⼀个u∈V,邻接表Adj[u]包含所有满⾜条件(u,v)∈E的顶点v。
亦即,Adj[u]包含图G中所有和顶点u相邻的顶点。
每个邻接表中的顶点⼀般以任意顺序存储。
如果G是⼀个有向图,则所有邻接表的长度之和为|E|,这是因为⼀条形如(u,v)的边是通过让v出现在Adj[u]中来表⽰的。
如果G是⼀个⽆向图,则所有邻接表的长度之和为2|E|,因为如果(u,v)是⼀条⽆向边,那么u会出现在v的邻接表中,反之亦然。
邻接表需要的存储空间为O(V+E)。
邻接表稍作变动,即可⽤来表⽰加权图,即每条边都有着相应权值的图,权值通常由加权函数w:E→R给出。
例如,设G=<V,E>是⼀个加权函数为w的加权图。
对每⼀条边(u,v)∈E,权值w(u,v)和顶点v⼀起存储在u的邻接表中。
邻接表C++实现:1 #include <iostream>2 #include <cstdio>3using namespace std;45#define maxn 100 //最⼤顶点个数6int n, m; //顶点数,边数78struct arcnode //边结点9 {10int vertex; //与表头结点相邻的顶点编号11int weight = 0; //连接两顶点的边的权值12 arcnode * next; //指向下⼀相邻接点13 arcnode() {}14 arcnode(int v,int w):vertex(v),weight(w),next(NULL) {}15 arcnode(int v):vertex(v),next(NULL) {}16 };1718struct vernode //顶点结点,为每⼀条邻接表的表头结点19 {20int vex; //当前定点编号21 arcnode * firarc; //与该顶点相连的第⼀个顶点组成的边22 }Ver[maxn];2324void Init() //建⽴图的邻接表需要先初始化,建⽴顶点结点25 {26for(int i = 1; i <= n; i++)27 {28 Ver[i].vex = i;29 Ver[i].firarc = NULL;30 }31 }3233void Insert(int a, int b, int w) //尾插法,插⼊以a为起点,b为终点,权为w的边,效率不如头插,但是可以去重边34 {35 arcnode * q = new arcnode(b, w);36if(Ver[a].firarc == NULL)37 Ver[a].firarc = q;38else39 {40 arcnode * p = Ver[a].firarc;41if(p->vertex == b) //如果不要去重边,去掉这⼀段42 {43if(p->weight < w)44 p->weight = w;45return ;46 }47while(p->next != NULL)48 {49if(p->next->vertex == b) //如果不要去重边,去掉这⼀段50 {51if(p->next->weight < w);52 p->next->weight = w;53return ;54 }55 p = p->next;56 }57 p->next = q;58 }59 }60void Insert2(int a, int b, int w) //头插法,效率更⾼,但不能去重边61 {62 arcnode * q = new arcnode(b, w);63if(Ver[a].firarc == NULL)64 Ver[a].firarc = q;65else66 {67 arcnode * p = Ver[a].firarc;68 q->next = p;69 Ver[a].firarc = q;70 }71 }7273void Insert(int a, int b) //尾插法,插⼊以a为起点,b为终点,⽆权的边,效率不如头插,但是可以去重边74 {75 arcnode * q = new arcnode(b);76if(Ver[a].firarc == NULL)77 Ver[a].firarc = q;78else79 {80 arcnode * p = Ver[a].firarc;81if(p->vertex == b) return; //去重边,如果不要去重边,去掉这⼀句82while(p->next != NULL)83 {84if(p->next->vertex == b) //去重边,如果不要去重边,去掉这⼀句85return;86 p = p->next;87 }88 p->next = q;89 }90 }91void Insert2(int a, int b) //头插法,效率跟⾼,但不能去重边92 {93 arcnode * q = new arcnode(b);94if(Ver[a].firarc == NULL)95 Ver[a].firarc = q;96else97 {98 arcnode * p = Ver[a].firarc;99 q->next = p;100 Ver[a].firarc = q;101 }102 }103void Delete(int a, int b) //删除以a为起点,b为终点的边104 {105 arcnode * p = Ver[a].firarc;106if(p->vertex == b)107 {108 Ver[a].firarc = p->next;109 delete p;110return ;111 }112while(p->next != NULL)113if(p->next->vertex == b)114 {115 p->next = p->next->next;116 delete p->next;117return ;118 }119 }120121void Show() //打印图的邻接表(有权值)122 {123for(int i = 1; i <= n; i++)124 {125 cout << Ver[i].vex;126 arcnode * p = Ver[i].firarc;127while(p != NULL)128 {129 cout << "->(" << p->vertex << "," << p->weight << ")";130 p = p->next;131 }132 cout << "->NULL" << endl;133 }134 }135136void Show2() //打印图的邻接表(⽆权值)137 {138for(int i = 1; i <= n; i++)140 cout << Ver[i].vex;141 arcnode * p = Ver[i].firarc;142while(p != NULL)143 {144 cout << "->" << p->vertex;145 p = p->next;146 }147 cout << "->NULL" << endl;148 }149 }150int main()151 {152int a, b, w;153 cout << "Enter n and m:";154 cin >> n >> m;155 Init();156while(m--)157 {158 cin >> a >> b >> w; //输⼊起点、终点159 Insert(a, b, w); //插⼊操作160 Insert(b, a, w); //如果是⽆向图还需要反向插⼊161 }162 Show();163return0;164 }View Code 邻接表表⽰法也有潜在的不⾜之处,即如果要确定图中边(u,v)是否存在,只能在顶点u邻接表Adj[u]中搜索v,除此之外没有其他更快的办法。
图的邻接表和邻接矩阵的相互转换
#iiiclude<iostieam.h>#iiiclude<stdio.h>#mclude<malloc.h>tvpedef int IiifoType;tvpedef int Vertex;#define MAXV 5tvpedef stmct{iiit no;InfoTyp亡uifb;JVertexType;tvpedef stmct{mt edges[MAXV][MAX\G; int n.e;VertexType vexs[MAXV]; }MGraph; tvpedef stmct ANode {mt adjvex;stmct ANode *nextarc;InfoTyp亡uifb;}AicNode;tvpedef stmct Vnode{Vertex data;AicNode *firstaic;}VNode;tvpedefVNode AdjListfNIAXVJ; tvpedef stmct{Adj List adj list;int n.e;}ALGraph;void InitialMG(MGraph *&MG) {MG=new MGraph;MG->e=0;MG->n=5;mtj;for(int 1=0 ;i<MAXV; i++) MG->vexs[i] .no=i;for(i=O;KMAXV;i++)for(j=Oj<MAXV;j++)MG->edges[i][j]=O;void InitialALG(ALGraph *&ALG)ALG=new ALGraph;ALG->n=5;ALG->e=O;for(int 1=0 ;i<MAXV;i++)ALG->adjlist[i] .data=i;ALG->adjlist[i] .fiistarc=NULL;void InputALG(ALGraph *&ALG) iiit ch;AicNode *p;cout«endl«H请输入邻接表,以-1结束输入(形式如:4 : 5 5 6-1):H«endl; fbr(int i=0;i<ALG->n;i++)cout«ALG->adjlist[i].data«": cin»ch;if(ch!=-l)ALG->adjlist[i].fiistarc=new AicNode; p=ALG->adjlist[i]. fiistarc;p->adjvex=ch;p->nextarc=NULL; cin»ch;} while(ch!=-l)p->nextarc=new AicNode; p=p->nextarc; p->adjvex=ch;p->nextarc=NULL; cin»ch;void OutputALG(ALGraph *&ALG)AicNode *p;cout«M邻接表如b: H«endl;for(int i=O;i<ALG->n;i++)cout«ALG->adjlist[i].data«M : H;p=ALG->adjlist[i].fiistarc; while(p?=NULL){cout«p->adjvex«n\t H; p=p->nextarc;}cout«endl;}}void InputMG(MGraph *&MG){chai- H;cout«M请输入(HN)(有向/无向):H«endl; cm»H;cout«”请以矩阵的方式输入顶点关系:\ir;血尸0;fbr(int i=0;i<MG->n;i++) for(j=0j <MG->n J ++) c in»MG->edges[i] [j ];fbr(i=O;i<MG->n;i++)for(j=0j <MG->n J ++) if(MG->edge s[i][j]=l) {MG->e++;}if(H==N){MG->e=MG->e/2;}}void OutputMG(MGraph *&MG){mtj;cout«endl«H图的邻接矩阵如下:”《endl; fbr(int i=0;i<MG->n;i++) {for(j=0j <MG->n J ++) cout«MG->edges[i][j]«n\t M;cout«endl;}cout«endl;}void Transchange(MGraph *&MGALGraph *&ALG){intij;AicNode *p;ALG->n=MG->n;ALG->e=MG->e;fbr(i=O;i<MG->n;i++){for(j=0 J <MG->nJ++){if(MG->edges[i][j]!=O){p=new AicNode; p->adjvex=j; p->nextarc=ALG->adjlist[i].fiistarc; ALG->adjlist[i].fiistarc=p;}}}}void ALGtoMG(ALGraph *&ALG^MGraph *MG){intij;AicNode *p;MG->n=ALG->n;fbr(i=O ;i<ALG->n;i-H-){if(ALG->adjlist[i].fiistarc!=NULL){p=ALG->adj list[i]. fhstarc; while(p!=NULL){MG->edges[i][p->adjvex]=l; p=p->nextarc;}}}fbr(i=0;i<MG->n;i++){for(j=0 J <MG->nJ++)MG->edges[i][j]=O;}}}void MatToList(MGraph gALGraph *&G) 〃将临街矩阵g 转换成邻接表G{intij;AicNode *p;G=(ALGraph *)malloc(sizeof(ALGraph));fbr(i=O;i<g.n;i++)G->adjlist[i].firstaic=NULL;fbr(i=O;i<g.n;i++)for(j=g.n-lj>=Oj-)if(g.edges[i][j]!=O){p=(AicNode *)malloc(sizeof(AicNode));p->adjvex=j;p->nextarc=G->adjlist[i].firstaic;G->adjlist[i] .firstarc=p;}G->n=g.n;G->e=g.e;}void ListToMat(ALGraph *G,MGraph &g) 〃将邻接表G 转换为邻接矩阵g{mt i;AicNode *p;fbr(i=O;i<G->n;i++){p=G->adjlist[i].firstaic;while(p!=NULL){g.edges[i][p->adjvex]=l;p=p->nextarc;}}g.n=G->n;g.e=G->e;}void main()MGraph *MG;ALGraph *ALG; IiutialALG(ALG);IiutialMG(MG);IiiputMG(MG);OutputMG(MG);IiiputALG(ALG);OutputALG(ALG);Transchaiige(MG;ALG);OutputALG(ALG); ALGtoMG(ALGMG);MGraph g,*p;g.n=NIAXV;P=&g;IiiputMG(p);OutputMG(p);MatToList(g^ALG);IiutialMG(p); ListToMat(ALG;*p); OutputMG(p);。
将一个无向图的邻接表转换为邻接矩阵算法
.#include<stdio.h>#include<stdlib.h>#define max 20#define digit 1#define zero 0typedef struct{int num;char data;}Vertex;typedef struct{int n; //顶点数int e; //弧数Vertex vexs[max];int edges[max][max];}MGraph;typedef struct node{int adjvex;node *nextarc;char info;}ARCNODE; //邻接表的结点结构typedef struct{char vexdata;ARCNODE *firstarc;}VEXNODE; //邻接表的表头结点typedef struct{int vexnum,arcnum; //顶点数、弧数VEXNODE ve[max];}ALGraph; //邻接表类型ALGraph *Creat_alg(){ //创建邻接表ALGraph *alg;int i,n,e,b,a;char ch;ARCNODE *AR;alg=(ALGraph*)malloc(sizeof(ALGraph));printf("输入顶点数:");scanf("%d",&n);printf("输入弧数:");scanf("%d",&e);alg->vexnum=n;alg->arcnum=e;printf("输入顶点信息:\n");for(i=0;i<n;i++){scanf("%s",&ch);alg->ve[i].vexdata=ch;alg->ve[i].firstarc=NULL;}printf("输入弧的信息(弧的两端点):\n");for(i=0;i<e;i++){scanf("%d%d",&a,&b);AR=(ARCNODE*)malloc(sizeof(ARCNODE));AR->adjvex=b;AR->info=alg->ve[b].vexdata;AR->nextarc=alg->ve[a].firstarc;alg->ve[a].firstarc=AR;AR=(ARCNODE*)malloc(sizeof(ARCNODE));AR->adjvex=a;AR->info=alg->ve[a].vexdata;AR->nextarc=alg->ve[b].firstarc;alg->ve[b].firstarc=AR;}return alg;}void ALGout(ALGraph *alg){ //邻接表输出int i,n1;ARCNODE *p;VEXNODE *q;n1=alg->vexnum;for(i=0;i<n1;i++){q=&alg->ve[i];printf("%c",q->vexdata);p=q->firstarc;while(p!=NULL){printf("─→");printf("%c",p->info);p=p->nextarc;}printf("\n");}}MGraph *ALG_change_MG(ALGraph *alg){ //将邻接表转换为邻接矩阵MGraph *mg;int i,n1;mg=(MGraph *)malloc(sizeof(MGraph));.mg->n=alg->vexnum;mg->e=alg->arcnum;n1=mg->n;for(i=0;i<n1;i++){mg->vexs[i].num=i;mg->vexs[i].data=alg->ve[i].vexdata;}ARCNODE *p;for(i=0;i<n1;i++){p=alg->ve[i].firstarc;while(p!=NULL){mg->edges[i][p->adjvex]=1;mg->edges[p->adjvex][i]=1;p=p->nextarc;}}return mg;}void MGout(MGraph *mg){ //输出邻接矩阵int i,j,k;k=mg->n;for(i=0;i<k;i++){for(j=0;j<k;j++){if(mg->edges[i][j]==1)printf("%-5d",digit);elseprintf("%-5d",zero);}printf("\n");}}void main(){MGraph *mg;ALGraph *alg;printf("建立无向图的邻接表:\n");alg=Creat_alg();printf("邻接表输出:\n");ALGout(alg);mg=ALG_change_MG(alg);printf("邻接矩阵输出:\n");MGout(mg);}。
数据结构第六章图理解练习知识题及答案解析详细解析(精华版)
图1. 填空题⑴设无向图G中顶点数为n,则图G至少有()条边,至多有()条边;若G为有向图,则至少有()条边,至多有()条边。
【解答】0,n(n-1)/2,0,n(n-1)【分析】图的顶点集合是有穷非空的,而边集可以是空集;边数达到最多的图称为完全图,在完全图中,任意两个顶点之间都存在边。
⑵任何连通图的连通分量只有一个,即是()。
【解答】其自身⑶图的存储结构主要有两种,分别是()和()。
【解答】邻接矩阵,邻接表【分析】这是最常用的两种存储结构,此外,还有十字链表、邻接多重表、边集数组等。
⑷已知无向图G的顶点数为n,边数为e,其邻接表表示的空间复杂度为()。
【解答】O(n+e)【分析】在无向图的邻接表中,顶点表有n个结点,边表有2e个结点,共有n+2e个结点,其空间复杂度为O(n+2e)=O(n+e)。
⑸已知一个有向图的邻接矩阵表示,计算第j个顶点的入度的方法是()。
【解答】求第j列的所有元素之和⑹有向图G用邻接矩阵A[n][n]存储,其第i行的所有元素之和等于顶点i的()。
【解答】出度⑺图的深度优先遍历类似于树的()遍历,它所用到的数据结构是();图的广度优先遍历类似于树的()遍历,它所用到的数据结构是()。
【解答】前序,栈,层序,队列⑻对于含有n个顶点e条边的连通图,利用Prim算法求最小生成树的时间复杂度为(),利用Kruskal 算法求最小生成树的时间复杂度为()。
【解答】O(n2),O(elog2e)【分析】Prim算法采用邻接矩阵做存储结构,适合于求稠密图的最小生成树;Kruskal算法采用边集数组做存储结构,适合于求稀疏图的最小生成树。
⑼如果一个有向图不存在(),则该图的全部顶点可以排列成一个拓扑序列。
【解答】回路⑽在一个有向图中,若存在弧、、,则在其拓扑序列中,顶点vi, vj, vk的相对次序为()。
【解答】vi, vj, vk【分析】对由顶点vi, vj, vk组成的图进行拓扑排序。
r语言 邻接矩阵转化为邻接表
邻接矩阵和邻接表是图论中常用的两种表示图的方法。
在计算机科学和数据分析领域中,我们经常需要将邻接矩阵转化为邻接表来进行进一步的分析和处理。
本文将介绍如何利用R语言来实现邻接矩阵到邻接表的转化过程。
1. 邻接矩阵和邻接表的概念邻接矩阵是一种二维数组,用来表示图中各个节点之间的连接关系。
若图中有n个节点,那么邻接矩阵就是一个n*n的矩阵,矩阵中的元素a[i][j]表示第i个节点和第j个节点之间是否有连接。
邻接表则是由若干个链表组成,每个节点的链表中包含了与该节点相邻的所有节点。
邻接表的实现一般使用链表或者数组来表示。
2. 邻接矩阵到邻接表的转化在R语言中,我们可以利用矩阵和列表来实现邻接矩阵到邻接表的转化过程。
以下是具体的转化步骤。
2.1 读取邻接矩阵我们需要将邻接矩阵读入R语言中。
假设我们的邻接矩阵存储在一个名为adj_matrix的矩阵中,其中元素adj_matrix[i, j]表示节点i和节点j之间的连接关系。
2.2 转化为邻接表接下来,我们可以利用R语言中的列表来表示邻接表。
我们可以创建一个长度为n的列表,其中每个元素对应一个节点,列表的每个元素又是一个包含与该节点相邻的所有节点的向量。
具体来说,我们可以使用如下代码将邻接矩阵转化为邻接表:```Radj_list <- list()for (i in 1:n) {neighbors <- which(adj_matrix[i,] == 1)adj_list[[i]] <- neighbors}```在上述代码中,我们首先创建了一个空列表adj_list用来存储邻接表,然后通过循环遍历邻接矩阵的每一行,找到与每个节点相邻的节点,并加入到相应节点的邻接表中。
3. 示例假设我们有如下的邻接矩阵:```1 2 31 0 1 02 1 0 13 0 1 0```通过上述的转化过程,我们可以得到如下的邻接表:```[[1]][1] 2[[2]][1] 1 3[[3]][1] 2```4. 总结在R语言中,我们可以通过简单的代码实现邻接矩阵到邻接表的转化。
数据结构单元8练习参考答案
单元练习8一.判断题〔以下各题,正确的请在前面的括号内打√;错误的打╳〕〔√〕〔1〕图可以没有边,但不能没有顶点。
〔ㄨ〕〔2〕在无向图中,〔V1,V2〕与〔V2,V1〕是两条不同的边。
〔ㄨ〕〔3〕邻接表只能用于有向图的存储。
〔√〕〔4〕一个图的邻接矩阵表示是唯一的。
〔ㄨ〕〔5〕用邻接矩阵法存储一个图时,所占用的存储空间大小与图中顶点个数无关,而只与图的边数有关。
〔ㄨ〕〔6〕有向图不能进展广度优先遍历。
〔√〕〔7〕假设一个无向图的以顶点V1为起点进展深度优先遍历,所得的遍历序列唯一,则可以唯一确定该图。
〔√〕〔8〕存储无向图的邻接矩阵是对称的,因此只要存储邻接矩阵的上三角〔或下三角〕局部就可以了。
〔ㄨ〕〔9〕用邻接表法存储图时,占用的存储空间大小只与图中的边数有关,而与结点的个数无关。
〔√〕〔10〕假设一个无向图中任一顶点出发,进展一次深度优先遍历,就可以访问图中所有的顶点,则该图一定是连通的。
二.填空题(1)图常用的存储方式有邻接矩阵和邻接表等。
(2)图的遍历有:深度优先搜和广度优先搜等方法。
(3)有n条边的无向图邻接矩阵中,1的个数是_2n____。
(4)有向图的边也称为_ 弧___。
(5)图的邻接矩阵表示法是表示__顶点____之间相邻关系的矩阵。
(6)有向图G用邻接矩阵存储,其第i行的所有元素之和等于顶点i的__出度____。
(7)n个顶点e条边的图假设采用邻接矩阵存储,则空间复杂度为: O〔n2〕。
(8)n个顶点e条边的图假设采用邻接表存储,则空间复杂度为: O〔n+e〕。
(9)设有一稀疏图G,则G采用_邻接表____存储比拟节省空间。
(10)设有一稠密图G,则G采用_邻接矩阵____存储比拟节省空间。
(11)图的逆邻接表存储构造只适用于__有向____图。
(12) n个顶点的完全无向图有 n(n-1)/2_ 条边。
(13)有向图的邻接表表示适于求顶点的出度。
(14)有向图的邻接矩阵表示中,第i列上非0元素的个数为顶点V i的入度。
邻接矩阵和邻接表 深度遍历和广度遍历原理
邻接矩阵和邻接表是图论中用于表示图结构的两种常见方式,而深度遍历和广度遍历则是图论中常用的两种图遍历算法。
本文将从简介、原理和应用三个方面探讨这四个主题。
一、邻接矩阵和邻接表1.邻接矩阵邻接矩阵是一种使用二维数组来表示图中顶点之间关系的方法。
如果图中有n个顶点,那么对应的邻接矩阵就是一个n*n的矩阵,其中元素a[i][j]表示顶点i和顶点j之间是否有边,通常用0和1表示。
邻接矩阵适用于稠密图,其存储结构简单,可以直观地展示图的结构,但对于稀疏图来说可能会造成存储空间的浪费。
2.邻接表邻接表是一种使用链表来表示图中顶点之间关系的方法。
对于图中的每一个顶点,都维护一个相邻顶点的列表,图中所有顶点的列表再组合成一个链表,用于表示整个图的结构。
邻接表适用于稀疏图,其存储结构灵活,可以有效地节省存储空间,但查找任意两个顶点之间的关系可能会比较耗时。
二、深度遍历和广度遍历原理1.深度遍历深度遍历是一种用于遍历或搜索图中节点的算法,其原理是从图的某一顶点出发,沿着一条路径不断向下遍历直到末端,然后回溯到上一个节点继续遍历。
深度遍历使用栈来实现,可以通过递归或迭代来进行。
2.广度遍历广度遍历是一种用于遍历或搜索图中节点的算法,其原理是从图的某一顶点出发,依次访问其所有相邻节点,然后再依次访问这些相邻节点的相邻节点,以此类推。
广度遍历使用队列来实现。
三、深度遍历和广度遍历的应用1.深度遍历的应用深度遍历常用于求解图的连通分量、拓扑排序、解决迷宫问题等。
在连通分量中,深度遍历可以帮助我们找到图中的所有连通分量,并对其进行标记,用于进一步的算法运算。
在拓扑排序中,深度遍历可以帮助我们找到一个合理的顺序,用以处理依赖关系问题。
在解决迷宫问题时,深度遍历可以帮助我们找到一条从起点到终点的路径。
2.广度遍历的应用广度遍历常用于求解最短路径、解决迷宫问题等。
在求解最短路径中,广度遍历可以帮助我们找到起点到终点的最短路径,从而解决了许多实际问题。
第5课 图
第五课图一、选择题1.图中有关路径的定义是()。
A.由顶点和相邻顶点序偶构成的边所形成的序列B.由不同顶点所形成的序列C.由不同边所形成的序列D.上述定义都不是参考答案:A2.设无向图的顶点个数为n,则该图最多有()条边。
A.n-1 B.n(n-1)/2 C.n(n+1)/2 D.0 E.n2参考答案:B3.一个n个顶点的连通无向图,其边的个数至少为()。
A.n-1 B.n C.n+1 D.nlogn参考答案:A4.要连通具有n个顶点的有向图,至少需要()条边。
A.n-l B.n C.n+l D.2n参考答案:B5.n个结点的完全有向图含有边的数目()。
A.n*n B.n(n+1)C.n/2 D.n*(n-1)参考答案:D6.一个有n个结点的图,最少有()个连通分量。
A.0 B.1 C.n-1 D.n参考答案:B7.一个有n个结点的图,最多有()个连通分量。
A.0 B.1 C.n-1 D.n参考答案:D8.用有向无环图描述表达式(A+B)*((A+B)/A),至少需要顶点的数目为()。
A.5 B.6 C.8 D.9参考答案:A9.用DFS遍历一个无环有向图,并在DFS算法退栈返回时打印相应的顶点,则输出的顶点序列是()。
A.逆拓扑有序B.拓扑有序C.无序的参考答案:A10.下面结构中最适于表示稀疏无向图的是()。
A.邻接矩阵B.逆邻接表C.邻接多重表D.十字链表E.邻接表参考答案:C11.下列哪一种图的邻接矩阵是对称矩阵?()A.有向图B.无向图C.AOV网D.AOE网参考答案:B12.当一个有N个顶点的图用邻接矩阵A表示时,顶点Vi的度是()。
A.∑=nijiA1],[B.[]∑=n1jj,iAC.∑=nii jA1],[D.∑=nijiA1],[+[]∑=n1ji,jA参考答案:B13.下列说法不正确的是()。
A.图的遍历是从给定的源点出发每一个顶点仅被访问一次B.遍历的基本算法有两种:深度遍历和广度遍历C.图的深度遍历不适用于有向图D.图的深度遍历是一个递归过程参考答案:C14.无向图G=(V,E),其中:V={a,b,c,d,e,f},E={(a,b),(a,e),(a,c),(b,e),(c,f),(f,d),(e,d)},对该图进行深度优先遍历,得到的顶点序列正确的是()。
数据结构第7章图习题
第7章图一、单项选择题1.在一个无向图G中,所有顶点的度数之和等于所有边数之和的______倍。
A.l/2 B.1C.2 D.42.在一个有向图中,所有顶点的入度之和等于所有顶点的出度之和的______倍。
A.l/2 B.1C.2 D.43.一个具有n个顶点的无向图最多包含______条边。
A.n B.n+1C.n-1 D.n(n-1)/24.一个具有n个顶点的无向完全图包含______条边。
A.n(n-l) B.n(n+l)C.n(n-l)/2 D.n(n-l)/25.一个具有n个顶点的有向完全图包含______条边。
A.n(n-1) B.n(n+l)C.n(n-l)/2 D.n(n+l)/26.对于具有n个顶点的图,若采用邻接矩阵表示,则该矩阵的大小为______。
A.nB.n×nC.n-1 D.(n-l)×(n-l)7.无向图的邻接矩阵是一个______。
A.对称矩阵B.零矩阵C.上三角矩阵D.对角矩阵8.对于一个具有n个顶点和e条边的无(有)向图,若采用邻接表表示,则表头向量的大小为______。
A.n B.eC.2n D.2e9.对于一个具有n个顶点和e条边的无(有)向图,若采用邻接表表示,则所有顶点邻接表中的结点总数为______。
A.n B.eC.2n D.2e10.在有向图的邻接表中,每个顶点邻接表链接着该顶点所有______邻接点。
A.入边B.出边C.入边和出边D.不是入边也不是出边11.在有向图的逆邻接表中,每个顶点邻接表链接着该顶点所有______邻接点。
A.入边B.出边C.入边和出边D.不是人边也不是出边12.如果从无向图的任一顶点出发进行一次深度优先搜索即可访问所有顶点,则该图一定是______。
A.完全图B.连通图C.有回路D.一棵树13.采用邻接表存储的图的深度优先遍历算法类似于二叉树的______算法。
A.先序遍历B.中序遍历C.后序遍历 D.按层遍历14.采用邻接表存储的图的广度优先遍历算法类似于二叉树的______算法。
邻接表转换成邻接矩阵
邻接表转换成邻接矩阵邻接表和邻接矩阵是图数据结构中常见的两种表示方式。
邻接表是一种链式存储结构,适用于稀疏图,而邻接矩阵则是一种二维数组的存储结构,适用于稠密图。
本文将介绍如何将邻接表转换成邻接矩阵,并对其优缺点进行比较。
1. 邻接表在图的邻接表表示中,每个顶点都对应一个链表,该链表存储了与该顶点相连的所有边的信息。
具体来说,可以使用一个数组来存储这些链表。
数组的大小为顶点的个数。
下面是一个示例图的邻接表表示:Vertex: 0 1 2 3Adjacency: 1 → 2 0 → 3 2 → 3 -对应的代码实现如下:class Node:def __init__(self, value):self.value = valueself.next = Noneclass Graph:def __init__(self, vertices):self.vertices = verticesself.adj_list = [None] * verticesdef add_edge(self, src, dest):node = Node(dest)node.next = self.adj_list[src]self.adj_list[src] = nodedef print_adj_list(graph):for i in range(graph.vertices):print(f"Vertex {i}:", end=" ")node = graph.adj_list[i]while node:print(node.value, end=" → ")node = node.nextprint("-")2. 邻接矩阵邻接矩阵是一种使用二维数组来表示图的方法。
对于包含n个顶点的图,邻接矩阵是一个n×n的矩阵,其中每个元素a[i][j]表示顶点i和顶点j之间是否存在边。
图的存储方式:邻接矩阵和邻接表【基础】
// 顶点数 边数
char vexs[max_vexNum];
// 顶点向量
double arcs[max_vexNum][max_vexNum]; // 邻接矩阵
}Graph;
5)基于邻接矩阵创建图 - CreateGraph()
1. 输入图的类型Kind,0--有向图,2--无向图; 2. 输入顶点数G.vexnum和边数G.arcnum; 3. 输入n个顶点,填入顶点数组G.vexs; 4. 输入边的偶对(vi,vj)或<vi,vj>, 填写邻接矩阵G.arcs
for (int i = 0; i < G.vex_num;i++) {
for (int j = 0; j < G.vex_num; j++) {
read_in >> G.arcs[i][j];
// calculate the arc_num if (G.arcs[i][j] > 0) {
G.arc_num++; } } }
// 顶点向量
double arcs[max_vexNum][max_vexNum]; // 邻接矩阵
}Graph;
2. 文件读取的方式,本程序采用文件流的方式进行数据的读写,相关代码如下:
#include <fstream>
ifstream read_in; read_in.open("L:\\Coding\\图的常见操作\\图的常见操作\\city_10.txt"); if (!read_in.is_open()) {
cout<<"文件读取失败."<<endl; return; }
图的两种存储方式---邻接矩阵和邻接表
图的两种存储⽅式---邻接矩阵和邻接表图:图是⼀种数据结构,由顶点的有穷⾮空集合和顶点之间边的集合组成,表⽰为G(V,E),V表⽰为顶点的集合,E表⽰为边的集合。
⾸先肯定是要对图进⾏存储,然后进⾏⼀系列的操作,下⾯对图的两种存储⽅式邻接矩阵和邻接表尽⾏介绍。
(⼀)、邻接矩阵存储:⽤两个数组分别进⾏存储数据元素(顶点)的信息和数据元素之间的关系(边或弧)的信息。
存储顶点:⽤⼀个连续的空间存储n个顶点。
存储顶点之间的边:将由n个顶点组成的边⽤⼀个n*n的矩阵来存储,如果两个顶点之间有边,则表⽰为1,否则表⽰为0。
下⾯⽤代码来实现邻接矩阵的存储:#define SIZE 10class Graph{public:Graph(){MaxVertices = SIZE;NumVertices = NumEdges = 0;VerticesList = new char[sizeof(char)*MaxVertices];Edge = new int*[sizeof(int*)*MaxVertices];int i,j;for(i = 0;i<MaxVertices;i++)Edge[i] = new int[sizeof(int)*MaxVertices];for(i = 0;i<MaxVertices;i++){for(j = 0;j<MaxVertices;++j)Edge[i][j] = 0;}}void ShowGraph(){int i,j;cout<<"";for(i = 0;i<NumVertices;i++)cout<<VerticesList[i]<<"";cout<<endl;for(i = 0;i<NumVertices;i++){cout<<VerticesList[i]<<"";for(j = 0;j<NumVertices;j++)cout<<Edge[i][j] <<"";cout<<endl;}cout<<endl;}int GetVertexPos(char v){int i;for(i = 0;i<NumVertices;i++){if(VerticesList[i] == v)return i;}return -1;}~Graph(){Destroy();}void Insert(char v){if(NumVertices < MaxVertices){VerticesList[NumVertices] = v;NumVertices++;}}void InsertEdge(char v1,char v2){int i,j;int p1 = GetVertexPos(v1);int p2 = GetVertexPos(v2);if(p1 == -1 || p2 == -1)return ;Edge[p1][p2] = Edge[p2][p1] = 1;NumEdges++;}void RemoveEdge(char v1,char v2){int p1 = GetVertexPos(v1);int p2 = GetVertexPos(v2);if(p1 == -1 || p2== -1)return;if(Edge[p1][p2] == 0)return;Edge[p1][p2] = Edge[p2][p1] = 0;NumEdges--;}void Destroy(){delete[] VerticesList;VerticesList = NULL;for(int i = 0;i<NumVertices;i++){delete Edge[i];Edge[i] = NULL;}delete[] Edge;Edge = NULL;MaxVertices = NumVertices = 0;}void RemoveVertex(char v){int i,j;int p = GetVertexPos(v);int reNum = 0;if(p == -1)return;for(i = p;i<NumVertices-1;i++){VerticesList[i] = VerticesList[i+1];}for(i = 0;i<NumVertices;i++){if(Edge[p][i] != 0)reNum++;}for(i = p;i<NumVertices-1;i++){for(j = 0;j<NumVertices;j++){Edge[i][j] = Edge[i+1][j];}}for(i = p;i<NumVertices;i++){for(j = 0;j<NumVertices;j++)Edge[j][i] = Edge[j][i+1];}NumVertices--;NumEdges = NumEdges - reNum;}private:int MaxVertices;int NumVertices;int NumEdges;char *VerticesList;int **Edge;};上⾯的类中的数据有定义最⼤的顶点的个数(MaxVertices),当前顶点的个数(NumVertices),当前边的个数(NumEdges),保存顶点的数组,保存边的数组。
邻接矩阵转换为邻接表
邻接矩阵转换为邻接表1 #include <stdio.h>2 #include <stdlib.h>3#define INFINITY INT_MAX4//定义最⼤定点数5#define MAX_VERTEX_NUM 2067//定义图的类型8 typedef enum GraphKind{9 DG, //DG有向图 ----010 DN, //DN有向⽹ ----111 UDG,//UDG⽆向图----212 UDN //UDN⽆向⽹----313 };1415//=========================----------邻接矩阵的定义--------=================================1617//adj的int,是顶点关系类型,对于⽆权图⽤1或者0,表⽰相邻否;对于有权图,为权值类型。
18 typedef struct{19int adj;20int * info; //info 该弧相关的信息指针21 }AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //邻接矩阵结构2223 typedef struct Graph{24char vex[MAX_VERTEX_NUM] ;//顶点向量,存储顶点名称25 AdjMatrix arcs; //邻接矩阵26int vexnum,arcnum; //图当前定点数和弧度数27//GraphKind kind; //图的种类标志28 }MGraph;2930//=========================----------邻接矩阵结束定义--------================================= 3132//=========================----------邻接表的定义--------===================================== 3334//表⽰图的节点35 typedef struct ArcNode{36int adjvex;//定义节点在图中的位置37 ArcNode *nextarc;//指向下⼀个节点38int *info; //互相关的信息指针39 }ArcNode;//定义图的节点4041//表⽰图的表头42 typedef struct VNode{43char vexdata;44 ArcNode *firstarc;45 } AdjList[MAX_VERTEX_NUM];//定义图的表头4647 typedef struct48 {49 AdjList vertices;//邻接表50int vexnum,arcnum;//顶点个数,弧的个数51 } ALGraph;5253//=========================----------邻接表结束定义-------===================================== 5455int Locate_Vex(MGraph * G, char ch)56 {57for (int i = 0; i < G->vexnum; i++)58 {59if(G->vex[i]==ch) return i;60 }61return -1;62 }6364 MGraph * Create_MGaph()65 {66 MGraph *mgraph;67char start,end;//start 表⽰起点, end 表⽰终点68int vexnum,arcnum;69int i,j;70 mgraph=(MGraph *)malloc(sizeof(MGraph)); //分配空间71if (!mgraph)72 {73 printf("分配失败");74 }75 printf("请输⼊图的顶点数和边数:");76 scanf("%d%d",&vexnum,&arcnum);77 mgraph->vexnum=vexnum;78 mgraph->arcnum=arcnum;7980 printf("请输⼊顶点的名称:");81for (i = 0; i < vexnum; i++) scanf("%s",&(mgraph->vex[i]));//存储顶点的值 82//初始化矩阵83for (i = 0; i < vexnum; i++)84for (j = 0; j< vexnum; j++)85 {86 mgraph->arcs[i][j].adj = 0 ;87 mgraph->arcs[i][j].info = NULL;88 }8990 printf("-------------请输⼊弧的信息------------\n");91for(int k=0; k<arcnum; k++)92 {93 printf("请输⼊第%d条弧起始和终点:",(k+1));94 fflush(stdin);95 scanf("%c %c",&start,&end);96 i=Locate_Vex(mgraph,start);97 j=Locate_Vex(mgraph,end);98 mgraph->arcs[i][j].adj = 1;99 mgraph->arcs[j][i].adj = 1;100 }101102return mgraph;103 }104105 ALGraph * MGraph_Change_ALGraph(MGraph * mgraph)106 {107 ALGraph *algraph;108int vexnum;109 algraph = (ALGraph *)malloc(sizeof (ALGraph)); //分配空间110 algraph->vexnum = mgraph->vexnum;111 algraph->arcnum = mgraph->arcnum;112 vexnum = algraph->vexnum;113for(int i=0; i<mgraph->vexnum; i++)//完成初始化114 {115 algraph->vertices[i].vexdata = mgraph->vex[i];116 algraph->vertices[i].firstarc = NULL;117 }118119for(int i=0; i< vexnum ; i++)120 {121for(int j=0; j< vexnum ; j++)122 {123if(mgraph->arcs[i][j].adj == 1)124 {125 ArcNode * arcnode = (ArcNode *)malloc(sizeof (ArcNode));126 arcnode->adjvex = j;127 arcnode->nextarc = algraph->vertices[i].firstarc;128 algraph->vertices[i].firstarc = arcnode;129 }130 }131 }132133return algraph;134135 }136137void PrintMGraph(MGraph * mgraph)138 {139for(int i=0; i<mgraph->vexnum ; i++)140 {141for(int j=0; j<mgraph->vexnum ; j++)142 {143 printf("%-5d",mgraph->arcs[i][j].adj);144 }145 printf("\n");146 }147 }148149void PrintALGraph(ALGraph * algraph)150 {151for(int i=0; i<algraph->vexnum; i++)152 {153 VNode *p;154 ArcNode *q;155 p = &(algraph->vertices[i]);156 printf("%c",p->vexdata);157 q = p ->firstarc;158while (q)159 {160 printf("-->");161 printf("%c",algraph->vertices[q->adjvex].vexdata);162 q= q->nextarc;163 }164 printf("\n");165 }166 }167168int main(void)169 {170 MGraph *mgraph;171 ALGraph *algraph;172 mgraph = Create_MGaph();173 printf("\n打印邻接矩阵如下:\n");174 PrintMGraph(mgraph);175176 algraph = MGraph_Change_ALGraph(mgraph); 177178 printf("\n打印转换成邻接表如下:\n");179 PrintALGraph(algraph);180 system("pause");181return0;182 }183/*184Output:185请输⼊图的顶点数和边数:5 6186请输⼊顶点的名称:A B C D E187-------------请输⼊弧的信息------------188请输⼊第1条弧起始和终点:A B189请输⼊第2条弧起始和终点:A D190请输⼊第3条弧起始和终点:B C191请输⼊第4条弧起始和终点:B E192请输⼊第5条弧起始和终点:C D193请输⼊第6条弧起始和终点:C E194打印邻接矩阵如下:1950 1 0 1 01961 0 1 0 11970 1 0 1 11981 0 1 0 01990 1 1 0 0200201打印转换成邻接表如下:202A-->D-->B203B-->E-->C-->A204C-->E-->D-->B205D-->C-->A206E-->C-->B207*/。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
请输入节点数和弧数:3 3
第1 个节点信息:5
第2 个节点信息:6
第3 个节点信息:7
第1 条弧的弧尾和弧头的位置:1 2 第2 条弧的弧尾和弧头的位置:2 3 第3 条弧的弧尾和弧头的位置:1 3 图的邻接表表示为:
[1,5]-->[3,7]-->[2,6]-->^
[2,6]-->[3,7]-->[1,5]-->^
[3,7]-->[1,5]-->[2,6]-->^
交换后是::
图的邻接矩阵表示为:
0 1 1
1 0 1
1 1 0
请按任意键继续. . .
代码是:
#include<stdio.h>
#include<stdlib.h>
#define MAXV 100
typedef struct
{
int no;
int info;
}vertextype;
typedef struct
{
int num;
int edges[MAXV][MAXV];
// vertextype vexs[MAXV];
}mgraph;
struct arcnode
{
int adjvex;
int info;
struct arcnode *nextarc;
};
struct vexnode
{
int data;
struct arcnode *firstarc;
};
struct graph
{
int vexnum,arcnum;
vexnode vexpex[100];
};
struct graph *creatgraph()
{
int i,s,d;
struct graph *g;
struct arcnode *p,*q;
g = (struct graph *)malloc(sizeof(struct graph));
printf("请输入节点数和弧数:");
scanf("%d%d", &g->vexnum, &g->arcnum);
for(i=1; i<=g->vexnum; i++)
{
printf("第%d 个节点信息:",i);
scanf("%d", &g->vexpex[i].data);
g->vexpex[i].firstarc = NULL;
}
for(i=1; i<=g->arcnum; i++)
{
p = (struct arcnode *)malloc(sizeof(struct arcnode));
q = (struct arcnode *)malloc(sizeof(struct arcnode));
printf("第%d 条弧的弧尾和弧头的位置:",i);
scanf("%d%d",&s,&d);
p->adjvex = d;
p->info = g->vexpex[d].data;
p->nextarc = g->vexpex[s].firstarc;
g->vexpex[s].firstarc = p;
q->adjvex = s;
q->info = g->vexpex[s].data;
q->nextarc = g->vexpex[d].firstarc;
g->vexpex[d].firstarc = q;
}
return g; //return graph!
}
void changeto(graph *G, mgraph &g)
{
int i,j;
arcnode *m;
g.num = G->vexnum;
for(i = 1; i<=G->vexnum; i++)
for(j = 1; j<=G->vexnum; j++)
g.edges[i][j] = 0;
for(i = 1; i<=G->vexnum; i++)
{
m = G->vexpex[i].firstarc;
while(m)
{
g.edges[i][m->adjvex] = 1;
m = m->nextarc;
}
}
}
void printtu(struct graph *g,int n)
{
int i;
arcnode *p;
printf("图的邻接表表示为:\n");
for(i=1; i<=n; i++)
{
printf(" [%d,%d]-->", i, g->vexpex[i].data);
p = g->vexpex[i].firstarc;
while(p != NULL)
{
printf("[%d,%d]-->", p->adjvex, p->info);
p = p->nextarc;
}
printf("^\n");
}
}
void printftu2(mgraph g)
{
int i,j;
printf("图的邻接矩阵表示为:\n");
for(i = 1; i<=g.num; i++)
{
for(j = 1;j <= g.num; j++)
printf("%d ",g.edges[i][j]);
printf("\n");
}
}
void main()
{
graph *G;
mgraph g;
G = creatgraph();
printtu(G,G->vexnum);
printf("交换后是::\n");
changeto(G, g);
printftu2(g);
system("PAUSE");
}。