您的位置：360文档中心› 图的邻接表表示法

图的邻接表表示法

图的邻接表表示法
图的邻接表表示法

图的邻接表表示法

图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点v i，该方法把所有邻接于v i的顶点v j链成一个带头结点的单链表，这个单链表就称为顶点v i的邻接表(Adjacency List)。

1．邻接表的结点结构

（1

:

① 邻接点域adjvex

存放与vi相邻接的顶点v j的序号j。

② 链域next

将邻接表的所有表结点链在一起。

注意：若要表示边上的信息(如权值)，则在表结点中还应增加一个数据域。

顶点v i邻接表的头结点包含两个域：

① 顶点域vertex

存放顶点v i的信息

② 指针域firstedge

v i的邻接表的头指针。

注意：

① 为了便于随机访问任一顶点的邻接表，将所有头结点顺序存储在一个向量中就构成了图的邻接表表示。

② 有时希望增加对图的顶点数及边数等属性的描述，可将邻接表和这些属性放在一起来描述图的存储结构。

2．无向图的邻接表

对于无向图，v i的邻接表中每个表结点都对应于与v i相关联的一条边。因此，将邻接表的表头向量称为顶点表。将无向图的邻接表称为边表。

【例】对于无向图G5，其邻接表表示如下面所示，其中顶点v0的边表上三个表结点中的顶点序号分别为1、2和3，它们分别表示关联于v0的三条边(v0，v1)，(v0，v2)和(v0，v3)。

注意：n个顶点e条边的无向图的邻接表表示中有n个顶点表结点和2e个边表结点。

3．有向图的邻接表

对于有向图，v i的邻接表中每个表结点都对应于以v i为始点射出的一条边。因此，将有向图的邻接表称为出边表。

【例】有向图G6的邻接表表示如下面(a)图所示，其中顶点v1的邻接表上两个表结点中的顶点序号分别为0和4，它们分别表示从v1射出的两条边(简称为v1的出边)：和。

注意：n个顶点e条边的有向图，它的邻接表表示中有n个顶点表结点和e个边表结点。

4．有向图的逆邻接表

在有向图中，为图中每个顶点v i建立一个入边表的方法称逆邻接表表示法。

入边表中的每个表结点均对应一条以v i为终点(即射入v i)的边。

【例】G6的逆邻表如上面(b)图所示，其中v0的人边表上两个表结点1和3分别表示射人v0的两条边(简称为v0的入边)：和。

注意：

n个顶点e条边的有向图，它的邻接表表示中有n个顶点表结点和e个边表结点。

5.邻接表的形式说明及其建表算法

（1）邻接表的形式说明

var

head,next,point:array[0..2001]of longint; /*邻接表的表首顶点为head，后继指针为next，顶点序列为point */

p:longint;

proc addedge(a,b:longint); /*（a,b）进入邻接表*/

var t:longint;

{ inc(p);point[p]←b; /*增加顶点b*/

if head[a]=0 /*（a,b）进入邻接表*/

then head[a]←p

else{ t←head[a];

while next[t]<>0 do t←next[t];

next[t]←p };/*else*/

};/* addedge } */

(2)邻接表的形式说明

const n=10; e=20; {n为顶点数，e为边数}

type edge=^edgenode;

edgenode=record {边节点信息}

adjvex:1..n; {边的终点(链接点)}

weight:integer;{该边上的权，无权图可以省去}

next:edge; {指向下一条边的链接}

end;

vex=record

vertex:integer;

firstedge:edge;

end;

var s:edge;

g=array [1..n] of vex;

begin

read(n,e); {n为顶点数，e为边数}

for i:=1 to n do

begin

read(g[i]. vertex); {读入顶点信息表}

g[i]. firstedge:=nil; {表头指针初始化}

end;

for k:=1 to e do {建立邻接表}

begin

read(i,j,w); {读入一条边的起点、终点及权值}

new(s);

s^. adjvex:=j; {新节点赋值}

s^.weight:=w;

s^.next:=g[i].firstedge;

g[i].firstedge:=s;

new(s);

s^. adjvex:=i; {新节点赋值}

s^.weight:=w;

s^.next:=g[j].firstedge;

g[j].firstedge:=s;

end;

end.

该算法的时间复杂度是O(n+e)。

注意：

①建立有向图的邻接表更简单，每当读入一个顶点对序号时，仅需生成一个邻接序号为j的边表结点，将其插入到vj 的出边表头部即可。

②建立网络的邻接表时，需在边表的每个结点中增加一个存储边上权的数据域。

图的两种存储结构比较

邻接矩阵和邻接表是图的两种最常用的存储结构，它们各有所长。下面从及执行某些常用操作的时间这两方面来作一比较。

邻接表存储结构建立无向图

//算法功能：采用邻接表存储结构建立无向图 #include #include #define OK 1 #define NULL 0 #define MAX_VERTEX_NUM 20 // 最大顶点数 typedef int Status; //函数的类型，其值是函数结果状态代码 typedef char VertexType; typedef int VRType; typedef int InforType; typedef struct ArcNode { int adjvex; //该边所指的顶点的位置 struct ArcNode *nextarc; //指向下一条边的指针 int weight; //边的权 }ArcNode; //表的结点 typedef struct VNode { VertexType data; //顶点信息（如数据等） ArcNode *firstarc; //指向第一条依附该顶点的边的弧指针}VNode, AdjList[MAX_VERTEX_NUM]; //头结点 typedef struct ALGraph { AdjList vertices; int vexnum, arcnum; //图的当前顶点数和弧数 }ALGraph; //返回顶点v在顶点向量中的位置 int LocateVex(ALGraph G, char v) { int i; for(i = 0; v != G.vertices[i].data && i < G.vexnum; i++) ; if(i >= G.vexnum) return -1;

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

图的邻接矩阵和邻接表相互转换 图的邻接矩阵存储方法具有如下几个特征：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 #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; //边数

邻接表表示的图的基本操作的实现

邻接表表示的图的基本操作的实现 //采用邻接表完成无权无向及有向图的"建立、输出、深度遍历、广度遍历"操作 #include #include #define OK 1 #define ERROR -1 typedef int Status; typedef int ElemType; //此例中设元素为单值元素，类型为整型 #define MAX_VERTEX_NUM 20 //最大顶点个数 typedef int ElemType; //图顶点数据类型 typedef int QueueElemType;//队列结点数据类型 //链表结点类型定义 typedef struct Qnode { QueueElemType data; struct Qnode *next; }QNode; //队列类型定义： typedef struct Linkqueue { QNode *front,*rear; }LinkQueue; //图的数据类型定义 typedef struct Tablenode//表结点结构 { int adjVex;//邻接点域，存放与vi相邻接的顶点vj的序号j struct Tablenode *next;//指针域，将邻接表的所有表结点链在一起 float weight;//对于带权图，表示权值，对于无权图则可省略此数据域 }TableNode;

typedef struct Headnode//头结点结构 { ElemType vertex;//顶点域vertex，存放顶点vi的信息 struct Tablenode *firstEdge;//vi的邻接表的头指针 }HeadNode; typedef struct Mgraph { struct Headnode vector[MAX_VERTEX_NUM]; //顶点向量 int vexnum; //图中当前顶点数 } MGraph; //队列初始化 Status InitLinkQueue(LinkQueue *Q) { QNode *p; p=(QNode*)malloc(sizeof(QNode));//开辟头结点空间 if(p!=NULL) { p->next=NULL; Q->front=Q->rear=p; return OK; } else return ERROR; } //链式队列的入队操作，在已知队列的队尾插入一个元素e，修改队尾指针rear。 Status InsertLinkQueue(LinkQueue *Q,ElemType e) { QNode *p;

邻接表存储表示

邻接表存储表示 Status Build_AdjList(ALGraph &G)//输入有向图的顶点数,边数,顶点信息和边的信息建立邻接表 { InitALGraph(G); scanf("%d",&v); if(v<0) return ERROR; G.vexnum=v; scanf("%d",&a); if(a<0) return ERROR; G.arcnum=a; for(m=0;mnextarc;q=q->nextarc); q->nextarc=p; } p->adjvex=j;p->nextarc=NULL; }//while return OK; }//Build_AdjList 邻接多重表存储表示 Status Build_AdjMulist(AMLGraph &G)//输入有向图的顶点数,边数,顶点信息和边的信息建立邻接多重表 { InitAMLGraph(G); scanf("%d",&v); if(v<0) return ERROR; //顶点数不能为负 G.vexnum=v; scanf(%d",&a); if(a<0) return ERROR; //边数不能为负 G.arcnum=a; for(m=0;m

用邻接矩阵表示法创建有向图(数据结构)

#include #include #include #define MAX_VERTEX_NUM 20 //定义最多顶点个数 #define INFINITY32768 //定义无穷大 //描述图的类型，用枚举型类型来说明 typedef enum{DG,DN,UDG,UDN}GraphKind; //定义顶点数据类型 typedef char V ertexData; //定义邻接矩阵中元素值(即边信息）的数据类型 typedef int ArcNode; //定义图的邻接矩阵类型：一个顶点信息的一维数组，一个邻接矩阵、当前图中包含的顶点数、边数以及图类型（有向图、有向网、无向图、无向网） typedef struct { V ertexData vertex[MAX_VERTEX_NUM]; ArcNode arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; int vertexnum,arcnum; GraphKind kind; } AdjMatrix;//图的邻接矩阵表示类型 int LocateV ertex(AdjMatrix *G,V ertexData v) //求顶点位置函数 { int j=-1,k; for(k=0;kvertexnum;k++) { if(G->vertex[k]==v) { return k; } } return j; } int CreateDN(AdjMatrix *G) //创建一个又向网 { int i,j,k,weight; V ertexData v1,v2; printf("输入图的顶点数和弧数，以逗号分隔\n"); //输入图的顶点数和弧数 scanf("%d,%d",&G->vertexnum,&G->arcnum); for(i=0;ivertexnum;i++) //初始化邻接矩阵（主对角线元素全为零，其余元素为无穷大） {

实验十三 图的基本操作—邻接表存储结构

浙江大学城市学院实验报告 课程名称数据结构基础 实验项目名称实验十三图的基本操作—邻接表存储结构 学生姓名专业班级学号 实验成绩指导老师（签名）日期2015-1-15 一.实验目的和要求 1、掌握图的存储结构：邻接表。 2、学会对图的存储结构进行基本操作。 二.实验内容 1、图的邻接表的定义及实现：建立头文件AdjLink.h，在该文件中定义图的邻接表存储结构，并编写图的初始化、建立图、输出图、输出图的每个顶点的度等基本操作实现函数。同时在主函数文件test5_2.cpp中调用这些函数进行验证。 2、选做：编写图的深度优先遍历函数与广度优先遍历函数，要求把这两个函数添加到头文件AdjLink.h中，并在主函数文件test5_2.cpp中添加相应语句进行测试。 3、填写实验报告，实验报告文件取名为report13.doc。 4、上传实验报告文件report13.doc及源程序文件test5_2.cpp、AdjLink.h到Ftp服务器上自己的文件夹下。 三. 函数的功能说明及算法思路 （包括每个函数的功能说明，及一些重要函数的算法实现思路） 邻接表表示法的C语言描述： typedef struct Node { int adjvex; // 邻接点的位置 WeightType weight; //权值域，根据需要设立 struct Node *next; // 指向下一条边（弧） } edgenode; // 边结点 typedef edgenode *adjlist[ MaxVertexNum ];//定义图的邻接表结构类型（没包含顶点信息） typedef struct{ vexlist vexs; //顶点数据元素

图的邻接表存储结构实验报告

《图的邻接表存储结构实验报告》1.需解决的的问题 利用邻接表存储结果，设计一种图。 2.数据结构的定义 typedef struct node {//边表结点 int adj;//边表结点数据域 struct node *next; }node; typedef struct vnode {//顶点表结点 char name[20]; node *fnext; }vnode,AList[M]; typedef struct{ AList List;//邻接表 int v,e;//顶点树和边数 }*Graph; 3.程序的结构图

4.函数的功能 1）建立无向邻接表 Graph Create1( )//建立无向邻接表{ Graph G; int i,j,k;

node *s; G=malloc(M*sizeof(vnode)); printf("输入图的顶点数和边数："); scanf("%d%d",&G->v,&G->e);//读入顶点数和边数for(i=0;iv;i++)//建立顶点表 { printf("请输入图第%d个元素:",i+1); scanf("%s",&G->List[i].name);//读入顶点信息 G->List[i].fnext=NULL;//边表置为空表 } for(k=0;ke;k++)//建立边表--建立了2倍边的结点{ printf("请输入边的两顶点序号：（从0考试）"); scanf("%d%d",&i,&j);//读入边（Vi,Vj）的顶点对序号 s=(node *)malloc(sizeof(node));//生成边表结点 s->adj=j; s->next=G->List[i].fnext; G->List[i].fnext=s;//将新结点*s插入顶点Vi的边表头部s=(node *)malloc(sizeof(node)); s->adj=i;//邻接点序号为i s->next=G->List[j].fnext; G->List[j].fnext=s;// 将新结点*s插入顶点Vj的边表头部} return G;

图的邻接表存储方式.

图的邻接表存储方式——数组实现初探 焦作市外国语中学岳卫华在图论中，图的存储结构最常用的就是就是邻接表和邻接矩阵。一旦顶点的个数超过5000，邻接矩阵就会“爆掉”空间，那么就只能用邻接表来存储。比如noip09的第三题，如果想过掉全部数据，就必须用邻接表来存储。 但是，在平时的教学中，发现用动态的链表来实现邻接表实现时，跟踪调试很困难，一些学生于是就觉得邻接表的存储方式很困难。经过查找资料，发现，其实完全可以用静态的数组来实现邻接表。本文就是对这种方式进行探讨。 我们知道，邻接表是用一个一维数组来存储顶点，并由顶点来扩展和其相邻的边。具体表示如下图：

其相应的类型定义如下： type point=^node; node=record v:integer; //另一个顶点 next:point; //下一条边 end; var a:array[1..maxv]of point; 而用数组实现邻接表，则需要定义两个数组：一个是顶点数组，一个 是边集数组。

顶点编号结点相临边的总数s第一条邻接边next 此边的另一邻接点边权值下一个邻接边 对于上图来说，具体的邻接表就是： 由上图我们可以知道，和编号为1的顶点相邻的有3条边，第一条边在边集数组里的编号是5，而和编号为5同一个顶点的下条边的编号为3，再往下的边的编号是1，那么和顶点1相邻的3条边的编号分别就是5，3，1。同理和顶点3相邻的3条边的编号分别是11，8，4。如果理解数组表示邻接表的原理，那么实现就很容易了。 类型定义如下：

见图的代码和动态邻接表类似： 下面提供一道例题 邀请卡分发deliver.pas/c/cpp 【题目描述】

实现图的邻接矩阵和邻接表存储

实现图的邻接矩阵和邻接表存储 1．需求分析 对于下图所示的有向图G，编写一个程序完成如下功能： 1．建立G的邻接矩阵并输出之 2．由G的邻接矩阵产生邻接表并输出之 3．再由2的邻接表产生对应的邻接矩阵并输出之 2．系统设计 1．图的抽象数据类型定义： ADT Graph{ 数据对象V：V是具有相同特性的数据元素的集合，称为顶点集 数据关系R： R={VR} VR={|v,w∈V且P(v,w),表示从v到w的弧， 谓词P(v,w)定义了弧的意义或信息} 基本操作P： CreatGraph(&G,V,VR) 初始条件：V是图的顶点集，VR是图中弧的集合 操作结果：按V和VR的定义构造图G DestroyGraph(&G) 初始条件：图G存在 操作结果：销毁图G InsertVex(&G,v) 初始条件：图G存在，v和图中顶点有相同特征 操作结果：在图G中增添新顶点v …… InsertArc(&G,v,w) 初始条件：图G存在，v和w是G中两个顶点 操作结果：在G中增添弧，若G是无向的则还增添对称弧 …… DFSTraverse(G,Visit()) 初始条件：图G存在，Visit是顶点的应用函数 操作结果：对图进行深度优先遍历，在遍历过程中对每个顶点调用函数Visit一次且仅一次。

一旦Visit()失败，则操作失败 BFSTraverse(G,Visit()) 初始条件：图G存在，Visit是顶点的应用函数 操作结果：对图进行广度优先遍历，在遍历过程中对每个顶点调用函数Visit一次且仅一次。一旦Visit()失败，则操作失败 }ADT Graph 2．主程序的流程： 调用CreateMG函数创建邻接矩阵M； 调用PrintMatrix函数输出邻接矩阵M 调用CreateMGtoDN函数，由邻接矩阵M创建邻接表G 调用PrintDN函数输出邻接表G 调用CreateDNtoMG函数，由邻接表M创建邻接矩阵N 调用PrintMatrix函数输出邻接矩阵N 3．函数关系调用图： 3．调试分析 （1）在MGraph的定义中有枚举类型 typedef enum{DG,DN,UDG,UDN}GraphKind;//{有向图,有向网,无向图,无向网} 赋值语句G.kind(int)=M.kind(GraphKind);是正确的，而反过来M.kind=G.kind则是错误的，要加上那个强制转换M.kind=GraphKind(G.kind);枚举类型enum{DG,DN,UDG,UDN} 会自动赋值DG=0；DN=1，UDG=2，UDN=3；可以自动从GraphKind类型转换到int型，但不会自动从int型转换到GraphKind类型

邻接表表示的带权有向图(网)

===实习报告一“邻接表表示的带权有向图（网）”演示程序=== （一）、程序的功能和特点 1. 程序功能：建立有向图的带权邻接表，能够对建立的邻接表进行添加顶点，添加边和删除顶点，删除边的操作，并能显示输出邻接表。 2. 程序特点：采用java面向对象语言，对边，顶点和邻接表用类进行封装。采用链式存储结构。 （二八程序的算法设计 算法一：“插入一个顶点”算法： 1. 【逻辑结构与存储结构设计】 逻辑结构：线性结构。存储结构：顺序存储与链式存储结合。 邻接表（Adjacency List）是图的一种顺序存储与链式存储结合的存储方法。。邻接表表示法类似于树的孩子链表表示法。就是对于图G中的每个顶点vi，将所有邻接于vi的顶点vj链成一个单链表，这个单链表就称为顶点vi的邻接表，再将所有点的邻接表表头放到数组中，就构成了图的邻接表。如下图就是一个临界表的存储图。 vertex firstedge adjvex n ext 序号vertex firstedge 图的邻接表表示在邻接表表示中有两种结点 结构，如图所示。 邻接矩阵表示的结点结构

顶点域边指针 流程示意图：顶点数据组成的数组 顶点数组表的顺序存储: V0 V1— V2— O 2.【基本操作设计】 文字说明： （1） .首先判断顶点表是否满。 （2） .若满则插入失败，放回false 。 （3） .顶点表若不满，创建新顶点，将新顶点加入顶点表 （4） .插入顶点成功，返回true 。

添加顶点前状态 添加顶点v2后 网图的边表结构 //插入一个顶点 public boolea n In sertVertex ( char vertex ){ if (NumVertices ==MaxVertices ) return false ; // 顶点表满 Vertex t= n ewVertex(); t. data =vertex; t. adj =null ; NodeTable[ NumVertices ]=t; NumVertices++; //注明：企图以下赋值不合Java 语法 〃NodeTable[NumVertices].data=vertex; 〃NodeTable[NumVertices].adj=null; return true ; } 算法二：“插入一条边”算法： 1. 【逻辑结构与存储结构设计】 逻辑结构：线性结构。 存储结构：链式存储结构 网图的边表结构如图所示。 邻接点域 4.【高级语言代码】

邻接表结构函数(GRAPH1.H)。。

/* 头文件：graph1.h:邻接表,中的遍历,生成树,关键路径 */ int menu_netselect1() { /* 邻接表菜单选择系统 */ char s[8]; int c; clrscr(); /* 清屏 */ printf("\n"); printf("\n"); printf(" ************************************ \n"); printf(" * * \n"); printf(" * 邻接表结构操作窗口 * \n"); printf(" * * \n"); printf(" * 无向网:a1.txt; ..... i1.txt; * \n"); printf(" * 有向网:a2.txt; ..... i2.txt; * \n"); printf(" * 无环网:a3.txt; ..... i3.txt; * \n"); printf(" * * \n"); printf(" ************************************ \n"); printf("\n"); printf(" 01:建立邻接表(无向网)\n"); printf(" 02:建立邻接表(有向网)\n"); printf(" 03:输出邻接表结构\n"); printf(" 04:深度遍(连通-非连通)\n"); printf(" 05:广度遍(连通-非连通)\n"); printf(" 06:邻接表 DFS 树\n"); printf(" 07:邻接表 BFS 树\n"); printf(" 08:深度遍历建生成树(无向 网)\n"); printf(" 09:拓扑排序(有向无环网)\n"); printf(" 10:关键路径(有向无环网)\n"); printf(" 11:销毁当前邻接表\n"); printf(" 12:返回主窗口\n"); do { printf("\n"); printf(" 输入你的选择号:1---12: "); gets(s); c=atoi(s); }while(c<0||c>12); return(c); } int LocateVex1(ALGraph G,VertexType u)

邻接矩阵表示的带权有向图

实习报告——“邻接矩阵表示的带权有向图”演示程序 （一）、程序的功能和特点 主要实现的功能：1.使用邻接矩阵表示带权有向图； 2.查找指定顶点序号； 3.判断图是否为空； 4.判断图是否满； 5.取得顶点数、边数、一条边的权值； 6.插入一个顶点、边； 7.删除一个顶点、边； （二）、程序的算法设计 “邻接矩阵的表示”算法： 1.【逻辑结构与存储结构设计】 逻辑结构：非线性结构——网状结构 存储结构:内存中连续的存储结构，邻接矩阵 2.【基本操作设计】 按指定输入，生成图并打印该图 删除一个顶点并打印 删除一条边并打印 3. 【算法设计】 插入一个顶点的算法： 首先判断该图是否已满，若已满：插入失败； 否则进行插入：1.顶点表增加一个元素 2.邻接矩阵增加一行一列 删除一个顶点的算法： A F E D C B

判断要删除顶点的存在性，若不存在：出错； 否则：1.修改顶点表，即在顶点数组中删除 该点； 2.修改邻接矩阵，即需要统计与该顶 点相关联的边，并将这些边也删除4.【高级语言代码】 public class Graph { static int MaxEdges=50; static int MaxVertices=10; static int MaxValue=9999;//无穷大 //存放顶点的数组 private char VerticesList[]=new char[MaxVertices]; //邻接矩阵（存放两个顶点的权值） private int Edge[][]=new int[MaxVertices][MaxVertices]; private int CurrentEdges;//现有边数 private int CurrentVertices;//现有顶点数 //构造函数：建立空的邻接矩阵 public Graph(){ for(int i=0;i

图的基本操作(邻接表)

标头.h #include #include #include #include #define TRUE 1 #define FLASE 0 #define OK 1 #define ERROR 0 #define FALSE 0 #define INFINITY INT_MAX//无穷大 typedef int status; #define MAX_VERTEX_NUM 20 #define MAX_NAME 5 #define MAX_INFO 20 typedef int VRType; typedef int InfoType; typedef char VertexType[MAX_NAME]; enum GraphKind{DG,DN,AG,AN};// 有向图，有向网，无向图，无向图 struct ArcNode { int adjvex; //该弧所指向的顶点的位置 ArcNode *nextarc;//指向吓下一条弧的指针 InfoType *info;//网的权值指针 };//表结点 typedef struct { VertexType data;//顶点信息 ArcNode *firstarc;//第一个表结点的地址，指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VERTEX_NUM]; //头结点 struct ALGraph { AdjList vertices; int vexnum,arcnum;//图的当前顶点数和弧数 int kind; //图的种类标志 }; int LocateVex(ALGraph G,VertexType u) {//初始条件：图G存在，u和G中顶点有相同的特征

数据结构实验报告无向图邻接矩阵存储结构

数学与计算机学院 课程设计说明书 课程名称: 数据结构与算法课程设计 课程代码: 6014389 题目: 无向图的邻接矩阵存储结构 年级/专业/班: 2018级软件4班 学生姓名: 吴超 学号: 312018********* 开始时间: 2018年12月9日 完成时间: 2018年12月30日 课程设计成绩： 指导教师签名：年月日 数据结构课程设计任务书

学院名称：数学与计算机学院课程代码：__6014389______ 专业：软件工程年级： 2018 一、设计题目 无向图的邻接矩阵存储结构 二、主要内容 图是无向带权图，对下列各题，要求写一算法实现。 1）能从键盘上输入各条边和边上的权值； 2）构造图的邻接矩阵和顶点集。 3）输出图的各顶点和邻接矩阵 4）插入一条边 5）删除一条边 6）求出各顶点的度 7）判断该图是否是连通图，若是，返回1；否则返回0. 8）使用深度遍历算法，输出遍历序列。 三、具体要求及应提交的材料 用C/C++语言编程实现上述内容，对每个问题写出一个算法实现，并按数学与计算机学院对课程设计说明书规范化要求，写出课程设计说明书，并提交下列材料： 1>课程设计说明书打印稿一份 2>课程设计说明书电子稿一份； 3>源程序电子文档一份。 四、主要技术路线提示 用一维数组存放图的顶点信息，二维数组存放各边信息。 五、进度安排 按教案计划规定，数据结构课程设计为2周，其进度及时间大致分配如下：

[1] 严蔚敏，吴伟民.数据结构.清华大学出版社出版。 [2] 严蔚敏，吴伟民. 数据结构题集(C语言版> .清华大学出版社.2003年5月。 [3]唐策善，李龙澎.数据结构(作C语言描述> .高等教育出版社.2001年9月 [4] 朱战立.数据结构(C++语言描述><第二版本）.高等出版社出版.2004年4月 [5]胡学钢.数据结构(C语言版> .高等教育出版社.2004年8月 指导教师签名日期年月日 系主任审核日期年月日 目录

实验六 图的邻接表存储及遍历

实验六图的邻接表存储及遍历 一、实验学时 2学时 二、背景知识 1．图的邻接表存储结构 在图的邻接表中，图中每个顶点都建立一个单链表，第i个单链表中的结点数为顶点i的出度。(逆邻接表中，第i个单链表中的结点数为顶点i的入度) 邻接表的数据结构描述为： struct node { int vertex; struct node *nextnode; }; typedef struct node *graph; struct node head[vertexnum]; 2.图的遍历 深度优先遍历（DFS）法： 算法步骤： 1）初始化： （1）置所有顶点“未访问”标志； （2）打印起始顶点； （3）置起始顶点“已访问”标志； （4）起始顶点进栈。 2）当栈非空时重复做： （1）取栈顶点； （2）如栈顶顶点存在未被访问过的邻接顶点，则选择第一个顶点做： ①打印该顶点； ②置顶点为“已访问”标志； ③该顶点进栈； 否则，当前栈顶顶点退栈。 3）结束。 广度优先遍历（BFS）法： 算法步骤： 1) 初始化： （1）置所有顶点“未访问”标志； （2）打印起始顶点； （3）置起始顶点“已访问”标志； （4）起始顶点入队。 2）当队列非空时重复做： （1）取队首顶点； （2）对与队首顶点邻接的所有未被访问的顶点依次做： ①打印该顶点； ②置顶点为“已访问”标志； ③该顶点入队； 否则，当前队首顶点出队。 3) 结束。

三、目的要求 1．掌握图的基本存储方法； 2．掌握有关图的操作算法并用高级语言实现； 3．熟练掌握图的两种搜索路径的遍历方法。 四、实验内容 1．编写程序实现下图的邻接表表示及其基础上的深度和广度优先遍历。 五、程序实例 图的邻接表表示法的C语言描述： #include #include struct node /* 图形顶点结构定义 */ { int vertex; /* 顶点 */ struct node *nextnode; /* 指下一顶点的指针 */ }; typedef struct node *graph; /* 图形的结构重定义 */ struct node head[6]; /* 图形顶点结构数组 */ /*----------建立图形--------*/ void creategraph(int *node,int num) { graph newnode; /* 新顶点指针 */ graph ptr; int from; /* 边线的起点 */ int to; /* 边线的终点 */ int i; for ( i = 0; i < num; i++ ) /* 读取边线的回路 */ { from = node[i*2]; /* 边线的起点 */ to = node[i*2+1]; /* 边线的终点 */ /* 申请存储新顶点的内存空间 */ newnode = ( graph ) malloc(sizeof(struct node)); newnode->vertex = to; /* 建立顶点内容 */ newnode->nextnode = NULL; /* 设定指针初值 */ ptr = &(head[from]); /* 顶点位置 */ while ( ptr->nextnode != NULL ) /* 遍历至链表尾 */ ptr = ptr->nextnode; /* 下一个顶点 */ ptr->nextnode = newnode; /* 插入结尾 */ } }

分别以邻接矩阵和邻接表作为图的存储结构

分别以邻接矩阵和邻接表作为图的存储结构，给出连通图的深度优先 遍历的递归算法 算法思想： （1）访问出发点vi，并将其标记为已访问过。 （2）遍历vi的的每一个邻接点vj，若vi未曾访问过，则以vi为新的出发点继续进行深度优先遍历。 算法实现： Boolean visited[max]; // 访问标志数 void DFS(Graph G, int v) { // 算法7.5从第v个顶点出发递归地深度优先遍历图G int w; visited[v] = TRUE; printf("%d ",v); // 访问第v个顶点for (w=FirstAdjVex(G, v); w>=0; w=NextAdjVex(G, v, w)) if (!visited[w]) // 对v的尚未访问的邻接顶点w递归调用DFS DFS(G, w); } /*****************************************************/ /*以邻接矩阵作为存储结构*/ DFS1(MGraph G,int i) {int j; visited[i]=1; printf("%c",G.vexs[i]); for(j=1;j<=G.vexnum;j++) if(!visited[j]&&G.arcs[i][j]==1) DFS1(G,j); } /*以邻接表作为存储结构*/ DFS2(ALGraph G,int i) {int j; ArcPtr p; visited[i]=1; printf("%c",G.vertices[i].data); for(p=G.vertices[i].firstarc;p!=NULL;p=p->nextarc) {j=p->adjvex; if(!visited[j]) DFS2(j); } }

邻接表存储结构建立无向图

ata && i < ; i++) ; if(i >= return -1; return i; } ata); irstarc = NULL; getchar(); } char v1, v2; for(int k = 0; k < ; k++) { printf("输入第 %d 条边依附的顶点v1: ", k+1); scanf("%c", &v1); getchar(); printf("输入第 %d 条边依附的顶点v2: ", k+1); scanf("%c", &v2); getchar(); int i = LocateVex(G, v1); int j = LocateVex(G, v2); irstarc; [i].firstarc =s; t->adjvex = i; irstarc; [j].firstarc =t;

} return OK; } Status PrintAdjList(ALGraph &G) { ArcNode *p; printf("%4s%6s%12s\n", "编号", "顶点", "相邻边编号"); for(int i = 0; i < ; i++) { printf("%4d%6c", i, [i].data); for(p = [i].firstarc; p; p = p->nextarc) printf("%4d", p->adjvex); printf("\n"); } return OK; } int main() { ALGraph G; CreateUDN(G); rintAdjList(G); return 0; }

2-深度优先遍历以邻接表存储的图-实验报告

福建江夏学院 《数据结构与关系数据库（本科）》实验报告姓名班级学号实验日期 课程名称数据结构与关系数据库（本科）指导教师成绩 实验名称：深度优先遍历以邻接表存储的图 一、实验目的 1、掌握以邻接表存储的图的深度优先遍历算法； 二、实验环境 1、硬件环境：微机 2、软件环境：Windows XP，VC6.0 三、实验内容、步骤及结果 1、实验内容： 基于图的深度优先遍历编写一个算法，判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径（i≠j）。 2、代码： #include #include #define MaxVertexNum 100 /*最大顶点数为100*/ typedef char VertexType; typedef struct node{ /*边表结点*/ int adjvex; /*邻接点域*/ struct node * next; /*指向下一个邻接点的指针域*/ /*若要表示边上信息，则应增加一个数据域info*/ }EdgeNode; typedef struct vnode{ /*顶点表结点*/ VertexType vertex; /*顶点域*/ EdgeNode * firstedge; /*边表头指针*/ }VertexNode; typedef VertexNode AdjList[MaxVertexNum]; /*AdjList 是邻接表类型*/ typedef struct{ AdjList adjlist; /*邻接表*/ int n,e; /*顶点数和边数*/ }ALGraph; /*ALGraph 是以邻接表方式存储的图类型*/ bool visited[MaxVertexNum]; void CreateALGraph(ALGraph *G)

有向图的邻接矩阵

有向图的邻接矩阵 设有向图，，。令为邻接到的边的条数，称为D的邻接矩阵，记作。 为图7.12的邻接矩阵，不难看出： (1)(即第i行元素之和为的出度)，。 (2)(即第j列元素之和为的入度)， 。 (3)由(1)，(2)可知，为D中边的总数，也可看成是D中长度为1的通路总数，而为D中环的个数，即D中长度为1的回路总数。 D中长度大于等于2的通路数和回路数应如何计算呢？ 为此，先讨论长度等于2的通路数和回路数。

在图D中，从顶点到顶点的长度等于2的通路，中间必经过一顶点。对于任意的k，若有通路，必有且，即。反之，若D中不存在通路，必有或，即。于是在图D中从顶点到顶点的长度等于2的通路数为： 由矩阵的乘法规则知，正好是矩阵中的第i 行与第j列元素，记，即就是从顶点到顶点的长度等于2的通路数，时，表示从顶点到顶点的长度等于2的回路数。 因此，即矩阵中所有元素的和为长度等于2的通路总数(含回路)，其中对角线的元素和为长度等于2的回路总数。 根据以上分析，则有下面的推论。 定义有向图，，D中长度为的通路数和回路数可以用矩阵(简记)来表示，这里，其中 ， 即

则为顶点到顶点长度为的通路数，为到自身长度为的回路数。中所有元素之和为D中长度为的通路数，而中对角线上元素之和为D中始于(终于)各顶点的长度为的回路数。 在图7.12中，计算，，如下： 观察各矩阵发现，，，。于是，D中到长度为2的通路有3条，长度为3的通路有4条，长度为4的通路有6条。由， ，可知，D中到自身长度为的回路各有1条(此时回路为 复杂的)。由于，所以D中长度为2的通路总数为10，其中有3条回路。 从上述分析，可得下面定理。 定理7.5设为有向图D的邻接矩阵，，则中元素 为到长度为的通路数，为D中长度为的通路总数，其中 为D中长度为的回路总数。 若再令矩阵 ，

采用邻接表存储结构实现图的广度优先遍历。

课程设计题目九：图的广度优先遍历 基本要求： 采用邻接表存储结构实现图的广度优先遍历。 （2）对任意给定的图（顶点数和边数自定），建立它的邻接表并输出；（3）实现图的广度优先遍历*/ #include #include #include #define MAX_NUM 20 int visited[MAX_NUM]={0}; typedef int VertexType; typedef enum {DG=1,UDG}GraphKind; typedef struct ArcNode { int adjvex; int weight; struct ArcNode *nextarc; ArcNode *info; }ArcNode; typedef struct VNode { VertexType data; ArcNode *firstarc; }VNode,AdjList[MAX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; GraphKind kind; }ALGraph; void PRIN(ALGraph &G); void Creat_adjgraph(ALGraph &G); void bfs(ALGraph &G,int v); void Creat_adjgraphDG(ALGraph &G); void Creat_adjgraphUDG(ALGraph &G); void Creat_adjgraph(ALGraph &G); void Creat_adjgraphDG(ALGraph &G) { int i,s,d; ArcNode *p=NULL,*q=NULL;G.kind=DG; printf("请输入顶点数和边数："); scanf("%d %d",&G.vexnum,&G.arcnum);

相关主题
相关文档
最新文档