图的建立与遍历实验报告
图的遍历 实验报告
![图的遍历 实验报告](https://img.taocdn.com/s3/m/3226a34377c66137ee06eff9aef8941ea66e4b70.png)
图的遍历实验报告一、引言图是一种非线性的数据结构,由一组节点(顶点)和节点之间的连线(边)组成。
图的遍历是指按照某种规则依次访问图中的每个节点,以便获取或处理节点中的信息。
图的遍历在计算机科学领域中有着广泛的应用,例如在社交网络中寻找关系紧密的人员,或者在地图中搜索最短路径等。
本实验旨在通过实际操作,掌握图的遍历算法。
在本实验中,我们将实现两种常见的图的遍历算法:深度优先搜索(DFS)和广度优先搜索(BFS),并比较它们的差异和适用场景。
二、实验目的1. 理解和掌握图的遍历算法的原理与实现;2. 比较深度优先搜索和广度优先搜索的差异;3. 掌握图的遍历算法在实际问题中的应用。
三、实验步骤实验材料1. 计算机;2. 编程环境(例如Python、Java等);3. 支持图操作的相关库(如NetworkX)。
实验流程1. 初始化图数据结构,创建节点和边;2. 实现深度优先搜索算法;3. 实现广度优先搜索算法;4. 比较两种算法的时间复杂度和空间复杂度;5. 比较两种算法的遍历顺序和适用场景;6. 在一个具体问题中应用图的遍历算法。
四、实验结果1. 深度优先搜索(DFS)深度优先搜索是一种通过探索图的深度来遍历节点的算法。
具体实现时,我们可以使用递归或栈来实现深度优先搜索。
算法的基本思想是从起始节点开始,选择一个相邻节点进行探索,直到达到最深的节点为止,然后返回上一个节点,再继续探索其他未被访问的节点。
2. 广度优先搜索(BFS)广度优先搜索是一种逐层遍历节点的算法。
具体实现时,我们可以使用队列来实现广度优先搜索。
算法的基本思想是从起始节点开始,依次遍历当前节点的所有相邻节点,并将这些相邻节点加入队列中,然后再依次遍历队列中的节点,直到队列为空。
3. 时间复杂度和空间复杂度深度优先搜索和广度优先搜索的时间复杂度和空间复杂度如下表所示:算法时间复杂度空间复杂度深度优先搜索O(V+E) O(V)广度优先搜索O(V+E) O(V)其中,V表示节点的数量,E表示边的数量。
图的遍历操作实验报告
![图的遍历操作实验报告](https://img.taocdn.com/s3/m/d4f076551611cc7931b765ce0508763230127443.png)
-实验三、图的遍历操作一、目的掌握有向图和无向图的概念;掌握邻接矩阵和邻接链表建立图的存储构造;掌握DFS及BFS对图的遍历操作;了解图构造在人工智能、工程等领域的广泛应用。
二、要求采用邻接矩阵和邻接链表作为图的存储构造,完成有向图和无向图的DFS 和BFS操作。
三、DFS和BFS 的根本思想深度优先搜索法DFS的根本思想:从图G中*个顶点Vo出发,首先访问Vo,然后选择一个与Vo相邻且没被访问过的顶点Vi访问,再从Vi出发选择一个与Vi相邻且没被访问过的顶点Vj访问,……依次继续。
如果当前被访问过的顶点的所有邻接顶点都已被访问,则回退到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W,从W出发按同样方法向前遍历。
直到图中所有的顶点都被访问。
广度优先算法BFS的根本思想:从图G中*个顶点Vo出发,首先访问Vo,然后访问与Vo相邻的所有未被访问过的顶点V1,V2,……,Vt;再依次访问与V1,V2,……,Vt相邻的起且未被访问过的的所有顶点。
如此继续,直到访问完图中的所有顶点。
四、例如程序1.邻接矩阵作为存储构造的程序例如#include"stdio.h"#include"stdlib.h"#define Ma*Verte*Num 100 //定义最大顶点数typedef struct{char ve*s[Ma*Verte*Num]; //顶点表int edges[Ma*Verte*Num][Ma*Verte*Num]; //邻接矩阵,可看作边表int n,e; //图中的顶点数n和边数e}MGraph; //用邻接矩阵表示的图的类型//=========建立邻接矩阵=======void CreatMGraph(MGraph *G){int i,j,k;char a;printf("Input Verte*Num(n) and EdgesNum(e): ");scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数scanf("%c",&a);printf("Input Verte* string:");for(i=0;i<G->n;i++){scanf("%c",&a);G->ve*s[i]=a; //读入顶点信息,建立顶点表}for(i=0;i<G->n;i++)for(j=0;j<G->n;j++)G->edges[i][j]=0; //初始化邻接矩阵printf("Input edges,Creat Adjacency Matri*\n");for(k=0;k<G->e;k++) { //读入e条边,建立邻接矩阵 scanf("%d%d",&i,&j); //输入边〔Vi,Vj〕的顶点序号G->edges[i][j]=1;G->edges[j][i]=1; //假设为无向图,矩阵为对称矩阵;假设建立有向图,去掉该条语句}}//=========定义标志向量,为全局变量=======typedef enum{FALSE,TRUE} Boolean;Boolean visited[Ma*Verte*Num];//========DFS:深度优先遍历的递归算法======void DFSM(MGraph *G,int i){ //以Vi为出发点对邻接矩阵表示的图G进展DFS搜索,邻接矩阵是0,1矩阵 int j;printf("%c",G->ve*s[i]); //访问顶点Vivisited[i]=TRUE; //置已访问标志for(j=0;j<G->n;j++) //依次搜索Vi的邻接点if(G->edges[i][j]==1 && ! visited[j])DFSM(G,j); //〔Vi,Vj〕∈E,且Vj未访问过,故Vj为新出发点}void DFS(MGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)if(!visited[i]) //Vi未访问过DFSM(G,i); //以Vi为源点开场DFS搜索}//===========BFS:广度优先遍历=======void BFS(MGraph *G,int k){ //以Vk为源点对用邻接矩阵表示的图G进展广度优先搜索 int i,j,f=0,r=0;int cq[Ma*Verte*Num]; //定义队列for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)cq[i]=-1; //队列初始化printf("%c",G->ve*s[k]); //访问源点Vkvisited[k]=TRUE;cq[r]=k; //Vk已访问,将其入队。
图的遍历的实验报告
![图的遍历的实验报告](https://img.taocdn.com/s3/m/0891cf804128915f804d2b160b4e767f5acf80bf.png)
图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构,它由一组节点和连接这些节点的边组成。
图的遍历是指从图中的某个节点出发,按照一定的规则依次访问图中的所有节点。
图的遍历在许多实际问题中都有广泛的应用,例如社交网络分析、路线规划等。
本实验旨在通过实际操作,深入理解图的遍历算法的原理和应用。
二、实验目的1. 掌握图的遍历算法的基本原理;2. 实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法;3. 比较并分析DFS和BFS算法的时间复杂度和空间复杂度。
三、实验过程1. 实验环境本实验使用Python编程语言进行实验,使用了networkx库来构建和操作图。
2. 实验步骤(1)首先,我们使用networkx库创建一个包含10个节点的无向图,并添加边以建立节点之间的连接关系。
(2)接下来,我们实现深度优先搜索算法。
深度优先搜索从起始节点开始,依次访问与当前节点相邻的未访问过的节点,直到遍历完所有节点或无法继续访问为止。
(3)然后,我们实现广度优先搜索算法。
广度优先搜索从起始节点开始,先访问与当前节点相邻的所有未访问过的节点,然后再访问这些节点的相邻节点,依此类推,直到遍历完所有节点或无法继续访问为止。
(4)最后,我们比较并分析DFS和BFS算法的时间复杂度和空间复杂度。
四、实验结果经过实验,我们得到了如下结果:(1)DFS算法的时间复杂度为O(V+E),空间复杂度为O(V)。
(2)BFS算法的时间复杂度为O(V+E),空间复杂度为O(V)。
其中,V表示图中的节点数,E表示图中的边数。
五、实验分析通过对DFS和BFS算法的实验结果进行分析,我们可以得出以下结论:(1)DFS算法和BFS算法的时间复杂度都是线性的,与图中的节点数和边数呈正比关系。
(2)DFS算法和BFS算法的空间复杂度也都是线性的,与图中的节点数呈正比关系。
但是,DFS算法的空间复杂度比BFS算法小,因为DFS算法只需要保存当前路径上的节点,而BFS算法需要保存所有已访问过的节点。
图的遍历实验报告
![图的遍历实验报告](https://img.taocdn.com/s3/m/7d5ec7dc9f3143323968011ca300a6c30c22f10b.png)
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为弧的类型。
C图的创建与遍历实验报告
![C图的创建与遍历实验报告](https://img.taocdn.com/s3/m/09c06a13c8d376eeafaa31e6.png)
实验五图的遍历及其应用实现一、实验目的1.熟悉图常用的存储结构。
2.掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。
3.会用图的遍历解决简单的实际问题。
二、需求分析很多问题都是建立在图的遍历的基础上实现的,所以必须有一个程序能够实现将图进行广度和深度遍历,必须对图的所有节点进行访问。
以无向图为例,以无向图的邻接表和邻接矩阵为存储结构,分别实现对图进行广度和深度遍历。
以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应的生成树的边集。
三、实验内容[题目一] :从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。
该程序包括图类型以及每一种操作的具体的函数定义和主函数。
提示:输入示例上图的顶点和边的信息输入数据为:5 7 DGA B C D EAB AE BC CD DA DB EC四、结构算法模块:typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;五、相关函数设计Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历BFSTraverse(ALGraph G)//有向图的广度遍历,从第v个顶点出发,v为顶点下标locatevex(ALGraph G,char v)//图的基本操作,寻找顶点位置的下标DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G六、程序流程图七、运行结果截图最初程序运行界面如下:输入图的先相关信息后运行结果(其中深度优先遍历的起点选择的是字符所在序列的序号,且0是起点),一下是深度优先遍历时选择不同的起点所出现的最终运行结果:程序源代码://图的邻接表表示:#include<iostream>#include<malloc.h>#include<queue>using namespace std;# define MAX_VEX_NUM 20//宏定义数组最大int visited[MAX_VEX_NUM];//设置标志数组queue<int>q;typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;ALGraph G;//申明一个无向图的邻接矩阵类型int locatevex(ALGraph G,char v)//图的基本操作,寻找顶点位置的下标{int i=0;while(i<G.vexnum && v!=G.vertices[i].data)i++;if(i<G.vexnum)return i;}void Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示{cout<<"请输入图的顶点数和弧数:"<<endl;cin>>G.vexnum;cin>>G.arcnum;char v1;char v2;int v1locate;int v2locate;ArcNode * p;cout<<"输入图的顶点信息"<<endl;for(int i=0;i<G.vexnum;i++)//构造表头向量{cin>>G.vertices[i].data;//输入顶点值G.vertices[i].firstarc=NULL;//初始化指针}cout<<"请输入从起点到终点的一条弧所对应的顶点"<<endl; for(int k=1;k<=G.arcnum;k++)//输入各弧并创建十字链表{cin>>v1>>v2;//输入一条弧的起点和终点v1locate=locatevex(G,v1);//确定v1在图G中位置v2locate=locatevex(G,v2);//确定v2在图G中位置p=new ArcNode;//假定有足够空间p->adjvex=v2locate;//有一条弧指向v2p->nextarc=G.vertices[v1locate].firstarc;//对弧节点赋值G.vertices[v1locate].firstarc=p;//完成在入弧和出弧链表的插入/*q=new ArcNode;q->adjvex=v1locate;q->nextarc=G.vertices[v2locate].firstarc;G.vertices[v2locate].firstarc=q;*/}}//Create_DGvoid DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G {visited[v]=1;//访问第v个节点cout<<G.vertices[v].data<<" ";//输出节点值for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc){if(!visited[p->adjvex])DFS(G,p->adjvex);//对v的尚未访问的邻接顶点p递归调用dfs}}//DFSvoid DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历{for(int i = 0;i < G.vexnum;i++)visited[i]=0; //访问数组初始化DFS(G,vex); //先对图从指定定点访问for(int v = 0;v < G.vexnum;v ++) //对可能出现的子图遍历if(!visited[v]) //对尚未访问的顶点调用dfsDFS(G,v);}//DFSTraverseint BFSTraverse(ALGraph G)//无向图的广度遍历,从第v个顶点出发,v 为顶点下标{for(int i = 0;i < G.vexnum;i++) //访问数组初始化visited[i]=0;q.empty();int v;int u;for(v=0;v<G.vexnum;v++)if(!visited[v])//v尚未被访问{visited[v]=1;cout<<G.vertices[v].data<<" ";q.push(v);//V入队列while(!q.empty()){u=q.front();//对头元素出队并置为uq.pop();for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc) if(!visited[p->adjvex])//p为u的尚未访问的邻接节点{visited[p->adjvex]=1;cout<<G.vertices[p->adjvex].data<<" "; q.push(p->adjvex);}//if}//while}//ifreturn 1;}//BFSTraversevoid main(){int a;Create_DG(G);cout<<"输入图深度遍历的起点"<<endl; cin>>a;cout<<"深度优先遍历"<<endl; DFSTraverse(G,a);cout<<endl;cout<<"广度优先遍历"<<endl; BFSTraverse(G);}。
图的遍历算法实验报告
![图的遍历算法实验报告](https://img.taocdn.com/s3/m/f25b792a7f21af45b307e87101f69e314332fa0f.png)
图的遍历算法实验报告图的遍历算法实验报告一、引言图是一种常用的数据结构,用于描述事物之间的关系。
在计算机科学中,图的遍历是一种重要的算法,用于查找和访问图中的所有节点。
本实验旨在探究图的遍历算法,并通过实验验证其正确性和效率。
二、实验目的1. 理解图的基本概念和遍历算法的原理;2. 实现图的遍历算法,并验证其正确性;3. 比较不同遍历算法的效率。
三、实验方法1. 实验环境:使用Python编程语言进行实验;2. 实验步骤:a. 构建图的数据结构,包括节点和边的定义;b. 实现深度优先搜索(DFS)算法;c. 实现广度优先搜索(BFS)算法;d. 验证算法的正确性,通过给定的图进行遍历;e. 比较DFS和BFS的效率,记录运行时间。
四、实验结果1. 图的构建:我们选择了一个简单的无向图作为实验对象,包含6个节点和7条边。
通过邻接矩阵表示图的关系。
```0 1 1 0 0 01 0 1 1 0 01 1 0 0 1 10 1 0 0 0 00 0 1 0 0 00 0 1 0 0 0```2. DFS遍历结果:从节点0开始,遍历结果为0-1-2-4-5-3。
3. BFS遍历结果:从节点0开始,遍历结果为0-1-2-3-4-5。
4. 算法效率比较:我们记录了DFS和BFS算法的运行时间。
经实验发现,在这个图的规模下,DFS算法的运行时间为0.001秒,BFS算法的运行时间为0.002秒。
可以看出,DFS算法相对于BFS算法具有更高的效率。
五、讨论与分析1. 图的遍历算法能够帮助我们了解图中的节点之间的关系,有助于分析和解决实际问题。
2. DFS算法和BFS算法都可以实现图的遍历,但其遍历顺序和效率有所不同。
DFS算法会优先访问深度较大的节点,而BFS算法会优先访问离起始节点最近的节点。
3. 在实验中,我们发现DFS算法相对于BFS算法具有更高的效率。
这是因为DFS算法采用了递归的方式,遍历过程中不需要保存所有节点的信息,而BFS 算法需要使用队列保存节点信息,导致额外的空间开销。
图的遍历实验报告
![图的遍历实验报告](https://img.taocdn.com/s3/m/f3fd5eca85868762caaedd3383c4bb4cf7ecb796.png)
图的遍历实验报告图的遍历实验报告一、引言图是一种常见的数据结构,广泛应用于计算机科学和其他领域。
图的遍历是指按照一定规则访问图中的所有节点。
本实验通过实际操作,探索了图的遍历算法的原理和应用。
二、实验目的1. 理解图的遍历算法的原理;2. 掌握深度优先搜索(DFS)和广度优先搜索(BFS)两种常用的图遍历算法;3. 通过实验验证图的遍历算法的正确性和效率。
三、实验过程1. 实验环境准备:在计算机上安装好图的遍历算法的实现环境,如Python编程环境;2. 实验数据准备:选择合适的图数据进行实验,包括图的节点和边的信息;3. 实验步骤:a. 根据实验数据,构建图的数据结构;b. 实现深度优先搜索算法;c. 实现广度优先搜索算法;d. 分别运行深度优先搜索和广度优先搜索算法,并记录遍历的结果;e. 比较两种算法的结果,分析其异同点;f. 对比算法的时间复杂度和空间复杂度,评估其性能。
四、实验结果与分析1. 实验结果:根据实验数据和算法实现,得到了深度优先搜索和广度优先搜索的遍历结果;2. 分析结果:a. 深度优先搜索:从起始节点出发,一直沿着深度方向遍历,直到无法继续深入为止。
该算法在遍历过程中可能产生较长的路径,但可以更快地找到目标节点,适用于解决一些路径搜索问题。
b. 广度优先搜索:从起始节点出发,按照层次顺序逐层遍历,直到遍历完所有节点。
该算法可以保证找到最短路径,但在遍历大规模图时可能需要较大的时间和空间开销。
五、实验总结1. 通过本次实验,我们深入理解了图的遍历算法的原理和应用;2. 掌握了深度优先搜索和广度优先搜索两种常用的图遍历算法;3. 通过实验验证了算法的正确性和效率;4. 在实际应用中,我们需要根据具体问题的需求选择合适的遍历算法,权衡时间复杂度和空间复杂度;5. 进一步研究和优化图的遍历算法,可以提高算法的性能和应用范围。
六、参考文献[1] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press.[2] Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley Professional.。
【实验】数据结构图的遍历实验报告
![【实验】数据结构图的遍历实验报告](https://img.taocdn.com/s3/m/1769329cf242336c1fb95e35.png)
【关键字】实验数据结构图的遍历实验报告篇一:【数据结构】图的保存和遍历实验报告《数据结构B》实验报告系计算机与电子专业级班姓名学号XX年1 0月9日1. 上机题目:图的保存和遍历2. 详细设计#include#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define error printf#define QueueSize 30typedef struct{char vexs[GRAPHMAX];int edges[GRAPHMAX][GRAPHMAX];int n,e;}MGraph;int visited[10];typedef struct{int front,rear,count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q){Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q){return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x){if(QueueFull(Q))error("Queue overflow");else{ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;}}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){ error("Queue underflow");return NULL;}else{ temp=Q->data[Q->front]; Q->count--;Q->front=(Q->front+1)%QueueSize;return temp;}}void CreateMGraph(MGraph *G){int i,j,k;char ch1,ch2;printf("\n\t\t请输入定点数,边数并按回车(格式如:3,4):");scanf("%d,%d",&(G->n),&(G->e));for(i=0;in;i++){ getchar();printf("\n\t\t请输入第%d个定点数并按回车:",i+1);scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->edges[i][j]=0;for(k=0;ke;k++){ getchar();printf("\n\t\t请输入第%d条边的顶点序号(格式如:i,j):",k+1); scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->edges[i][j]=1;}}void DFSM(MGraph *G,int i){int j;printf("\n\t\t深度优先遍历序列:%c\n",G->vexs[i]);visited[i]=TRUE;for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) ////////////////DFSM(G,j);}void BFSM(MGraph *G,int k){ int i,j;CirQueue Q;InitQueue(&Q);printf("\n\t\t广度优先遍历序列:%c\n",G->vexs[k]);visited[k]=TRUE;EnQueue(&Q,k);while(!QueueEmpty(&Q)){ i=DeQueue(&Q);for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1){ visited[j]=TRUE;EnQueue(&Q,j);}}}void DFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) DFSM(G,i);}void BFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) BFSM(G,i);}void main(){MGraph *G,a;char ch1;int i,j,ch2;G=&a;printf("\n\t\t建立一个有向图的邻接矩阵表示\n"); CreateMGraph(G);printf("\n\t\t已建立一个有向图的邻接矩阵保存\n"); for(i=0;in;i++){ printf("\n\t\t");for(j=0;jn;j++)printf("%5d",G->edges[i][j]);}getchar();ch1='y';while(ch1=='y'||ch1=='Y'){ printf("\n");printf("\n\t\t图的保存与遍历");printf("\n\t\t********************************"); printf("\n\t\t*1-----更新邻接矩阵*");printf("\n\t\t*2-----深度优先遍历*");printf("\n\t\t*3-----广度优先遍历*");printf("\n\t\t*0-----退出*");printf("\n\t\t********************************");}} printf("\n\t\t请选择菜单号(0----3)"); scanf("%d",&ch2); getchar(); switch(ch2) { case 1:CreateMGraph(G); printf("\n\t\t图的邻接矩阵保存建立完成\n");break; case 2:DFSTraverseM(G);break; case 3:BFSTraverseM(G);break; case 0:ch1='n';break; default:printf("\n\t\t输出错误!清重新输入!"); }3. 调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?由于实习之初对邻接表的保存结构了解不是很清楚,所以在运行出了一个小错误,即在输出邻接表时,每个结点都少了一个邻接点。
实现图的遍历算法实验报告
![实现图的遍历算法实验报告](https://img.taocdn.com/s3/m/96173131182e453610661ed9ad51f01dc2815712.png)
实现图的遍历算法实验报告实现图的遍历算法实验报告⼀实验题⽬: 实现图的遍历算法⼆实验要求:2.1:(1)建⽴如图(p126 8.1)所⽰的有向图 G 的邻接矩阵,并输出之(2)由有向图G的邻接矩阵产⽣邻接表,并输出之(3)再由(2)的邻接表产⽣对应的邻接矩阵,并输出之2.2 (1)输出如图8.1所⽰的有向图G从顶点0开始的深度优先遍历序列(递归算法)(2)输出如图8.1所⽰的有向图G从顶点0开始的深度优先遍历序列(⾮递归算法)(3)输出如图8.1所⽰的有向图G从顶点0开始的⼴度优先遍历序列三实验内容:3.1 图的抽象数据类型:ADT Graph{数据对象V:V是具有相同特性的数据元素的集合,称为顶点集。
数据关系R:R={VR}VR={|v,w∈V且P(v,w),表⽰从v到w的弧,谓词P(v,w)定义了弧的意义或信息}基本操作:CreateGraph( &G, V, VR )初始条件:V是图的顶点集,VR是图中弧的集合。
操作结果:按V和VR的定义构造图G。
DestroyGraph( &G )初始条件:图G存在。
操作结果:销毁图G。
LocateVex( G, u )初始条件:图G存在,u和G中顶点有相同特征。
操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回其它信息。
GetVex( G, v )初始条件:图G存在,v是G中某个顶点。
操作结果:返回v的值。
PutVex( &G, v, value )初始条件:图G存在,v是G中某个顶点。
初始条件:图G存在,v是G中某个顶点。
操作结果:返回v的第⼀个邻接顶点。
若顶点在G中没有邻接顶点,则返回“空”。
NextAdjVex( G, v, w )初始条件:图G存在,v是G中某个顶点,w是v的邻接顶点。
操作结果:返回v的(相对于w的)下⼀个邻接顶点。
若w是v 的最后⼀个邻接点,则返回“空”。
InsertVex( &G, v )初始条件:图G存在,v和图中顶点有相同特征。
数据结构实验八、图的建立和遍历
![数据结构实验八、图的建立和遍历](https://img.taocdn.com/s3/m/2c2f56d8d5bbfd0a78567300.png)
}SqQueue;
void InitQueue(SqQueue &Q)
{Q.front =Q.rear =0;
}
int QueueEmpty(SqQueue &Q)
{if(Q.front==Q.rear) return 1;
else return 0;
}
int QueueFull(SqQueue &Q)
SqQueue Q;
InitQueue(Q); //初始化队列
cout<<"广度优先遍历序列如下:"<<endl;
if (G.Visited[Starti]==0) //尚未访问
{ G.Visited[Starti] = 1;
cout<<"访问"<<G.V[Starti]<<endl;//访问u
EnQueue(Q, Starti); // v入队列
for(k=1;k<=G1.e;k++)
{
cout<<"请输入第"<<k<<"边<<"请输入第"<<k<<"边的终点序号:";
cin>>j;
G1.E[i][j]=1;
if( G1.flag==0 ) G1.E[j][i]=G1.E[i][j];
}
cout<<"图对应的邻接矩阵如下:"<<endl;
山东英才职业技工学校实验报告
系:__计算机_____成绩_______________
实验 图的创建与遍历
![实验 图的创建与遍历](https://img.taocdn.com/s3/m/9fcb4d6258fafab069dc02e4.png)
实验八图的创建与遍历实验目的:掌握图的邻接矩阵、邻接表、十字链表和邻接多重表四种存储结构,能够实现在任意一种存储结构上的创建和遍历两种基本操作实验要求:1、认真阅读和掌握教材上和本实验相关内容和算法(见P161~170)。
2、上机将图的任意一种存储表示的创建和遍历(DFS和BFS至少实现一种)算法实现。
3、实现下面实验内容要求的功能,并能够进行简单的输入输出验证。
实验内容:1、图的创建部分编程实现图的任意一种存储表示的创建算法,要求能够进行简单的输入输出验证。
#include <iostream.h>typedef struct Graph{char vexs[10];int arc[10][10];int vexnum;int arcnum;}Graph;int locatevex(Graph G,char x){int i=0;while(G.vexs[i]!=x)i++;return i;}void creatgraph(Graph &G){int i,j,k;char v1,v2;cin>>G.vexnum>>G.arcnum;for(i=0;i<G.vexnum;i++)cin>>G.vexs[i];for(i=0;i<G.vexnum;i++)for(j=0;j<G.vexnum;j++)G.arc[i][j]=0;for(k=0;k<G.arcnum;k++){cin>>v1>>v2;i=locatevex(G,v1);j=locatevex(G,v2);G.arc[i][j]=1;G.arc[j][i]=1;}}void printgraph(Graph G){for(int i=0;i<G.vexnum;i++)cout<<G.vexs[i]<<" ";cout<<endl;for(i=0;i<G.vexnum;i++)for(int j=0;j<G.vexnum;j++){if(G.arc[i][j]==1)cout<<G.vexs[i]<<" ->"<<G.vexs[j]<<" ";}}int FirstAdjVex(Graph G,char v){ /* 初始条件: 图G存在,v是G中某个顶点*//* 操作结果: 返回v的第一个邻接顶点的序号。
实验四图的建立与遍历
![实验四图的建立与遍历](https://img.taocdn.com/s3/m/34b2152651e79b8969022686.png)
实验四数据结构图的建立与遍历实验类型:综合性实验时数: 2 学时一、实验目的1. 掌握图的基本存储方法;2. 掌握有关图的操作算法并用高级语言实现;3. 熟练掌握图的两种搜索路径的遍历方法。
二、实验设备Windows 计算机(含Visual C++ 6.0)。
三、实验原理1. 图是由若干个顶点和若干条边构成的结构,每个顶点具有任意多个前驱和后继。
顶点是一些具体对象的抽象,而边是对象间关系的抽象。
图是一种复杂的数据结构,其信息包括两部分:图中数据元素即顶点的信息,元素间的关系(顶点之间的关系)——边或者弧的信息。
2. 图的常用存储结构包括邻接矩阵存储、邻接表存储、十字链表存储以及邻接多重表存储。
3. 邻接表存储法类似于树的孩子链表表示法。
它对图中的每个顶点建立一个带头节点的线性链表,用于存储图中与顶点相邻接的边或弧的信息。
头节点中存放该顶点的信息。
所有头节点用一个顺序表存放。
4. 邻接表存储图很容易找到任一顶点的邻接点,但是要判定任意两个顶点之间是否有边或弧相连,则需搜索第i 个或第j 个链表,不及邻接矩阵方便。
四、实验内容及步骤(一)实验内容假设以一个带权有向图表示某一区域的公交线路网,图中顶点代表一些区域中的重要场所,弧代表已有的公交线路,弧上的权表示该线路上的票价(或搭乘所需时间),试设计一个交通指南系统,指导前来咨询者以最低的票价或最少的时间从区域中的某一场所到达另一场所。
(二)实验步骤1. 定义结点结构,定义图结构。
2. 存储图信息;3. 定义求任意两点最短路径函数;4. 写出主函数。
(三)实验提示typedef struct node{ int no;float wgt;struct node *next;}edgenode;typedef struct{ char vtx;edgenode *link;}vexnode;typedef vexnode Graph[n];void Floyd(Graph G, float A[n][n], int p[n][n]) {int i, j, k;for (i=0; i<n; i++)for(j=0;j<n;j++){A[i][j]=G[i][j];P[i][j]=-1;}for (k=0; k<n; k++)for (i=0; i<n; i++)for (j=0; j<n; j++) if(A[i][k] +A[k][j]<A[i][j]){P[i][j]=k;A[i][j]=A[i][k]+A[k][j]; }}五、思考题1. 判断两点是否可达。
图的遍历操作实验报告
![图的遍历操作实验报告](https://img.taocdn.com/s3/m/e9154e6c11661ed9ad51f01dc281e53a580251c4.png)
图的遍历操作实验报告一、实验目的本次实验的主要目的是深入理解图的遍历操作的基本原理和方法,并通过实际编程实现,掌握图的深度优先遍历(DepthFirst Search,DFS)和广度优先遍历(BreadthFirst Search,BFS)算法,比较它们在不同类型图中的性能和应用场景。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
实验中使用的数据结构为邻接表来表示图。
三、实验原理(一)深度优先遍历深度优先遍历是一种递归的图遍历算法。
它从起始节点开始,沿着一条路径尽可能深地访问节点,直到无法继续,然后回溯到上一个未完全探索的节点,继续探索其他分支。
(二)广度优先遍历广度优先遍历则是一种逐层访问的算法。
它从起始节点开始,先访问起始节点的所有相邻节点,然后再依次访问这些相邻节点的相邻节点,以此类推,逐层展开。
四、实验步骤(一)数据准备首先,定义一个图的邻接表表示。
例如,对于一个简单的有向图,可以使用以下方式创建邻接表:```pythongraph ={'A':'B','C','B':'D','E','C':'F','D':,'E':,'F':}```(二)深度优先遍历算法实现```pythondef dfs(graph, start, visited=None):if visited is None:visited = set()visitedadd(start)print(start)for next_node in graphstart:if next_node not in visited:dfs(graph, next_node, visited)```(三)广度优先遍历算法实现```pythonfrom collections import deque def bfs(graph, start):visited ={start}queue = deque(start)while queue:node = queuepopleft()print(node)for next_node in graphnode:if next_node not in visited:visitedadd(next_node)queueappend(next_node)```(四)测试与分析分别使用深度优先遍历和广度优先遍历算法对上述示例图进行遍历,并记录遍历的顺序和时间开销。
图的遍历数据结构实验报告
![图的遍历数据结构实验报告](https://img.taocdn.com/s3/m/0259e813905f804d2b160b4e767f5acfa1c78386.png)
图的遍历数据结构实验报告图的遍历数据结构实验报告1. 实验目的本实验旨在通过使用图的遍历算法,深入理解图的数据结构以及相关算法的运行原理。
2. 实验背景图是一种非线性的数据结构,由顶点和边组成。
图的遍历是指按照某种规则,从图中的一个顶点出发,访问图中的所有顶点且仅访问一次的过程。
3. 实验环境本次实验使用的操作系统为Windows 10,编程语言为Python3.8,使用的图数据结构库为NetworkX。
4. 实验步骤4.1 创建图首先,我们使用NetworkX库创建一个有向图。
通过调用add_nodes_from()方法添加顶点,并调用add_edge()方法添加边,构建图的结构。
4.2 深度优先搜索(DFS)接下来,我们使用深度优先搜索算法来遍历这个图。
深度优先搜索是一种递归的遍历法,从一个顶点开始,沿着深度方向访问图中的顶点,直到不能继续深入为止。
4.3 广度优先搜索(BFS)然后,我们使用广度优先搜索算法来遍历这个图。
广度优先搜索是一种先访问离起始顶点最近的顶点的遍历法,从一个顶点开始,依次访问与之相邻的顶点,直到访问完所有的顶点为止。
5. 实验结果我们根据深度优先搜索和广度优先搜索算法,分别得到了图的遍历结果。
通过实验可以观察到每种遍历方式所访问的顶点顺序以及所需的时间复杂度。
6. 结论通过本次实验,我们了解了图的遍历数据结构及相关算法的原理和实现方式。
深度优先搜索和广度优先搜索算法适用于不同的场景,可以根据具体情况选择合适的算法进行图的遍历。
附件:无附录:本文所涉及的法律名词及注释:- 图:由结点和边组成的非线性数据结构。
- 顶点:图中的每个元素都称为顶点,也称为结点。
- 边:顶点之间的连接关系称为边。
图的建立与遍历实验报告
![图的建立与遍历实验报告](https://img.taocdn.com/s3/m/5a325d2b1a37f111f1855bf5.png)
图的建立与遍历实验报告------------图的建立与遍历姓名:曹庆松班级:1104学号:1111611512实验日期:2012.10.15报告撰写日期:2012.10.16一、实验目的:1、熟悉图的概念、存储结构和遍历方法。
2、以邻接表为存储结构,掌握无向图的基本操作和实现方法。
3、以邻接表为存储结构,掌握无向图的深度优先遍历的算法实现。
二、实验内容:以邻接表为存储结构,编写程序实现。
1、要求通过键盘输入图的顶点,以及每一条边的两个顶点从而建立无向。
为了简化实验,顶点用数字表示。
2、在以上实验的基础上,实现无向图的深度优先遍历算法。
要求以用户给定的顶点为起始点,显示深度优先遍历的次序。
三、程序代码及结果展示:#include "stdafx.h"#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define MAX_VERTER_NUM 20typedef struct ArcNode{ //表节点int adjvex; //邻接点struct ArcNode *nextarc; //指向下一条弧的指针}ArcNode;typedef struct VNode{ //头结点int data; //定点信息ArcNode * firstarc; //指向第一个依附该顶点的弧的指针}VNode,AdjList[MAX_VERTER_NUM];typedef struct{ //图AdjList vertices; //顶int vexnum,arcnum;//图的顶点数和弧数int Kind;// 图的种类标志}ALGraph;// 对图 G 作深度优先遍历int LocateVex(ALGraph * G,int v) //寻找节点V的位置 { int k,n;for(k=0;k<G->vexnum;k++){ if(G->vertices[k].data==v){n=k;break;}}return n;}int n=1;int visited[MAX_VERTER_NUM]; void DFS(ALGraph *G,int v)//递归调用{ArcNode *p;>vertices[v].firstarc; p=G-if(n<G->vexnum+1){printf(" V%d ",G->vertices[v].data);n++;}visited[v]=1;while(p){if(!visited[p->adjvex])DFS(G,p->adjvex);p=p->nextarc;}}void DFSVisited(ALGraph * G)//深度遍历{int v;int n;printf("请输入遍历的起始的顶点:");scanf("%d",&n);n"); printf("递归深度优先遍历点顺序: \DFS(G,n-1);for(v=0;v<G->vexnum;v++)visited[v]=0;for(v=0;v<G->vexnum;v++)if(!visited[v])DFS(G,v);}void Insertadj(ALGraph * G,int i,int j) //插入邻接点的下标 { ArcNode *a1,*a2;a1=(ArcNode *)malloc(sizeof(ArcNode));a1->adjvex=j;a1->nextarc=NULL;if(G->vertices[i].firstarc==NULL){G->vertices[i].firstarc=a1;}else{a2=G->vertices[i].firstarc;while(a2->nextarc){a2=a2->nextarc;}a2->nextarc=a1;}}void Init_ALGraph(ALGraph * G) //初始化图并建图 { int v,v1,v2,i,j,q,p;int m=0;printf("请输入顶点数:");scanf("%d",&G->vexnum);printf("请输入边数:");scanf("%d",&G->arcnum);for(v=0;v<G->vexnum;v++){printf("顶点 V%d:",(v+1));scanf("%d",&(G->vertices[v].data));>vertices[v].firstarc=NULL; G-}for(v=0;v<G->arcnum;v++) {printf("请输入点点: ");scanf("%d%d",&v1,&v2);i=LocateVex(G,v1); //v1的位置j=LocateVex(G,v2); //v2的位置Insertadj(G,i,j);Insertadj(G,j,i);}}int main(int argc,char **argv) {ALGraph G;Init_ALGraph(&G);//初始化图并建图DFSVisited(&G);//深度优先遍历printf("\n");return 0;}四、实验总结:通过本实验,我对图的存储结构、图的遍历等有了比较深的理解与运用,图的遍历和树的遍历很类似,但是却比树的遍历复杂很多。
图的建立与遍历实验报告
![图的建立与遍历实验报告](https://img.taocdn.com/s3/m/fef806ddad51f01dc281f1a6.png)
实验图的建立与遍历姓名:曹国君梁辰唐琪皓黄悦班级:信息1班学号:09125676 09125675 09125672 09125673 实验时间:第9周1.问题描述输入图的顶点和边的信息建立图,并对其进行深度和广度遍历,输出遍历结果。
2.数据结构设计template <class ElemType>void AdjMatrixUndirGraph<ElemType>::InsertArc(int v1, int v2)// 操作结果:插入依附顶点v1和v2的边{if (v1 < 0 || v1 >= vexNum)throw Error("v1不合法!"); // 抛出异常if (v2 < 0 || v2 >= vexNum)throw Error("v2不合法!"); // 抛出异常if (v1 == v2)throw Error("v1不能等于v2!");// 抛出异常if (Matrix[v1][v2] == 0) { // 原无向图中没有边(v1, v2)arcNum++;Matrix[v1][v2] = 1;Matrix[v2][v1] = 1;}}template <class ElemType>void BFS(const AdjMatrixUndirGraph<ElemType> &g, int v, void (*Visit)(constElemType &))// 初始条件:存在图g// 操作结果:从顶点v出发进行广度优先搜索{LinkQueue<int> q;int u, w;ElemType e;g.SetTag(v, VISITED); // 作访问标志g.GetElem(v, e); // 取顶点v的数据元素值Visit(e); // 访问顶点vq.EnQueue(v); // 顶点v入队while (!q.Empty()) {q.DelQueue(u);for (w = g.FirstAdjVex(u); w != -1; w = g.NextAdjVex(u, w))if (g.GetTag(w) == UNVISITED){ // 对u尚未访问过的邻接顶点w 进行访问g.SetTag(w, VISITED);g.GetElem(w, e);Visit(e);q.EnQueue(w);}}}template <class ElemType>void DFS(const AdjMatrixUndirGraph<ElemType> &g, int v, void (*Visit)(const ElemType &))// 初始条件:存在图g// 操作结果:从顶点v出发进行深度优先搜索{ElemType e;g.SetTag(v, VISITED); // 设置顶点v已访问标志g.GetElem(v, e); // 取顶点v的数据元素值Visit(e); // 访问顶点vfor (int w = g.FirstAdjVex(v); w != -1; w = g.NextAdjVex(v, w)) if (g.GetTag(w) == UNVISITED)DFS(g, w , Visit); // 从v的尚未访问过的邻接顶点w开始进行深度优先搜索}3.算法设计#include "assistance.h" // 实用程序软件包#include "adj_matrix_undir_graph.h" // 无向图邻接矩阵#include "dfs.h" // 图的深度优先遍历#include "bfs.h" // 图的广度优先遍历int main(void){try // 用try封装可能出现异常的代码{int n=0, i, j, k, l;cout<<"请输入图的顶点个数:";cin>>n;if (n<=0||n>=26)throw Error("节点输入错误!");char a='A' ;char vexs[26];int m[26][26] ;for (i=0; i<n; i++){for (j=0; j<n; j++){m[i][j]=0;}}for(i=0; i<n; i++){vexs[i]=a;a++;}cout<<"输入边的两个顶点:(输入-1 -1结束)" ;cin>>k;cin>>l;if (k>=n||l>=n)throw Error("节点输入错误!");m[k][l]=1;m[l][k]=1;while (k!=-1||l!=-1){cout<<"输入边的两个顶点:(输入-1 -1结束)" ;cin>>k;cin>>l;if (k>=n||l>=n)throw Error("节点输入错误!");m[k][l]=1;m[l][k]=1;}AdjMatrixUndirGraph<char> g(vexs, n);AdjMatrixUndirGraph<char> g1(vexs, n);for(int u=0; u<n; u++){for(int v=0; v<n; v++){if( m[u][v]==1){ g.InsertArc(u,v);g1.InsertArc(u,v);} }}cout << "原有图:" << endl;g.Display(); // 显示图gcout << endl;system("PAUSE"); // 调用库函数system()int v=0;cout<<"请输入开始遍历的顶点"<<endl;cin>>v;if (v>=n)throw Error("节点输入错误!");cout << "深度优先遍历:";DFS<char>(g, v, Write<char>);// <char>用于确定函数模板参数cout << endl;system("PAUSE");cout << "广度优先遍历:";BFS(g1, v, Write<char>); // 对图g进行广度优先遍历cout << endl;}catch (Error err) // 捕捉并处理异常{err.Show(); // 显示异常信息}system("PAUSE"); // 调用库函数system()return 0; // 返回值0, 返回操作系统}4.测试与运行图的建立与遍历数据测试实验序号输入输出节点数相连的边开始遍历的点深度遍历广度遍历备注1 -1 / / / / 报错2 2 <1,3> / / / 报错3 3 <1,0>4 / / 报错4 2 <0.1> 0 A B A B /5 3 <0,1> <1,2> 0 A B C A B C /6 3 <0,2> <2,1> 2 C A B C A B /7 5 <0,2> <0,1><2,3> <1,4>2 C A B E D C A D B E /8 5 <0,1> <1,2><1,3> <1,4>0 A B C D E A B C D E /9 5 <0,1> <1,2><1,3> <1,4>3 D B A C E D B A C E /10 9 <0,1> <1,2><2,3> <3,7><3,4> <4,5><4,6> <7,8>A B C D EF G H IA B C D EH F G I/5.测试记录及收获给出测试中遇到的问题及解决的方法和过程。
实验十二 图的创建和遍历
![实验十二 图的创建和遍历](https://img.taocdn.com/s3/m/84f78d33f5335a8103d22028.png)
图的创建和遍历——0000000000 ***一、实验目的(1)掌握图的含义;(2)掌握用邻接矩阵方法描述图的存储结构;(3)理解并掌握深度优先遍历和广度优先遍历的算法。
二、实验数据实验随机输入。
三、实验内容与步骤(1)以邻接矩阵的描述方法创无向联通图;(2)用深度优先遍历实现图的遍历;(3)用广度优先遍历实现图的遍历。
(4)思考若图为无向非连通图,程序应该如何修改创建图void CREATGRAPH(GRAPH *ga){int i,j,k;float w;printf("图的顶点数为%d,边数为%d\n\n",n,e);for(i=0;i<n;i++){printf("请读入定点信息:");fflush(stdin);scanf("%c",&ga->vexs[i]);}for(i=0;i<n;i++){for(j=0;j<n;j++){ga->arcs[i][j]=0;}}for(k=0;k<e;k++){printf("请读入第%d边权值信息:",k);scanf("%d%d%f",&i,&j,&w);ga->arcs[i][j]=w;ga->arcs[j][i]=w;}printf("图表创建完毕\n");}深度优先遍历void DFS(GRAPH g,int i){int j;printf("%c\n",[i]);visited[i]=1;for(j=0;j<n;j++)if([i][j])==1 && (! visited[j]))DFS(g,j);}广度优先遍历void BFS(GRAPH g,int k){sequeue sq1,*sq=&sq1;int i,j;SETNULL(sq);printf("%c\n",[k]);visited[k]=1;ENQUEUE(sq,k);while(!EMPTY(sq)){i=DEQUEUE(sq);for(j=0;j<n;j++)if([i][j])==1 && (! visited[j])){printf("%c\n",[j]);visited[j]=1;ENQUEUE(sq,j);}}}四、结论与讨论需要注意的问题:1. fflush(stdin)表示清除清空输入缓冲区,通常是为了确保不影响后面的数据读取(例如在读完一个字符串后紧接着又要读取一个字符,此时应该先执行fflush(stdin);)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
图的建立与遍历实验报告
------------图的建立与遍历
姓名:曹庆松
班级:1104
学号:1111611512
实验日期:2012.10.15
报告撰写日期:2012.10.16
一、实验目的:
1、熟悉图的概念、存储结构和遍历方法。
2、以邻接表为存储结构,掌握无向图的基本操作和实现方法。
3、以邻接表为存储结构,掌握无向图的深度优先遍历的算法实
现。
二、实验内容:
以邻接表为存储结构,编写程序实现。
1、要求通过键盘输入图的顶点,以及每一条边的两个顶点从而建
立无向。
为了简化实验,顶点用数字表示。
2、在以上实验的基础上,实现无向图的深度优先遍历算法。
要求
以用户给定的顶点为起始点,显示深度优先遍历的次序。
三、程序代码及结果展示:
#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include <malloc.h>
#define MAX_VERTER_NUM 20
typedef struct ArcNode
{ //表节点
int adjvex; //邻接点
struct ArcNode *nextarc; //指向下一条弧的指针
}ArcNode;
typedef struct VNode
{ //头结点
int data; //定点信息
ArcNode * firstarc; //指向第一个依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTER_NUM];
typedef struct
{ //图
AdjList vertices; //顶
int vexnum,arcnum;//图的顶点数和弧数
int Kind;// 图的种类标志
}ALGraph;// 对图 G 作深度优先遍历
int LocateVex(ALGraph * G,int v) //寻找节点V的位置 { int k,n;
for(k=0;k<G->vexnum;k++)
{ if(G->vertices[k].data==v)
{
n=k;
break;
}
}
return n;
}
int n=1;
int visited[MAX_VERTER_NUM]; void DFS(ALGraph *G,int v)//递归调用{
ArcNode *p;
>vertices[v].firstarc; p=G-
if(n<G->vexnum+1)
{
printf(" V%d ",G->vertices[v].data);
n++;
}
visited[v]=1;
while(p)
{
if(!visited[p->adjvex])
DFS(G,p->adjvex);
p=p->nextarc;
}
}
void DFSVisited(ALGraph * G)//深度遍历
{
int v;
int n;
printf("请输入遍历的起始的顶点:");
scanf("%d",&n);
n"); printf("递归深度优先遍历点顺序: \
DFS(G,n-1);
for(v=0;v<G->vexnum;v++)
visited[v]=0;
for(v=0;v<G->vexnum;v++)
if(!visited[v])
DFS(G,v);
}
void Insertadj(ALGraph * G,int i,int j) //插入邻接点的下标 { ArcNode *a1,*a2;
a1=(ArcNode *)malloc(sizeof(ArcNode));
a1->adjvex=j;a1->nextarc=NULL;
if(G->vertices[i].firstarc==NULL)
{
G->vertices[i].firstarc=a1;
}
else
{
a2=G->vertices[i].firstarc;
while(a2->nextarc)
{
a2=a2->nextarc;
}
a2->nextarc=a1;
}
}
void Init_ALGraph(ALGraph * G) //初始化图并建图 { int v,v1,v2,i,j,q,p;
int m=0;
printf("请输入顶点数:");
scanf("%d",&G->vexnum);
printf("请输入边数:");
scanf("%d",&G->arcnum);
for(v=0;v<G->vexnum;v++)
{
printf("顶点 V%d:",(v+1));
scanf("%d",&(G->vertices[v].data));
>vertices[v].firstarc=NULL; G-
}
for(v=0;v<G->arcnum;v++) {
printf("请输入点点: ");
scanf("%d%d",&v1,&v2);
i=LocateVex(G,v1); //v1的位置
j=LocateVex(G,v2); //v2的位置
Insertadj(G,i,j);
Insertadj(G,j,i);
}
}
int main(int argc,char **argv) {
ALGraph G;
Init_ALGraph(&G);//初始化图并建图
DFSVisited(&G);//深度优先遍历
printf("\n");
return 0;
}
四、实验总结:
通过本实验,我对图的存储结构、图的遍历等有了比较深的理解与运用,图的遍历和树的遍历很类似,但是却比树的遍历复杂很多。
因为图具有结点与结点之间的关系可以是任意的,任意两个数据元素时间都可能相关等特点,所以图的应用很
广泛。
本实验用邻接表形式存储图是比较普遍的,而对图的遍历有两种本实验旨在深度优先遍历,深度优先遍历很多时候我们会用递归方法解决,要把所有的结点都被访问为止。