数据结构——图的基本操作

合集下载

图的基本操作 实验报告

图的基本操作 实验报告

图的基本操作实验报告图的基本操作实验报告引言:图是一种常见的数据结构,广泛应用于计算机科学和其他领域。

本实验报告旨在介绍图的基本操作,包括创建图、添加节点和边、遍历图等,并通过实验验证这些操作的正确性和效率。

实验目的:1. 了解图的基本概念和术语;2. 掌握图的创建和修改操作;3. 熟悉图的遍历算法;4. 分析图的操作的时间复杂度。

实验过程:1. 创建图首先,我们需要创建一个图对象。

图可以用邻接矩阵或邻接表来表示。

在本实验中,我们选择使用邻接表来表示图。

通过遍历输入的节点和边信息,我们可以创建一个包含所有节点和边的图。

2. 添加节点和边在创建图对象后,我们可以通过添加节点和边来构建图的结构。

通过输入节点的标识符和边的起始和结束节点,我们可以在图中添加新的节点和边。

添加节点和边的操作可以通过修改邻接表来实现,将节点和边的信息存储在对应的链表中。

3. 遍历图遍历图是图操作中常用的操作之一。

通过遍历图,我们可以访问图中的所有节点和边。

在本实验中,我们选择使用深度优先搜索(DFS)算法来遍历图。

DFS算法通过递归的方式遍历图中的节点,先访问当前节点,然后再递归地访问与当前节点相邻的节点。

4. 分析时间复杂度在实验过程中,我们记录了图的操作所花费的时间,并分析了它们的时间复杂度。

通过对比不同规模的图的操作时间,我们可以评估图操作的效率和可扩展性。

实验结果:通过实验,我们成功创建了一个图对象,并添加了多个节点和边。

我们还通过DFS算法遍历了图,并记录了遍历的顺序。

实验结果表明,我们的图操作实现正确,并且在不同规模的图上都能够高效地工作。

讨论与结论:本实验报告介绍了图的基本操作,并通过实验验证了这些操作的正确性和效率。

通过实验,我们了解到图是一种重要的数据结构,可以用于解决许多实际问题。

同时,我们还深入分析了图操作的时间复杂度,为后续的图算法设计和优化提供了参考。

总结:通过本次实验,我们对图的基本操作有了更深入的了解。

数据结构学习内容

数据结构学习内容

数据结构学习内容
《数据结构》主要学习线性表、栈的队列和数组、树与二叉树、图。

详细内容如下:
1、线性表:线性表的定义和基本操作、线性表的实现、顺序存储结构;
2、栈的队列和数组:栈和队列的基本概念、栈和队列的顺序存储结构、栈和队列的链式存储结构、栈和队列的应用、特殊矩阵的压缩存储;
3、树与二叉树:树的概念、二叉树的定义及其主要特征、二叉树的顺序存储结构和链式存储结构、线索二叉树的基本概念和构造;
4、图:图的概念、图的存储及基本操作、图的基本应用及其复杂度分析。

数据结构——图思维导图-高清简单脑图模板-知犀思维导图

数据结构——图思维导图-高清简单脑图模板-知犀思维导图

数据结构——图图的定义和基本术语
定义是由一个顶点集V和一个顶点间的关系集合组成的数据结构
分类
有向图
无向图
基本术语
有(无)向网弧或边带权的图
子图
完全图含有e=n(n-1)/2条边的无向图
有向完全图含有e=n(n-1)条弧的有向图
稀疏图边或弧的个数<nlogn
稠密图边或弧的个数>=nlogn
度(入度+出度)
入度以顶点v为弧尾的弧的数目
出度以顶点v为弧头的弧的数目
路径长度路径上边的数目
连通图图中任意两个顶点之间都有路径相通
图的遍历
深度优先搜索DPS
类似于先序遍历
实质对每个顶点查找其邻接点的过程
广度优先搜索BFS实质通过边或弧找邻接点的过程
图的存储结构
邻接矩阵
有向图:对称统计第i行1的个数可得顶点i的出度
无向图:不对称统计第j列1的个数可得顶点j的入度
邻接表只存储图中已有的弧或边的信息
有向图的十字链表将有向图的邻接表和逆邻接表结合起来的一种链
图的应用
最小生成树
普里姆(Prim)算法
贪心算法
最短路径
Dijkstra算法
Floyd算法
拓扑排序
关键路径。

数据结构试验报告-图的基本操作

数据结构试验报告-图的基本操作

中原工学院《数据结构》实验报告学院:计算机学院专业:计算机科学与技术班级:计科112姓名:康岩岩学号:201100814220 指导老师:高艳霞2012-11-22实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。

2、熟练掌握图的存储结构。

3、熟练掌握图的两种遍历算法。

二、实验内容[问题描述]对给定图,实现图的深度优先遍历和广度优先遍历。

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

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列。

【测试数据】由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握图的相关概念。

2、掌握图的逻辑结构和存储结构。

3、掌握图的两种遍历算法的实现。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果,对程序进行分析。

【设计思路】【代码整理】#include "stdafx.h"#include <iostream>#include <malloc.h>using namespace std;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW -1#define MAX_SIZE 20typedef enum{DG,DN,UDG,UDN}Kind;typedef struct ArcNode{int adjvex; //顶点位置struct ArcNode *nextarc; //下一条弧int *info; //弧信息};typedef struct{char info[10]; //顶点信息ArcNode *fistarc; //指向第一条弧}VNode,AdjList[MAX_SIZE];typedef struct{AdjList vertices;int vexnum,arcnum; //顶点数,弧数int kind; //图的种类,此为无向图}ALGraph;//这是队列的节点,仅用于广度优先搜索typedef struct Node{int num;struct Node* next;};//队列的头和尾typedef struct{Node * front;Node *rear;}PreBit;int LocateV ex(ALGraph G,char info[]);//定位顶点的位置Status addArcNode(ALGraph &G,int adjvex); //图中加入弧Status CreatGraph(ALGraph&G);//创建图的邻接表Status DFSTraverse(ALGraph G);//深度优先搜索Status BFSTraverse(ALGraph G);//广度优先搜索Status DFS(ALGraph G,int v);//深度优先搜索中的数据读取函数,用于递归bool visited[MAX_SIZE]; // 访问标志数组//初始化队列Status init_q(PreBit&P_B){P_B.front=P_B.rear=(Node*)malloc(sizeof(Node));if(!P_B.front){exit(OVERFLOW);}P_B.front->next=NULL;}//将数据入队Status en_q(PreBit & P_B,int num){Node *p=(Node*)malloc(sizeof(Node));if(!p){exit(OVERFLOW);}p->num=num;p->next=NULL;P_B.rear->next=p;P_B.rear=p;return OK;}//出队Status de_q(PreBit & P_B){if(P_B.front==P_B.rear){return ERROR;}Node* p=P_B.front->next;P_B.front->next=p->next;if(P_B.rear==p){P_B.rear=P_B.front;}free(p);return OK;}Status CreatGraph(ALGraph&G){cout<<"请输入顶点数目和弧数目"<<endl;cin>>G.vexnum>>G.arcnum;//依次输入顶点信息for(int i=0;i<G.vexnum;i++){cout<<"请输入顶点名称"<<endl;cin>>G.vertices[i].info;G.vertices[i].fistarc=NULL;}//依次输入弧信息for(int k=1;k<=G.arcnum;k++){char v1[10],v2[10]; //用于表示顶点名称的字符数组int i,j; //表示两个顶点的位置BACK: //返回点cout<<"请输入第"<<k<<"条弧的两个顶点"<<endl;cin>>v1>>v2;i=LocateV ex(G,v1); //得到顶点v1的位置j=LocateV ex(G,v2); //得到顶点v2的位置if(i==-1||j==-1){ //头信息不存在则返回重输cout<<"不存在该节点!"<<endl;goto BACK; //跳到BACK 返回点}addArcNode(G,i); //将弧的顶点信息插入表中addArcNode(G,j);}return OK;}//倒序插入弧的顶点信息Status addArcNode(ALGraph &G,int adjvex){ArcNode *p; //弧节点指针p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=adjvex;p->nextarc=G.vertices[adjvex].fistarc;//指向头结点的第一条弧G.vertices[adjvex].fistarc=p; //头结点的第一条弧指向p,即将p作为头结点的第一条弧return OK;}//定位顶点的位置int LocateV ex(ALGraph G,char info[]){for(int i=0;i<G.vexnum;i++){if(strcmp(G.vertices[i].info,info)==0){ //头结点名称与传入的信息相等,证明该头节点存在return i; //此时返回位置}}return -1;}//深度优先搜索Status DFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int i;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;i=LocateV ex(G,v1);if(i==-1){cout<<"不存在该节点!"<<endl;goto BACK;}DFS(G,i);return OK;}//深度优先搜索递归访问图Status DFS(ALGraph G,int v){visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息ArcNode *p;p=G.vertices[v].fistarc; //向头节点第一条while(p) //当弧存在{if(!visited[p->adjvex]){DFS(G,p->adjvex); //递归读取}p=p->nextarc;}return OK;}//广度优先搜索Status BFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int v;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;v=LocateV ex(G,v1);if(v==-1){cout<<"不存在该节点!"<<endl;goto BACK;}PreBit P_B;init_q(P_B);ArcNode *p;visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息en_q(P_B,v); //将头位置v入队while(P_B.front!=P_B.rear){//当队列不为空时,对其进行访问int w=P_B.front->next->num;//读出顶点位置de_q(P_B);//顶点已经访问过,将其出队列p=G.vertices[w].fistarc;//得到与顶点相关的第一条弧while(p){if(!visited[p->adjvex]){en_q(P_B,p->adjvex);//将弧入队,但不读取,只是将其放在队尾}p=p->nextarc;}}return OK;}int _tmain(int argc, _TCHAR* argv[]){ALGraph G;CreatGraph(G);cout<<"深度优先搜索图:"<<endl;DFSTraverse(G);cout<<endl;cout<<"广度优先搜索图:"<<endl;BFSTraverse(G);cout<<endl;system("pause");return 0;}。

数据结构第七章:图

数据结构第七章:图


a c G1
b d
vexdata firstarc adjvex next 1 4 ^ a 2 3 4 b c d 1 1 3 ^ ^ ^
19
7.3 图的遍历
深度优先遍历(DFS) 深度优先遍历
方法:从图的某一顶点 出发,访问此顶点; 方法:从图的某一顶点V0出发,访问此顶点;然后依 次从V 的未被访问的邻接点出发,深度优先遍历图, 次从 0的未被访问的邻接点出发,深度优先遍历图, 直至图中所有和V 相通的顶点都被访问到; 直至图中所有和 0相通的顶点都被访问到;若此时图 中尚有顶点未被访问, 中尚有顶点未被访问,则另选图中一个未被访问的顶 点作起点,重复上述过程, 点作起点,重复上述过程,直至图中所有顶点都被访 问为止。 问为止。
ω ij , 若(v i , v j )或 < v i , v j >∈ E(G) A[i, j ] = 0,其它
11

1 3
5
2
8 4 7 5 1 6 3 4 2
0 5 7 0 3
5 0 0 4 8
7 0 0 2 1
0 4 2 0 6
3 8 1 6 0
12
关联矩阵——表示顶点与边的关联关系的矩阵 表示顶点与边的关联关系的矩阵 关联矩阵
1
7.1 图的定义和术语
是由两个集合V(G)和E(G)组成的 组成的, 图(Graph)——图G是由两个集合 图 是由两个集合 和 组成的 记为G=(V,E) 记为
其中: 其中:V(G)是顶点的非空有限集 是顶点的非空有限集 E(G)是边的有限集合,边是顶点的无序对或有序对 是边的有限集合, 是边的有限集合
有向图——有向图 是由两个集合 有向图G是由两个集合 有向图 有向图 是由两个集合V(G)和E(G)组成的 和 组成的

《数据结构》实验教学大纲

《数据结构》实验教学大纲

《数据结构》实验教学大纲课程代码: B03203课程名称:数据结构英文名称: Data Structures课程总学时: 60 (其中理论课 46 学时,实验 14 学时)学分: 2.5课程类别:必修课程性质:专业基础课先修课程:计算机导论、Java语言程序设计面向专业:软件技术、计算机网络技术开课单位:软件工程系一、实验教学的性质地位和任务数据结构实验课是计算机类专业的一门专业基础实验课,是后续专业课程的基础;该课程的主要任务是:进一步掌握和拓展所学的理论知识,初步掌握解决问题的基本结构以及建立在该结构上的算法,培养学生的综合能力;本课程主要内容包括:线性表及其应用实验,串及其应用实验,树及其应用实验,图及其应用实验,查找实验,内部排序实验;通过本实验课的学习,学生应学会分析研究计算机加工的数据结构的特性,培养数据抽象的能力,训练学生进行复杂程序设计的技能,培养良好程序设计的习惯,初步掌握算法的时间分析和空间分析的技术。

二、实验内容与要求项目一、线性表及其应用(1)实验目标1.加深理解线性表的顺序表示与链式表示的意义和区别,理解不同存储结构下插入与删除操作的算法;2.熟练掌握线性表的顺序存储方式及其插入、删除等基本操作的算法实现;3.熟练掌握线性表的链式存储方式及其插入、删除等基本操作的算法实现;(2)具体内容1.设计一组输入数据并编写主程序分别调用上述算法(顺序表示的算法为InitList_Sq、ListInsert_Sq、ListDelete_Sq等,链式表示的算法为InitList_L、ListInsert_L、ListDelete_L等),调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解;2.设计一个可以容纳40位数的求n!的程序。

(3)主要仪器设备与工具PC机一台/每人。

项目二、栈及其应用(1)实验目标1.理解栈的概念;2.掌握利用数组实现栈的基本操作;3.应用栈结构来解决表达式求值的问题。

数据结构流程图

数据结构流程图

数据结构流程图数据结构是计算机科学中非常重要的概念之一,它用于描述数据元素之间的关系和存储方式。

而流程图则是一种用于表示算法、操作过程或系统设计的图形化工具。

在计算机科学领域中,流程图常用于描述算法和程序设计过程。

本文将探讨数据结构流程图的相关概念和使用方法。

一、概述数据结构流程图是一种使用标准符号和连线来表示数据结构及其操作的图形化工具。

它包括了各种数据结构的表示方法和基本操作的实现流程。

通过使用数据结构流程图,人们可以清晰地了解数据元素之间的关系以及各种操作的执行过程。

二、符号表示数据结构流程图使用了一系列标准化的符号来表示不同类型的数据结构和操作。

下面是几种常用的符号表示:1. 开始/结束符号:用于表示程序的开始和结束点,通常使用圆角矩形来表示。

2. 输入/输出符号:用于表示输入或输出操作,通常使用矩形或平行四边形来表示。

3. 过程符号:用于表示具体的执行过程,通常使用矩形来表示。

4. 判断符号:用于表示条件分支和判断操作,通常使用菱形来表示。

5. 箭头线:用于表示不同符号之间的流向,表示数据或控制信息的传输方向。

三、使用方法数据结构流程图的使用方法可以分为以下几个步骤:1. 定义数据结构:根据实际需求,确定所需的数据结构类型,例如数组、链表、栈、队列等。

2. 设计算法流程:根据数据结构的特点和需求,设计相应的算法流程,包括数据的插入、删除、查找等操作。

3. 表示数据结构:使用符号表示数据结构及其属性,例如使用方框表示数组,使用箭头表示指针等。

4. 表示算法流程:使用符号表示算法流程,包括条件判断、循环操作、数据的移动等。

5. 绘制流程图:根据之前的设计,将数据结构和算法流程以符号形式绘制在图形界面上,使用箭头线表示数据流向。

6. 调试和改进:通过对流程图的分析和调试,发现问题并进行改进,保证算法的正确性和高效性。

四、实例演示以下是一个使用数据结构流程图描述数组插入操作的示例:思路:1. 输入待插入的元素和插入位置;2. 检查插入位置是否合法;3. 如果合法,将插入位置后的元素依次向后移动一个位置;4. 将待插入的元素放入插入位置处;5. 输出修改后的数组。

数据结构图的存储结构及基本操作

数据结构图的存储结构及基本操作

数据结构图的存储结构及基本操作数据结构图的存储结构及基本操作1·引言数据结构图是一种用来描述数据元素之间关系的图形结构,它可以表示实体之间的联系和依赖关系。

本文将介绍数据结构图的存储结构及基本操作。

2·存储结构2·1 邻接矩阵邻接矩阵是使用二维数组来表示数据结构图中各个节点之间的关系。

矩阵的行和列代表节点,如果两个节点之间存在边,则矩阵相应位置的值为1,否则为0。

2·2 邻接表邻接表是使用链表来表示数据结构图中各个节点之间的关系。

每个节点都有一个链表,链表中的每个元素表示与该节点相邻的节点。

2·3 十字链表十字链表是使用链表来表示数据结构图中各个节点之间的关系。

每个节点都有两个链表,一个表示该节点指向的节点,另一个表示指向该节点的节点。

2·4 邻接多重表邻接多重表是使用链表来表示数据结构图中各个节点之间的关系。

每个节点都有一个链表,链表中的每个元素表示与该节点相邻的边。

3·基本操作3·1 创建图创建一个空的数据结构图,根据需要选择适当的存储结构。

3·2 插入节点在数据结构图中插入一个节点,并建立与其他节点的关系。

3·3 删除节点从数据结构图中删除一个节点,并删除与其他节点的关系。

3·4 插入边在数据结构图中插入一条边,连接两个节点。

3·5 删除边从数据结构图中删除一条边,断开两个节点的连接。

3·6 遍历图按照某种规则遍历整个数据结构图,访问每个节点。

本文档涉及附件:无本文所涉及的法律名词及注释:1·邻接矩阵:用于表示图的存储结构,矩阵的行和列代表图的节点,矩阵的值表示节点之间的连接关系。

2·邻接表:用于表示图的存储结构,每个节点都有一个链表,链表中的每个元素表示与该节点相邻的节点。

3·十字链表:用于表示图的存储结构,每个节点都有两个链表,一个表示该节点指向的节点,另一个表示指向该节点的节点。

图的基本概念及基本操作

图的基本概念及基本操作
U 显然,简单路径中不含回路。
12
8.子图/生成图
若某图G'的结点集合与边集合分别是另一图 G的结点集 合和边集合的子集,则称G'为G的子图(Subgraph)。
设有两个图G与G',若它们的结点集合相同,但G'的边 集合是 G 的边集合的子集,则称 G' 是 G 的生成图 (Spanning Graph)。
7
3.结点、边、弧
图中的数据元素称为结点(或顶点) (vertice/node/point),有时为了强调,对有向图, 称<x,y>为弧(arc),x与y分别为弧尾与弧头,或始 点与终点,称y为x的出点/可达邻接点,称x为y的 入点称<x, y>为x的出边/出弧,<x, y>
为y的入边/入弧。对无向图,
7.路径(通路)
对有向图,若存在弧序列
<x0,x1>,<x1,x2>,…,<xn-1,xn> 且n≥1,则称从x0到xn有通路(路径)(Path)。上列序列称 为x0到xn的路径。该路径也可表示为 (x0, x1, … ,xn)
11
对无向图,若有边序列
(x0,x1),(x1,x2),…,(xn-1,xn) 且n≥1,则称x0与xn之间有路径(通路),该路径可用上
多个后继,结点是一些具体对象的抽象,而边是对 象间的关系的抽象。值得注意的是,与一般意义下 的图不同,这里的图只涉及图的拓扑结构,与图的 几何性质无关。图论重点讨论图的数学性质,而这
里的重点是图结点间的关系以及图的存贮结构与基
本操作的实现。图是一种复杂的非线性结构,它有 极强的表达能力,现实世界中许多问题均可用图结 构描述。
4

图的基本操作实验报告

图的基本操作实验报告

图的基本操作实验报告图的基本操作实验报告一、引言图是计算机科学中常用的数据结构之一,它由节点和边组成,用于表示事物之间的关系。

图的基本操作是对图进行增、删、改、查等操作,本实验旨在通过编程实现图的基本操作,加深对图的理解。

二、实验目的1. 理解图的基本概念和表示方法;2. 掌握图的基本操作,包括节点的插入、删除,边的添加、删除等;3. 运用图的基本操作解决实际问题。

三、实验方法本实验使用Python编程语言实现图的基本操作。

首先,定义图类,包括图的初始化、节点的插入、删除,边的添加、删除等方法。

然后,根据实际需求设计测试用例,验证图的基本操作的正确性。

四、实验过程1. 图的初始化在图类的初始化方法中,创建一个空的字典用于存储节点和边的信息。

节点用唯一的标识符表示,边用包含两个节点标识符的元组表示。

2. 节点的插入编写节点插入方法,接收节点标识符作为参数,将节点添加到图中。

在添加节点时,需要判断节点是否已存在于图中,如果存在则不进行插入操作。

3. 节点的删除编写节点删除方法,接收节点标识符作为参数,将节点从图中删除。

在删除节点时,需要同时删除与该节点相关的边。

4. 边的添加编写边添加方法,接收两个节点标识符作为参数,将边添加到图中。

在添加边时,需要判断节点是否存在于图中,如果不存在则先进行节点的插入操作。

5. 边的删除编写边删除方法,接收两个节点标识符作为参数,将边从图中删除。

在删除边时,需要判断边是否存在于图中。

6. 测试用例设计设计多个测试用例,包括插入节点、删除节点、添加边、删除边等操作,并验证操作的正确性。

七、实验结果经过多次测试,图的基本操作均能正常运行,符合预期结果。

通过图的基本操作,可以方便地对图进行增、删、改、查等操作,解决实际问题。

八、实验总结通过本次实验,我深入理解了图的基本概念和表示方法,并掌握了图的基本操作。

图作为一种重要的数据结构,在计算机科学中有着广泛的应用,例如社交网络分析、路线规划等领域。

数据结构常用操作

数据结构常用操作

数据结构常用操作数据结构是计算机科学中的关键概念,它是组织和管理数据的方法。

常用的数据结构包括数组、链表、树、图和队列等。

在实际的编程中,我们经常需要对数据结构进行一些操作,如添加、删除和查找等。

以下是一些常用的数据结构操作。

1.添加元素:将新元素插入到数据结构中。

对于数组,可以通过在指定索引位置赋值来添加元素。

对于链表,可以通过创建新节点并调整指针来实现。

对于树和图,可以添加新节点或边来扩展结构。

2.删除元素:从数据结构中移除指定元素。

对于数组,可以通过将元素设置为特定值来删除。

对于链表,可以遍历链表并删除匹配的节点。

对于树和图,可以删除指定节点或边。

3.查找元素:在数据结构中指定元素。

对于有序数组,可以使用二分查找来提高效率。

对于链表,可以遍历链表并比较每个节点的值。

对于树和图,可以使用深度优先(DFS)或广度优先(BFS)等算法进行查找。

4.遍历元素:按照其中一种顺序遍历数据结构中的所有元素。

对于数组和链表,可以使用循环来遍历每个元素。

对于树,可以使用先序、中序或后序遍历来访问每个节点。

对于图,可以使用DFS或BFS来遍历每个节点。

5.排序元素:对数据结构中的元素进行排序。

对于数组,可以使用快速排序、归并排序等常用算法。

对于链表,可以使用插入排序或选择排序等算法。

对于树和图,可以使用DFS或BFS进行遍历并将元素排序。

6.查找最小/最大值:在数据结构中查找最小或最大值。

对于有序数组,最小值在索引0的位置。

对于链表,可以遍历链表并比较每个节点的值。

对于树,可以遍历树的左子树或右子树来找到最小或最大值。

7.合并数据结构:将两个数据结构合并成一个。

对于有序数组,可以先将两个数组合并成一个,然后再排序。

对于链表,可以将一个链表的尾节点连接到另一个链表的头节点。

对于树和图,可以将两个结构合并成一个,保持其关系。

8.拆分数据结构:将一个数据结构拆分成多个。

对于有序数组,可以根据一些值将数组拆分为两个子数组。

数据结构——图

数据结构——图

数据结构——图图是一种重要的数据结构,它以顶点和边的方式来表示数据之间的关系。

在计算机科学和信息技术领域,图被广泛应用于解决各种问题,如网络路由、社交网络分析和数据挖掘等。

本文将介绍图的基本概念、表示方法和常见算法,以及图在实际应用中的一些案例。

一、图的基本概念图是由顶点集合和边集合组成的有序对,用G=(V,E)表示,其中V表示顶点集合,E表示边集合。

图可以分为有向图和无向图两种类型,有向图的边具有方向性,无向图的边没有方向性。

1. 顶点(Vertex):图中的一个元素,可以用来表示某个实体。

2. 边(Edge):顶点之间的连接关系,可以用来表示实体之间的关联。

3. 路径(Path):在图中顶点之间经过的一系列边和顶点构成的序列。

4. 环(Cycle):在图中由一个顶点开始经过若干边后再回到该顶点的路径。

5. 连通图(Connected Graph):图中任意两个顶点之间存在路径。

二、图的表示方法图可以使用邻接矩阵和邻接表两种方式进行表示。

1. 邻接矩阵:邻接矩阵是一个二维数组,其中数组元素表示顶点之间的边,若两个顶点之间存在边,则对应元素为1或权重值,否则为0或无穷大。

2. 邻接表:邻接表由一个顶点数组和一个边链表组成,顶点数组存储顶点的信息,边链表存储每个顶点的邻接顶点。

三、常见图算法图的常见算法包括深度优先搜索(DFS)和广度优先搜索(BFS)、最短路径算法(Dijkstra算法和Floyd算法)以及最小生成树算法(Prim算法和Kruskal算法)等。

1. 深度优先搜索(DFS):从图的一个顶点出发,沿着一条路径一直深入直到没有未访问过的邻接顶点,然后返回并查找其他路径。

DFS 可以用于查找连通图中的所有顶点以及判断图中是否存在环等。

2. 广度优先搜索(BFS):从图的一个顶点出发,首先访问其所有邻接顶点,然后按照相同的方式访问每个邻接顶点的邻接顶点,直到所有顶点都被访问。

BFS可以用于查找最短路径、拓扑排序以及解决迷宫等问题。

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

数据结构实验 图的邻接表和邻接矩阵操作
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.邻接矩阵存储结构邻接矩阵是使用二维数组表示数据结构图的存储结构。

数组的行和列分别代表数据结构图中的顶点,矩阵中的元素表示对应顶点之间的关系。

例如,如果顶点i和顶点j之间存在边,则邻接矩阵中(i,j)位置的元素为1;否则为0。

邻接矩阵的优点是可以快速判断两个顶点之间是否存在边,但缺点是当图中顶点较多时,矩阵中大部分元素为0,造成空间浪费。

2.邻接表存储结构邻接表是使用链表表示数据结构图的存储结构。

每个顶点对应一个链表,链表中的节点表示与该顶点直接相连的其他顶点。

顶点的链表可以使用数组或链表等数据结构来表示。

邻接表的优点是可以有效地利用存储空间,只存储存在边的关系,不存储无关边的信息。

但缺点是判断两个顶点之间是否存在边需要遍历链表,时间复杂度较高。

二、数据结构图的基本操作1.创建数据结构图创建数据结构图的操作是初始化一个空的图结构,可以选择使用邻接矩阵或邻接表存储结构。

根据实际需求,可以根据顶点和边的信息逐个添加到图结构中。

2.添加顶点添加顶点是向数据结构图中增加一个新的顶点,可以根据实际需求给顶点赋予相应的值或标识。

添加顶点的操作需要更新邻接矩阵或邻接表的相应位置。

3.添加边添加边是在两个已存在的顶点之间建立连接关系。

根据实际需求,可以指定边的权重或其他属性。

添加边的操作需要更新邻接矩阵或邻接表的相应位置。

4.删除顶点删除顶点是将一个存在的顶点从图结构中移除,同时将与该顶点相关的边也一并删除。

删除顶点的操作需要更新邻接矩阵或邻接表的相应位置。

5.删除边删除边是在两个已存在的顶点之间断开连接关系。

删除边的操作需要更新邻接矩阵或邻接表的相应位置。

6.查找顶点查找顶点是根据给定的值或标识在图结构中查找相应的顶点。

数据结构考研讲义 第五章 图

数据结构考研讲义	第五章	图

第四章图4.1图的概念1.图的定义图是由一个顶点集V和一个弧集R构成的数据结构。

2.图的重要术语;(1)无向图:在一个图中,如果任意两个顶点构成的偶对(v,w)∈E是无序的,即顶点之间的连线是没有方向的,则称该图为无向图。

(2)有向图:在一个图中,如果任意两个顶点构成的偶对(v,w)∈E是有序的,即顶点之间的连线是有方向的,则称该图为有向图。

(3)无向完全图:在一个无向图中,如果任意两顶点都有一条直接边相连接,则称该图为无向完全图。

在一个含有n个顶点的无向完全图中,有n(n-1)/2条边。

(4)有向完全图:在一个有向图中,如果任意两顶点之间都有方向互为相反的两条弧相连接,则称该图为有向完全图。

在一个含有n个顶点的有向完全图中,有n(n-1)条边。

(5)稠密图、稀疏图:若一个图接近完全图,称为稠密图;称边数很少(e<nlogn)的图为稀疏图。

(6)顶点的度、入度、出度:顶点的度(degree)是指依附于某顶点v的边数,通常记为TD(v)。

在有向图中,要区别顶点的入度与出度的概念。

顶点v的入度是指以顶点为终点的弧的数目,记为ID(v);顶点v出度是指以顶点v为始点的弧的数目,记为OD(v)。

TD(v)=ID(v)+OD(v)。

(7)边的权、网图:与边有关的数据信息称为权(weight)。

在实际应用中,权值可以有某种含义。

边上带权的图称为网图或网络(network)。

如果边是有方向的带权图,则就是一个有向网图。

(8)路径、路径长度:顶点vp到顶点vq之间的路径(path)是指顶点序列vp,vi1,vi2,…,vim,vq.。

其中,(vp,vi1),(vi1,vi2),…,(vim,.vq)分别为图中的边。

路径上边的数目称为路径长度。

(9)简单路径、简单回路:序列中顶点不重复出现的路径称为简单路径。

除第一个顶点与最后一个顶点之外,其他顶点不重复出现的回路称为简单回路,或者简单环。

(10)子图:对于图G=(V,E),G’=(V’,E’),若存在V’是V的子集,E’是E的子集,则称图G’是G的一个子图。

数据结构程序设计

数据结构程序设计

数据结构程序设计数据结构,是指在计算机科学中,用于存储、管理和操作数据的方法。

数据结构直接影响程序的效率和质量,因此在程序设计中起着非常重要的作用。

本文将从数据结构的定义、基本操作、常见数据结构及其应用等方面进行阐述,希望能够为读者提供有帮助的指导和提示。

一、数据结构的定义数据结构是指在计算机上组织和存储数据的方式,它关心的是数据如何在计算机中进行处理和组织。

数据结构常见的类型包括数组、链表、队列、栈、树、图等。

不同的数据结构适用于不同的数据场景,可以提高程序的实现效率和性能。

二、数据结构的基本操作数据结构的基本操作包括插入、删除、查找、修改等。

这些操作是数据结构的基石,实现它们可以方便地对数据进行增删改查操作。

比如,在数组中查找某个元素时,需要对数组中的每个元素进行遍历来找到匹配的元素,这是一个时间复杂度为O(n)的操作,而在二叉搜索树中查找元素则可以通过树的结构在O(log n)的时间内完成查找。

三、常见数据结构及其应用1. 数组数组是最基本的数据结构之一,可以用来存储一系列相同类型的元素。

它的优点是访问速度快,但插入、删除等操作会很慢。

数组的应用广泛,比如在排序算法中可以用来存储待排序数据、在图像处理中可以用来存储像素信息等。

2. 链表链表是由一系列节点组成的数据结构,每个节点包括数据和指向下一个节点的指针。

它的优点是插入、删除等操作会很快,但访问速度比数组慢。

链表的应用包括在嵌入式设备中存储数据、在编译器中构建语法分析树等。

3. 栈栈是一种基于后进先出(LIFO)原则的数据结构。

它的操作包括压栈、出栈等。

栈的优点是它的内存分配和释放更加高效,常用于递归算法中以及表达式求值中。

4. 队列队列是一种基于先进先出(FIFO)原则的数据结构,只允许在队列的前端进行删除操作,在队列的后端进行插入操作。

队列的应用包括在操作系统中进行进程调度等。

5. 树树是由节点和指向自己子树的指针组成的分层结构,其中最顶层的节点称为根节点。

2024版《数据结构图》ppt课件

2024版《数据结构图》ppt课件
重要性
良好的数据结构可以带来更高的运 行或存储效率,是算法设计的基础, 对程序设计的成败起到关键作用。
常见数据结构类型介绍
线性数据结构
如数组、链表、栈、队 列等,数据元素之间存
在一对一的关系。
树形数据结构
如二叉树、多叉树、森 林等,数据元素之间存
在一对多的关系。
图形数据结构
由顶点和边组成,数据 元素之间存在多对多的
队列定义、特点及应用场景
队列的特点 只能在队尾进行插入操作,队头进行删除操作。
队列是一种双端开口的线性结构。
队列定义、特点及应用场景
应用场景 操作系统的任务调度。 缓冲区的实现,如打印机缓冲区。
队列定义、特点及应用场景
广度优先搜索(BFS)。
消息队列和事件驱动模型。
串定义、基本操作及实现方法
最短路径问题 求解图中两个顶点之间的最短路径,即路径上边 的权值之和最小。
3
算法介绍 Prim算法、Kruskal算法、Dijkstra算法、Floyd 算法等。
拓扑排序和关键路径问题探讨
拓扑排序
对有向无环图(DAG)进行排序, 使得对每一条有向边(u,v),均有
u在v之前。
关键路径问题
求解有向无环图中从源点到汇点 的最长路径,即关键路径,它决
遍历二叉树和线索二叉树
遍历二叉树
先序遍历、中序遍历和后序遍历。遍历算 法可以采用递归或非递归方式实现。
VS
线索二叉树
利用二叉链表中的空指针来存放其前驱结 点和后继结点的信息,使得在遍历二叉树 时可以利用这些线索得到前驱和后继结点, 从而方便地遍历二叉树。
树、森林与二叉树转换技巧
树转换为二叉树
加线、去线、层次调整。将树中的每个结点的所有孩子结点用线连接起来,再去掉与原结点相连的线,最后 将整棵树的层次进行调整,使得每个结点的左子树为其第一个孩子,右子树为其兄弟结点。

图的定义和基本操作

图的定义和基本操作
数据结构
图的定义和基本操作
一、图的定义 二、图的基本术语 三、图的基本操作
一、图的定义
图(Graph)是由顶点的有限集合和描述顶点关系的有限集合组成的。
G=(V, R)
V是图G中顶点的有限
V={v0, v1, v2, …, vn}
ห้องสมุดไป่ตู้
集合,称为顶点集
R={VR}
VR={<vi, vj> | vi, vj∈V且P(vi, vj)}
⑧ InsertVex (G, v):图G存在,在G中增加一个新顶点v。 ⑨ DeleteVex (G, v):图G存在,v是G中某个顶点,删除顶点v及其相关 联的弧。 ⑩ InsertArc (G, v, w):图G存在,v和w是G中两个顶点,在G中增加一条 从顶点v到顶点w的弧或边。 ⑪ DeleteArc (G, v, w):图G存在,v和w是G中两个顶点,删除G中从顶 点v到顶点w的弧或边。
⑫ DFSTraverse (G):图G存在,对G进行深度优先遍历。
⑬ BFSTraverse (G):图G存在,对G进行广度优先遍历。
数据结构
生成树
三、图的基本操作
① CreateGraph (G):构造图G。 ② DestoryGraph (G):图G存在,销毁图G。 ③ LocateVex (G, v):图G存在,若图G中存在顶点v,则返回顶点v在图 中的位置;否则返回0。 ④ GetVex (G, v):图G存在,v是G中某个顶点,返回v的值。 ⑤ PutVex (G, v, value):图G存在,v是G中某个顶点,将value值赋给v。 ⑥ FirstAdjVex (G, v):图G存在,v是G中某个顶点,返回v的第一个邻接 点;若v无邻接点,则返回空。 ⑦ NextAdjVex (G, v, w):图G存在,v是G中某个顶点,w是v的邻接顶点, 返回v的(相对于w的)下一个邻接顶点;若w是v的最后一个邻接顶点, 则返回空。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

- .1.实验题目图的基本操作2.实验目的1)掌握图的邻接矩阵、邻接表的表示方法。

2)掌握建立图的邻接矩阵的算法。

3)掌握建立图的邻接表的算法。

4)加深对图的理解,逐步培养解决实际问题的编程能力3.需求分析(1)编写图基本操作函数。

①建立图的邻接表,邻接矩阵Create_Graph( LGraph lg. MGraph mg )②邻接表表示的图的递归深度优先遍历LDFS( LGraph g, int i )③邻接矩阵表示的图的递归深度优先遍历MDFS( MGraph g,int i, int vn )④邻接表表示的图的广度优先遍历LBFS( LGraph g, int s, int n )⑤邻接矩阵表示的图的广度优先遍历MBFS(MGraph g, int s, int n )(2)调用上述函数实现下列操作。

①建立一个图的邻接矩阵和图的邻接表。

②采用递归深度优先遍历输出图的邻接矩阵③采用递归深度优先遍历输出图的邻接表。

④采用图的广度优先调历输出图的邻接表。

⑤采用图的广度优先遍历输出图的邻接矩阵4.概要设计(1):/**********************************图的基本操作**********************************///------------------------------- 邻接矩阵数据类型的定义--------------------------------// 最大顶点个数typedef struct{char vexs[MAX_VERTEX_NUM]; // 顶点向量int acrs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵int vexnum,arum; // 图当前顶点数和弧数}MGraph ;//--------------------------------邻接表数据类型的定义---------------------------------- typedef struct Arode{int adjvex;// 该弧所指向的顶点的位置struct Arode *nextarc;// 指向下一条弧的指针}Arode;typedef struct VNode { char data;// 顶点信息Arode *firstarc;// 指向第一条依附该顶点的弧的指针}VNode, AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices;int vexnum,arum;// 图当前顶点数和弧数}LGraph;(2) 本程序主要包含6个函数:• 主函数main()• 建立图的邻接矩阵,邻接表Create_Graph() • 邻接表表示的图的递归深度优先遍历LDFS() • 邻接矩阵表示的图的递归深度优先遍历 MDFS()• 邻接表表示的图的广度优先遍历LBFS() • 邻接矩阵表示的图的广度优先遍历MBFS () 各函数间调用关系如下:(3) 主函数的伪码main(){ 定义邻接矩阵和邻接表;建立邻接矩阵和邻接表; 邻接矩阵MDFS 深度优先遍历;mainCreate_Graph () LDFS () MDFS () LBFS () MBFS ()邻接矩阵MBFS广度优先遍历;邻接表LDFS深度优先遍历;邻接表LBFS广度优先遍历}5详细设计/**********************************图的基本操作**********************************///------------------------------- 邻接矩阵数据类型的定义--------------------------------// 最大顶点个数typedef struct{char vexs[MAX_VERTEX_NUM]; // 顶点向量int acrs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵int vexnum,arum; // 图当前顶点数和弧数}MGraph ;//--------------------------------邻接表数据类型的定义---------------------------------- typedef struct Arode{int adjvex; // 该弧所指向的顶点的位置struct Arode *nextarc; // 指向下一条弧的指针}Arode;typedef struct VNode{char data; // 顶点信息Arode *firstarc; // 指向第一条依附该顶点的弧的指针}VNode, AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arum; // 图当前顶点数和弧数}LGraph;int Create_Graph( MGraph *Mg , LGraph *Lg ) // 建立图的邻接矩阵,邻接表{输入图的顶点个数(字符),构造顶点向量输入图的任意两个顶点的弧构造邻接矩阵构造邻接表}void LDFS(LGraph *Lg,int i) 邻接表表示的图的递归深度优先遍历{显示顶点向量,指针指向下一个顶点向量下一个顶点没有被访问,继续否则退会上一个顶点向量的另一个边}void MDFS(MGraph *Mg,int i)邻接矩阵表示的图的递归深度优先遍历{显示顶点向量,指针指向下一个顶点向量下一个顶点没有被访问,继续否则退会上一个顶点向量的另一个边}void LBFS( LGraph *Lg )邻接表表示的图的广度优先遍历{初始化visited[]初始化队列没被访问过显示顶点向量入队出队访问下一个顶点向量}void MBFS(MGraph *Mg )邻接矩阵表示的图的广度优先遍历{初始化visited[]初始化队列没被访问过显示顶点向量入队出队访问下一个顶点向量}//-------------------主函数------------------------------- main(){ 定义邻接矩阵和邻接表;建立邻接矩阵和邻接表;邻接矩阵MDFS深度优先遍历;邻接矩阵MBFS广度优先遍历;邻接表LDFS深度优先遍历;邻接表LBFS广度优先遍历}6测试结果7. 参考文献《数据结构》8.附录#include <stdio.h>#include <malloc.h>#include <stddef.h>#include <math.h>#define OK 1#define ERROR 0#define MAX_VERTEX_NUM 20/**********************************图的基本操作**********************************/int visited[MAX_VERTEX_NUM]; // 访问标志数组//------------------------------- 邻接矩阵数据类型的定义-------------------------------- // 最大顶点个数typedef struct{char vexs[MAX_VERTEX_NUM]; // 顶点向量int acrs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵int vexnum,arum; // 图当前顶点数和弧数}MGraph ;//--------------------------------邻接表数据类型的定义----------------------------------typedef struct Arode{int adjvex; // 该弧所指向的顶点的位置struct Arode *nextarc; // 指向下一条弧的指针}Arode;typedef struct VNode{char data; // 顶点信息Arode *firstarc; // 指向第一条依附该顶点的弧的指针}VNode, AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arum; // 图当前顶点数和弧数}LGraph;//_________________________________队列函数__________________________________________ typedef struct Queue{int arry[MAX_VERTEX_NUM];int front,rear;}Queue;Queue Q;void InitQueue() // 队列初始化{Q.front=Q.rear=0;}int QueueEmpty(Queue *Q) // 清空队列{if(Q->front==Q->rear)return 1;elsereturn 0;}void EnQueue(Queue *Q,int w)// 入队{if((Q->rear+1)%MAX_VERTEX_NUM==Q->front)printf("Error!");else{Q->arry[Q->rear]=w;Q->rear=(Q->rear+1)%MAX_VERTEX_NUM;}}int DeQueue(Queue *Q) // 出队{int u;if(Q->front==Q->rear)return -1;u=Q->front;Q->front=(Q->front+1)%MAX_VERTEX_NUM;return u;}//____________________________________队列函数end_______________________________________ /**************************************************************************************** *函数:Create_Graph*功能:建立图的邻接矩阵,邻接表*说明:该构建的为无向网mg 为邻接矩阵,lg为邻接表, 无权值***************************************************************************************/ int Locatevex(MGraph *Mg , char v) // 确定v 元素在Mg中的位置{int i;for(i=0;Mg->vexs[i]!=v;i++);if(i>Mg->vexnum) // 输入的元素不正确则显示错误printf("ERROR ");return i; // 返回位置}int Create_Graph( MGraph *Mg , LGraph *Lg ) // 建立图的邻接矩阵,邻接表{int i , j , k ;char v1 , v2 ;Arode *q,*p;printf("输入图的顶点数和弧数: ");scanf("%d %d",&Mg->vexnum,&Mg->arum);getchar();Lg->vexnum=Mg->vexnum; // 邻接表的顶点数和弧数Lg->arum=Mg->arum;for(i=0;i<Mg->vexnum;i++) // 构造顶点向量{printf("请输入一个图的顶点(字符):");scanf("%c" , &Mg->vexs[i]);getchar();Lg->vertices[i].data=Mg->vexs[i]; // 赋值Lg->vertices[i].firstarc=NULL; // 指向第一条依附该顶点的弧的指针为空}for(i=0;i<Mg->vexnum;i++) // 初始化邻接矩阵for(j=0;j<Mg->vexnum;j++)Mg->acrs[i][j]=0 ;for(k=0;k<Mg->arum;k++) // 构造邻接矩阵和邻接表{printf("请输入一条边连接的2个顶点:");scanf("%c %c",&v1,&v2);getchar();i=Locatevex(Mg,v1); // 确定v1 在Mg 中的位置j=Locatevex(Mg,v2); // 确定v2 在Mg 中的位置Mg->acrs[j][i]=Mg->acrs[i][j]=1; // 置《v1,v2》的对称弧《v2,v1》p=(Arode *)malloc(sizeof(Arode));p->adjvex=i; // 确认顶点位置p->nextarc=Lg->vertices[j].firstarc;// 指向下一条弧的指针Lg->vertices[j].firstarc=p; // 赋值q=(Arode *)malloc(sizeof(Arode));q->adjvex=j; // 确认顶点位置q->nextarc=Lg->vertices[i].firstarc;// 指向下一条弧的指针Lg->vertices[i].firstarc=q; // 赋值}return OK ;}/**************************************************************************************** *函数:LDFS*功能:邻接表表示的图的递归深度优先遍历*说明:***************************************************************************************/ int LAdjVex(LGraph *Lg,int k) // 位置{Arode *p;for(p=Lg->vertices[k].firstarc;p!=NULL;p=p->nextarc)if(!visited[p->adjvex])return p->adjvex;return -1;}void LDFS(LGraph *Lg,int i){int k;visited[i]=OK;printf("%c",Lg->vertices[i].data);for(k=LAdjVex(Lg,i);k>=0;k=LAdjVex(Lg,k))if(!visited[k])LDFS(Lg,k);}/**************************************************************************************** *函数:MDFS*功能:邻接矩阵表示的图的递归深度优先遍历*说明:***************************************************************************************/ int AdjVes(MGraph *Mg,int k) // 位置{int i;for(i=0;i<Mg->vexnum;i++)if(Mg->acrs[k][i]&&(!visited[i]))return i;return -1;}void MDFS(MGraph *Mg,int i) // 递归深度优先遍历{int k;visited[i]=1; // 访问标志数组某位置1printf("%c",Mg->vexs[i]); // 显示for(k=AdjVes(Mg,i);k>=0;k=AdjVes(Mg,k))if(!visited[k])MDFS(Mg,k); // 递归}/**************************************************************************************** *函数:LBFS*功能:邻接表表示的图的广度优先遍历*说明:***************************************************************************************/void LBFS( LGraph *Lg ){int i,u,w;for(i=0;i<Lg->vexnum;++i) // 初始化visited[]visited[i]=0;InitQueue(); // 初始化队列for(i=0;i<Lg->vexnum;++i)if(!visited[i]) // 没被访问过{visited[i]=1;printf("%c",Lg->vertices[i].data);EnQueue(&Q,i); // 入队while(!QueueEmpty(&Q)){u=DeQueue(&Q); // 出队for(w=LAdjVex(Lg,u);w>=0;w=LAdjVex(Lg,u))if(!visited[w]) // 没被访问过{visited[w]=1;printf("%c",Lg->vertices[w].data);EnQueue(&Q,w); // 入队}}}}/**************************************************************************************** *函数:MBFS*功能:邻接矩阵表示的图的广度优先遍历*说明:***************************************************************************************/ void MBFS(MGraph *Mg ){int i,w,u;for(i=0;i<Mg->vexnum;i++) // 初始化visited[]visited[i]=0;InitQueue(); // 初始化队列for(i=0;i<Mg->vexnum;++i)if(!visited[i]) // 没被访问过{visited[i]=1;printf("%c",Mg->vexs[i]); // 显示EnQueue(&Q,i); // 入队while(!QueueEmpty(&Q)){u=DeQueue(&Q); // 出队for(w=AdjVes(Mg,u);w>=0;w=AdjVes(Mg,u))if(!visited[w]) // 没被访问过{visited[w]=1;printf("%c",Mg->vexs[w]);// 显示EnQueue(&Q,w); // 入队}}}}/***************************************主函数*******************************************/void main(){int i ;MGraph Mg;LGraph Lg;Create_Graph( &Mg, &Lg);printf("邻接矩阵MDFS深度优先遍历:\t");for(i=0;i<Mg.vexnum;i++)visited[i]=0; // 初始化visited[]for(i=0;i<Mg.vexnum;i++)if(!visited[i])MDFS(&Mg,i); // 遍历Mgprintf("\n邻接矩阵MBFS广度优先遍历:\t");MBFS(&Mg) ; // 遍历Mgprintf("\n");printf("邻接表LDFS深度优先遍历:\t");for(i=0;i<Lg.vexnum;++i)visited[i]=0; // 初始化visited[]for(i=0;i<Lg.vexnum;++i)if(!visited[i])LDFS(&Lg,i); // 遍历Lgprintf("\n邻接表LBFS广度优先遍历:\t");LBFS(&Lg) ; // 遍历Lgprintf("\n");}}注意事项:●每位同学必须完成实验任务,并提交实验报告。

相关文档
最新文档