建立一个有向图的邻接矩阵存储的算法

合集下载

迪杰斯特拉算法

迪杰斯特拉算法

第七章图迪杰斯特拉算法如下:SHORTEST—PATH(intcost[][n],intv,intn,intdist[],intpath[)){ihti,N,u,count,pos[n];for(i=0;i<n;i++){s[i]=0;/x标记数组置0 x/dist[i]=cost[V][i];/。

将邻接矩阵第v行元素依次送dist数组xpath[i][0]=v;/x源点v到各顶点的路径置初值。

/pos[i]=0;/。

第i条路径的位置计数器置初值x/} /x对辅助数组进行初始化。

/s[v]=l;count=1; /x计数器赋初值1 x/while(count<n){ /‘以下过程执行n-1次x/u=MINDIST(s,dist);/x利用s和dist在尚未找到最短路径的顶点中确定一个与v最近的顶点u。

/s[u]=1;/‘置u的标记为1●/path[u)C++pos[u]]=u;/x将u添加到v到u的最短路径中。

/count++;/,计数器累力n1 x/while(1){ /。

根据u更新v到所有尚未确定最短路径的顶点的路径长度。

/if((w=SEARCH_VER(s,dist,u))==-1)/,找到通过u可以直接到达、且尚未确定最短路径的一个顶点。

/break;/x未找到,路径长度更新过程结束。

/else{if(dist[u]+cost[u][w]<dist[w]]{dist[N]=dist[u]+cost[u][w];/x更新路径长度●/for[i=0;i<pos[u];i++)path[w][i]=path[u][i];/。

用源点v到顶点u的路径替换源点v到w的路径。

/}} } .习题8.1 判断题(在你认为正确的题后的括号中打√,否则打X)。

(1)没有顶点的图称为空图。

( )(2)图的度是图中所有顶点的度的最大值。

( )(3)边上带权值的图称为网(络)。

( )(4)图中一个顶点的度应该是它的出度与人度之和。

计算机专业基础综合数据结构(图)历年真题试卷汇编4

计算机专业基础综合数据结构(图)历年真题试卷汇编4

计算机专业基础综合数据结构(图)历年真题试卷汇编4(总分:58.00,做题时间:90分钟)一、综合题(总题数:7,分数:14.00)1.已知一图如下图所示:(1)写出全部拓扑排序;(2)以V1为源点,以V8为终点,给出所有事件允许发生的最早时间和最晚时间,并给出关键路径;(3)求V1结点到各点的最短距离。

【北京邮电大学2000五(15分)】__________________________________________________________________________________________正确答案:(正确答案:关键路径有3条,长17。

各事件允许发生的最早时间和最晚时间略。

V1→V2→V6→V8,V1→V3→V5→V7→V8,V1→V7→V8→V1→V4→V5→V8 (3)V1结点到其他各结点的最短距离为:2,3,6,12,10,15,16。

)2.(1)对于有向无环图,叙述求拓扑有序序列的步骤;(2)对于以下的图,写出它的四个不同的拓扑有序序列。

【南开大学1998二(12分)】__________________________________________________________________________________________ 正确答案:(正确答案:(1)对有向图,求拓扑序列步骤为: 1)在有向图中选一个没有前驱(即入度为零)的顶点并输出。

2)在图中删除该顶点及所有以它为尾的弧。

3)重复1)和2),直至全部顶点输出,这时拓扑排序完成;否则,图中存在环,拓扑排序失败。

(2)这里使用形式化描述方法,当有多个顶点可以输出时,将其按序从上往下排列,这样不会丢掉拓扑序列。

这里只画出从顶点1开始的所有可能的拓扑序列,从顶点3开始的拓扑序列可类似画出。

)3.有向图的拓扑排序能否用图的深度搜索模式来查找?若能,请简述方法;若不能,请简述原因。

【西北大学2000二、8(5分)】__________________________________________________________________________________________ 正确答案:(正确答案:图的深度优先遍历可用于拓扑排序。

...统计有向图中每个顶点的出度和入度(以邻接矩阵和邻接表两种方式实现...

...统计有向图中每个顶点的出度和入度(以邻接矩阵和邻接表两种方式实现...

数据结构—统计有向图中每个顶点的出度和⼊度(以邻接矩阵和邻接表两种⼊式实现)⼊、邻接矩阵实现假设不带权有向图采⼊邻接矩阵 g 存储,设计实现以下功能的算法:(1)求出图中每个顶点的⼊度。

(2)求出图中每个顶点的出度。

(3)求出图中出度为 0 的顶点数。

#include#include#includeusing namespace std;#define INFINITY 65535#define MAX_VERTEX_NUM 100typedef char VertexType;typedef struct {VertexType vexs[MAX_VERTEX_NUM];顶点 //数组int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];邻接矩 //阵int v, e; 图顶点//和边的数量} MGraph;int num=0;全局变量负责统计出度为 0 的顶点个数void CreateMGraph(MGraph &G){int i,j,k,w;printf("输⼊顶点数和边数:\n");scanf("%d%d",&G.v,&G.e);//for(i=0;iG.arcs[i][j]=INFINITY;初始化邻接//矩阵for(k=0;k{printf("输⼊边(i,j)上的下标 i,j 和权 w\n");scanf("%d%d%d",&i,&j,&w);G.arcs[i][j]=w;}}void indu(MGraph G){int n=0;printf("⼊度:\n");for(int i=0;i//scanf("%c",G.vexs[i]);for(i=0;i{for(int j=0;j} if(n==0) num++; printf("%d ",n); n=0; } } int main() { MGraph G; CreateMGraph(G); { indu(G); if(G.arcs[j][i]!=INFINITY) printf("\n"); n++; outdu(G); } printf("\n"); printf("%d ",n); printf("出度为 0 的顶点个数:%d",num); n=0; return 0; } } } #include#include#includeusing namespace std;#define INFINITY 65535#define MAX_VERTEX_NUM 100typedef int VertexType;int num=0;n++;⼊、邻接表void outdu(MGraph G) 要 不 //要加引⼊,有时候需要仔细考虑⼊下 { 假设不带权有向图采⼊邻接表 G 存储,设计实现以下功能的算法: int n=0;(1) 求出图中每个顶点的⼊度。

天大《数据结构》学习笔记五

天大《数据结构》学习笔记五

主 题: 《数据结构》学习笔记内 容:《数据结构》学习笔记五——图一、图的概念:1、术语:有向图,无向图,子图,顶点,边,弧,邻接点,出度,入度,路径,连通图。

2、图的存储:2.1邻接矩阵:0 1 1 0 0 1 0 1 00 0 0 0 1 0 1 0 10 0 0 1 0 1 0 1 11 0 0 0 1 0 1 0 00 1 1 0 02.2邻接表:2 3 ^4 ^1 ^Struct node{int data;struct node *next;}struct node V[n+1];3、程序:3.1已知邻接表,建立邻接矩阵。

{……for(I=1;I<=n;I++)for(j=1;j<=n;j++)w[I][j]=0;for(I=1;I<=n;I++){p=v[I].next;while(p){j=p->data;w[I][j]=1;p=p->next;}}}3.2已知邻接矩阵,建立邻接表。

{……for(I=1;I<=n;I++)v[I].next=0;for(I=1;I<=n;I++)for(j=1;j<=n;j++)if (w[I][j]= =1){p=(……)malloc(……);p->data=j;p->next=v[I].next;v[I].next=p;}}1、广度优先遍历1.1作法:(i)初始化(打印,加标记,进队)(ii)出队.(J)(iii)扫描(J)链,遇未访问点,则打印,加标记,进队.返回ii,直至队空.1.2 结果:2、深度优先遍历:2.1作法:从某点进入,打印,加标记,扫描此链:如没遇到未访问点,则返到原转来点.算法结束于进入点那个链的链尾.2.2 结果:1,2,4,8,5,3,6,73、广度优先程序:bfs(I)int I;{……f=0; r=0;for(t=1;t<=n;t++)v[t].data=0;printf(“%d”,I);v[I].data=1;r++; q[r]=I;while(f!=r){f++; j=q[f];p=v[j].next;while(p){k=p->data;if(v[k].data= =0){printf(“%d”,k);v[k].data=1;r++;q[r]=k;}p=p->next;}}}4、深度优先程序:dfs(I)int I;{……v[I].data=1;printf(“%d”,I);p=v[I].next;while(p){j=p->data;if(v[j].data= =0)dfs(j);p=p->next;}}三、最小生成树:1、解法11.1问题:选哪几条边,使得(I)能连到各点(II)边长之和最小?1.2思路:i. 从当前点集的发出边中选最小者,打印。

数据结构-实验6图的存储和遍历

数据结构-实验6图的存储和遍历

实验6.1实现图的存储和遍历一,实验目的掌握图的邻接矩阵和邻接表存储以及图的邻接矩阵存储的递归遍历。

二,实验内容6.1实现图的邻接矩阵和邻接表存储编写一个程序,实现图的相关运算,并在此基础上设计一个主程序,完成如下功能:(1)建立如教材图7.9所示的有向图G的邻接矩阵,并输出。

(2)由有向图G的邻接矩阵产生邻接表,并输出。

(3)再由(2)的邻接表产生对应的邻接矩阵,并输出。

6.2 实现图的遍历算法(4)在图G的邻接矩阵存储表示基础上,输出从顶点V1开始的深度优先遍历序列(递归算法)。

(5)利用非递归算法重解任务(4)。

(6)在图G的邻接表存储表示基础上,输出从顶点V1开始的广度优先遍历序列。

三,源代码及结果截图#include<stdio.h>#include<stdlib.h>#include<string.h>#include<iostream.h>#include<malloc.h>#define MAX_VERTEX_NUM 20typedef char VRType;typedef int InfoType; // 存放网的权值typedef char VertexType; // 字符串类型typedef enum{DG,DN,AG,AN}GraphKind; // {有向图,有向网,无向图,无向网}/*建立有向图的邻接矩阵*/typedef struct ArcCell{VRType adj;//VRType是顶点关系类型,对无权图用1或0表示是否相邻;对带权图则为权值类型InfoType *info; //该弧相关信息的指针(可无)}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vexs[MAX_VERTEX_NUM];//顶点向量AdjMatrix arcs;//邻接矩阵int vexnum,arcnum;;//图的当前顶点数和弧数GraphKind kind;//图的种类标志}MGraph;/* 顶点在顶点向量中的定位*/int LocateVex(MGraph &M,VRType v1){int i;for(i=0;i<M.vexnum;i++)if(v1==M.vexs[i])return i;return -1;}void CreateGraph(MGraph &M)//建立有向图的邻接矩阵{int i,j,k,w;VRType v1,v2;M.kind=DN;printf("构造有向网:\n");printf("\n输入图的顶点数和边数(以空格作为间隔):");scanf("%d%d",&M.vexnum,&M.arcnum);printf("输入%d个顶点的值(字符):",M.vexnum);getchar();for(i=0;i<M.vexnum;i++) //输入顶点向量{scanf("%c",&M.vexs[i]);}printf("建立邻接矩阵:\n");for(i=0;i<M.vexnum;i++)for(j=0;j<M.vexnum;j++){M.arcs[i][j].adj=0;M.arcs[i][j].info=NULL;}printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");for(k=0;k<M.arcnum;++k)// 构造表结点链表{cin>>w>>v1>>v2;i=LocateVex(M,v1);j=LocateVex(M,v2);M.arcs[i][j].adj=w;}}//按邻接矩阵方式输出有向图void PrintGraph(MGraph M){int i,j;printf("\n输出邻接矩阵:\n");for(i=0; i<M.vexnum; i++){printf("%10c",M.vexs[i]);for(j=0; j<M.vexnum; j++)printf("%2d",M.arcs[i][j].adj);printf("\n");}}// 图的邻接表存储表示typedef struct ArcNode{int adjvex; // 该弧所指向的顶点的位置struct ArcNode *nextarc; // 指向下一条弧的指针InfoType *info; // 网的权值指针)}ArcNode; // 表结点typedef struct VNode{VertexType data; // 顶点信息ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];// 头结点typedef struct{AdjList vertices;int vexnum,arcnum; // 图的当前顶点数和弧数int kind; // 图的种类标志}ALGraph;void CreateMGtoDN(ALGraph &G,MGraph &M){//由有向图M的邻接矩阵产生邻接表int i,j;ArcNode *p;G.kind=M.kind;G.vexnum=M.vexnum;G.arcnum=M.arcnum;for(i=0;i<G.vexnum;++i){//构造表头向量G.vertices[i].data=M.vexs[i];G.vertices[i].firstarc=NULL;//初始化指针}for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;++j)if(M.arcs[i][j].adj){p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;p->info=M.arcs[i][j].info;G.vertices[i].firstarc=p;}}void CreateDNtoMG(MGraph &M,ALGraph &G){ //由邻接表产生对应的邻接矩阵int i,j;ArcNode *p;M.kind=GraphKind(G.kind);M.vexnum=G.vexnum;M.arcnum=G.arcnum;for(i=0;i<M.vexnum;++i)M.vexs[i]=G.vertices[i].data;for(i=0;i<M.vexnum;++i){p=G.vertices[i].firstarc;while(p){M.arcs[i][p->adjvex].adj=1;p=p->nextarc;}//whilefor(j=0;j<M.vexnum;++j)if(M.arcs[i][j].adj!=1)M.arcs[i][j].adj=0;}//for}//输出邻接表void PrintDN(ALGraph G){int i;ArcNode *p;printf("\n输出邻接表:\n");printf("顶点:\n");for(i=0;i<G.vexnum;++i)printf("%2c",G.vertices[i].data);printf("\n弧:\n");for(i=0;i<G.vexnum;++i){p=G.vertices[i].firstarc;while(p){printf("%c→%c(%d)\t",G.vertices[i].data,G.vertices[p->adjvex].data,p->info);p=p->nextarc;}printf("\n");}//for}int visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)void(*VisitFunc)(char* v); // 函数变量(全局量)// 从第v个顶点出发递归地深度优先遍历图G。

哈工大计算机考研真题2003-2008

哈工大计算机考研真题2003-2008

哈尔滨工业大学2008年考研试题Ⅰ数据结构部分一填空题1.已知一个线性表有n个元素,其中每个元素的数据占8个字节,假设一个指针的大小为4个字节,如果采用有30个元素的数组存储,那么当数组中有效元素个数满足⑴条件时,数组的存储效率比不带头结点的单链表更高。

2. 给定14个字母,假设它们的权值都相等.采用huffman编码,则每个字母的平均代码长度是⑵。

3. 按C语言的运算符优先级,中缀表达式“A&&B||!(E>F)”的等价后缀形式为⑶。

4. 设按顺时针方向移动的循环队列Q[N]的头尾指针分别为F、R,头指针F总是指在队列中的第一个元素的前一位置,尾指针R在最后一个元素的位置,则队列中的元素个数为⑷。

5. 从空二叉树开始,严格按照BST(二又查找树)的插入算法,逐个插入关键字{18,73,10,5,68,99,27,41,32,25)构造出一颗BST ,对该BST按照先根遍历得到的序列为⑸。

6. 将两个长度为m的有序序列归并为一个有序序列,最少需要做⑹次关键字比较,最多需要做⑺次关键字比较。

7. 散列查找中,⑻现象称为冲突,⑼现象称为聚集。

8. 设可用的内存单元可处理4个记录,采用4 路归并的选择树法生成由小到大的初始归并段,对有12个记录在案的文件,产生的第一个初的归并段长度为⑽个。

9. 在两种求图的最小生成树的算法中,⑾算法适合于边稀疏的图的最小生成树。

10. 已知一个序列为{21,39,35,12,17,43},则利用堆排序方法建立的初始堆为:⑿。

二、判断(每题1分.共9分)1. 倒排文件只能按关键字的顺序存储。

(①)2. 堆的存储表示可能是链接式的,也可以是顺序的。

(②)3. 在AOE网中,任何一个关键活动的延迟,都会使整个工程延迟。

(③)4. 有环路的有向图不能进行拓扑排序。

(④)5. 对无向图进行一次深度优先搜索可以访问到图中的所有顶点。

(⑤)6. 大根堆的最大元素应该在堆顶,即根结点。

图基本算法图的表示方法邻接矩阵邻接表

图基本算法图的表示方法邻接矩阵邻接表

图基本算法图的表⽰⽅法邻接矩阵邻接表 要表⽰⼀个图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,除此之外没有其他更快的办法。

数据结构与算法课程设计报告---图的算法实现

数据结构与算法课程设计报告---图的算法实现

数据结构与算法课程设计报告课程设计题目:图的算法实现专业班级:信息与计算科学1002班目录摘要 (1)1、引言 (1)2、需求分析 (1)3、概要设计 (2)4、详细设计 (4)5、程序设计 (10)6、运行结果 (18)7、总结体会 (19)摘要(题目): 图的算法实现实验内容图的算法实现问题描述:(1)将图的信息建立文件;(2)从文件读入图的信息,建立邻接矩阵和邻接表;(3)实现Prim、Kruskal、Dijkstra和拓扑排序算法。

关键字:邻接矩阵、Dijkstra和拓扑排序算法1.引言本次数据结构课程设计共完成图的存储结构的建立、Prim、Kruskal、Dijkstra 和拓扑排序算法等问题。

通过本次课程设计,可以巩固和加深对数据结构的理解,通过上机和程序调试,加深对课本知识的理解和熟练实践操作。

(1)通过本课程的学习,能够熟练掌握数据结构中图的几种基本操作;(2)能针对给定题目,选择相应的数据结构,分析并设计算法,进而给出问题的正确求解过程并编写代码实现。

使用语言:CPrim算法思想:从连通网N={V,E}中的某一顶点v0出发,选择与它关联的具有最小权值的边(v0,v),将其顶点加入到生成树的顶点集合V中。

以后每一步从一个顶点在V中,而另一个顶点不在V中的各条边中选择权值最小的边(u,v),把它的顶点加入到集合V中。

如此继续下去,直到网中的所有顶点都加入到生成树顶点集合V中为止。

拓扑排序算法思想:1、从有向图中选取一个没有前驱的顶点,并输出之;2、从有向图中删去此顶点以及所有以它为尾的弧;重复上述两步,直至图空,或者图不空但找不到无前驱的顶点为止。

没有前驱-- 入度为零,删除顶点及以它为尾的弧-- 弧头顶点的入度减1。

2.需求分析1、通过键盘输入建立一个新的有向带权图,建立相应的文件;2、对建立的有向带权图进行处理,要求具有如下功能:(1)用邻接矩阵和邻接表的存储结构输出该有向带权图,并生成相应的输出结果;(2)用Prim、Kruskal算法实现对图的最小生成树的求解,并输出相应的输出结果;(3)用Dijkstra算法实现对图中从某个源点到其余各顶点的最短路径的求解,并输出相应的输出结果;(4)实现该图的拓扑排序算法。

数据结构-Python语言描述试卷(三)附答案

数据结构-Python语言描述试卷(三)附答案

数据结构试卷(三)一、选择题(每题2分,共20分)1. 设某数据结构的二元组形式表示为A=(D,R),D={01,02,03,04,05,06,07,08,09},R={r},r={<01,02>,<01,03>,<01,04>,<02,05>,<02,06>,<03,07>,<03,08>,<03,09>},则数据结构A是( B )。

A. 线性结构B. 树形结构C. 物理结构D. 图形结构2. 下面程序的时间复杂度为( B )。

1 i=12 s=03 w hile i<=n:4 i +=15 t =16 for j in range(1,i):7 t = t * j8 s = s + tA. O(n)B. O(n2)C. O(n3)D. O(n4)3. 设指针变量p指向单链表中的结点A,若删除单链表中的结点A,则需要修改指针的操作序列为( A )。

A. q=p.next; p.data=q.data; p.next=q.next;B. q=p.next; q.data=p.data; p.next=q.next;C. q=p.next; p.next=q.next;D. q=p.next; p.data=q.data;4. 设有n个待排序的记录关键字,在堆排序中需要( A )个辅助记录单元。

A. 1B. nC. nlog2nD. n25. 设一组记录关键字为(20,15,14,18,21,36,40,10),则以20为基准记录的一趟快速排序结束后的结果为( A )。

A. 10,15,14,18,20,36,40,21B. 10,15,14,18,20,40,36,21C. 10,15,14,20,18,40,36,21D. 15,10,14,18,20,36,40,216. 设二叉排序树中有n个结点,则二叉排序树的平均查找长度为( B )。

邻接矩阵的实验原理及应用

邻接矩阵的实验原理及应用

邻接矩阵的实验原理及应用实验原理邻接矩阵是一种图的表示方法,通过矩阵的形式记录图中各个顶点之间的连接关系。

邻接矩阵可以用于描述有向图和无向图。

无向图的邻接矩阵无向图的邻接矩阵是一个方阵,其中的每个元素表示图中两个顶点之间是否存在边。

如果顶点i和顶点j之间存在边,则邻接矩阵的第i行第j列和第j行第i列的元素值都为1;否则,为0。

邻接矩阵的对角线上的元素表示各个顶点的度数。

有向图的邻接矩阵有向图的邻接矩阵同样是一个方阵,其中的每个元素表示从顶点i到顶点j是否存在边。

如果顶点i到顶点j存在边,则邻接矩阵的第i行第j列的元素值为1;否则,为0。

邻接矩阵的表示方法邻接矩阵可以用二维数组来表示,数组的大小为n×n,其中n为图中顶点的个数。

数组的下标表示顶点的编号,而数组中的元素表示邻接关系。

应用邻接矩阵在图的算法和应用领域有重要的应用。

图的遍历使用邻接矩阵可以进行图的遍历操作,包括深度优先遍历和广度优先遍历。

通过对邻接矩阵的遍历,可以访问图中所有的顶点和边。

最短路径算法邻接矩阵可以作为最短路径算法的基本数据结构。

通过邻接矩阵,可以方便地计算两个顶点之间的最短路径。

最小生成树算法最小生成树算法可以使用邻接矩阵作为数据结构。

通过构建邻接矩阵,并使用Prim算法或Kruskal算法,可以生成图的最小生成树。

图的连通性判断邻接矩阵可以用来判断图的连通性。

通过对邻接矩阵进行深度优先搜索或广度优先搜索,可以确定图中的连通分量。

图的可达性分析邻接矩阵可以用于分析图中顶点之间的可达性。

通过对邻接矩阵进行矩阵运算,可以得到图中任意两个顶点之间的可达性。

总结邻接矩阵是一种表示图的方法,通过矩阵的形式记录图中各个顶点之间的连接关系。

邻接矩阵具有简单、直观、易于操作等优点,在图的算法和应用中有广泛的应用。

通过对邻接矩阵的遍历、最短路径算法、最小生成树算法、连通性判断和可达性分析等操作,可以解决各种与图相关的问题。

以上就是邻接矩阵的实验原理及应用,希望对你有所帮助。

数据结构单元8练习参考答案

数据结构单元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的入度。

图的存储方式

图的存储方式

p→next=g[d].link;
g[d].link=p; /*将新结点插入顶点Vd边表的头部*/
}
}
返回
数据结构
do {
产生无向图邻接矩阵算法续
scanf (“%d,%d”,&v1,&v2); /*输入边*/ adjarray[v1][v2]=1; adjarray[v2][v1]=1; } while(v1!=0 && v2!=0); } else num=0; retrun num; }
1.2 邻接表
在每个链表设一表头结点,一般这些表头结 点本身以向量的形式存储。
对于无向图的邻接表来说,一条边对应两个 单链表结点,邻接表结点总数是边数的2倍。
在无向图的邻接表中,各顶点对应的单链表 的结点数(不算表头结点)就等于该顶点的 度数。
在有向图邻接表中,一条弧对应一个表结点, 表结点的数目和弧的数目相同。
邻接表是图的一种链接存储结构。
在邻接表结构中,对图中每个顶点建立 一个单链表,第i个单链表中的结点表示 依个附 结于 点表该示顶与点该Vi的顶边点,相即邻对接于的无一向个图顶每点; 对于有向图则表示以该顶点为起点的一 条边的终点。
一个图的邻接矩阵表示是唯一的,但其 邻接表表示是不唯一的。因为在邻接表 的每个单链表中,各结点的顺序是任意 的。
在有向图邻接表中,单链表的结点数就等于 相应顶点的出度数。
要求有向图中某顶点的入度数,需扫视邻接 表的所有单链表,统计与顶点标号相应的结 点个数。
邻接表存储结构定义
#define MAXVEX 30
struct edgenode
{
int adjvex ;
/*邻接点域*/
struct edgenode *next ; /*链域*/

邻接矩阵法

邻接矩阵法

邻接矩阵法邻接矩阵法是图论中一种常用的表示图结构的方法。

它通过一个二维矩阵来表示图中各个顶点之间的连接关系。

在邻接矩阵中,矩阵的行和列分别代表图中的顶点,而矩阵中的元素则表示对应顶点之间是否存在边。

邻接矩阵的定义假设有一个无向图G=(V,E),其中V为顶点集合,E为边集合。

邻接矩阵A是一个n×n的方阵,其中n为图中顶点的个数。

邻接矩阵A满足以下条件:•如果顶点i和顶点j之间存在边,则A[i][j]=1;•如果顶点i和顶点j之间不存在边,则A[i][j]=0。

对于有向图来说,邻接矩阵也可以用来表示其连接关系,只是在有向图中,边具有方向性。

邻接矩阵的应用邻接矩阵作为一种常见的图表示方法,在许多算法和应用中都得到了广泛的应用。

下面介绍一些常见的应用场景:1. 图遍历通过邻接矩阵,我们可以方便地遍历图中的顶点和边。

对于一个顶点i,我们只需要遍历邻接矩阵的第i行(或第i列),就可以获取到与该顶点直接相连的所有顶点。

2. 最短路径算法邻接矩阵常被用于求解最短路径问题,例如Dijkstra算法和Floyd-Warshall算法。

在这些算法中,通过邻接矩阵来表示各个顶点之间的距离或权重,然后根据具体的算法逻辑来计算最短路径。

3. 最小生成树邻接矩阵也可以用于求解最小生成树问题,例如Prim算法和Kruskal算法。

在这些算法中,邻接矩阵用来表示图中各个顶点之间的连接关系,并根据具体的算法逻辑选择合适的边来构建最小生成树。

4. 图的连通性判断通过邻接矩阵,我们可以判断一个图是否是连通图。

如果一个无向图的邻接矩阵是对称且连通的,则说明该图是一个连通图。

如果一个有向图的邻接矩阵是强连通的,则说明该有向图是强连通图。

邻接矩阵的优缺点邻接矩阵作为一种图的表示方法,具有以下优点:•表示简单:邻接矩阵直观地表示了图中各个顶点之间的连接关系,易于理解和实现。

•查询高效:通过邻接矩阵,可以快速判断两个顶点之间是否存在边,时间复杂度为O(1)。

第5章 图结构分析

第5章 图结构分析
2018年10月14日
5.1 引言
5.1.1 问题的提出
第 3页
问题1:寻求走迷宫问题的解,迷宫可表示成图,求解即 为寻求满足某种要求的从迷宫的入口结点到迷宫的出口 结点的路径。 问题2:从公园入口处寻找一条参观某个动物的最短路径。 问题3:在几个村落之间铺设通讯线路,如何铺设最省钱。 问题4:计算机科学与技术专业的大学生,本科四年需要 学习公共基础课、专业基础课、专业课几十门,每门课 程都可能有先修课程的要求,如何合理安排课程的教学 顺序,使学生能够顺利完成学业。 。。。。。。
v1
v2
v3
v4
2018年10月14日
第6页
(3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14)
邻接点、邻接边 完全图 稠密图、稀疏图 顶点的度、入度、出度 边的权、网图 路径和路径长度 回路、简单路径、简单回路 子图 连通的、连通图、连通分量 强连通图、强连通分量 连通图(或子图)的生成树 非连通图的生成森林
2018年10月14日
5.2 图的存储方法
5.2.1 邻接矩阵 1.邻接矩阵的存储思想
(1) 图中顶点顺序存储;
第 9页
(2) 用一个n*n矩阵(设图有n个顶点)来存储任意两个 顶点之间边的信息,也就是各顶点之间的邻接关系。
A[i][j]=
{0 若(v ,v )或<v ,v >不是E(G)中的边
i j i j
1 若(vi,vj)或<vi,vj>是E(G)中的边
若G是带权图,则邻接矩阵可定义为:
A[i][j]=
{ 0或∞ 若(v ,v )或<v ,v >不是E(G)中的边
i j i j

计算机专业基础综合数据结构图历年真题试卷汇编7_真题无答案

计算机专业基础综合数据结构图历年真题试卷汇编7_真题无答案

计算机专业基础综合数据结构(图)历年真题试卷汇编7(总分62, 做题时间90分钟)7. 设计题1.已知连通图如下:(1)若从顶点B出发对该图进行遍历,在(1)的基础上分别给出本图的按深度优先搜索和按广度优先搜索的顶点序列;(2)写出按深度优先搜索的递归程序。

【厦门大学200l三(12%分)】SSS_TEXT_QUSTI2.设计算法以实现对无向图G的深度遍历,要求:将每一个连通分量中的顶点以一个表的形,式输出。

例如,下图的输出结果为:(1,3)(2,6,7,4,5,8)(9,10)。

注:本算法中可以调用以下几个函数:firstadj(g,1,)——返回图g中顶点v的第一个邻接点的号码,若不存在,则返回0。

nextadj(g,v,w)——返回图g中顶点v的邻接点中处于w之后的邻接点的号码,若不存在,则返回0。

nodes(g)——返回图g中的顶点数。

【合肥工业大学2000五、4(8分)】SSS_TEXT_QUSTI3.请设计一个图的抽象数据类型(只需要用类Pascal或类C/C++语言给出其主要功能函数或过程的接口说明,不需要指定存储结构,也不需要写出函数或过程的实现方法),利用抽象数据类型所提供的函数或过程编写图的广度优先周游算法。

算法不应该涉及具体的存储结构,也不允许不通过函数或过程而直接引用图结构的数据成员,抽象数据类型和算法都应该加足够的注释。

【北京大学1999二、1(10分)】SSS_TEXT_QUSTI4.设计算法以判断给定的无向图G中是否存在一条以网为起点的包含所有顶点的简单路径,若存在,返回TRUE,否则,返回FALSE(注:本算法中可以调用以下几个函数:FIRSTADJ(G,V)——返回图G中顶点V的第一个邻接点的号码,若不存在,则返回0;NEXTADJ(G,W)——返回图G中顶点V的邻接点中处于W之后的邻接点的号码,若不存在,则返回0;NODES(G)——返回图G中的顶点数)。

【合肥工业大学1999五、5(8分)】SSS_TEXT_QUSTI5.已有邻接表表示的有向图,请编程判断从第u顶点至第v顶点是否有简单路径,若有,则印出该路径上的顶点。

第七章图迪杰斯特拉算法如下:SHORTEST—PATH(intcost[][n],intv

第七章图迪杰斯特拉算法如下:SHORTEST—PATH(intcost[][n],intv

第七章图迪杰斯特拉算法如下:SHORTEST—PA TH(intcost[][n],intv,intn,intdist[],intpath[)){ihti,N,u,count,pos[n];for(i=0;i<n;i++){s[i]=0;/x标记数组置0 x/dist[i]=cost[V][i];/。

将邻接矩阵第v行元素依次送dist数组xpath[i][0]=v;/x源点v到各顶点的路径置初值。

/pos[i]=0;/。

第i条路径的位置计数器置初值x/} /x对辅助数组进行初始化。

/s[v]=l;count=1; /x计数器赋初值1 x/while(count<n){ /‘以下过程执行n-1次x/u=MINDIST(s,dist);/x利用s和dist在尚未找到最短路径的顶点中确定一个与v最近的顶点u。

/s[u]=1;/‘置u的标记为1●/path[u)C++pos[u]]=u;/x将u添加到v到u的最短路径中。

/count++;/,计数器累力n1 x/while(1){ /。

根据u更新v到所有尚未确定最短路径的顶点的路径长度。

/if((w=SEARCH_VER(s,dist,u))==-1)/,找到通过u可以直接到达、且尚未确定最短路径的一个顶点。

/break;/x未找到,路径长度更新过程结束。

/else{if(dist[u]+cost[u][w]<dist[w]]{dist[N]=dist[u]+cost[u][w];/x更新路径长度●/for[i=0;i<pos[u];i++)path[w][i]=path[u][i];/。

用源点v到顶点u的路径替换源点v到w的路径。

/}} } .习题8.1 判断题(在你认为正确的题后的括号中打√,否则打X)。

(1)没有顶点的图称为空图。

( )(2)图的度是图中所有顶点的度的最大值。

( )(3)边上带权值的图称为网(络)。

( )(4)图中一个顶点的度应该是它的出度与人度之和。

数据结构实验 图的邻接表和邻接矩阵操作

数据结构实验 图的邻接表和邻接矩阵操作
5
p->weight=weight; p->nextarc=G.vertices[vv].firstarc; G.vertices[vv].firstarc=p; strcmp(G.vertices[vv].data,v);
q=(ArcNode *)malloc(sizeof(ArcNode)); q->adjvex=vv; q->weight=weight; q->nextarc=G.vertices[ww].firstarc; G.vertices[ww].firstarc=q; strcmp(G.vertices[ww].data,w);
实验报告 6
课程 数据结构 实验名称 图的建立及遍历
第页
专业
班级_ __ 学号_ ___ 姓名
实验日期: 2010 年 11 月 23 日
评分
一 、实验目的
1.学会用邻接矩阵和邻接表实现图结构和对图的基本操作。 2.掌握对图操作的具体实现; 3. 掌握图的两种遍历算法(深度优先、广度优先); 4、掌握求图的最小生成树和顶点间最短路径的算法;
int adjvex;//该弧指向的顶点的位置 ArcType weight; struct ArcNode *nextarc;//指向下一条弧指针 //InfoType *info;该弧相关信息的指针 }ArcNode; typedef struct VNode { VertexType data;//顶点信息 ArcNode *firstarc;//指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; GraphKind kind; }ALGraph; ALGraph G; struct MiniSpanTree_Flag { VertexType adjvex; ArcType lowcost; }closedge[MAX_VEX_NUM]; typedef bool PathMatrix[MAX_VEX_NUM][MAX_VEX_NUM];

数据结构下学期测试题及答案

数据结构下学期测试题及答案

一、单项选择题1. 将一个 n ×n 的三对角矩阵 A=[a ij ]的三条对角线上的元素按行优先顺序存储在一维数组B[1..3n-2]中,则元素a ij 在B 中的位置是________。

A. i+2j-12. 术语________与数据的逻辑结构无关。

A. 链式结构B. 线性结构C. 树型结构B. i+j+2C. 3i-j+1D. 2i+j-2D. 网状结构3. 对一个栈S 依次进行操作PUSH(S,1),PUSH(S,2),POP(S),PUSH(S,3),PUSH(S,4),POP(S),PUSH(S,5)后,栈 S 中从栈顶到栈底元素的排列顺序是________。

A. 5,3,1B. 1,3,5C. 2,4,5D. 5,4,24. 数组Q[0..n-1]作为一个循环队列,f 为队头元素的前一个位置,r 为队尾元素的位置,那么在队列未满时进行将元素x 进队的操作需要执行________。

A. r=r+1;Q[r]=x ;C. Q[r]=x ;r=r+1; B. r=(r+1) % n ;Q[r]=x ;D. Q[r]=x ;r=(r+1) % n ;5. 若一棵二叉树的先序序列是ABCEGDF ,中序序列是GECBFDA ,那么其后序序列是________。

A. EGCDFBA6. ________的邻接矩阵是对称矩阵。

A. 有向图 B. 无向图B. AGECDFB C. ABDFCEG D. GECFDBA C. AOV-网 D. AOE-网7. 有n 个顶点的强连通图至少含有________条弧(有向边)。

A. n B. n(n-1)/2 C. n-1 D. n+18.为了实现图的广度优先遍历,其广度优先搜索算法使用的一种辅助数据结构为_________。

A .栈B .队列C .二叉树D .集合9.长度为12 的有序表采用顺序存储结构,采用折半查找技术,在等概率情况下,查找成功的平均查找长度是_________。

算法与数据结构试题及答案

算法与数据结构试题及答案

数据结构试卷(一)一、单选题(每题 2 分,共20分)1.栈和队列的共同特点是( )。

A.只允许在端点处插入和删除元素B.都是先进后出C.都是先进先出D.没有共同点2.用链接方式存储的队列,在进行插入运算时( ).A. 仅修改头指针B. 头、尾指针都要修改C. 仅修改尾指针D.头、尾指针可能都要修改3.以下数据结构中哪一个是非线性结构?( )A. 队列B. 栈C. 线性表D. 二叉树4.设有一个二维数组A[m][n],假设A[0][0]存放位置在644(10),A[2][2],每个元素占一个空间,问A[3][3](10)存放在什么存放位置在676(10)表示用10进制表示。

位置?脚注(10)A.688 B.678 C.692 D.6965.树最适合用来表示( )。

A.有序数据元素B.无序数据元素C.元素之间具有分支层次关系的数据D.元素之间无联系的数据6.二叉树的第k层的结点数最多为( ).A.2k-1 B.2K+1 C.2K-1 D. 2k-17.若有18个元素的有序表存放在一维数组A[19]中,第一个元素放A[1]中,现进行二分查找,则查找A[3]的比较序列的下标依次为( )A. 1,2,3B. 9,5,2,3C. 9,5,3D. 9,4,2,38.对n个记录的文件进行快速排序,所需要的辅助存储空间大致为n) D. O A. O(1) B. O(n) C. O(1og2(n2)9.对于线性表(7,34,55,25,64,46,20,10)进行散列存储时,若选用H(K)=K %9作为散列函数,则散列地址为1的元素有()个,A.1 B.2 C.3 D.410.设有6个结点的无向图,该图至少应有( )条边才能确保是一个连通图。

A.5B.6C.7D.8二、填空题(每空1分,共26分)1.通常从四个方面评价算法的质量:_________、_________、_________和_________。

2.一个算法的时间复杂度为(n3+n2log2n+14n)/n2,其数量级表示为________。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

/*******************************************************
建立一个有向图的邻接矩阵存储的算法
void CreateMGraph(MGraph *G){
//建立有向图G的邻接矩阵存储
int i,j,k;
char ch;
cout<<"请输入顶点数和边数(输入格式为:顶点数,边数):"<<endl;
for (i=0;i<G->vnum;i++)
for (j=0;j<G->vnum;j++)
G->edges[i][j]=0; //初始化邻接矩阵
cout<<"请输入每条边对应的两个顶点的序号(输入格式为:i,j):"<<endl;
for (k=0;k<G->enum;k++)
// 以邻接矩阵为存储结构进行广度优先遍历的算法
void BFSM(MGraph *G,int k){
//以vk为出发点,对邻接矩阵存储的图G进行广度优先搜索
int i,j;
CirQueue Q;
InitQueue(Q);
cout<<"visit vertex:V"<<G->vexs[k]<<endl; //访问原点vk
/********************************************************
// 第一组
//*邻接矩阵存储类型
#define MaxVertexNum … //根据实际需要设定的最大顶点数
typedef char VertexType; //顶点类型设为字符型
if (G->edges[i][j]==1 && !visited[j]) //若vj未访问
{ cout<<"visit vertex:V"<<G->vexs[j]<<endl; //访问vj
visited[j]=1;
EnQueue(Q,j); //访问过的vj入队列
}
}//CreateALGraph
/****************************************************
//以邻接表为存储结构的深度优先遍历算法
void DFSAL(ALGraph *G,int i){
//以vi为出发点对邻接表存储的图G进行深度优先搜索
{ cin>>i>>j; //输入e条边,建立邻接矩阵
G->edges[i][j]=1;
//若加入G->edges[j][i]=1;,则为无向图的邻接矩阵存储建立
}
}//Cr
/****************************************************
/****************************************************
/*建立一个有向图的邻接表存储的算法
void CreateALGraph(ALGraph *G){
//建立有向图的邻接表存储
int i,j,k;
EdgeNode *s;
cout<<"请输入顶点数和边数(输入格式为:顶点数,边数):"<<endl;
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum];
/*AdjList是邻接表类型*/
typedef int EdgeType; //边的权值设为整型
typedef struct {
VertexType vexs[MaxVertexNum]; //顶点表
EdeType edges[MaxVertexNum][MaxVertexNum];
cin>>G->vnum>>G->enum; //输入顶点数和边数
cout<<"请输入顶点信息(输入格式为:顶点号<CR>):"<<endl;
for (i=0;i<G->vnum;i++)
cin>>G->vexs[i]; //输入顶点信息,建立顶点表
int adjvex; /*邻接点域*/
struct node * next; /*指向下一个邻接点的指针域*/
/*若要表示边上信息,则应增加一个数据域info*/
visited[k]=1;
EnQueue(Q,k); //原点vk入队列
while (!QueueEmpty(Q))
{ i=DeQueue(Q); //vi出队列
for (j=0;j<G->vnum;j++) //依次搜索vi的邻接点vj
G->adjlist[i].firstedge=NULL; //顶点的边表头指针设为空
}
cout<<"请输入边的信息(输入格式为:i,j):"<<endl;
for (k=0;k<G->enum;k++) //建立边表
{ cin>>i>>j; //读入边<vi,vj>的顶点对应序号
//邻接矩阵,即边表
int vnum,enum; //顶点数和边数
}Mgragh; //Maragh是以邻接矩阵存储的图类型
//第二组
//***************************************************
//*邻接表表示的形式描述如下:
#define MaxVerNum 100 /*最大顶点数为100*/
typedef struct node{ /*边表结点*/
}
}
}//BFSM
void BFSTraverseAL(MGraph *G){
//广度优先遍历以邻接矩阵存储的图G
int i;
int visited[MaxVerNum];
for (i=0;i<G->vnum;i++)
visited[i]=0; //标志向量初始化
while (p) //依次搜索vi的邻接点vj,j=p->adjvex
{ if (!visited[pБайду номын сангаас>adjvex]) //若vj尚未访问,则以vj为出发点向纵深搜索
DFSAL(G,p->adjvex);
p=p->next; //找vi的下一个邻接点
}
}//DFSAL
void DFSTraverseAL(ALGraph *G){
//深度优先遍历以邻接表存储的图G
int i;
int visited[];
for (i=0;i<G->vnum;i++)
visited[i]=0; //标志向量初始化
cin>>G->vnum>>G->enum; //读入顶点数和边数
cout<<"请输入顶点信息(输入格式为:顶点号<CR>):"<<endl;
for (i=0;i<G->vnum;i++) //建立有n个顶点的顶点表
{ cin>>G->adjlist[i].vertex; //读入顶点信息
EdgeNode *p;
cout<<"visit vertex:V"<<G->adjlist[i].vertex<<endl; //访问顶点vi
visited[i]=1; //标记vi已访问
p=G->adjlist[i].firstedge; //取vi边表的头指针
}EdgeNode;
typedef struct vnode{ /*顶点表结点*/
VertexType vertex; /*顶点域*/
EdgeNode * firstedge; /*边表头指针*/
for (i=0;i<G->vnum;i++)
if (!visited[i])
DFSAL(G,i); //vi未访问过,从vi开始DFS搜索
}//DFSTraveseAL
、********************************eateMGraph
s=new EdgeNode; //生成新边表结点s
s->adjvex=j; //邻接点序号为j
s->next=G->adjlist[i].firstedge;
//将新边表结点s插入到顶点vi的边表头部
G->adjlist[i].firstedge=s;
for (i=0;i<G->vnum;i++)
if (!visited[i])
BFSM(G,i); //vi未访问过,从vi开始BFS搜索
}//BFSTraverseAL
//*************************************************
相关文档
最新文档