邻接矩阵表示图_深度_广度优先遍历

合集下载

数据结构专升本模拟题及参考答案

数据结构专升本模拟题及参考答案

作业题(一)一、单项选择题1. 从逻辑上可以把数据结构分为()两大类。

A.动态结构、静态结构 B.顺序结构、链式结构C.线性结构、非线性结构 D.初等结构、构造型结构2. 链表不具有的特点是()A.插入、删除不需要移动元素 B.可随机访问任一元素C.不必事先估计存储空间 D.所需空间与线性长度成正比3.下面程序段的时间复杂度的量级为()。

For(i=1;i<=n;i++)For(j=1;j<=I;j++)For(k=1;k<=j;k++)X=x+1;A.O(1) B.O(n)C.O(n²) D.O(n³)4.在一个带头结点的双向循环链表中,若要在p所指向的结点之前插入一个新结点,则需要相继修改()个指针域的值。

A.2 B.3C.4 D.65、一个顺序存储线性表的第一个元素的存储地址是90,每个元素的长度是2,则第6个元素的存储地址是()。

A.98 B.100C.102 D.1066、判定一个栈s(最多元素为m0)为空的条件是()。

A.s-〉top! =0 B.s-〉top= =0C.s-〉top! =m0 D.s-〉top= =m07、循环队列用数组A[m](下标从0到m-1)存放其元素值,已知其头尾指针分别是front和rear,则当前队列中的元素个数是()。

A.(rear-front+m)%m B.rear-front+1C.rear-front-1 D. rear-front8、设有两个串S1与S2,求串S2在S1中首次出现位置的运算称作()。

A.连接 B.求子串C.模式匹配 D.判子串9、设串S1='ABCDEFG',S2='PQRST',函数con(x,y)返回x和y串的连接串,subs(s,i,j)返回串S的的从序号i的字符开始的j个字符组成的子串,len(s)返回串S的长度,则con(subs(S1,2,len(S2)),subs(S1,len(S2),2))的结果是()。

解释结构模型邻接矩阵

解释结构模型邻接矩阵

解释结构模型邻接矩阵结构模型(Structural Model)是指在软件工程中,用于描述系统的静态结构的一种模型。

它通常用于表示系统的组件、类、对象之间的静态关系以及它们的属性和行为。

结构模型可以帮助开发人员理解系统的组成部分以及它们之间的相互关系,从而更好地设计、开发和维护软件系统。

在结构模型中,最常用的表示方法是邻接矩阵(Adjacency Matrix)。

邻接矩阵是一种用来表示图形结构的矩阵。

图形结构是由节点和连接节点的边组成的。

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

如果两个节点之间存在边,则对应矩阵元素的值为1;如果两个节点之间不存在边,则对应矩阵元素的值为0。

邻接矩阵可以提供关于图形结构的丰富信息。

通过分析矩阵的行和列,可以确定图中节点的数量、节点之间的连接关系、节点的度等。

邻接矩阵还可以用于进行图的遍历和算法,如深度优先(DFS)和广度优先(BFS)。

此外,邻接矩阵还可以用于解决一些图形相关的优化问题,如最短路径问题和最小生成树问题。

邻接矩阵在实际应用中有广泛的用途。

例如,在社交网络分析中,可以使用邻接矩阵来表示用户之间的关系,并通过矩阵的运算来发现社交网络中的社群结构。

在路由器和互联网中,邻接矩阵可以用来描述网络节点之间的物理连接,从而实现路由表的生成和更新。

邻接矩阵还可以用于解决诸如稀疏矩阵压缩和图形聚类等问题。

然而,邻接矩阵也存在着一些限制和不足之处。

首先,矩阵的大小由节点的数量决定,对于大型图形结构,矩阵会占用大量的内存空间。

其次,对于稀疏图,即节点之间的连接较少的情况,邻接矩阵会浪费大量的空间来表示不存在的边,从而造成存储的浪费。

此外,邻接矩阵在表示稀疏图时的运算效率较低,不适用于一些复杂的图形分析算法。

为了克服邻接矩阵的不足,还有其他的表示图形结构的方法,如邻接表(Adjacency List)和邻接多重表(Adjacency Multilist)。

数据结构复习题-第7章答案2014-6-16

数据结构复习题-第7章答案2014-6-16

、选择题(每小题 1 分,共 10分)1. 一个 n 个顶点的连通无向图,其边的个数至少为( C )。

A.n+l B.n C.n-l D.2n2. 下列哪一种图的邻接矩阵是对称矩阵( B )。

A. 有向图 B. 无向图 C.AOV 网 D.AOE 网5. 无 向 图 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 )} ,由顶点 a 开始对该图进行深度优先遍历, 得到的顶点序列正确的是 ( D )。

A. a,b,e,c,d,f B. a,c,f,e,b,d C. a,e,b,c,f,d D. a,e,d,f,c,b6. 用邻接表表示图进行广度优先遍历时,通常是采用( B )来实现算法的。

A. 栈 B. 队列 C. 树 D. 图7. 以下数据结构中,哪一个是线性结构( D )。

A. 广义表 B. 二叉树 C. 图 D. 栈8. 下面哪一方法可以判断出一个有向图是否有环(回路) ( B )。

A. 最小生成树B. 拓扑排序C. 求最短路径D. 求关键路径 9. 在一个图中,所有顶点的度数之和等于图的边数的( C )倍。

10. 在一个有向图中,所有顶点的入度之和等于所有顶点的出度之和的(B )倍。

A. 1/2B. 1C. 2D. 411. 有 8 个顶点无向图最多有( B )条边。

A. 14 B. 28 C. 56 D. 11212. 有 8 个顶点无向连通图最少有( C )条边。

A. 5 B. 6 C. 7 D. 813. 有 8个顶点有向完全图有( C )条边。

A. 14 B. 28 C. 56 D. 11214. 下列说法不正确的是( A )。

A. 图的遍历是从给定的源点出发每一个顶点仅被访问一次 C. 图的深度遍历不适用于有向图B. 遍历的基本算法有两种:深度遍历和广度遍历 D •图的深度遍历是一个递归过程 二、判断题(每小题 1 分,共 10分)1. n 个顶点的无向图至多有 n (n-1) 条边。

深度优先算法和广度优先算法的时间复杂度

深度优先算法和广度优先算法的时间复杂度

深度优先算法和广度优先算法都是图搜索中常见的算法,它们具有不同的特点和适用场景。

在进行全面评估之前,让我们先来了解一下深度优先算法和广度优先算法的基本概念和原理。

### 1. 深度优先算法(Depth-First Search, DFS)深度优先算法是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发,沿着一条路径直到末端,然后回溯,继续搜索下一条路径,直到所有路径都被探索。

在实际应用中,深度优先算法常常通过递归或栈来实现。

### 2. 广度优先算法(Breadth-First Search, BFS)广度优先算法也是一种用于遍历或搜索树或图的算法。

其核心思想是从起始顶点出发,依次遍历该顶点的所有相邻顶点,然后再以这些相邻顶点作为起点,继续遍历它们的相邻顶点,以此类推,直到所有顶点都被遍历。

在实际应用中,广度优先算法通常通过队列来实现。

### 3. 深度优先算法和广度优先算法的时间复杂度在实际应用中,我们经常需要对算法的时间复杂度进行分析。

针对深度优先算法和广度优先算法,它们的时间复杂度并不相同。

- 深度优先算法的时间复杂度:O(V + E),其中V为顶点数,E为边数。

在最坏的情况下,如果采用邻接矩阵来表示图的话,深度优先算法的时间复杂度为O(V^2);如果采用邻接表来表示图的话,时间复杂度为O(V + E)。

- 广度优先算法的时间复杂度:O(V + E),其中V为顶点数,E为边数。

无论采用邻接矩阵还是邻接表表示图,广度优先算法的时间复杂度都是O(V + E)。

### 4. 个人理解和观点在实际应用中,我们在选择使用深度优先算法还是广度优先算法时,需要根据具体的问题场景来进行选择。

如果要寻找图中的一条路径,或者判断两个节点之间是否存在路径,通常会选择使用深度优先算法;如果要寻找最短路径或者进行层次遍历,通常会选择使用广度优先算法。

深度优先算法和广度优先算法都是非常重要的图搜索算法,它们各自适用于不同的场景,并且具有不同的时间复杂度。

图的遍历实验报告

图的遍历实验报告

1.问题描述:不少涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序,演示在连通的无向图上访问全部结点的操作。

2.基本要求:以邻接表为存储结构,实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成树的边集。

3.测试数据:教科书图7.33。

暂时忽略里程,起点为北京。

4.实现提示:设图的结点不超过30个,每一个结点用一个编号表示(如果一个图有n个结点,则它们的编号分别为1,2,…,n)。

通过输入图的全部边输入一个图,每一个边为一个数对,可以对边的输入顺序作出某种限制,注意,生成树的边是有向边,端点顺序不能颠倒。

5.选作内容:(1) .借助于栈类型(自己定义和实现),用非递归算法实现深度优先遍历。

(2) .以邻接表为存储结构,建立深度优先生成树和广度优先生成树,再按凹入表或者树形打印生成树。

1.为实现上述功能,需要有一个图的抽象数据类型。

该抽象数据类型的定义为:ADT Graph{V 是具有相同特性的数据元素的集合,称为顶点集。

R={VR}VR={<v,w> | v ,w v 且P(v,w),<v,w>表示从v 到w 得弧,谓词P(v,w)定义了弧<v,w>的意义或者信息}} ADT Graph2.此抽象数据类型中的一些常量如下:#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};3.树的结构体类型如下所示:typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。

图--0,1;网--权值int *Info; //与弧相关的信息的指针,可省略}ArcCell, AdjMatrix[max_n][max_n];typedef struct{VertexType vexs[max_n]; //顶点AdjMatrix arcs; //邻接矩阵int vexnum, arcnum; //顶点数,边数}MGraph;//队列的类型定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4.本程序包含三个模块1).主程序模块void main( ){创建树;深度优先搜索遍历;广度优先搜索遍历;}2).树模块——实现树的抽象数据类型3).遍历模块——实现树的深度优先遍历和广度优先遍历各模块之间的调用关系如下:主程序模块树模块遍历模块#include "stdafx.h"#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。

数据结构:图

数据结构:图

数据结构:图在计算机科学领域,数据结构是我们组织和存储数据的方式,以便能够高效地进行操作和处理。

而图,作为一种重要的数据结构,在许多应用中都发挥着关键作用。

想象一下,我们生活中的各种关系,比如朋友关系、交通网络、电路连接等等,这些都可以用图来表示。

图由顶点(也称为节点)和边组成。

顶点代表着事物或者对象,而边则表示顶点之间的关系。

比如说,在一个社交网络中,每个人可以看作是一个顶点,如果两个人是朋友,那么在他们对应的顶点之间就会有一条边。

这种直观的表示方式让我们能够清晰地理解和分析复杂的关系。

图有两种主要的表示方式:邻接矩阵和邻接表。

邻接矩阵就像是一个表格,行和列都对应着顶点,如果两个顶点之间有边相连,对应的位置就标记为 1,否则为 0 。

这种表示方式简单直观,但当顶点数量很多而边的数量相对较少时,会浪费大量的存储空间。

邻接表则是为每个顶点创建一个链表,链表中存储着与该顶点相邻的顶点。

这种方式在处理稀疏图(边的数量相对较少的图)时,能够节省大量的空间,并且在查找相邻顶点时也比较高效。

图的遍历是操作图的重要方式之一。

深度优先遍历就像是在迷宫中一直往前走,直到走不通了再回溯;而广度优先遍历则像是以一个点为中心,一层一层地向外扩展。

深度优先遍历通常使用递归的方式实现。

从一个起始顶点开始,沿着一条路径尽可能地深入,直到无法继续,然后回溯,尝试其他的路径。

这种遍历方式在搜索、查找路径等问题中经常被使用。

广度优先遍历则使用队列来实现。

先将起始顶点入队,然后依次取出队列头部的顶点,并将其相邻的未访问过的顶点入队。

这种方式常用于计算最短路径、层次遍历等问题。

图的应用非常广泛。

在网络路由中,通过构建网络的图模型,可以找到最优的数据包传输路径;在任务调度中,可以根据任务之间的依赖关系,使用图来安排任务的执行顺序;在地图导航中,城市和道路可以表示为图,从而为用户规划最佳的出行路线。

再比如,在人工智能中的搜索算法中,图可以用来表示状态空间。

考研计算机学科专业基础综合-19_真题-无答案

考研计算机学科专业基础综合-19_真题-无答案

考研计算机学科专业基础综合-19(总分120,考试时间90分钟)一、单项选择题1. 若二叉树的前序序列为DABCEFG,中序序列为BACDFGE,则其层次序列为( )。

A.BCAGFED B.DAEBCFGC.ABCDEFG D.BCAEFGD2. 页面置换算法( )可能会产生Belady异常现象。

A.先进先出算法FIFO B.最近最少使用算法LRUC.利用reference bit的近似的LRU D.最优算法Optimal3. 如果一个没有内存映射的IO设备与主存之间交换数据,希望这种数据交换不经过CPU 来完成,那么,可以采用的方法是( )。

A.程序查询方式 B.中断技术 C.通道技术 D.DMA方式4. MIPS(每秒百万次指令数)和MFLOPS(每秒百万次浮点运算数)是衡量CPU性能的两个指标,其中( )。

A.MIPS适合衡量向量处理机的性能,MFLOPS适合衡量标量处理机的性能B.MIPS适合衡量标量处理机的性能,MFLOPS适合衡量向量处理机的性能C.MIPS反映计算机系统的峰值性能,MFLOPS反映计算机系统的持续性能D.MIPS反映计算机系统的持续性能,MFLOPS反映计算机系统的峰值性能5. 进行P0和P1的共享变量定义及其初值为boolean flag[2];int turn=0;flag[0]=faulse; flag[1]=faulse;若进行P0和P1访问临界资源的类C代码实现如下:V oid P0( )//进程p0 V oicl P1( )//进程p1while(TuRE) while(TURE)Flag[0]=TURE;Flag[1]=TuRE;turn=1;turn=0;While(flag[1]&&(turn==1)) While(flag[0]%&(turn==0));;临界区;临界区;Flag[0]=FALSE; Flag[1]=FALSE;则并发执行进程P0和P1时产生的情况是:A.不能保证进程互斥进入临界区,会出现“饥饿”现象B.不能保证进程互斥进入临界区,不会出现“饥饿”现象C.能保证进程互斥进入临界区,会出现“饥饿”现象D.能保证进程互斥进入临界区,不会出现“饥饿”现象6. 有四个用户Li,zhang,sun和wang,对应的用户组分别为system,staff,stLldent,stuation。

图的各种算法(深度、广度等)

图的各种算法(深度、广度等)

vex next 4 p
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^
^
4 ^
top
4
输出序列:6 1
1 2 3 4 5 6
in link 0 2 ^ 1 0 2 0
vex next 4 p
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^
^
4 ^
top 4
输出序列:6 1
1 2 3 4 5 6
in link 0 2 ^ 1 0 2 0
c a g b h f d e
a
b h c d g f
e
在算法中需要用定量的描述替代定性的概念
没有前驱的顶点 入度为零的顶点 删除顶点及以它为尾的弧 弧头顶点的入度减1
算法实现
以邻接表作存储结构 把邻接表中所有入度为0的顶点进栈 栈非空时,输出栈顶元素Vj并退栈;在邻接表中查找 Vj的直接后继Vk,把Vk的入度减1;若Vk的入度为0 则进栈 重复上述操作直至栈空为止。若栈空时输出的顶点个 数不是n,则有向图有环;否则,拓扑排序完毕
^
4
^
top
输出序列:6 1 3 2 4
1 2 3 4 5 6
in link 0 0 ^ 0 0 0 0
vex next 4
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^ p
^
4
^topBiblioteka 5输出序列:6 1 3 2 4
1 2 3 4 5 6
in link 0 0 ^ 0 0 0 0
vex next 4
w2 w1 V w7 w6 w3

算法设计:深度优先遍历和广度优先遍历

算法设计:深度优先遍历和广度优先遍历

算法设计:深度优先遍历和广度优先遍历实现深度优先遍历过程1、图的遍历和树的遍历类似,图的遍历也是从某个顶点出发,沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。

它是许多图的算法的基础。

深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。

它们对无向图和有向图均适用。

注意:以下假定遍历过程中访问顶点的操作是简单地输出顶点。

2、布尔向量visited[0..n-1]的设置图中任一顶点都可能和其它顶点相邻接。

在访问了某顶点之后,又可能顺着某条回路又回到了该顶点。

为了避免重复访问同一个顶点,必须记住每个已访问的顶点。

为此,可设一布尔向量visited[0..n-1],其初值为假,一旦访问了顶点Vi之后,便将visited[i]置为真。

--------------------------深度优先遍历(Depth-First Traversal)1.图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。

在G中任选一顶点v为初始出发点(源点),则深度优先遍历可定义如下:首先访问出发点v,并将其标记为已访问过;然后依次从v出发搜索v的每个邻接点w。

若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。

若此时图中仍有未访问的顶点,则另选一个尚未访问的顶点作为新的源点重复上述过程,直至图中所有顶点均已被访问为止。

图的深度优先遍历类似于树的前序遍历。

采用的搜索方法的特点是尽可能先对纵深方向进行搜索。

这种搜索方法称为深度优先搜索(Depth-First Search)。

相应地,用此方法遍历图就很自然地称之为图的深度优先遍历。

2、深度优先搜索的过程设x是当前被访问顶点,在对x做过访问标记后,选择一条从x出发的未检测过的边(x,y)。

若发现顶点y已访问过,则重新选择另一条从x出发的未检测过的边,否则沿边(x,y)到达未曾访问过的y,对y访问并将其标记为已访问过;然后从y开始搜索,直到搜索完从y出发的所有路径,即访问完所有从y出发可达的顶点之后,才回溯到顶点x,并且再选择一条从x出发的未检测过的边。

邻接矩阵

邻接矩阵

哈尔滨工业大学计算机科学与技术学院实验报告课程名称:数据结构与算法课程类型:必修实验项目名称:图实验题目:图的遍历班级:0703301学号:1070330101姓名:任冬伟设计成绩报告成绩指导老师一、实验目的1)掌握图的邻接矩阵表示2)熟练掌握图的深度优先和广度优先搜索3)熟悉队列的基本操作,完成广度优先搜索二、实验要求及实验环境1)本程序是对图的邻接矩阵表示,进行广度优先和深度优先搜索2)本程序要求输入图中结点个数及边条数,以字符输入顶点信息。

然后输入边信息3)对图实现深度优先搜索4)对图实现广度优先搜索三、设计思想(本程序中的用到的所有数据类型的定义,主程序的流程图及各程序模块之间的调用关系)1.数据类型定义1)邻接矩阵struct MTGraph{char vexlist[NumbersVertices]; //顶点表int edge[NumbersVertices][NumbersVertices]; //边表int n,e; //当前顶点和边的个数};2)队列struct celltype{int element;celltype *next;};Typedef celltype *ELE;struct QUEUE {ELE front;ELE rear;};2.基本操作1)建立邻接矩阵void CreateMGragh(MTGraph &G); //建立邻接矩阵2)搜索void DFS(MTGraph G, int i); //深度优先搜索void BFS(MTGraph G, int k); //广度优先搜索3)队列的基本操作void MakeNull(QUEUE &q); //初始化bool Empty(QUEUE q); //判空char Front(QUEUE q); //返回队首void EnQueue(int x,QUEUE &q); //进队操作void Delete(QUEUE &q); //删除3.主函数流程1)创建图的邻接矩阵表示,输入图中结点个数及边条数,以字符输入顶点信息。

数据结构选择题考试精选

数据结构选择题考试精选

一、单项选择题 (每题1分,共142分)1. 向一个有128个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动(A)个元素。

A.64B.63C.63.5D.72. 线性表是具有n个(C)的有限序列(n≠0)。

A.表元素B.字符C.数据元素D.数据项3. 下列哪种排序方法在最坏的情况下的时间复杂度是O(n*log2n)(B)。

A .直接插入排序 B. 堆排序C. 简单选择排序D. 快速排序4. 数组A[5][6]的每个元素占5个单元,将其按行优先次序存储在起始地址为1000的连续的内存单元中,则元素A[4][4]的地址为(A)。

A.1140B.1145C.1120D.11255. 从一个栈顶指针为HS的链栈中删除一个结点时,用x保存被删结点的值,则执行(D)。

A.x=HS;HS=HS->next;B.x=HS->data;C.HS=HS->next;x=HS->data;D.x=HS->data;HS=HS->next;6. 已知含6个顶点(v0,v1,v2,v3,v4,v5)的无向图的邻接矩阵如图所示,则从顶点v0出发进行深度优先遍历可能得到的顶点访问序列为(A)。

A.(v0,v1,v2,v5,v4,v3B.(v0,v1,v2,v3,v4,v5)C.(v0,v1,v5,v2,v3,v4)D.(v0,v1,v4,v5,v2,v3)7. 如下陈述中正确的是(A)。

A.串是一种特殊的线性B.串的长度必须大于零C.串中元素只能是字母D.空串就是空白串8. 在一个长度为n的顺序表中插入一个元素时,等概率情况下的平均移动元素的次数是(A)。

A.n/2B.(n-1)/2 C.n*(n-1)/2 D.(n+1)/29.数据的存储结构包括顺序、链接、散列和(D)4种基本类型。

A.向量B.数组C.集合D.索引10. 在含n个顶点和e条边的无向图的邻接矩阵中,零元素的个数为(D)。

图的遍历深度优先遍历和广度优先遍历

图的遍历深度优先遍历和广度优先遍历
visited
4
5
f
^
对应的邻接表
终点2作为下次的始点, 由于1点已访问过,跳过, 找到4,记标识,送输出, 4有作为新的始点重复上 述过程
1 2 4
5
输出数组 resu
3.邻接表深度优先遍历的实现
template <class TElem, class TEdgeElem>long DFS2(TGraphNodeAL<TElem, TEdgeElem> *nodes,long n,long v0, char *visited, long *resu,long &top) {//深度优先遍历用邻接表表示的图。nodes是邻接表的头数组,n 为结点个数(编号为0~n)。 //v0为遍历的起点。返回实际遍历到的结点的数目。 //visited是访问标志数组,调用本函数前,应为其分配空间并初 始化为全0(未访问) //resu为一维数组,用于存放所遍历到的结点的编号,调用本函 数前,应为其分配空间 long nNodes, i; TGraphEdgeAL<TEdgeElem> *p; nNodes=1;
1 2
4
图 20-1有向图
5
3
1 2 3 4 5
1 0 1 0 1 0
2 1 0 0 0 0
3 0 0 0 0 0
4 0 1 0 0 0
5 1 0 1 0 0
1 2 3 4 5
1 1 0 1 1
1 2 4 5
所示图的邻接矩阵g
访问标识数组 visited
输出数组 resu
例如从1点深度优先遍历,先把1设置访问标志,并置入输出数组resu,然后从邻接 矩阵的第一行,扫描各列,找到最近的邻接点2,将其设置访问标志,并进入输出数 组,接着从邻接矩阵的2行扫描,找到第一个构成边的点是1,检查访问标识数组, 发现1已经访问过,跳过,找第二个构成边 的点4,设置访问标识,进入输出数组, 再从邻接矩阵的第4行扫描,寻找构成边的点,除1外在无其他点,返回2行,继续 寻找,也无新点,返回1,找到5,将5置访问标志,进入输出数组,1行再无其他新 点,遍历结束,返回遍历元素个数为4 。

数据结构图练习题(附答案).doc

数据结构图练习题(附答案).doc

第七章 图一、选择题1.图中有关路径的定义是( )。

【北方交通大学 2001 一、24 (2分)】A .由顶点和相邻顶点序偶构成的边所形成的序列B .由不同顶点所形成的序列C .由不同边所形成的序列D .上述定义都不是2.设无向图的顶点个数为n ,则该图最多有( )条边。

A .n-1B .n(n-1)/2C . n(n+1)/2D .0E .n 2【清华大学 1998 一、5 (2分)】【西安电子科技大 1998 一、6 (2分)】【北京航空航天大学 1999 一、7 (2分)】3.一个n 个顶点的连通无向图,其边的个数至少为( )。

【浙江大学 1999 四、4 (4分)】A .n-1B .nC .n+1D .nlogn ;4.要连通具有n 个顶点的有向图,至少需要( )条边。

【北京航空航天大学 2000 一、6(2分)】A .n-lB .nC .n+lD .2n5.n 个结点的完全有向图含有边的数目( )。

【中山大学 1998 二、9 (2分)】A .n*n B.n (n +1) C .n /2 D .n*(n -l )6.一个有n 个结点的图,最少有( )个连通分量,最多有( )个连通分量。

A .0B .1C .n-1D .n【北京邮电大学 2000 二、5 (20/8分)】7.在一个无向图中,所有顶点的度数之和等于所有边数( )倍,在一个有向图中,所有顶点的入度之和等于所有顶点出度之和的( )倍。

【哈尔滨工业大学 2001 二、3 (2分)】A .1/2B .2C .1D .48.用有向无环图描述表达式(A+B)*((A+B )/A ),至少需要顶点的数目为( )。

【中山大学1999一、14】A .5B .6C .8D .99.用DFS 遍历一个无环有向图,并在DFS 算法退栈返回时打印相应的顶点,则输出的顶点序列是( )。

A .逆拓扑有序B .拓扑有序C .无序的 【中科院软件所1998】10.下面结构中最适于表示稀疏无向图的是( ),适于表示稀疏有向图的是( )。

中南大学《数据结构》课程作业(在线作业)二及参考答案

中南大学《数据结构》课程作业(在线作业)二及参考答案

(一) 单选题1. 用邻接表表示图进行深度优先遍历时,通常是采用()来实现算法的。

(A) 栈(B) 队列(C) 树(D) 图参考答案: (A)2. 设图的邻接链表如图所示,则该图的边的数目是()。

(A) 4(B)5 (C) 10(D) 20参考答案: (B)3. 若采用邻接矩阵翻存储一个n 个顶点的无向图,则该邻接矩阵是一个()。

(A)上三角矩阵(B)稀疏矩阵(C)对角矩阵(D)对称矩阵参考答案: (D)4.无向图,其中:,对该图进行深度优先遍历,得到的顶点序列正确的是()。

(A)a,b,e,c,d,f (B)a,c,f,e,b,d (C)a,e,b,c,f,d(D)a,e,d,f,c,b参考答案: (D)5. 设森林F 对应的二叉树为B ,它有m 个结点,B 的根为p ,p 的右子树结点个数为n,森林F 中第一棵子树的结点个数是()。

(A)(B)(C)(D) 条件不足,无法确定参考答案: (A)6. 关键路径是事件结点网络中()。

(A) 从源点到汇点的最长路径(B) 从源点到汇点的最短路径(C) 最长回路(D) 最短回路参考答案: (A)7. 树最适合用来表示()。

(A)有序数据元素(B) 无序数据元素(C) 元素之间具有分支层次关系的数据(D) 元素之间无联系的数据参考答案:(C)8. 在一棵具有n个结点的二叉链表中,所有结点的空域个数等于()。

(A)n(B)(C)(D)参考答案:(C)9. 在一个非空二叉树的中序遍历序列中,根结点的右边()。

(A)只有右子树上的所有结点(B) 只有右子树上的部分结点(C) 只有左子树的上的部分结点(D) 只有左子树上的所有结点参考答案:(A)10. 有8个结点的无向连通图最少有()条边。

(A)5 (B) 6 (C) 7 (D) 8参考答案:(C)11. 含有10个结点的二叉树中,度为0的结点数为4,则度为2的结点数为()。

(A)3 (B) 4 (C) 5 (D) 6参考答案:(A)12. 在有n个叶子结点的哈夫曼树中,其结点总数为()。

邻接矩阵实验报告

邻接矩阵实验报告

一、实验目的1. 理解邻接矩阵的概念及其在图论中的应用。

2. 掌握邻接矩阵的构建方法。

3. 学会使用邻接矩阵进行图的深度优先遍历和广度优先遍历。

4. 比较邻接矩阵和邻接表两种图的存储结构的优缺点。

二、实验内容1. 构建邻接矩阵2. 使用邻接矩阵进行图的深度优先遍历3. 使用邻接矩阵进行图的广度优先遍历4. 分析邻接矩阵和邻接表的优缺点三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019四、实验步骤1. 构建邻接矩阵(1)定义图的顶点数量n。

(2)创建一个nn的二维数组A,用于存储邻接矩阵。

(3)根据图的边信息,将对应的A[i][j]值设置为1(表示存在边)或0(表示不存在边)。

2. 使用邻接矩阵进行图的深度优先遍历(1)初始化访问标记数组visited,用于记录顶点是否被访问过。

(2)从某个顶点v开始,将其标记为已访问,并将其加入访问序列。

(3)对于v的每个邻接顶点u,如果u未被访问过,则递归调用深度优先遍历算法,并将u加入访问序列。

(4)重复步骤3,直到所有顶点都被访问过。

3. 使用邻接矩阵进行图的广度优先遍历(1)初始化队列Q和一个访问标记数组visited。

(2)将起始顶点v入队,并将其标记为已访问。

(3)当队列不为空时,执行以下步骤:a. 从队列中取出一个顶点v。

b. 将v的邻接顶点u入队,并将u标记为已访问。

c. 将v加入访问序列。

(4)重复步骤3,直到队列空为止。

4. 分析邻接矩阵和邻接表的优缺点(1)邻接矩阵的优点:a. 查找边的时间复杂度为O(1)。

b. 遍历图的时间复杂度为O(n^2)。

c. 适用于稠密图。

(2)邻接矩阵的缺点:a. 空间复杂度为O(n^2),对于稀疏图,空间利用率低。

b. 查找边和遍历图的时间复杂度较高。

(3)邻接表的优点:a. 空间复杂度为O(n+e),对于稀疏图,空间利用率高。

b. 查找边和遍历图的时间复杂度为O(n+e)。

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

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

邻接矩阵表示的图的基本操作的实现//采用邻接矩阵完成无权无向及有向图的"建立、输出、深度遍历、广度遍历"操作#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR -1typedef 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 Mgraph{ElemType vector[MAX_VERTEX_NUM]; //顶点向量int adj[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//邻接矩阵int vexnum; //图中当前顶点数int arcnum; //图中当前边数} 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;}elsereturn ERROR;}//链式队列的入队操作,在已知队列的队尾插入一个元素e,修改队尾指针rear。

数据结构题及参考答案

数据结构题及参考答案

数据结构作业题作业题(一)一、单项选择题1. 从逻辑上可以把数据结构分为( c )两大类。

A.动态结构、静态结构 B.顺序结构、链式结构C.线性结构、非线性结构 D.初等结构、构造型结构2. 链表不具有的特点是( b )A.插入、删除不需要移动元素 B.可随机访问任一元素C.不必事先估计存储空间 D.所需空间与线性长度成正比3.下面程序段的时间复杂度的量级为( d )。

For(i=1;i<=n;i++)For(j=1;j<=I;j++)For(k=1;k<=j;k++)X=x+1;A.O(1) B.O(n)C.O(n²) D.O(n³)4.在一个带头结点的双向循环链表中,若要在p所指向的结点之前插入一个新结点,则需要相继修改(c)个指针域的值。

A.2 B.3C.4 D.65、一个顺序存储线性表的第一个元素的存储地址是90,每个元素的长度是2,则第6个元素的存储地址是( b )。

A.98 B.100C.102 D.1066、判定一个栈s(最多元素为m0)为空的条件是(b)。

A.s-〉top! =0 B.s-〉top= =0C.s-〉top! =m0 D.s-〉top= =m07、循环队列用数组A[m](下标从0到m-1)存放其元素值,已知其头尾指针分别是front和rear,则当前队列中的元素个数是( a )。

A.(rear-front+m)%m B.rear-front+1C.rear-front-1 D. rear-front8、设有两个串S1与S2,求串S2在S1中首次出现位置的运算称作(c)。

A.连接 B.求子串C.模式匹配 D.判子串9、设串S1='ABCDEFG',S2='PQRST',函数con(x,y)返回x和y串的连接串,subs(s,i,j)返回串S的的从序号i的字符开始的j个字符组成的子串,len(s)返回串S的长度,则con(subs(S1,2,len(S2)),subs(S1,len(S2),2))的结果是( d )。

邻接矩阵表示图-深度-广度优先遍历

邻接矩阵表示图-深度-广度优先遍历

*问题描述:建立图的存储结构(图的类型可以是有向图、无向图、有向网、无向网,学生可以任选两种类型),能够输入图的顶点和边的信息,并存储到相应存储结构中,而后输出图的邻接矩阵。

1、邻接矩阵表示法:设G=(V,E)是一个图,其中V={V1,V2,V3…,Vn}。

G的邻接矩阵是一个他有下述性质的n阶方阵:1,若(Vi,Vj)∈E 或<Vi,Vj>∈E;A[i,j]={0,反之图5-2中有向图G1和无向图G2的邻接矩阵分别为M1和M2:M1=┌0 1 0 1 ┐│ 1 0 1 0 ││ 1 0 0 1 │└0 0 0 0 ┘M2=┌0 1 1 1 ┐│ 1 0 1 0 ││ 1 1 0 1 │└ 1 0 1 0 ┘注意无向图的邻接是一个对称矩阵,例如M2。

用邻接矩阵表示法来表示一个具有n个顶点的图时,除了用邻接矩阵中的n*n个元素存储顶点间相邻关系外,往往还需要另设一个向量存储n个顶点的信息。

因此其类型定义如下:VertexType vertex[MAX_VERTEX_NUM]; // 顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志若图中每个顶点只含一个编号i(1≤i≤vnum),则只需一个二维数组表示图的邻接矩阵。

此时存储结构可简单说明如下:type adjmatrix=array[1..vnum,1..vnum]of adj;利用邻接矩阵很容易判定任意两个顶点之间是否有边(或弧)相联,并容易求得各个顶点的度。

对于无向图,顶点Vi的度是邻接矩阵中第i行元素之和,即n nD(Vi)=∑A[i,j](或∑A[i,j])j=1 i=1对于有向图,顶点Vi的出度OD(Vi)为邻接矩阵第i行元素之和,顶点Vi 的入度ID(Vi)为第i列元素之和。

即n nOD(Vi)=∑A[i,j],OD(Vi)=∑A[j,i])j=1j=1用邻接矩阵也可以表示带权图,只要令Wij, 若<Vi,Vj>或(Vi,Vj)A[i,j]={∞, 否则。

实验报告:图的存储结构和遍历

实验报告:图的存储结构和遍历
{ ArcNode *p;
int queue[6],front=0,rear=0;
int visited[6];
int w,i;
for(i=0;i<G->n;i++)
visited[i]=0;
printf("%d ",v);
visited[v]=1;
rear=(rea叶1)%6;
queue[rear]=v;
ArcNode *p;
for(i=0;i<G->n;i++)
{ p=G->adjlist[i].firstarc; printf("%d:",i);
while (p!=NULL)
{ printf("%d ",p->adjvex); p=p_>nextarc;
}
printf("\n");
}
}
void dfs (ALGraph *G,int v)
{ p=(ArcNode*)malloc(sizeof(ArcNode)); p->adjvex=j;
p->nextarc=G->adjlist[i].firstarc;
G->adjlist[i].firstarc=p;
}
G->n=g.n;
}
void dispadj(ALGraph *G)
{ int i;
printf("\n");
}
printf("邻接矩阵\n");
G=(ALGraph*)malloc(sizeof(ALGraph));
mattolist(g,G);
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

*问题描述:建立图的存储结构,能够输入图的顶点和边的信息,并存储到相应存储结构中,而后输出图的邻接矩阵。

1、邻接矩阵表示法:设G=(V,E)是一个图,其中V={V1,V2,V3…,Vn}。

G的邻接矩阵是一个他有下述性质的n阶方阵:1,若(Vi,Vj)∈E 或<Vi,Vj>∈E;A[i,j]={0,反之图5-2中有向图G1的邻接矩阵为M1M1=┌0 1 0 1 ┐│ 1 0 1 0 ││ 1 0 0 1 │└0 0 0 0 ┘用邻接矩阵表示法来表示一个具有n个顶点的图时,除了用邻接矩阵中的n*n个元素存储顶点间相邻关系外,往往还需要另设一个向量存储n个顶点的信息。

因此其类型定义如下:VertexType vertex[MAX_VERTEX_NUM]; // 顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志若图中每个顶点只含一个编号i(1≤i≤vnum),则只需一个二维数组表示图的邻接矩阵。

此时存储结构可简单说明如下:type adjmatrix=array[1..vnum,1..vnum]of adj;利用邻接矩阵很容易判定任意两个顶点之间是否有边(或弧)相联,并容易求得各个顶点的度。

对于有向图,顶点Vi的出度OD(Vi)为邻接矩阵第i行元素之和,顶点Vi 的入度ID(Vi)为第i列元素之和。

即n nOD(Vi)=∑A[i,j],OD(Vi)=∑A[j,i])j=1j=1用邻接矩阵也可以表示带权图,只要令Wij, 若<Vi,Vj>或(Vi,Vj)A[i,j]={∞, 否则。

其中Wij为<Vi,Vj>或(Vi,Vj)上的权值。

相应地,网的邻接矩阵表示的类型定义应作如下的修改:adj:weightype ; {weightype为权类型}2、图的遍历:*深度优先搜索深度优先搜索遍历类似于树的先根遍历,是树的先根遍历的推广。

假设初始状态是图中所有的顶点未曾被访问,则深度优先遍历可从图的某个顶点V出发,访问此顶点,然后依次从V的未被访问的邻接点出发深度优先遍历图,直至图中所有和V有路径相通的顶点都被访问到;若此时图中尚有顶点未被访问,则另选图中的一个未被访问的顶点,重复上述过程,直至图中所有顶点都被访问到为止。

以图中无向图G4为例,深度优先遍历图的过程如图所示。

假设从顶点V1出发进行搜索,在访问了顶点V1后,选择邻接点V2。

因为V2未曾访问,则从V2出发进行搜索。

依次类推,接着从V4,V8,V5出发进行搜索。

在访问了V5之后,由于V 5的邻接点已都被访问,则搜索回到V8。

由于同样的理由,搜索继续回到V4,V2直至V1,此时由于V1的另一个邻接点为被访问,则搜索又从V1到V3,再继续进行下去。

由此得到顶点的访问序列为:V1 V2V4V8V5V3V6V7显然,这是一个递归的过程。

为了在遍历过程中便于区别顶点是否已被访问,需附设访问标志数组visted[0...n-1],其初值为0,一但某个顶点被访问,则其相应的分量置为1。

2、图的输出语句的嵌套依次输出。

图的邻接矩阵是一个二维数组,运用for主程序流程图图的构造流程图1、无向图邻接矩阵的建立算法如下:procedure build-graph; {建立无向图的邻接矩阵}beginfor i:=1 to n do read(G.vertex[i]);{读入n个顶点的信息}for i:=1 to n dofor j:=1 to e doG.arcs[i][j] =0;{将邻接矩阵的每个元素初始化成0 }for k:=1 to e do {e为边的数目}[ read(i,j,w) {读入边<i,j>和权}G.arcs[i][j]:=w]G.arcs[i][j]=G.arcs[i][i]{置对称弧}end;该算法的执行时间是O(n+n2+e),其中消耗在邻接矩阵初始化操作上的时间是O(n2),而e<n2,所以上述算法的时间复杂度是O(n2)。

4、图的广度优先遍历算法分析beginfor i:=1 to n do(visited[i]){初始化标志数组}while (i<n){for:i=1 to n do{if…..if…..}}end二维数组表示邻接矩阵作图的存储结构,其中n为图中顶点数,查找每个顶点的邻接点所需时间为O(n2)。

/* Graph.h */#include<stdio.h>#include<malloc.h>#include<conio.h>#include<stdlib.h>#include<string.h>#define ERROR 0#define OK 1#define MAX_VERTEX_NUM 20 //定义最大值#define INFINITY 32768 //定义极大值#define MAX_INFO 20typedef int VrType; //定义新的类型typedef int InfoType;typedef char VertexType;typedef enum{DG,DN,UDG,UDN}GraphKind;//有向图,有向网,无向图,无向网typedef struct ArcCell{//邻接矩阵表示法的各个数据结构VrType adj; // 顶点关系类型。

对无权图,用或表示相邻否;对带权图,则为权值类型。

InfoType *info; // 该弧相关信息的指针} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vertex[MAX_VERTEX_NUM]; // 顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志} MGraph;typedef struct{//设置栈int elem1[MAX_VERTEX_NUM];int top;}SeqStack;int LocateVertex(MGraph G,VertexType v);void CreateUDG(MGraph &G);void CreateUDN(MGraph &G);void DepthFirstSearch1(MGraph G);void BreadthFirstSearch1(MGraph G);int CreateGraph(MGraph &G);void Display(MGraph G);/* Graph.cpp */#include"Graph.h"int LocateVertex(MGraph G,VertexType v){//用于返回输弧端点所表示的数值int j=0,k;for(k=0;k<G.vexnum;++k)if(G.vertex[k]==v){j=k;break;}return(j);}void CreateUDG(MGraph &G){ // 采用数组(邻接矩阵)表示法,构造无向图int i,j,k,IncInfo;//i,j,k为计数器,IncInfo为标志符char ch; //用于吃掉多余的字符VertexType v1,v2; //用于放置输入的弧的两个顶点printf("请输入无向图G的顶点数,边数,弧是否含相关信息(是:,否:): \n"); scanf("%d,%d,%d",&G.vexnum,&G.arcnum,&IncInfo);ch=getchar(); //用于吃掉回车printf("请输入%d个顶点的值(1个字符,空格隔开):\n",G.vexnum);for(i=0;i<G.vexnum;++i) // 构造顶点向量{scanf("%c",&G.vertex[i]);ch=getchar();}printf("请输入%d条边的顶点顶点(以空格作为间隔): \n",G.arcnum);for(i=0;i<G.vexnum;++i) // 初始化邻接矩阵for(j=0;j<G.vexnum;++j){G.arcs[i][j].adj=0;G.arcs[i][j].info=NULL; // {adj,info}}for(k=0;k<G.arcnum;++k){scanf("%c %c",&v1,&v2);ch=getchar();// ch吃掉回车符i=LocateVertex(G,v1); j=LocateVertex(G,v2);if(IncInfo)scanf("%d",&G.arcs[i][j].info);G.arcs[i][j].adj=G.arcs[j][i].adj=1; // 置<v1,v2>的对称弧<v2,v1>}}//CreateUDGvoid CreateUDN(MGraph &G){ // 采用数组(邻接矩阵)表示法,构造无向网int i,j,k,w,IncInfo;//i,j,k为计数器,w用于放置权值,IncInfo为标志符char ch; //用于吃掉多余的字符VertexType v1,v2; //用于放置输入的弧的两个顶点printf("请输入无向图G的顶点数,边数,弧是否含相关信息(是:,否:):\n ");scanf("%d,%d,%d",&G.vexnum,&G.arcnum,&IncInfo);ch=getchar(); //用于吃掉回车printf("请输入%d个顶点的值(1个字符,空格隔开):\n",G.vexnum);for(i=0;i<G.vexnum;++i) // 构造顶点向量{scanf("%c",&G.vertex[i]);ch=getchar();}printf("请输入%d条边的顶点顶点(以空格作为间隔): \n",G.arcnum);for(i=0;i<G.vexnum;++i) // 初始化邻接矩阵for(j=0;j<G.vexnum;++j){G.arcs[i][j].adj=0;G.arcs[i][j].info=NULL; //{adj,info}}for(k=0;k<G.arcnum;++k){scanf("%c %c",&v1,&v2);ch=getchar();// ch吃掉回车符printf("请输入该边的权值: ");scanf("%d",&w);ch=getchar();i=LocateVertex(G,v1);j=LocateVertex(G,v2);G.arcs[i][j].adj=w;if(IncInfo)scanf("%d",&G.arcs[i][j].info);G.arcs[i][j]=G.arcs[j][i]; // 置<v1,v2>的对称弧<v2,v1>}}//CreateUDNvoid DepthFirstSearch1(MGraph G){//无向图、无向网深度优先遍历int i,j,k,visited[20],t=1,a=1; //i,j,k为计数器,visited[20]为标志符用于表示是否已经访问过SeqStack p;for(i=0;i<G.vexnum;++i) //初始化标志符visited[i]=0;visited[0]=1; //规定以第一个字符开始遍历printf("深度优先遍历开始:\n");k=0;i=0;printf("%c ",G.vertex[0]);while(i<G.vexnum){//不断以行循环在遇到符合条件时打印,每打印出一个就让t加,把合适的值用栈来表示,把指针指向新的项for(j=0;j<G.vexnum;++j){if(G.arcs[i][j].adj!=0&&G.arcs[i][j].adj!=INFINITY&&visited[j]==0){printf("%c ",G.vertex[j]);visited[j]=1;p.elem1[k]=i;p.top=k;k++;i++;a++;t++;break;}}if(j==G.vexnum){//当在某一行无法找到合适值时,输出栈内的值,返回上一行重新开始循环i=p.elem1[p.top];p.top--;k--;}if(t==G.vexnum)break; //当全部的定点都打印出来了就退出循环}printf("\n");}void BreadthFirstSearch1(MGraph G){//无向图、无向网广度优先遍历int i,j,k,visited[20],t=1; //i,j为计数器,visited[20]为标志符用于表示是否已经访问过SeqStack p;for(i=0;i<G.vexnum;++i) //初始化标志符visited[i]=0;visited[0]=1; //规定以第一个字符开始遍历printf("广度优先遍历开始:\n");k=0;i=0;printf("%c ",G.vertex[0]);while(i<G.vexnum){for(j=0;j<G.vexnum;++j)//不断以行循环在遇到符合条件时打印,每打印出一个就让t加,把指针指向新的项{if(G.arcs[i][j].adj!=0&&G.arcs[i][j].adj!=INFINITY&&visited[j]==0){printf("%c ",G.vertex[j]);visited[j]=1;p.elem1[k]=i;p.top=k;k++;t++;}}i++; //换行,重新开始循环if(t==G.vexnum)break;}printf("\n");}int CreateGraph(MGraph &G){ //构造图printf("请输入要构造的图的类型(有向图:0,有向网:1,无向图:2,无向网:3):\n");scanf ("%d",&G.kind);switch(G.kind){case 2: CreateUDG(G);break;case 3: CreateUDN(G);break;default: return ERROR;}}//CreateGraphvoid Display(MGraph G){//输出图的邻接矩阵int i,j;printf("该图的邻接矩阵为:\n");for(i=0;i<G.vexnum;++i){for(j=0;j<G.vexnum;++j){printf("%d ",G.arcs[i][j].adj);}printf("\n");}}/* main.cpp */#include"Graph.h"void main(){int i;MGraph G;CreateGraph(G);DepthFirstSearch1(G);BreadthFirstSearch1(G);Display(G);scanf("%d",&i);1、程序开始运行时输出:显示:请输入无向图G的顶点数:输入:5显示:请输入无向图G的边数:输入:6显示:请输入无向图G的弧是否含相关信息(是:1,否:0): 输入:0显示:请输入5个顶点的值(1个字符,空格隔开):输入:1 2 3 4 5显示:请输入%d条边的顶点1 顶点2(以空格作为间隔): 输入:1 2 1 4 2 3 2 5 3 4 3 5显示:深度优先遍历开始:1 2 3 4 5广度优先遍历开始:1 2 4 3 5该图的邻接矩阵为:0 1 0 1 01 0 1 0 10 1 0 1 11 0 1 0 00 1 1 0 0请输入任意键退出2、程序运行结果如图:10。

相关文档
最新文档