图的深度优先遍历算法课程设计报告

合集下载

图的深度优先搜索遍历算法分析及其应用

图的深度优先搜索遍历算法分析及其应用

图的深度优先搜索遍历算法分析及其应用重庆邮电大学数学大类专业2008级《数学建模与数学实验》课程设计设计题目:图的深度优先搜索遍历算法分析及其应用设计时间: 2010.9.7-----2010.9. 12设计成绩:姓名:班级:学号:指导教师:图的深度优先搜索遍历算法分析及其应用摘要:文章介绍了图论,图的基本概念及其图的表示方法。

详细的分析了图中以邻接表为存储结构进行的图的深度优先搜索遍历的算法,并且在VC++环境中实现其算法的过程,对运行记过做了一定量的分析,最后介绍了基于该算法的一些应用。

关键词:图;深度优先搜索;遍历;算法图论〔Graph Theory〕是数学的一个分支。

它以图为研究对象。

图论中的图是由若干给定的点及连接两点的线所构成的图形,这种图形通常用来描述某些事物之间的某种特定关系,用点代表事物,用连接两点的线表示相应两个事物间具有这种关系。

图(Graph)是一种较线性表和树更复杂的数据结构,图形结构中,结点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。

因此,在研究有关图的问题时,要考虑图中每个顶点的信息,访问图中的各个顶点,而访问图中各个顶点的操作过程即使图的遍历,图的遍历算法是求解图的连通性问题,拓扑排序和求关键路径等算法的基础。

1 图的三元组定义图G是一个三元组由集合V,E和关联函数组成,记为:G=(V,E,W(G))。

其中V是顶点的集合,表示V(G)={V1,V2,V3,……Vn},V(G)≠NULL。

E是V中的点偶对的有穷集,表示为E(G)={e1,e2,e3……em},其中ei为<V j,Vt>或{Vj,Vt},若ei为{Vj,Vt},称ei为以V j 和Vt为端点的无向边;若ei为<Vj,Vt>,称ei为以V j为起点,Vt为终点的有向边;W(G)称为E→VxV的关联函数。

2图的存储结构图的存储结构除了要存储图中各个顶点的本身的信息外,同时还要存储顶点与顶点之间的所有关系(边的信息),因此,图的结构比较复杂,很难以数据元素在存储区中的物理位置来表示元素之间的关系,但也正是由于其任意的特性,故物理表示方法很多。

图论深度优先搜索实验报告

图论深度优先搜索实验报告

深度优先遍历一、实验目的了解深度优先遍历的基本概念以及实现方式。

二、实验内容1、设计一个算法来对图的进行深度优先遍历;2、用C语言编程来实现此算法。

用下面的实例来调试程序:三、使用环境Xcode编译器四、编程思路深度优先遍历图的方法是,从邻接矩阵出发:访问顶点v;依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;构造一个遍历辅助矩阵visited[]进行比较若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止,并将顶点信息存储在数组Q[]里面。

反复搜索可以通过使用函数的嵌套来实现。

五、调试过程1.程序代码://为方便调试,程序清晰直观删除了邻接矩阵的构造函数,//并且修改了main()函数,只保留了DFS函数#include <stdio.h>#define N 4 //定义顶点数int a[N][N]={{0,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,0,1}}; //邻接矩阵由之前程序函给出int visited[N]={0}; //遍历比较的辅助矩阵,初始化为0矩阵int Q[N]; //用来存储各个顶点的信息static int last=-1;void DFS(int G[][N], int s){visited[s] = 1;Q[++last]=s;for (int i=0;i<N;i++) //进行遍历{if (G[s][i]==1){if(visited[i] == 0)DFS(G,i); //函数嵌套,完成一次搜索,指向下一个顶点 }}}int main(){DFS(a,0);printf("深度优先搜索为\n");for (int i=0;i<N;i++) //打印遍历的结果printf("%d ",Q[i]+1);return 0;}2.运行窗口:输出结果为各顶点按深度优先遍历的排序。

图的遍历 实验报告

图的遍历  实验报告

图的遍历实验报告一、引言图是一种非线性的数据结构,由一组节点(顶点)和节点之间的连线(边)组成。

图的遍历是指按照某种规则依次访问图中的每个节点,以便获取或处理节点中的信息。

图的遍历在计算机科学领域中有着广泛的应用,例如在社交网络中寻找关系紧密的人员,或者在地图中搜索最短路径等。

本实验旨在通过实际操作,掌握图的遍历算法。

在本实验中,我们将实现两种常见的图的遍历算法:深度优先搜索(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表示边的数量。

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

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

华北水利水电学院数据结构实验报告20 10 ~20 11 学年第一学期2008级计算机专业班级:107学号:200810702姓名:王文波实验四图的应用一、实验目的:1.掌握图的存储结构及其构造方法2.掌握图的两种遍历算法及其执行过程二、实验内容:以邻接矩阵或邻接表为存储结构,以用户指定的顶点为起始点,实现无向连通图的深度优先及广度优先搜索遍历,并输出遍历的结点序列。

提示:首先,根据用户输入的顶点总数和边数,构造无向图,然后以用户输入的顶点为起始点,进行深度优先和广度优先遍历,并输出遍历的结果。

三、实验要求:1.各班学号为单号的同学采用邻接矩阵实现,学号为双号的同学采用邻接表实现。

2.C/ C++完成算法设计和程序设计并上机调试通过。

3.撰写实验报告,提供实验结果和数据。

4.写出算法设计小结和心得。

四、程序源代码:#include<iostream.h>#define MaxVerNum 50struct edgenode{int endver;int inform;edgenode* edgenext;};struct vexnode{char vertex;edgenode* edgelink;};struct Graph{vexnode adjlists[MaxVerNum];int vexnum;int arcnum;};//队列的定义及相关函数的实现struct QueueNode{int nData;QueueNode* next;};struct QueueList{QueueNode* front;QueueNode* rear;};void EnQueue(QueueList* Q,int e) {QueueNode *q=new QueueNode;q->nData=e;q->next=NULL;if(Q==NULL)return;if(Q->rear==NULL)Q->front=Q->rear=q;else{Q->rear->next=q;Q->rear=Q->rear->next;}}void DeQueue(QueueList* Q,int* e) {if (Q==NULL)return;if (Q->front==Q->rear){*e=Q->front->nData;Q->front=Q->rear=NULL;}else{*e=Q->front->nData;Q->front=Q->front->next;}}//创建图void CreatAdjList(Graph* G){int i,j,k;edgenode* p1;edgenode* p2;cout<<"请输入顶点数和边数:"<<endl;cin>>G->vexnum>>G->arcnum;cout<<"开始输入顶点表:"<<endl;for (i=0;i<G->vexnum;i++){cin>>G->adjlists[i].vertex;G->adjlists[i].edgelink=NULL;}cout<<"开始输入边表信息:"<<endl;for (k=0;k<G->arcnum;k++){cout<<"请输入边<Vi,Vj>对应的顶点:";cin>>i>>j;p1=new edgenode;p1->endver=j;p1->edgenext=G->adjlists[i].edgelink;G->adjlists[i].edgelink=p1;p2=new edgenode;p2->endver=i;p2->edgenext=G->adjlists[j].edgelink;G->adjlists[j].edgelink=p2;//因为是无向图,所以有两次建立边表的过程}}//-------------------------------------------------------------深度优先遍历void DFS(Graph *G,int i,int visit[]){cout<<G->adjlists[i].vertex<<" ";visit[i]=1;edgenode *p=new edgenode;p=G->adjlists[i].edgelink;if(G->adjlists[i].edgelink&&!visit[p->endver]){DFS(G,p->endver,visit);}}void DFStraversal(Graph *G,char c)//深度优先遍历{cout<<"该图的深度优先遍历结果为:"<<endl;int visit[MaxVerNum];for(int i=0;i<G->vexnum;i++){visit[i]=0;//全部初始化为0,即未访问状态}int m;for (i=0;i<G->vexnum;i++){if (G->adjlists[i].vertex==c)//根据字符查找序号{m=i;DFS(G,i,visit);break;}}//继续访问未被访问的结点for(i=0;i<G->vexnum;i++){if(visit[i]==0)DFS(G,i,visit);}cout<<endl;}//-------------------------------------------------------------广度优先遍历void BFS(Graph* G,int v,int visit[]){QueueList *Q=new QueueList;Q->front=Q->rear=NULL;EnQueue(Q,v);while(Q->rear!=NULL){int e=0;DeQueue(Q,&e);cout<<G->adjlists[e].vertex<<" ";visit[e]=1;edgenode* p=new edgenode;p=G->adjlists[e].edgelink;if(p){int m=p->endver;if(m==0){EnQueue(Q,m);while(visit[m]==0){p=p->edgenext;if(p==NULL)break;m=p->endver;EnQueue(Q,m);}}}}}void BFStraversal(Graph *G,char c){cout<<"该图的广度优先遍历结果为:"<<endl;int visited[MaxVerNum];for (int i=0;i<G->vexnum;i++){visited[i]=0;}int m;for (i=0;i<G->vexnum;i++){if (G->adjlists[i].vertex==c){m=i;BFS(G,i,visited);break;}}//继续访问未被访问的结点for(i=0;i<G->vexnum;i++){if(visited[i]==0)BFS(G,i,visited);}cout<<endl;}void main(){Graph * G=new Graph;CreatAdjList(G);char ch;cout<<"请输入开始遍历的顶点:";cin>>ch;DFStraversal(G,ch);BFStraversal(G,ch);}五、程序运行情况(写出输入数据及运行结果)六、小结(包括收获、心得体会、存在的问题及解决问题的方法、建议等)注:内容一律使用宋体五号字,单倍行间距本次试验采用的是邻接表的方式实现图的深度优先遍历和广度优先遍历。

深度优先搜索实验报告

深度优先搜索实验报告

深度优先搜索实验报告引言深度优先搜索(Depth First Search,DFS)是图论中的一种重要算法,主要用于遍历和搜索图的节点。

在实际应用中,DFS被广泛用于解决迷宫问题、图的连通性问题等,具有较高的实用性和性能。

本实验旨在通过实际编程实现深度优先搜索算法,并通过实际案例验证其正确性和效率。

实验中我们将以迷宫问题为例,使用深度优先搜索算法寻找从入口到出口的路径。

实验过程实验准备在开始实验之前,我们需要准备一些必要的工具和数据。

1. 编程环境:我们选择使用Python语言进行编程实验,因其语法简洁而强大的数据处理能力。

2. 迷宫地图:我们需要设计一个迷宫地图,包含迷宫的入口和出口,以及迷宫的各个路径和墙壁。

实验步骤1. 首先,我们需要将迷宫地图转化为计算机可处理的数据结构。

我们选择使用二维数组表示迷宫地图,其中0表示墙壁,1表示路径。

2. 接着,我们将编写深度优先搜索算法的实现。

在DFS函数中,我们将使用递归的方式遍历迷宫地图的所有路径,直到找到出口或者遇到墙壁。

3. 在每次遍历时,我们将记录已经访问过的路径,以防止重复访问。

4. 当找到出口时,我们将输出找到的路径,并计算路径的长度。

实验结果经过实验,我们成功地实现了深度优先搜索算法,并在迷宫地图上进行了测试。

以下是我们的实验结果:迷宫地图:1 1 1 1 11 0 0 0 11 1 1 0 11 0 0 0 11 1 1 1 1最短路径及长度:(1, 1) -> (1, 2) -> (1, 3) -> (1, 4) -> (2, 4) -> (3, 4) -> (4, 4) -> (5, 4)路径长度:7从实验结果可以看出,深度优先搜索算法能够准确地找到从入口到出口的最短路径,并输出了路径的长度。

实验分析我们通过本实验验证了深度优先搜索算法的正确性和有效性。

然而,深度优先搜索算法也存在一些缺点:1. 只能找到路径的一种解,不能确定是否为最优解。

数据结构与算法实验报告图的深度优先与广度优先遍历

数据结构与算法实验报告图的深度优先与广度优先遍历
}
w=NextAdj(g,v);
}
}
}
void Travel_BFS(源自Node g[],int visited[],int n){
int i;
for(i=0;i<n;i++){
visited[i]=0;
}
for(i=0;i<n;i++){
if(visited[i]==0)
BFS(g,i,visited);
vertexType data;
Arcnode *firstarc;
}VNode;
irstarc=NULL;
}
for(i=0;i<n;i++){
printf("create the edges for the %dth vertex\n",i);
scanf("%d",&e);
while(e!=-1){
二、实验题目与要求
图的遍历
利用邻接矩阵或邻接表作为存储结构建立一个无向图,每个顶点中存放一种水果名(例如apple、orange、banana等,并要求从键盘输入),顶点数不少于5个。要求分别以深度优先搜索(DFS)和广度优先搜索(BFS)进行遍历,输出遍历结果。
3、源代码清单
=#include<>
p=(Arcnode *)malloc(sizeof(Arcnode));
p->next=NULL;
p->adjvex=e;
if(G[i].firstarc==NULL){
G[i].firstarc=p;
}else{
q->next=p;
}
q=p;

图的广度深度优先遍历课程设计

图的广度深度优先遍历课程设计

图的广度深度优先遍历摘要我们希望从图中某一顶点出发访遍图中其余各顶点,且使每一顶点仅被访问一次,这个过程就叫图的遍历。

而图的深度优先遍历类似与树的先根遍历,是树的先根遍历的推广,图的广度优先遍历是类似于树的按层次遍历的过程。

图的遍历过程实质上就是通过边或者弧找邻接点的过程。

在这,我们主要就是介绍遍历图的两种基本方法:深度优先搜索和广度优先搜索。

这两种方法无论是有向图还是有向图都适用。

广度优先搜索遍历图和深度优先搜索遍历图的时间复杂度相同,两者不同之处仅仅在于对顶点访问的顺序不同。

关键词图的遍历;广度优先遍历;深度优先遍历;目录1 引言 (1)2设计思路与方案 (2)2.1设计思路 (2)2.2设计方案 (2)3 详细实现 (4)3.1队列的定义及相关操作 (4)3.2图的邻接表存储结构的定义及无向图的建立 (5)3.3图的深度优先遍历算法 (6)3.4图的广度优先遍历非递归算法 (7)4 运行环境与结果 (8)4.1运行环境 (8)4.2 运行结果 (9)5结束语 (12)参考文献 (13)附录 (14)1 引言图的遍历算法是求解图的连通性问题,拓扑排序和求关键路径等算法的基础。

然而,图的遍历要比树的遍历复杂的多。

因为图的任何一顶点都有可能和其余的顶点相邻接。

所以在访问了某个顶点之后,可能沿着某条路径搜索之后,又回到该点是行。

为了避免同一顶点被访问多次,在图的遍历过程中,必须先记下每个已访问的顶点。

在次介绍两种对有向图和无向图都适用的遍历图的路径:深度优先搜索和广度优先搜索。

在此次设计中,用到的最多的队列,图的深度优先遍历类似于树的前序遍历。

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

广度优先遍历类似于树的按层次遍历。

采用的搜索方法的特点是尽可能先对横向进行搜索,鼓称其为广度优先搜索,相应的遍历称为广度优先遍历。

通过课程设计,我们会认识自身存在的很多问题,也有利于提高我们的动手能力,也把我们所学的东西和实践很好的结合起来,在这次设计中,再次体会了队列,深度优先搜索,广度优先搜索,等数据结构中的基本算法及其原理。

图的深度和广度优先遍历

图的深度和广度优先遍历

数据结构课程实验报告课程名称数据结构班级计算123 实验日期2014年6月1日--3日姓名学号实验成绩实验名称实验四图的深度和广度优先遍历实验目的及要求【实验目的】熟练掌握图的邻接表存储结构及其图的建立方法和深度和广度优先遍历的方法。

【实验要求】1.图的存储可采用邻接矩阵或邻接表2.GraphCreate(): 按从键盘的数据建立图3.GraphDFS():深度优先遍历图4.GraphBFS():广度优先遍历图5.编写完整程序完成下面的实验内容并上机运行6.整理并上交实验报告实验环境硬件平台:普通的PC机软件平台:Windows 7 操作系统编程环境:VisualC++ 6.0实验内容1.以邻接矩阵或邻接表为存储结构,以用户指定的顶点为起始点,实现图的深度优先及广度优先搜索遍历,并输出遍历的结点序列。

算法描述及实验步骤算法:1)定义图的邻接表存储结构2)实现图的邻接表存储,即建立图的存储结构3)实现图的深度优先遍历4)定义队列的顺序存储结构,并实现队列的基本操作如初始化队列、入队、出对、判断队列是否为空等。

利用队列实现图的广度优先遍历。

伪代码:1)定义邻接矩阵和队列的存取结构;2)创建图L:1.置空图L->num=0;2.输入顶点数目num;3.i++,输入结点L->vexs[i]直到L->num;3)输出图L的各顶点;4)深度优先遍历图g中能访问的各个顶点1.输入起点的下标qidian;2.标志数组初始化mark[v]=0;3.for(v=qidian;v<g.num+qidian;v++) //{v1=v%g.num;if(mark[v1]==0)DFS(g,v1,mark); //从第v1个点出发深度优先遍历图g中能访问的各个顶点(算法描述里的流程图很详细)}5)广度优先周游图g中能访问的各个顶点。

1.构造空队列;2.入队a[0];3.a[0]出队,a[0]的邻接点入队,遍历a[0];4.队首出队,重复3直到队列为空;5.判断是否全遍历完了;6.输出广度优先遍历序列流程图:开始访问V 0,置标志求V 0邻接点有邻接点w求下一邻接点w V 0W 访问过结束NYN YDFS开始标志数组初始化V i =1Vi 访问过DFSV i =V i +1V i ==Vexnums结束NNYY调试过程及实验结果总结本次试验采用的是邻接表的方式实现图的深度优先遍历和广度优先遍历。

图的遍历算法实验报告

图的遍历算法实验报告

图的遍历算法实验报告
《图的遍历算法实验报告》
在计算机科学领域,图的遍历算法是一种重要的算法,它用于在图数据结构中
访问每个顶点和边。

图的遍历算法有两种常见的方法:深度优先搜索(DFS)
和广度优先搜索(BFS)。

在本实验中,我们将对这两种算法进行实验,并比较
它们的性能和应用场景。

首先,我们使用深度优先搜索算法对一个简单的无向图进行遍历。

通过实验结
果可以看出,DFS算法会首先访问一个顶点的所有邻居,然后再递归地访问每
个邻居的邻居,直到图中所有的顶点都被访问到。

这种算法在一些应用场景中
非常有效,比如寻找图中的连通分量或者寻找图中的环路。

接下来,我们使用广度优先搜索算法对同样的无向图进行遍历。

通过实验结果
可以看出,BFS算法会首先访问一个顶点的所有邻居,然后再按照距离递增的
顺序访问每个邻居的邻居。

这种算法在一些应用场景中也非常有效,比如寻找
图中的最短路径或者寻找图中的最小生成树。

通过对比实验结果,我们可以发现DFS和BFS算法各自的优势和劣势。

DFS算
法适合用于寻找图中的连通分量和环路,而BFS算法适合用于寻找最短路径和
最小生成树。

因此,在实际应用中,我们需要根据具体的需求来选择合适的算法。

总的来说,图的遍历算法是计算机科学中非常重要的算法之一,它在许多领域
都有着广泛的应用。

通过本次实验,我们对DFS和BFS算法有了更深入的了解,并且对它们的性能和应用场景有了更清晰的认识。

希望通过这篇实验报告,读
者们也能对图的遍历算法有更深入的理解和认识。

图的遍历操作实验报告

图的遍历操作实验报告

图的遍历操作实验报告一、实验目的本次实验的主要目的是深入理解图的遍历操作的基本原理和方法,并通过实际编程实现,掌握图的深度优先遍历(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)```(四)测试与分析分别使用深度优先遍历和广度优先遍历算法对上述示例图进行遍历,并记录遍历的顺序和时间开销。

图的深度优先遍历算法课程设计报告

图的深度优先遍历算法课程设计报告

合肥学院计算机科学与技术系课程设计报告2013~2014学年第二学期课程数据结构与算法课程设计名称图的深度优先遍历算法的实现学生姓名陈琳学号1204091022专业班级软件工程指导教师何立新2014 年9 月一:问题分析和任务定义涉及到数据结构遍会涉及到对应存储方法的遍历问题。

本次程序采用邻接表的存储方法,并且以深度优先实现遍历的过程得到其遍历序列。

深度优先遍历图的方法是,从图中某顶点v 出发: (1)访问顶点v ;(2)依次从v 的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v 有路径相通的顶点都被访问;(3)若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

二:数据结构的选择和概要设计 设计流程如图:图1 设计流程利用一维数组创建邻接表,同时还需要一个一维数组来存储顶点信息。

之后利用创建的邻接表来创建图,最后用深度优先的方法来实现遍历。

图 2 原始图 1.从0开始,首先找到0的关联顶点32.由3出发,找到1;由1出发,没有关联的顶点。

3.回到3,从3出发,找到2;由2出发,没有关联的顶点。

4.回到4,出4出发,找到1,因为1已经被访问过了,所以不访问。

所以最后顺序是0,3,1,2,4三:详细设计和编码1.创建邻接表和图void CreateALGraph (ALGraph* G) //建立邻接表函数.{int i,j,k,s;char y;EdgeNode* p; //工作指针.printf("请输入图的顶点数n与边数e(以逗号做分隔符):\n");scanf("%d,%d",&(G->n),&(G->e));scanf("%c",&y); //用y来接收回车符.for(s=0;s<G->n;s++){printf("请输入下标为%d的顶点的元素:\n",s);scanf("%c",&(G->adjlist[s].vertex));scanf("%c",&y); //用y来接收回车符.当后面要输入的是和单个字符有关的数据时候要存贮回车符,以免回车符被误接收。

课程设计报告-图的遍历

课程设计报告-图的遍历

目录一、课题的主要功能 (2)1.1设计内容 (2)1.2对课程设计功能的需求分析 (2)二、课题的功能模块的划分 (2)2.1模块划分 (2)2.2系统的概要设计 (3)三、主要功能的实现 (4)3.1算法思想 (4)1.图的邻接矩阵的建立 (4)2.图的遍历的实现 (4)3.2数据结构 (4)3.3主函数流程图 (5)3.4深度优先遍历流程图 (6)3.5深度优先遍历递归 (7)3.6深度优先遍历流程图 (9)3.7广度优先遍历递归流程图 (10)四、程序调试 (11)4.1程序的调试分析 (11)4.2程序的测试结果 (11)五、总结 (15)六、附件 (16)6.1源程序一、课题的主要功能1.1设计内容演示图的深度优先, 广度优先遍历过程,并输出原图结构及遍历结果。

要求图的结点数不能少于6个。

可以由系统随机生成图,也可以由用户手动输入图。

报告中要写出画图的思路;画出图的结构,有兴趣的同学可以进一步改进图的效果。

1.2对课程设计功能的需求分析图的遍历并不需要是一个过于复杂的工作环境,一般来说:最合适的才是最好的。

软件设计必须符合我们使用实际情况的需要。

根据要求,图的遍历主要功能如下:1.用户可以随时建立一个有向图或无向图;2.用户可以根据自己的需要,对图进行深度遍历或广度遍历;3.用户可以根据自己的需要对图进行修改;4.在整个程序中,用户可以不断的按照不同的方式对图进行遍历,若不继续,用户也可以随时跳出程序,同时,如果用户输入的序号错误,程序会提示用户重新输入序号;二、课题的功能模块的划分2.1模块划分1.队列的初始化、进队、出队、队列空、队列满的函数void InitQueue(CirQueue *Q) //初始化队列int QueueEmpty(CirQueue *Q)//队列是否为空int QueueFull(CirQueue *Q)//队列满Void EnQueue(CirQueue *Q,int x)//将队员进队int DeQueue(CirQueue *Q)//将队员出队2.创建图的函数void CreateMGraph(MGraph *G)//根据用户需要创建一个图3.图的深度优先遍历递归void DFSM(MGraph *G,int i)/*含有输出已访问的顶点的语句*/4.图的广度优先遍历递归void BFSM(MGraph *G,int k) /*含有输出已访问的顶点的语句*/5.深度优先遍历void DFSTraverseM(MGraph *G)/*调用DFSM函数*/6.广度优先遍历void BFSTraverseM(MGraph *G) /*调用BFSM函数*/7.主函数main() /*包含一些调用和控制语句*/2.2系统的概要设计三、主要功能的实现3.1算法思想本课题所采用的是邻接矩阵的方式存储图,实现图的深度、广度两种遍历,并将每种遍历结果输出来。

图的优先遍历课程设计

图的优先遍历课程设计

图的优先遍历课程设计一、课程目标知识目标:1. 学生能理解图的优先遍历的基本概念,掌握其算法原理和应用场景。

2. 学生能运用所学算法,解决实际问题,如最短路径、拓扑排序等。

3. 学生了解优先遍历与其他遍历方法(如深度优先遍历、广度优先遍历)的区别和联系。

技能目标:1. 学生能运用编程语言(如Python)实现图的优先遍历算法。

2. 学生能通过实际案例分析,设计并优化图的优先遍历解决方案。

3. 学生具备分析问题、解决问题和团队协作的能力。

情感态度价值观目标:1. 学生培养对数据结构与算法的兴趣和热情,增强学习主动性和积极性。

2. 学生通过团队协作,培养沟通能力、团队意识和合作精神。

3. 学生在解决实际问题的过程中,体会算法的实用价值,提高对计算机科学的认识和兴趣。

本课程针对高中年级学生,结合学生已有知识水平和认知特点,注重理论与实践相结合,培养学生分析问题、解决问题的能力。

课程目标明确,分解为具体的学习成果,便于教学设计和评估。

在教学过程中,关注学生的个体差异,鼓励学生积极参与,提高课堂互动效果。

二、教学内容1. 图的基本概念:图的定义、顶点与边、有向图与无向图、连通图与连通分量。

2. 优先遍历算法原理:优先遍历的概念、优先队列的作用、优先遍历与深度优先遍历的关系。

3. 最短路径问题:Dijkstra算法原理、算法实现步骤、实际案例分析。

4. 拓扑排序:拓扑排序的概念、有向无环图(DAG)的判定、拓扑排序的算法实现。

5. 优先遍历的应用场景:如关键路径、任务调度等。

6. 编程实践:使用Python等编程语言实现优先遍历相关算法。

教学内容依据课程目标,结合教材相关章节,进行科学、系统的组织。

教学大纲安排如下:第一课时:图的基本概念及优先遍历原理介绍。

第二课时:Dijkstra算法及其实现。

第三课时:拓扑排序及其应用。

第四课时:优先遍历在其他场景的应用。

第五课时:编程实践,巩固所学知识。

教学内容注重理论与实践相结合,让学生在掌握基本概念和算法原理的基础上,通过实际案例和编程实践,提高解决问题的能力。

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

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

《数据结构与关系数据库(本科)》实验报告姓名班级学号实验日期课程名称数据结构与关系数据库(本科)指导教师成绩实验名称:深度优先遍历以邻接表存储的图一、实验目的1、掌握以邻接表存储的图的深度优先遍历算法;二、实验环境1、硬件环境:微机2、软件环境:Windows XP,VC6.0三、实验内容、步骤及结果1、实验内容:基于图的深度优先遍历编写一个算法,判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径(i≠j)。

2、代码:#include <stdio.h>#include <stdlib.h>#define MaxVertexNum 100 /*最大顶点数为100*/typedef char VertexType;typedef struct node{ /*边表结点*/int adjvex; /*邻接点域*/struct node * next; /*指向下一个邻接点的指针域*//*若要表示边上信息,则应增加一个数据域info*/}EdgeNode;typedef struct vnode{ /*顶点表结点*/VertexType vertex; /*顶点域*/EdgeNode * firstedge; /*边表头指针*/}VertexNode;typedef VertexNode AdjList[MaxVertexNum]; /*AdjList 是邻接表类型*/typedef struct{AdjList adjlist; /*邻接表*/int n,e; /*顶点数和边数*/}ALGraph; /*ALGraph 是以邻接表方式存储的图类型*/bool visited[MaxVertexNum];void CreateTestALGraph(ALGraph *G){/*建立有向图的邻接表存储*/int i,j;EdgeNode * s;G->n=8;G->e=9;for (i=0;i<G->n;i++) /*建立有n 个顶点的顶点表*/{G->adjlist[i].vertex='1'+i;//转换为字符型G->adjlist[i].firstedge=NULL; /*顶点的边表头指针设为空*/}{i=0,j=1;s=(EdgeNode*)malloc(sizeof(EdgeNode)); /*生成新边表结点s*/s->adjvex=j; /*邻接点序号为j*/s->next=G->adjlist[i].firstedge; /*将新边表结点s 插入到顶点Vi 的边表头部*/ G->adjlist[i].firstedge=s;i=0,j=2;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; ///*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=1,j=3;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=1,j=4;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=2,j=0;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=2,j=6;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=3,j=4;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=4,j=3;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;}///*CreateALGraph}void DFSTraverseAL(ALGraph *G){/*深度优先遍历以邻接表存储的图G*/int i;for (i=0;i<G->n;i++)visited[i]=false; /*标志向量初始化*/for (i=0;i<G->n;i++)if (!visited[i]) DFSAL(G,i); /*vi 未访问过,从vi 开始DFS 搜索*/ }/*DFSTraveseAL*///int level=1;//递归进行的层数int exist_path_DFS(ALGraph *G,int i,int j)//深度优先判断有向图G中顶点i到顶点j是否有路径,是则返回1,否则返回0{EdgeNode *p;int k;if(i==j) return 1; //i就是jelse{visited[i]=true;//for(p=G->adjlist[i].firstedge;p;p=p->next,level--)for(p=G->adjlist[i].firstedge;p;p=p->next){//level++;k=p->adjvex;if(!visited[k] && exist_path_DFS(G,k,j)){printf("V%d ",k+1);return 1;//i下游的顶点到j有路径}}//forreturn 0;}//else//if (level==1) return 0;}//exist_path_DFSvoid main(){ALGraph *G;G=(ALGraph *)malloc(sizeof(ALGraph));CreateTestALGraph(G);int i,j;printf("请输入i和j的值格式:i,j\n");scanf("%d,%d",&i,&j);i=i-1;j=j-1;if(i==j){printf("i不能等于j\n");}else{if(exist_path_DFS(G,i,j)){printf("该路径存在。

Python图的遍历课程设计

Python图的遍历课程设计

Python图的遍历课程设计一、课程目标知识目标:1. 让学生掌握图的遍历基本概念,理解深度优先搜索(DFS)与广度优先搜索(BFS)的算法原理。

2. 能够运用Python编程语言实现图的邻接表表示方法。

3. 能够运用DFS和BFS算法对给定的图进行遍历,并输出遍历结果。

技能目标:1. 培养学生分析问题、解决问题的能力,能够将实际问题转化为图的遍历问题。

2. 培养学生的编程实践能力,能够独立编写和调试图的遍历程序。

3. 培养学生的团队协作能力,能够在小组讨论中发表自己的见解,共同解决问题。

情感态度价值观目标:1. 激发学生对计算机科学的兴趣,提高对编程的热爱和信心。

2. 培养学生面对困难时勇于挑战、积极进取的精神。

3. 培养学生的创新意识,鼓励学生尝试不同的算法解决问题。

课程性质:本课程为Python编程的进阶课程,以图的遍历为主题,旨在巩固学生已学的编程知识,提高学生的编程能力。

学生特点:学生已具备基本的Python编程能力,有一定的逻辑思维能力,但对复杂算法的理解和应用尚需引导。

教学要求:注重理论与实践相结合,以案例驱动教学,引导学生自主探究、合作学习,提高学生的编程实践能力。

在教学过程中,关注学生的个体差异,提供个性化的指导和支持。

二、教学内容1. 图的基本概念:图的结构定义,图的邻接矩阵与邻接表表示方法,图的遍历意义。

相关教材章节:第二章 图论基础,第1-3节。

2. 深度优先搜索(DFS)算法:DFS算法原理,递归实现与非递归实现,DFS 算法的应用。

相关教材章节:第二章 图论基础,第4节。

3. 广度优先搜索(BFS)算法:BFS算法原理,队列的应用,BFS算法的应用。

相关教材章节:第二章 图论基础,第5节。

4. Python实现图的遍历:图的邻接表表示,DFS和BFS算法的Python实现,遍历结果的输出。

实践项目:编写Python程序,实现对给定图的DFS和BFS遍历。

5. 图遍历应用案例分析:分析实际问题,将问题转化为图的遍历问题,运用所学算法解决问题。

图的遍历课程设计报告参考模板

图的遍历课程设计报告参考模板

广东工业大学华立学院课程设计(论文)课程名称数据结构题目名称图的遍历学生学部(系)专业班级学号学生姓名指导教师二○○八年七月八日广东工业大学华立学院课程设计(论文)任务书一、课程设计(论文)的内容图的遍历任务:实现图的深度优先, 广度优先遍历算法,并输出原图结构及遍历结果。

二、课程设计(论文)的要求与数据(1)函数功能要划分好(2)总体设计应画流程图(3)程序要加必要的注释(4)要提供程序测试方案三、课程设计(论文)应完成的工作(1)按照课程设计要求完成报告,具体内容包括:①具体任务;②软件环境;③算法设计思想及流程图;④.源代码;⑤调试分析及算法的改进设想;⑥运行结果;⑦总结;⑧参考文献等。

(2)课程设计报告可采用统一规范的格式单面打印,并装订成册上交。

(3)以班级为单位刻一张光盘上交。

四、课程设计(论文)进程安排五、应收集的资料及主要参考文献[1]数据结构—使用C语言(第3版)朱战立编,西安交通大学出版社。

[2]四川中外科技文化交流中心组编(王松主编).Visual C++ 6.0程序设计与开发指南.北京:高等教育出版社,2004[3]朱晴婷,黄海鹰,陈莲君.Visual C++程序设计──基础与实例分析.北京:清华大学出版社,2004发出任务书日期:2008 年5 月27 日指导教师签名:计划完成日期:2008 年7 月8 日教学单位责任人签章:目录任务书 (1)目录 (4)1).具体任务 (5)2).软件环境 (5)3).算法设计思想及流程图 (5)4).源代码: (6)5).调试分析: (11)6).运行结果 (11)7).参考文献 (11)8).收获及体会 (12)一、具体任务1.实现图的深度优先,广度优先遍历算法,并输出原图结构及遍历结果。

2.通过这次的程序设计,加深对图的遍历的认识,加强编程的能力。

二、运行环境(软、硬件环境)硬件环境:CPU 2.0Hz硬盘160G内存1G软件环境:Windows XpMicrosoft Visual C++ 6.0三、算法设计思想及流程图四、源代码#define M 20#include <stdio.h>#include <stdlib.h>#include <malloc.h>/*定义图*/typedef struct{int V[M];int R[M][M];int vexnum;}Graph;/*创建图*/void creatgraph(Graph *g,int n){int i,j,r1,r2;g->vexnum=n;/*顶点用i表示*/for(i=1;i<=n;i++){g->V[i]=i;}/*初始化R*/for(i=1;i<=n;i++)for(j=1;j<=n;j++){g->R[i][j]=0;}/*输入R*/printf("请按如下形式(2,4)输入R(0,0 END):\n"); scanf("%d,%d",&r1,&r2);while(r1!=0&&r2!=0){g->R[r1][r2]=1;g->R[r2][r1]=1;scanf("%d,%d",&r1,&r2);}}/*打印图的邻接矩阵*/void printgraph(Graph *g){int i,j;for(i=1;i<=g->vexnum;i++){ for(j=1;j<=g->vexnum;j++){printf("%2d ",g->R[i][j]);}printf("\n");}}/*全局变量:访问标志数组*/int visited[M];/*访问顶点*/void visitvex(Graph *g,int vex){printf("%d ",g->V[vex]);}/*获取第一个未被访问的邻接节点*/int firstadjvex(Graph *g,int vex){int w,i;for(i=1;i<=g->vexnum;i++){if(g->R[vex][i]==1&&visited[i]==0){w=i;break;}else{w=0;}}return w;}/*获取下一个未被访问的邻接节点(深度遍历)*/int nextadjvex(Graph *g,int vex,int w){int t;t=firstadjvex(g,w);return t;}/*深度递归遍历*/void dfs(Graph *g,int vex){int w;visited[vex]=1;visitvex(g,vex);for(w=firstadjvex(g,vex);w>0;w=nextadjvex(g,vex,w)) if(!visited[w]){dfs(g,w);}void dfstraverse(Graph *g){int i;for(i=1;i<=g->vexnum;i++)visited[i]=0;for(i=1;i<=g->vexnum;i++)if(!visited[i]){dfs(g,i);}}/*定义队列*/typedef struct{int V[M];int front;int rear;}Queue;/*初始化队列*/initqueue(Queue *q){q->front=0;q->rear=0;}/*判断队列是否为空*/int quempty(Queue *q){if(q->front==q->rear){return 0;}else{return 1;}}/*入队操作*/enqueue(Queue *q,int e){if((q->rear+1)%M==q->front){printf("The queue is overflow!\n"); return 0;}else{q->V[q->rear]=e;q->rear=(q->rear+1)%M;return 1;}}/*出队操作*/dequeue(Queue *q){int t;if(q->front==q->rear){printf("The queue is empty!\n"); return 0;else{t=q->V[q->front];q->front=(q->front+1)%M;return t;}}/*广度遍历*/void BESTraverse(Graph *g){int i;Queue *q=(Queue *)malloc(sizeof(Queue));for(i=1;i<=g->vexnum;i++){visited[i]=0;}initqueue(q);for(i=1;i<=g->vexnum;i++){if(!visited[i]){visited[i]=1;visitvex(g,g->V[i]);enqueue(q,g->V[i]);while(!quempty(q)){int u,w;u=dequeue(q);for(w=firstadjvex(g,u);w>0;w=nextadjvex(g,u,w)){if(!visited[w]){visited[w]=1;visitvex(g,w);enqueue(q,w);}}}}}}/*主程序*/main(){int n;Graph *g=(Graph *)malloc(sizeof(Graph));char menu;printf("请输入节点的个数:\n");scanf("%d",&n);creatgraph(g,n);printf("This is the linjiejuzhen of graph:\n");printgraph(g);input:printf("Please input b or d or q ,Breadth_first: b Depth_first: d quit: q\n");while((menu=getchar())=='\n');if(menu=='b')printf("Breadth_first:\n");BESTraverse(g);printf("\n");goto input;}else if(menu=='d'){printf("Depth_first:\n");dfstraverse(g);printf("\n");goto input;}else if(menu=='q'){exit(0);}else{printf("Input error!Please input b or d!\n");}}五、调试分析及算法的改进设想1.由于对图的性质和算法掌握的比较好,所以在程序运行是比较顺利,没有遇到大的问题。

图的深度优先遍历实验报告

图的深度优先遍历实验报告

.\ 一.实验目的熟悉图的存储结构,掌握用单链表存储数据元素信息和数据元素之间的关系的信息的方法,并能运用图的深度优先搜索遍历一个图,对其输出。

二.实验原理深度优先搜索遍历是树的先根遍历的推广。

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

图的邻接表的存储表示:#define MAX_VERTEX_NUM 20#define MAXNAME 10typedef char VertexType[MAXNAME];typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{VertexType data;ArcNode *firstarc;.\ }VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;三.实验内容编写LocateVex函数,Create函数,print函数,main函数,输入要构造的图的相关信息,得到其邻接表并输出显示。

四。

实验步骤1)结构体定义,预定义,全局变量定义。

#include"stdio.h"#include"stdlib.h"#include"string.h"#define FALSE 0#define TRUE 1#define MAX 20typedef int Boolean;#define MAX_VERTEX_NUM 20#define MAXNAME 10typedef char VertexType[MAXNAME];typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{VertexType data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;ALGraph G;Boolean visited[MAX];int degree[MAX_VERTEX_NUM];//定义一个数组求每一个顶点的总度数(无向图)或出度(有向图)。

图的遍历的实现 课设报告

图的遍历的实现 课设报告

数据结构课程设计设计说明书图的遍历的实现学生姓名周朝学号********** 班级网络1101班成绩指导教师申静数学与计算机科学学院2014年1 月4日课程设计任务书2013—2014学年第一学期课程设计名称:数据结构课程设计课程设计题目:图的遍历实现完成期限:自2013年12 月23日至2014年 1 月4 日共 2 周设计内容:1. 任务说明(1) 采用邻接表存储结构创建一个图;(2) 编程实现图的深度优先搜索(或广度优先搜索)遍历算法;(3) 输出遍历结果;(4) 给定具体数据调试程序。

2. 要求1)问题分析和任务定义:根据设计题目的要求,充分地分析和理解问题,明确问题要求做什么?2)逻辑设计:写出抽象数据类型的定义,各个主要模块的算法,并画出模块之间的调用关系图;3)详细设计:定义相应的存储结构并写出各函数的伪码算法。

4)程序编码:把详细设计的结果进一步求精为程序设计语言程序。

5)程序调试与测试:采用自底向上,分模块进行,即先调试低层函数。

6)结果分析:程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。

算法的时间、空间复杂性分析;7)编写课程设计报告。

3. 参考资料指导教师:申静教研室负责人:余冬梅课程设计评阅摘要本课程设计主要目的在于更深一步的了解图的遍历的问题,以无向图为例分别实现了广度优先遍历和深度优先遍历,在课程设计中,程序设计设计语言采用Visual C,程序运行平台为Windows 98/2000/XP。

在程序设计中我主要是解决的是给出一个图如何用多种方法完成图的遍历的问题。

程序最终通过调试运行,实现了设计目标。

关键词:程序设计;数据结构;无向图目录一课题描述 (1)二设计目的与任务 (2)2.1课程设计的目的 (2)2.2课程设计的任务 (2)三设计方案和实施 (3)3.1总体设计 (3)3.2基本操作 (3)3.3详细设计 (4)四运行调试结果 (6)五结论与致谢 (9)六附录 (10)一课题描述图是一种较为复杂且重要的数据结构,其特殊性在于图形结构中结点之间的关系可以是任意的,图中任意两个数据元素之间都有可能相关。

无向图的深度优先遍历操作

无向图的深度优先遍历操作

信息工程学院《数据结构》课程设计报告设计题目无向图的深度优先遍历操作专业班级小组成员一、题目:无向图的深度优先遍历操作二、小组任务分工共同编写三、设计目标帮助学生熟练掌握图的遍历循环。

四、问题描述为了实现图的深度优先遍历操作五、概要设计void createGraph(int (*edge)[VERTEXNUM],int start, int end);//创建图函数void displayGraph(int (*edge)[VERTEXNUM]);void DFT(int (*edge)[VERTEXNUM],int* vertexStartusArr);//图的深度优先遍历函数void DFTcore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr);六、详细设计(程序代码及核心代码流程图)#include"stdio.h"#include"malloc.h"#define VERTEXNUM 5//函数声明void createGraph(int (*edge)[VERTEXNUM],int start, int end);void displayGraph(int (*edge)[VERTEXNUM]);void DFS(int (*edge)[VERTEXNUM],int* vertexStartusArr);void DFScore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr);void createGraph(int (*edge)[VERTEXNUM],int start,int end) //写入数据 1 创建结点位置存进数组{edge[start][end] = 1;}void displayGraph(int (*edge)[VERTEXNUM])//打印存储的图{int i,j;for(i=0;i<VERTEXNUM;i++){for(j=0;j<VERTEXNUM;j++){printf(" %d",edge[i][j]);}printf("\n");}}//深度优先遍历void DFS(int (*edge)[VERTEXNUM],int* vertexStatusArr){ int i;printf("深度遍历循环后的结果:\n");for(i=0;i<VERTEXNUM;i++){DFScore(edge,i,vertexStatusArr);//调用}printf("\n");}void DFScore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr)//核心{int j;if(vertexStatusArr[i]== 1){return; //返回到函数结束}printf("%d",i);//打印数字vertexStatusArr[i] = 1;for(j=0;j<VERTEXNUM;j++){if(edge[i][j] == 1){DFScore(edge,j,vertexStatusArr);}}}int main(void){ //动态创建存放边的二维数组int(*edge)[VERTEXNUM] =(int(*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);int i,j;for(i=0;i<VERTEXNUM;i++)//初始化矩阵{for(j=0;j<VERTEXNUM;j++){edge[i][j]=0;}}//存放顶点的遍历状态,0:未遍历,1:已遍历int* vertexStatusArr =(int*)malloc(sizeof(int)*VERTEXNUM);for(i=0;i<VERTEXNUM;i++){vertexStatusArr[i] = 0;}printf("初始化后:\n");displayGraph(edge);//打印存储的图createGraph(edge,0,3); //创建结点位置存进数组createGraph(edge,3,0);createGraph(edge,0,4);createGraph(edge,4,0);createGraph(edge,3,1);createGraph(edge,1,3);createGraph(edge,3,2);createGraph(edge,2,3);createGraph(edge,4,1);createGraph(edge,1,4);printf("图创建后的矩阵:\n");displayGraph(edge);DFS(edge,vertexStatusArr);//深度优先遍历free(edge);return 0;}七、测试数据八、课程设计总结通过此次课程设计,令我们感触颇深,首先,借助双重for循环初始化图所对应的矩阵,然后,借助调用函数一次将图所对应的矩阵表示并打印出来,然后,将深度优先遍历的结果打印输出,在此次设计过程中,遇到了相当数量的问题,首先,对于知识不能够灵活应用,为此,使得此次课程设计的难度加大,但也正因为如此,使我们能够在自主学习(课程设计的完成)的过程中将知识点完全理解、吃透。

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

合肥学院计算机科学与技术系课程设计报告2013~2014学年第二学期课程数据结构与算法课程设计名称图的深度优先遍历算法的实现学生姓名陈琳学号1204091022专业班级软件工程指导教师何立新2014 年9 月一:问题分析和任务定义涉及到数据结构遍会涉及到对应存储方法的遍历问题。

本次程序采用邻接表的存储方法,并且以深度优先实现遍历的过程得到其遍历序列。

深度优先遍历图的方法是,从图中某顶点v 出发: (1)访问顶点v ;(2)依次从v 的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v 有路径相通的顶点都被访问;(3)若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

二:数据结构的选择和概要设计 设计流程如图:图1 设计流程利用一维数组创建邻接表,同时还需要一个一维数组来存储顶点信息。

之后利用创建的邻接表来创建图,最后用深度优先的方法来实现遍历。

图 2 原始图 1.从0开始,首先找到0的关联顶点32.由3出发,找到1;由1出发,没有关联的顶点。

3.回到3,从3出发,找到2;由2出发,没有关联的顶点。

4.回到4,出4出发,找到1,因为1已经被访问过了,所以不访问。

所以最后顺序是0,3,1,2,4三:详细设计和编码1.创建邻接表和图void CreateALGraph (ALGraph* G) //建立邻接表函数.{int i,j,k,s;char y;EdgeNode* p; //工作指针.printf("请输入图的顶点数n与边数e(以逗号做分隔符):\n");scanf("%d,%d",&(G->n),&(G->e));scanf("%c",&y); //用y来接收回车符.for(s=0;s<G->n;s++){printf("请输入下标为%d的顶点的元素:\n",s);scanf("%c",&(G->adjlist[s].vertex));scanf("%c",&y); //用y来接收回车符.当后面要输入的是和单个字符有关的数据时候要存贮回车符,以免回车符被误接收。

G->adjlist[s].firstedge=NULL;}printf("请分别输入该图的%d条弧\n",G->e);for(k=0;k<G->e;k++){printf("请输入第%d条弧的起点和终点(起点下标,终点下标):\n",(k+1));scanf("%d,%d",&i,&j);p=(EdgeNode*)malloc(sizeof(EdgeNode));p->adjvex=j;p->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=p;}}2.深度优先遍历void DFS(ALGraph* G,int v) //深度优先遍历{EdgeNode* p;int w;printf("%c ",G->adjlist[v].vertex);visited[v]=True;for(p=G->adjlist[v].firstedge;p;p=p->next){w=p->adjvex;if(!visited[w])DFS(G,w); //对于没有访问过的顶点,调用深度优先搜索函数 }}void DFStraverse(ALGraph* G){int v;for(v=0;v<G->n;v++){visited[v]=False;}for(v=0;v<G->n;v++) //对v尚未访问到的邻接点w进行一个递归遍历.{if(!visited[v])DFS(G,v);}}四:上机调试过程在创建图时,输入程序printf("第%d条弧的起点和终点(格式为"起点下标,终点下标"):\n",(k+1));运行发现有十六个错误,错误截图为:图3 调试错误图经调试,将该段程序修改为:printf("请输入第%d 条弧的起点和终点(起点下标,终点下标):\n",(k+1));即可成功。

五:测试结果及其分析 1.测试结果:图4 测试结果图 2.分析此程序的图如下:图5 原始图遍历从0开始,第一步到3 0 3 241图6 第一次遍历与3相连的有1和2,在此先遍历1图7 第二次遍历而与1相关的没有,则返回到3,与3相连的有1和2,1遍历过,所以遍历2图8 第三次遍历2没有与之相关的顶点返回3,3的所有相关都遍历过,返回0,只剩下4图9 第四次遍历与4相关的1已遍历过,返回0,0的所有相关都已遍历,则深度优先遍历结束。

遍历顺序:0 3 1 2 4六:用户使用说明1.根据屏幕提示输入图的顶点数n与边数e(以逗号做分隔符);2.依次输入下标为0,1,2……(n-1)的顶点的元素;3.依次输入第1,2……e条弧的起点和终点,格式为:起点下标,终点下标;4.即可得出所输入图的深度优先遍历序列;七:参考文献1.王昆仑、李红.《数据结构与算法(第二版)》.北京:中国铁道出版社,20122.程杰.《大话数据结构[M]》.北京:清华大学出版社,20113.韩利凯、李军.《数据结构[M]》.浙江:浙江大学出版社,20134.谢若阳.《数据结构[M].北京》:清华大学出版社,20105.黄国瑜、叶乃菁.《数据结构[M]》.北京:清华大学出版社,2009八:附录//以邻接表为存储结构的深度优先搜索算法#include "stdio.h"#include "malloc.h"#define MaxVerNum 8#define MAXSIZE 100 //顶点最大个数#define False 0#define True 1int visited[MaxVerNum];//全局变量,0表示未被访问过,1表示已被访问过typedef char VertexType;typedef struct node //邻接表节点.{int adjvex; //邻接点的位置struct node* next; //指向下一个节点}EdgeNode; //邻接表中的节点类型typedef struct vnode //顶点节点.{VertexType vertex; //顶点信息EdgeNode* firstedge; //指向第一个邻接表节点}VertexNode; //表头节点类型typedef struct{VertexNode adjlist[MaxVerNum];//存储邻接表节点的一维数组int n,e; //定义顶点数n和边数e}ALGraph; //邻接表类型void CreateALGraph (ALGraph* G) //建立邻接表函数.{int i,j,k,s;char y;EdgeNode* p; //工作指针.printf("请输入图的顶点数n与边数e(以逗号做分隔符):\n");scanf("%d,%d",&(G->n),&(G->e));scanf("%c",&y); //用y来接收回车符.for(s=0;s<G->n;s++){printf(“请输入下标为%d的顶点的元素:\n",s);scanf("%c",&(G->adjlist[s].vertex));scanf("%c",&y);//用y来接收回车符.当后面要输入的是和单个字符有关的数据时候要存贮回车符,以免回车符被误接收。

G->adjlist[s].firstedge=NULL;}printf("请分别输入该图的%d条弧\n",G->e);for(k=0;k<G->e;k++){printf("请输入第%d条弧的起点和终点(起点下标,终点下标):\n",(k+1));scanf("%d,%d",&i,&j);p=(EdgeNode*)malloc(sizeof(EdgeNode))p->adjvex=j;p->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=p;}}void DFS(ALGraph* G,int v) //深度优先遍历{EdgeNode* p;int w;printf("%c ",G->adjlist[v].vertex);visited[v]=True;for(p=G->adjlist[v].firstedge;p;p=p->next)w=p->adjvex;if(!visited[w])DFS(G,w); //对于没有访问过的顶点,调用深度优先搜索函数}}void DFStraverse(ALGraph* G){int v;for(v=0;v<G->n;v++){visited[v]=False;}for(v=0;v<G->n;v++) //对v尚未访问到的邻接点w进行一个递归遍历{if(!visited[v])DFS(G,,v)}}int main(){ALGraph net; //定义一个有向图CreateALGraph(&net); //创建一个给定的有向图printf("图的深度优先遍历为:\n");DFStraverse(&net); //进行该有向图的深度优先遍历,并打印结果printf("\n");return 0;}。

相关文档
最新文档