图的遍历的实现课程设计
图的遍历 实验报告
图的遍历实验报告一、引言图是一种非线性的数据结构，由一组节点（顶点）和节点之间的连线（边）组成。
图的遍历是指按照某种规则依次访问图中的每个节点，以便获取或处理节点中的信息。
图的遍历在计算机科学领域中有着广泛的应用，例如在社交网络中寻找关系紧密的人员，或者在地图中搜索最短路径等。
本实验旨在通过实际操作，掌握图的遍历算法。
在本实验中，我们将实现两种常见的图的遍历算法：深度优先搜索（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表示边的数量。
数据结构课程设计文档-图的遍历
2012级计算机科学与技术专业《数据结构》课程设计文档设计题目图的遍历班级12网路工程组长学号3121101124 姓名庄俊坤学号3121101135 姓名林捷学号3121101136 姓名周柏煌学号3121101160 姓名赵云鹏学号3111101119 姓名谢国印完成日期2014.1前言图遍历又称图的遍历，属于数据结构中的内容。
指的是从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。
图的遍历操作和树的遍历操作功能相似。
图的遍历是图的一种基本操作，图的许多其它操作都是建立在遍历操作的基础之上。
一、设计题目图遍历的演示二、实验目的：本课程设计是《数据结构》课程的组成之一，也是它的继续和延伸。
采用集中学习方法，分组完成一个小型应用系统。
开设本课程的目的是使学生通过参加小型软件的开发过程，进一步了解并掌握数据结构与算法的设计方法，具备初步的分析和设计能力；同时培养学生的创新能力和创新意识，锻炼他们的团队协作精神。
三、问题描述：由于图结构本身的复杂性，所以图的遍历操作也较复杂，主要表现在以下四个方面：①在图结构中，没有一个“自然”的首结点，图中任意一个顶点都可作为第一个被访问的结点。
②在非连通图中，从一个顶点出发，只能够访问它所在的连通分量上的所有顶点，因此，还需考虑如何选取下一个出发点以访问图中其余的连通分量。
③在图结构中，如果有回路存在，那么一个顶点被访问之后，有可能沿回路又回到该顶点。
④在图结构中，一个顶点可以和其它多个顶点相连，当这样的顶点访问过后，存在如何选取下一个要访问的顶点的问题。
四、功能要求（1）以邻接表作为存储结构；（2）由用户指定遍历的起点；（3）实现深度优先和广度优先遍历；（4）输出深度优先遍历和广度优先遍历的结点访问序列；（5）并给出相应生成树的边集。
（6）给出至少3组测试数据，其中图顶点的个数大于10小于30。
较高要求：建立深度和广度生成树，按凹入表或树形打印生成树。
图的遍历课程设计报告参考模板
广东工业大学华立学院课程设计（论文）课程名称数据结构题目名称图的遍历学生学部（系）专业班级学号学生姓名指导教师二○○八年七月八日广东工业大学华立学院课程设计（论文）任务书一、课程设计（论文）的内容图的遍历任务：实现图的深度优先, 广度优先遍历算法，并输出原图结构及遍历结果。
二、课程设计（论文）的要求与数据（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．由于对图的性质和算法掌握的比较好，所以在程序运行是比较顺利，没有遇到大的问题。
图的遍历实验报告
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.引言数据结构是计算机科学与技术专业的一门核心专业基础课程，是一门理论性强、思维抽象、难度较大的课程。
在软件工程专业的课程体系中起着承上启下的作用，学好数据结构对于提高理论认知水平和实践能力有着极为重要的作用。
通过本门课程的学习，我们应该能透彻地理解各种数据对象的特点，学会数据的组织方法和实现方法，并进一步培养良好的程序设计能力和解决实际问题的能力。
我认为学习数据结构的最终目的是为了获得求解问题的能力。
对于现实世界中的问题，我们应该能从中抽象出一个适当的数学模型，该数学模型在计算机内部用相应的数据结构来表示，然后设计一个解此数学模型的算法，再进行编程调试，最后获得问题的解答。
图是一种非常重要的数据结构，在《数据结构》中也占着相当大的比重。
这个学期的数据结构课程中，我们学习了很多图的存储结构，有邻接矩阵、邻接表、十字链表等。
其中邻接矩阵和邻接表为图的主要存储结构。
图的邻接矩阵存储结构的主要特点是把图的边信息存储在一个矩阵中，是一种静态存储方法。
图的邻接表存储结构是一种顺序存储与链式存储相结合的存储方法。
从空间性能上说，图越稀疏邻接表的空间效率相应的越高。
从时间性能上来说，邻接表在图的算法中时间代价较邻接矩阵要低。
本课程设计主要是实现使用邻接表存储结构存储一个图，并在所存储的图中实现深度优先和广度优先遍历以及其链表结构的输出。
2.需求分析2.1 原理当图比较稀疏时，邻接表存储是最佳的选择。
并且在存储图的时候邻接表要比邻接矩阵节省时间。
在图存储在系统中后，我们有时还需要对图进行一些操作，如需要添加一个顶点，修改一个顶点，或者删除一个顶点，而这些操作都需要一图的深度优先及广度优先遍历为基础。
本系统将构建一个图，图的结点存储的是int型数据。
运行本系统可对该图进行链式结构输出、深度优先及广度优先遍历。
控制方法如下：表2-1 控制键的功能2.2 要求（1）建立基于邻接表的图；（2）对图进行遍历；（3）输出遍历结果；2.3 运行环境(1)WINDOWS 7系统(2)C++ 编译环境2.4 开发工具C++语言3.数据结构分析本课程设计是针对于图的，程序中采用邻接表进行数据存储。
Python图的遍历课程设计
Python图的遍历课程设计一、教学目标本课程旨在通过Python编程语言，让学生掌握图的遍历算法，培养学生的编程思维能力和问题解决能力。
具体目标如下：1.理解图的基本概念和相关术语。
2.掌握图的邻接表和邻接矩阵表示方法。
3.学习图的遍历算法，包括深度优先搜索和广度优先搜索。
4.能够使用Python语言实现图的邻接表和邻接矩阵。
5.能够使用Python语言实现深度优先搜索和广度优先搜索算法。
6.能够分析并解决图的相关问题，如最短路径、最小生成树等。
情感态度价值观目标：1.培养学生的团队合作意识和沟通能力，通过小组合作完成项目。
2.培养学生的问题解决能力和创新思维，鼓励学生自主探索和尝试新的解题方法。
二、教学内容本课程的教学内容主要包括图的基本概念、图的表示方法、图的遍历算法等。
具体安排如下：第1课时：图的基本概念和术语。
第2课时：图的邻接表和邻接矩阵表示方法。
第3课时：深度优先搜索算法。
第4课时：广度优先搜索算法。
第5课时：图的应用问题，如最短路径、最小生成树等。
三、教学方法为了激发学生的学习兴趣和主动性，本课程将采用多种教学方法，包括讲授法、讨论法、案例分析法和实验法等。
1.讲授法：通过教师的讲解和演示，让学生掌握图的基本概念和遍历算法。
2.讨论法：通过小组讨论和分享，培养学生的团队合作意识和问题解决能力。
3.案例分析法：通过分析实际案例，让学生理解和应用图的遍历算法解决实际问题。
4.实验法：通过编程实验，让学生动手实现图的表示和遍历算法，培养学生的编程能力。
四、教学资源为了支持教学内容和教学方法的实施，丰富学生的学习体验，我们将准备以下教学资源：1.教材：《Python编程：从入门到实践》2.参考书：《数据结构与算法分析：Python描述》3.多媒体资料：PPT课件、教学视频、在线编程练习平台4.实验设备：计算机、网络环境、编程软件（如Python IDE）五、教学评估本课程的教学评估将采用多元化的方式，以全面客观地评价学生的学习成果。
图遍历操作的实现
实验六图遍历操作的实现一、实验学时：2学时二、实验目的1．实现图的基本操作2．实现图的遍历操作三、实验内容（2,3选做）1. 深度优先和广度优先搜索图2. 求图的关键路径3．求图的最短路径四、主要仪器设备及耗材硬件：计算机一台软件：VC++ 6.0，MSDN2003或者以上版本五、实验步骤1. 分析问题2. 写出算法3. 编制程序4. 上机调试5. 分析结果六、程序清单#include <iostream>#include <stdlib.h>using namespace std;#define MaxInt 32767 //权值的最大值#define MVNum 100 //最大顶点数#define max 50//邻接矩阵存储结构定义typedef struct{char vexs[MVNum]; //存放顶点的数组int arcs[MVNum][MVNum]; //存放邻接矩阵的数组int vexnum,arcnum; //顶点数和边（弧）数}AMGraph;//边（弧）结点结构定义typedef struct ArcNode{int adjvex;struct ArcNode* nextarc;int weight;}ArcNode;//顶点类型定义typedef struct VNode{char data;ArcNode* firstarc;}VNode,AdjList[MVNum]; //顶点数组类型定义//邻接表结构定义typedef struct{AdjList vertices; //顶点数组int vexnum,arcnum; //顶点数和边（弧）数}ALGraph;//顺序队列结构定义typedef struct{int front; //队头int rear; //队尾char base[MVNum]; //存放队列元素的数组}SqQueue;bool visited[MVNum]; //存放图中顶点访问标志的数组//初始化队列void InitQueue(SqQueue &Q){Q.front = Q.rear = 0;}//判断队列Q是否为空，为空返回true，非空返回falsebool QueueEmpty(SqQueue Q){if(Q.rear == Q.front )return true;elsereturn false;}//入队操作，将n插入顺序队列Q的尾部void EnQueue(SqQueue &Q,int n){if(Q.rear-Q.front == MVNum) //队满时，不能执行入队操作exit(-1);else{Q.base[Q.rear] = n;Q.rear++;}}//出队操作，删除队列Q的队头元素，被删元素用n返回void DeQueue(SqQueue &Q,int &n){if(QueueEmpty(Q)) //若队列为空，不能执行出队操作exit(-1);else{n = Q.base [Q.front];Q.front++;}}//在以邻接表方式存储的图G中，查找值为ch的顶点的位置int LocateVex(ALGraph G,char ch){for(int i=0;i<G.vexnum;++i){if(G.vertices[i].data == ch)return i;}}//在以邻接矩阵方式存储的图G中，查找值为ch的顶点的位置int LocateVex1(AMGraph G,char ch){for(int i=0;i<G.vexnum;i++){if(G.vexs[i] == ch)return i;}}//以邻接表为存储结构，创建无向图Gvoid CreateUDG_AL(ALGraph &G){int i, j, k;char v1, v2;ArcNode *p1,*p2;cout<<"请输入要创建的无向图的顶点数和边数，中间用空格分隔:"<<endl;cin>>G.vexnum>>G.arcnum; //输入总顶点数，总边数cout<<"请输入图中的顶点"<<endl;for(i=0;i<G.vexnum;i++) //将顶点依次存储在数组G.vertices中{cin>>G.vertices[i].data; //输入顶点值G.vertices[i].firstarc=NULL; //初始化第i个表头结点的指针域为NULL}for(k=0;k<G.arcnum;k++) //输入各边，构造邻接表{cout<<"请输入第"<<k+1<<"条边的两个顶点"<<endl;cin >> v1 >> v2; //输入一条边依附的两个顶点i = LocateVex(G, v1); //查找顶点v1在图中的位置j = LocateVex(G, v2); //查找顶点v2在图中的位置,即顶点在G.vertices中的序号p1=new ArcNode; //创建一个新的边结点p1p1->adjvex=j; //设置p1的邻接点域为jp1->nextarc= G.vertices[i].firstarc; //把边结点p1插入到第i个边链表中（前插法）G.vertices[i].firstarc=p1; //将新结点p1插入顶点vi的边表头部p2=new ArcNode; //创建另一个对称的新的边结点p2p2->adjvex=i; //设置p1的邻接点域为ip2->nextarc= G.vertices[j].firstarc;G.vertices[j].firstarc=p2; //将新结点p2插入顶点vj的边表头部}}//以邻接矩阵为存储结构，创建有向图Gvoid CreateDG_AM(AMGraph &G){int i, j, k;char v1, v2;cout<<"请输入要创建的有向网的顶点数和边数，中间用空格分隔:"<<endl;cin>>G.vexnum>>G.arcnum; //输入总顶点数，总边数cout<<"请输入顶点"<<endl;for(i=0;i<G.vexnum ;i++) //将顶点依次存储在数组G.vexs中{cin>>G.vexs [i];}for(i=0;i<G.vexnum;++i) //初始化邻接矩阵,将邻接矩阵中的值初始化为极大值0 {for(j=0;j<G.vexnum;j++){G.arcs[i][j]=0;}}//依次输入每条弧及权值，建立邻接矩阵for(k=0;k<G.arcnum;k++){//构造邻接矩阵cout<<"请输入第"<<k+1<<"条弧的弧尾、弧头和权值（输入示例：a到b的一条弧，权值为20，输入方式：a b 20)"<<endl;cin>>v1>>v2; //输入弧尾v1，弧头v2和权值weighti = LocateVex1(G,v1); //确定v1和v2在G中的位置，即顶点数组的下标j = LocateVex1(G,v2);G.arcs[i][j]=1; //将邻接矩阵中第i行第j列的值修改为权值}}//以邻接矩阵为存储结构，创建有向网Gvoid CreateDN_AM(AMGraph &G){int i, j, k, w;char v1, v2;cout<<"请输入要创建的有向网的顶点数和边数，中间用空格分隔:"<<endl;cin>>G.vexnum>>G.arcnum; //输入总顶点数，总边数cout<<"请输入顶点"<<endl;for(i=0;i<G.vexnum ;i++) //将顶点依次存储在数组G.vexs中{cin>>G.vexs [i];}for(i=0;i<G.vexnum;++i)//初始化邻接矩阵,将邻接矩阵中的值初始化为极大值MaxInt {for(j=0;j<G.vexnum;j++){G.arcs[i][j]=MaxInt;}}//依次输入每条弧及权值，建立邻接矩阵for(k=0;k<G.arcnum;k++){//构造邻接矩阵cout<<"请输入第"<<k+1<<"条弧的弧尾、弧头和权值（输入示例：a到b的一条弧，权值为20，输入方式：a b 20)"<<endl;cin>>v1>>v2>>w; //输入弧尾v1，弧头v2和权值wi = LocateVex1(G,v1); //确定v1和v2在G中的位置，即顶点数组的下标j = LocateVex1(G,v2);G.arcs[i][j]=w; //将邻接矩阵中第i行第j列的值修改为权值}}//从图中的第v个顶点出发，深度遍历图G（以邻接表为存储结构）void DFS(ALGraph G,int v){ArcNode *p;int w;cout << G.vertices[v].data << " "; //输出第v个顶点visited[v] = true; //设置第v个顶点的访问标志//依次从v的未被访问过的邻接点出发，深度遍历图Gp = G.vertices[v].firstarc; //p指向v的边链表的第一个边结点while(p) //边结点非空{w = p->adjvex; //表示w是v的邻接点if(!visited[w]) DFS(G, w); //如果w未访问，则递归调用DFSp = p->nextarc; //p指向下一个边结点}}//深度遍历图Gvoid DFSTraverse(ALGraph G){int v;for(v=0;v<G.vexnum ;v++) //初始化所有顶点的访问标志位falsevisited[v] = false;for(v=0;v<G.vexnum ;v++) //逐一检查每个顶点的访问标志，找一个未被访问过的顶点v为出发点，对图G进行深度遍历{if(visited[v] == false)DFS(G,v);}}//从图中的第v个顶点出发，广度遍历图G（以邻接表为存储结构）void BFS(ALGraph G,int v){SqQueue Q; //Q为顺序队列ArcNode *p;int w,u;InitQueue(Q); //初始化队列Qcout<<G.vertices [v].data<<" "; //输出第v个顶点visited[v] = true; //设置第v个顶点的访问标志EnQueue(Q,v); //将第v个顶点入队while(!QueueEmpty(Q)){DeQueue(Q, u); //删除队头元素u，开始依次访问顶点u的未被访问过的邻接点p = G.vertices[u].firstarc;while(p){w = p->adjvex; //取得邻接点wif(!visited[w]){cout<<G.vertices[w].data<<" ";visited[w] = true;EnQueue(Q,w);}p = p->nextarc; //处理下一个边（弧）结点}}}//广度遍历图Gvoid BFSTraverse(ALGraph G){int v;for(v=0;v<G.vexnum;v++) //初始化所有顶点的访问标志位falsevisited[v] = false;for(v=0;v<G.vexnum;v++){if(visited[v] == false)BFS(G,v);}}//使用迪杰斯特拉算法求第v0个顶点到其它顶点的最短路径void ShortestPath_DIJ(AMGraph G,int v0){int D[MVNum],Path[MVNum],i,v,w,min;bool S[MVNum];for(v=0;v<G.vexnum;v++){S[v] = false; //S初始为空集D[v] = G.arcs[v0][v]; //将v0到各个终点的最短路径长度初始化为弧上的权值if(D[v] < MaxInt)Path[v] = v0; //如果v0和v之间有弧，则将v的前驱置为v0 elsePath[v] = -1; //如果v0和v之间无弧，则将v的前驱置为-1 }//将第v0个顶点设置为源点S[v0] = true;D[v0] = 0;//循环G.vexnum-1次,求第v0个顶点到图中其它顶点的最短距离for(i=1;i<G.vexnum;i++){min= MaxInt; //寻找距离源点最近的第v个顶点for(w=0;w<G.vexnum;++w){if(!S[w] && D[w] < min){ //选择一条当前的最短路径，终点为vv = w;min = D[w];}}S[v] = true; //将第v个顶点加入到S中，S表示已求得最短路径的顶点集合for(w=0;w<G.vexnum ;w++) //更新源点到其它顶点的最短距离{if(!S[w] && (D[v] + G.arcs[v][w] < D[w])){D[w] = D[v] + G.arcs[v][w]; //更新D[w]Path[w] = v; //更改w的前驱为v}}}//输出源点到其它顶点的最短路径及路径长度for(int i=0;i<G.vexnum ;i++){cout<<"顶点"<<G.vexs[v0]<<"到顶点"<<G.vexs[i]<<"的最短路径长度为"<<D[i]<<",路径为：";int temp = i;int temp1, temp2;int flag[max], m = 0;while (temp!= -1){flag[m++] = temp;temp1 = temp ;temp2 = Path[temp1];temp = temp2;}cout << G.vexs[flag[m-1]];for (int i = m-2; i >= 0; i--){cout << "->";cout <<G.vexs[flag[i]];}cout<<endl;}}void AdjacentMatrix(AMGraph &G){for(int i = 0 ; i < G.vexnum ; ++i){for( int j = 0; j < G.vexnum; ++j){if(j != G.vexnum - 1){if(G.arcs[i][j] != MaxInt)cout << G.arcs[i][j] << "\t";elsecout << "∞" << "\t";}else{if(G.arcs[i][j] != MaxInt)cout << G.arcs[i][j] <<endl;elsecout << "∞" <<endl;}}}}void AdjacencyList(ALGraph &G){for(int i = 0 ; i < G.vexnum ; ++i){VNode temp = G.vertices[i];ArcNode *p = temp.firstarc;if(p == NULL){cout << G.vertices[i].data;cout << endl;}else{cout << temp.data;while(p){cout << "->";cout << p->adjvex;p = p->nextarc;}}cout << endl;}}int main(){ALGraph G;AMGraph G1;char ch;int k;//以下操作完成无向图G的创建(基于邻接表存储方式)、G的深度遍历和广度遍历cout<<"以下操作完成无向图G的创建(基于邻接表存储方式)、G的深度遍历和广度遍历"<<endl;CreateUDG_AL(G); //创建无向图Gcout << "*****邻接表表示法创建的无向图*****" << endl;AdjacencyList(G);cout<<"图G的深度遍历序列为:";DFSTraverse(G); //深度优先遍历图Gcout<<endl;cout<<"图G的广度遍历序列为:";BFSTraverse(G); //广度优先遍历图Gcout<<endl<<endl;//以下操作完成有向网G1的创建(基于邻接矩阵存储方式),并在G1中求最短路径cout<<"******************************************************************** ********"<<endl;cout<<"以下操作完成有向网G1的创建(基于邻接矩阵存储方式),并在G1中求最短路径"<<endl;CreateDN_AM(G1); //创建有向网G1cout << "*****邻接矩阵表示法创建的有向网*****" << endl;AdjacentMatrix(G1);cout<<"请输入源点：";cin>>ch; //输入源点k=LocateVex1(G1,ch); //求源点在G1中的位置kShortestPath_DIJ(G1,k); //使用迪杰斯特拉算法求第k个顶点到其它顶点的最短路径return 0;}七、运行结果及分析一、无向图G的邻接表和深度、广度遍历：下图是一种解法：二、无向网G1的邻接矩阵和迪杰斯特拉求最短路径：下图是一种解法：三、问题与解决方法：问题一：广度遍历序列和预想的不一样。
数据结构课程设计-图的遍历
数据结构课程设计-图的遍历1. 介绍图是一种非线性数据结构，它由节点和边组成。
在图中，节点可以表示任何对象，而边则表示节点之间的关系。
图可以用于表示许多现实世界中的问题，例如社交网络、电路板和道路网络。
图遍历是图算法的基础，它是指从图的一个特定节点出发，按照一定顺序访问图中所有节点的过程。
在这篇文章中，我们将讨论基本的图遍历算法，包括深度优先遍历（DFS）和广度优先遍历（BFS）。
2. 深度优先遍历 (DFS)深度优先遍历是一种用于遍历或搜索树或图的算法。
在深度优先遍历中，我们先访问一个顶点，然后沿着这个顶点下一条未访问的边走到下一个顶点，直到遇到一个没有未访问的邻居为止。
然后我们回溯到之前的节点，并访问该节点的另一个未访问的邻居。
我们重复这个过程，直到所有的节点都被访问。
在深度优先遍历中，每个节点仅被访问一次。
深度优先遍历有两种实现方式：递归实现和迭代实现。
递归实现方式是深度优先遍历的传统实现方式。
当对一个节点进行深度优先遍历时，我们首先访问这个节点，然后递归地遍历它的每一个邻居节点。
这个过程会一直持续到当前节点的所有邻居节点都被访问到为止。
下面是递归实现方式的伪代码：void DFS(Node node){visit(node);for (Node neighbor : node.neighbors) {if (!neighbor.visited) {DFS(neighbor);}}}另一种实现方式是使用栈来模拟递归过程，称为迭代实现方式。
在这种实现方式中，我们使用深度优先搜索的方式逐步遍历节点。
在遍历过程中，我们将每个节点的邻居节点加入到栈中，以便后续处理。
下面是迭代实现方式的伪代码：void DFS(Node node){Stack stack = new Stack();stack.push(node);while (!stack.isEmpty()) {Node currentNode = stack.pop();if (!currentNode.visited) {visit(currentNode);for (Node neighbor : currentNode.neighbors) {stack.push(neighbor);}}}}3. 广度优先遍历 (BFS)广度优先遍历是另一种图遍历算法。
图遍历的演示课程设计报告.
合肥学院计算机科学与技术系课程设计报告20 11～20 12 学年第二学期课程数据结构与算法课程设计名称图遍历的演示学生姓名汪青松学号1004031010专业班级网络工程1班指导教师吕刚、陈圣兵2011 年 6 月图遍历的演示一、问题分析和任务定义很多涉及图上操作的算法都是以图的遍历操作为基础的。
试写一个程序，演示在连通的无向图上访问全部结点的操作。
将每个结点看做一个地名，如合肥。
然后任选国内的城市，起点未合肥，忽略城市间的里程。
设图的结点20-30个，每个结点用一个编号表示(如果一个图有n个结点，则它们的编号分别为1，2，…，n)。
通过输入图的全部边(存于数据文件中，从文件读写)输入一个图，每个边为一个数对，可以对边的输入顺序作出某种限制。
注意，生成树的边是有向边，端点顺序不能颠倒。
二、数据结构的选择和概要设计城市与城市之间的关系使没有方向的，无向图采用邻近多重表来实现，主要要表示无向图中的各个结点和边，在多重表中边是采用两个结点来表示的。
在邻接表中Edgenode表示邻接表中的结点类型，其中含有访问标记mark，一条边所依附的两个结点的序号ivex和jvex，以及分别指向依附于ivex和jvex 的顶点边的链域ilink和jlink。
其中，邻接表中的表头结点用Vexnode表示，包含了顶点信息data和指向第一个边结点的firstedge。
用AMLGraph表示整个无向图，包含了图的顶点vexnum和边数edgenum。
结点坐标信息：struct loc //结点坐标信息{int v; //结点序号int x; //x坐标int y; //y坐标};边结点数据结构：struct Edgenode //边结点{int mark;//标志域，指示该边是否被访问过(0:没有1:有)int ivex,jvex;//该边关联的两个顶点的位置Edgenode *ilink,*jlink;//分别指向关联这两个顶点的下一条边};顶点结点：struct Vexnode //顶点结点{int data; //顶点名称,用数字表示城市Edgenode *firstedge;//指向第一条关联该结点的边};AMLGraph类：三、详细设计和编码程序主体部分主要包括两大部分，一是遍历算法部分；另一部分是对演示图的处理。
(完整word版)图的遍历的实现课程设计
学号：课程设计题目图的遍历的实现学院计算机科学与技术学院专业软件工程班级姓名指导教师2013年12月23日课程设计任务书学生姓名：专业班级：指导教师：工作单位:计算机科学与技术学院题目: 图的遍历的实现初始条件：理论：学习了《数据结构》课程，掌握了一种计算机高级语言。
实践：计算机技术系实验中心提供计算机及软件开发环境。
要求完成的主要任务: (包括课程设计工作量及其技术要求，以及说明书撰写等具体要求)1、系统应具备的功能：1）先任意创建一个图;2)图的DFS，BFS的递归或非递归算法的实现3)要求用有向图或无向图分别实现4）要求用邻接矩阵、邻接表多种结构存储实现2、数据结构设计；3、主要算法设计;4、编程及上机实现;5、撰写课程设计报告,包括:(1)设计题目;（2）摘要和关键字(中文和英文)；(3）正文,包括引言、需求分析、数据结构设计、算法设计、有关技术的讨论、设计体会等；（4）结束语;（5）参考文献。
时间安排：2013年12月16日—-25日12月19日查阅资料12月20日系统设计12月21日—22日编程并上机调试12月23日撰写报告12月24日验收程序，提交设计报告书指导教师签名：2013年12月14日系主任(或责任教师）签名：年月日图的遍历的实现摘要本课程设计主要目的在于更深一步的了解图的遍历的问题，图的DFS,BFS的递归和非递归算法的实现,用有向图和无向图分别实现图的遍历,广度优先遍历和深度优先遍历的实现，用邻接矩阵和邻接表等多种结构存储存储图.在课程设计中,程序设计设计语言采用Visual C,程序运行平台为Windows 98/2000/XP。
在程序设计中我主要是解决的是给出一个图如何用多种方法完成图的遍历的问题，也包括如何创建一个图，深度优先遍历和广度优先遍历一个图，递归和非递归的方法实现图的遍历.程序最终通过调试运行，初步实现了设计目标。
关键词程序设计；数据结构；有向图；无向图;存储结构；邻接矩阵；递归算法Abstract The purpose of this course design is to further understand the problem of graph traversal，figure DFS and BFS recursive and non-recursive algorithms of implementation，using directed graph and undirected graph，graph traversal is implemented，breadth-first traversal and the realization of the depth-first traversal, using adjacency matrix and adjacency list and so on the many kinds of structure to store。
图的遍历实现课程设计 数据结构 程序 图
图的遍历实现课程设计-数据结图-程序-构．数据结构课程设计设计说明书图的遍历的实现学生姓名英茜1118064033学号级班网络1101班绩成教导指师静申数学与计算机科学学院2014年1 月4日课程设计任务书2014学年第一学期2013—课程设数据结构课程设计计名称：课程设图的遍历实现计题目：自2013年12 月23日至2014 完成年1 月4期限：日共 2 周设计内容：1. 任务说明(1) 采用邻接表存储结构创建一个图；(2) 编程实现图的深度优先搜索（或广度优先搜索）遍历算法；(3) 输出遍历结果；(4) 给定具体数据调试程序。
2. 要求1）问题分析和任务定义：根据设计题目的要求，充分地分析和理解问题，明确问题要求做什么？2）逻辑设计：写出抽象数据类型的定义，各个主要模块的算法，并画出模块之间的调用关系图；3）详细设计：定义相应的存储结构并写出各函数的伪码算法。
4）程序编码：把详细设计的结果进一步求精为程序设计语言程序。
5）程序调试与测试：采用自底向上，分模块进行，即先调试低层函数。
6）结果分析：程序运行结果包括正确的输入及其输出结果和含有错误的输入及其输出结果。
算法的时间、空间复杂性分析；7）编写课程设计报告。
3. 参考资料指导教师：申静教研室负责人：余冬梅课程设计评阅评语指导教师签名摘要针对图问题中如何更好地实现图的遍历问题，以无向图为例，分别采用广度优先遍历和深度优先遍历的算法实现对各节点的遍历，以VC++为开发环境进行系统的设计和实现，其运行结果表明，系统能很好地完成遍历后节点的输出，实现了遍历的目的，系统界面友好，可操作性强。
关键词：数据结构；存储结构；邻接矩阵目录一课题描述 (1)二................................................. 设计目的与任务 22.1课程设计的目的 (2)2.2课程设计的任务 (2)三................................................. 设计方案和实施 43.1总体设计 (4)3.2基本操作 (4)3.3详细设计 (6)四运行调试结果 (9)五结论与致谢 (9)六..................................................................... 附录11一课题描述数据结构是一门专业基础课，它对学习者的要求很明确：学会分析、研究计算机加工的数据结构的特性，以便为应用设计所需的数据选择适当的逻辑结构、存储结构及其相应的算法，并初步掌握算法的时间分析和空间分析的技术。
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. 图遍历应用案例分析：分析实际问题，将问题转化为图的遍历问题，运用所学算法解决问题。
图的深度优先遍历算法课程设计报告
合肥学院计算机科学与技术系课程设计报告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来接收回车符.当后面要输入的是和单个字符有关的数据时候要存贮回车符，以免回车符被误接收。
图的遍历课程设计
数据结构课程设计报告题目：图的遍历学生姓名：刘再科学号：0213专业班级：计科10102班同组姓名: 蔡双指导教师：孙叶枫设计时间： 2011年下学期第18周目录一．前言1. 课程设计的目的 (3)2.课程设计的基本要求 (4)二．课程设计内容 (5)三．系统（项目）设计 (6)四．源程序 (8)五．程序的调试及测试结果 (18)六．小结 (21)七．参考文献 (21)一．前言1、课程设计的目的《数据结构》主要介绍一些最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。
数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
学习数据结构是为了将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理。
通过课程设计可以提高学生的思维能力，促进学生的综合应用能力和专业素质的提高。
通过此次课程设计主要达到以下目的：⏹了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；⏹初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；⏹提高综合运用所学的理论知识和方法独立分析和解决问题的能力；⏹训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
2、课程设计的基本要求1.问题分析和任务定义：根据设计题目的要求，充分地分析和理解问题，明确问题要求做什么？（而不是怎么做？）限制条件是什么？2.逻辑设计：对问题描述中涉及的操作对象定义相应的数据类型，并按照以数据结构为中心的原则划分模块，定义主程序模块和各抽象数据类型。
逻辑设计的结果应写出每个抽象数据类型的定义(包括数据结构的描述和每个基本操作的功能说明)，各个主要模块的算法，并画出模块之间的调用关系图；3.详细设计：定义相应的存储结构并写出各函数的伪码算法。
图的优先遍历课程设计
图的优先遍历课程设计一、课程目标知识目标：1. 学生能理解图的优先遍历的基本概念，掌握其算法原理和应用场景。
2. 学生能运用所学算法，解决实际问题，如最短路径、拓扑排序等。
3. 学生了解优先遍历与其他遍历方法（如深度优先遍历、广度优先遍历）的区别和联系。
技能目标：1. 学生能运用编程语言（如Python）实现图的优先遍历算法。
2. 学生能通过实际案例分析，设计并优化图的优先遍历解决方案。
3. 学生具备分析问题、解决问题和团队协作的能力。
情感态度价值观目标：1. 学生培养对数据结构与算法的兴趣和热情，增强学习主动性和积极性。
2. 学生通过团队协作，培养沟通能力、团队意识和合作精神。
3. 学生在解决实际问题的过程中，体会算法的实用价值，提高对计算机科学的认识和兴趣。
本课程针对高中年级学生，结合学生已有知识水平和认知特点，注重理论与实践相结合，培养学生分析问题、解决问题的能力。
课程目标明确，分解为具体的学习成果，便于教学设计和评估。
在教学过程中，关注学生的个体差异，鼓励学生积极参与，提高课堂互动效果。
二、教学内容1. 图的基本概念：图的定义、顶点与边、有向图与无向图、连通图与连通分量。
2. 优先遍历算法原理：优先遍历的概念、优先队列的作用、优先遍历与深度优先遍历的关系。
3. 最短路径问题：Dijkstra算法原理、算法实现步骤、实际案例分析。
4. 拓扑排序：拓扑排序的概念、有向无环图（DAG）的判定、拓扑排序的算法实现。
5. 优先遍历的应用场景：如关键路径、任务调度等。
6. 编程实践：使用Python等编程语言实现优先遍历相关算法。
教学内容依据课程目标，结合教材相关章节，进行科学、系统的组织。
教学大纲安排如下：第一课时：图的基本概念及优先遍历原理介绍。
第二课时：Dijkstra算法及其实现。
第三课时：拓扑排序及其应用。
第四课时：优先遍历在其他场景的应用。
第五课时：编程实践，巩固所学知识。
教学内容注重理论与实践相结合，让学生在掌握基本概念和算法原理的基础上，通过实际案例和编程实践，提高解决问题的能力。
课程设计报告-图的遍历
目录一、课题的主要功能 (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算法思想本课题所采用的是邻接矩阵的方式存储图，实现图的深度、广度两种遍历，并将每种遍历结果输出来。
图的遍历_课程设计
图的遍历课程设计题目图的遍历教学院计算机专业班级姓名指导教师2011 年12 月31 日课程设计任务书2010 ～2011 学年第1 学期学生姓名：专业班级：指导教师：工作部门：一、课程设计题目图的遍历二、课程设计内容（含技术指标）1．显示图的邻接矩阵, 图的邻接表, 深度优先遍历, 广度优先遍历, 最小生成树PRIM算法, 最小生成树KRUSCAL算法,图的连通分量。
2．当用户选择的功能错误时，系统会输出相应的提示。
3．通过图操作的实现，把一些实际生活中的具体的事物抽象出来三、进度安排1．初步完成总体设计，搭好框架；2．完成最低要求：两种必须都要实现，写出画图的思路；3．进一步要求：画出图的结构，有兴趣的同学可以进一步改进图的效果。
四、基本要求1．界面友好，函数功能要划分好2．程序要加必要的注释3．要提供程序测试方案目录一概述 (1)1.问题描述 (1)2.系统分析 (1)3.课程设计（论文）进程安排 (1)二.总体设计方案 (2)1．整体设计思路 (2)2．算法的整体思路 (3)3．工作内容 (3)三详细设计 (4)1.详细设计思路及算法 (4)2.程序流程图 (11)四程序的调试与运行结果说明 (12)１.运行结果 (12)五．课程设计总结 (15)参考文献 (16)附录 A 原程序清单 (16)数据结构课程设计成绩评定表 (30)一概述1.问题描述1)函数功能要划分好2)总体设计应画流程图3)程序要加必要的注释4)要提供程序测试方案2.系统分析1)掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力2)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能3)提高综合运用所学的理论知识和方法独立分析和解决问题的能力4)训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风3.课程设计（论文）进程安排二.总体设计方案1．整体设计思路图的邻接矩阵：对于一个具有n个顶点的图，可以使用n*n的矩阵（二维数组）来表示它们间的邻接关系。
图的基本操作-遍历的实现
《数据结构》实验报告网络081200800824126甘春泉实验五图的遍历及其应用实现一、实验目的1．熟悉图常用的存储结构。
2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。
3．会用图的遍历解决简单的实际问题。
二、实验内容[题目一] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。
该程序包括图类型以及每一种操作的具体的函数定义和主函数。
三、实验步骤㈠、数据结构与核心算法的设计描述依次输入顶点偶对，建立无向图邻接表void CreatGraphAdList(ALGraph &G) // 依次输入顶点偶对，建立无向图邻接表{ArcNode *p;int i,j,k,m;cout<<"请输入无向图顶点的数目"<<endl;cin>>G.vexnum;cout<<"请输入无向图弧的数目"<<endl;num;for(k=1;k<=G.vexnum;k++)G.vertices[k].firstarc=NULL;//初始化每个链表为空for(m=1;m<=G.arcnum;m++){cout<<"输入一条边的两个顶点序号"<<endl;cin>>i>>j; //输入一条边依附的两个顶点的序号p=(ArcNode *)malloc(sizeof(ArcNode)); //生成一个结点p->adjvex=j; //为结点j的序号赋值p->data=j; //假设结点数据域为整型，且以结点序号为其值p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p; //将结点j插入到第i个链表p=(ArcNode *)malloc(sizeof(ArcNode)); //生成一个结点p->adjvex=i;p->data=i;p->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p; //将结点i插入到第j个链表// cin>>i>>j; //再次输入下一条边的两个顶点序号}}从第v个顶点出发递归的深度优先遍历图void DFS(ALGraph &G,int v,int flag[]){//从第v个顶点出发递归的深度优先遍历图ArcNode *p;int i;flag[v]=1;cout<<v;for(p=G.vertices[v].firstarc;p!=NULL;p=p->nextarc){i=p->adjvex;if(flag[i]==0)DFS(G,i,flag);}}对整个图G作深度优先遍历void GraphDFS(ALGraph &G) //对整个图G作深度优先遍历{int v;int flag[MAX_VERTEX_NUM];for(v=1;v<=G.vexnum;v++)flag[v]=0;for(v=1;v<=G.vexnum;v++){if(flag[v]==0)DFS(G,v,flag);}cout<<endl;}从第v个顶点出发对图G进行广度优先搜索void BFS(ALGraph &G,int v,int flag[]){//从第v个顶点出发对图G进行广度优先搜索int que[MAX_VERTEX_NUM]; //用队列que进行处理int front=0,rear=0; //front,rear分别为队头队尾ArcNode *p;flag[v]=1;cout<<v;que[0]=v;while(front<=rear) //当队不为空时{v=que[front++]; //访问过的顶点出队p=G.vertices[v].firstarc; //p指向v的第一个邻接边while(p!=NULL){v=p->adjvex;if(flag[v]==0){flag[v]=1;cout<<v;que[++rear]=v; //访问过的顶点入队}p=p->nextarc; //访问p的下一个邻接边}}}对整个图G作广度优先遍历void GraphBFS(ALGraph &G) //对整个图G作广度优先遍历{int v;for(v=1;v<=G.vexnum;v++)flag[v]=0;for(v=1;v<=G.vexnum;v++){if(flag[v]==0)BFS(G,v,flag);}cout<<endl;}构造一个空队列void InitQueue(LinkQueue &Q)// 构造一个空队列{Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(1);Q.front->next=NULL;}插入元素v为新的队尾元素int EnQueue(LinkQueue &Q,QElemType v)//插入元素v为新的队尾元素{QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(1);p->data=v;p->next=NULL;Q.rear->next=p;Q.rear=p;return 0;}检查队列是否为空int EmptyQueue(LinkQueue &Q)//检查队列是否为空{if(Q.front==Q.rear) //队列为空返回1，否则返回0return 1;elsereturn 0;}删除队列的队头元素int DeQueue(LinkQueue &Q,QElemType v)//删除队列的队头元素{QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(1);if(Q.front==Q.rear) return 0;else{p=Q.front->next;v=p->data;Q.front->next=p->next;}if(Q.rear==p)Q.rear=Q.front;free(p);return (v);}对图进行广度优先搜索遍历该图,并输出起对应的遍历序void BFSTraverse(ALGraph &G,int v,int flag[]){//对图进行广度优先搜索遍历该图,并输出起对应的遍历序LinkQueue Q;ArcNode *p;for(v=1;v<=G.vexnum;v++)flag[v]=0;InitQueue(Q);for(v=1;v<=G.vexnum;v++)if(flag[v]==0){flag[v]=1;cout<<v;EnQueue(Q,v);while(!EmptyQueue(Q)) //当队列不空{DeQueue(Q,v);for(p=G.vertices[v].firstarc;p!=NULL;p=p->nextarc){v=p->data;if(flag[v]==0){flag[v]=1;cout<<v;EnQueue(Q,v);}}}//while}//ifcout<<endl;}//BFSTraverse㈡、函数调用及主函数设计int main(){ALGraph G;int flag[MAX_VERTEX_NUM],v=1;cout<<"建立图的邻接表存储结构"<<endl;CreatGraphAdList(G);cout<<"图的深度优先搜索遍历"<<endl;GraphDFS(G);cout<<"图的广度优先搜索遍历1"<<endl;GraphBFS(G);cout<<"图的广度优先搜索遍历2"<<endl;BFSTraverse(G,v,flag);return 0;}㈢程序调试及运行结果分析依次输入顶点偶对，建立无向图G的邻接表以深度优先搜索和广度优先搜索遍历图G,并输出起对应的遍历序列（四）主要算法流程图：四、实验总结在深度优先搜索算法中，是深度越大的结点越先得到扩展。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学号：课程设计题目图的遍历的实现学院计算机科学与技术学院专业软件工程班级姓名指导教师2013 年12 月23 日课程设计任务书学生姓名：专业班级：指导教师：工作单位：计算机科学与技术学院题目: 图的遍历的实现初始条件：理论：学习了《数据结构》课程，掌握了一种计算机高级语言。
实践：计算机技术系实验中心提供计算机及软件开发环境。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1、系统应具备的功能：1)先任意创建一个图；2)图的DFS,BFS的递归或非递归算法的实现3)要求用有向图或无向图分别实现4)要求用邻接矩阵、邻接表多种结构存储实现2、数据结构设计；3、主要算法设计；4、编程及上机实现；5、撰写课程设计报告，包括：（1）设计题目；（2）摘要和关键字（中文和英文）；（3）正文，包括引言、需求分析、数据结构设计、算法设计、有关技术的讨论、设计体会等；（4）结束语；（5）参考文献。
时间安排：2013年12月16日--25日12月19日查阅资料12月20日系统设计12月21日-22日编程并上机调试12月23日撰写报告12月24日验收程序，提交设计报告书指导教师签名： 2013年12月14日系主任（或责任教师）签名：年月日图的遍历的实现摘要本课程设计主要目的在于更深一步的了解图的遍历的问题，图的DFS,BFS的递归和非递归算法的实现，用有向图和无向图分别实现图的遍历，广度优先遍历和深度优先遍历的实现，用邻接矩阵和邻接表等多种结构存储存储图。
在课程设计中，程序设计设计语言采用Visual C，程序运行平台为Windows 98/2000/XP。
在程序设计中我主要是解决的是给出一个图如何用多种方法完成图的遍历的问题，也包括如何创建一个图，深度优先遍历和广度优先遍历一个图，递归和非递归的方法实现图的遍历。
程序最终通过调试运行，初步实现了设计目标。
关键词程序设计；数据结构；有向图；无向图；存储结构；邻接矩阵；递归算法Abstract The purpose of this course design is to further understand the problem of graph traversal, figure DFS and BFS recursive and non-recursive algorithms of implementation, using directed graph and undirected graph, graph traversal is implemented, breadth-first traversal and the realization of the depth-first traversal, using adjacency matrix and adjacency list and so on the many kinds of structure to store.In curriculum design, using Visual C programming design language, application platform for Windows XP / 98/2000.In programming is given a figure I mainly solve how to use a variety of methods to complete graph traversal problems, including how to create a figure, depth-first traversal and breadth-first traversal a figure, the method of recursive and non-recursive traversal graph.Program debugging and running, ultimately through preliminary design goal is realized.Keywords program design;Data structure;Directed graph;Undirected graph.Storage structure;Adjacency matrix目录1.引言 (6)2.需求分析 (7)2.1 原理 (7)2.2要求 (7)2.3 运行环境 (7)2.4 开发工具 (7)3.数据结构分析 (8)3.1邻接表的结构： (8)3.2图的深度优先访问： (8)3.3图的广度优先遍历： (8)4. 算法设计 (9)4.1结构体定义及函数的声明 (9)4.2 主要模块的算法描述 (10)4.3 函数调用图 (11)5.程序实现及测试 (13)5.1 创建工程并建立文件 (13)6. 心得体会 (14)7.结束语 (15)参考文献 (16)附源程序清单和运行结果 (17)运行结果（截图） (22)本科生课程设计成绩评定表 (24)1.引言数据结构是计算机科学与技术专业的一门核心专业基础课程，是一门理论性强、思维抽象、难度较大的课程。
在软件工程专业的课程体系中起着承上启下的作用，学好数据结构对于提高理论认知水平和实践能力有着极为重要的作用。
通过本门课程的学习，我们应该能透彻地理解各种数据对象的特点，学会数据的组织方法和实现方法，并进一步培养良好的程序设计能力和解决实际问题的能力。
我认为学习数据结构的最终目的是为了获得求解问题的能力。
对于现实世界中的问题，我们应该能从中抽象出一个适当的数学模型，该数学模型在计算机内部用相应的数据结构来表示，然后设计一个解此数学模型的算法，再进行编程调试，最后获得问题的解答。
图是一种非常重要的数据结构，在《数据结构》中也占着相当大的比重。
这个学期的数据结构课程中，我们学习了很多图的存储结构，有邻接矩阵、邻接表、十字链表等。
其中邻接矩阵和邻接表为图的主要存储结构。
图的邻接矩阵存储结构的主要特点是把图的边信息存储在一个矩阵中，是一种静态存储方法。
图的邻接表存储结构是一种顺序存储与链式存储相结合的存储方法。
从空间性能上说，图越稀疏邻接表的空间效率相应的越高。
从时间性能上来说，邻接表在图的算法中时间代价较邻接矩阵要低。
本课程设计主要是实现使用邻接表存储结构存储一个图，并在所存储的图中实现深度优先和广度优先遍历以及其链表结构的输出。
2.需求分析2.1 原理当图比较稀疏时，邻接表存储是最佳的选择。
并且在存储图的时候邻接表要比邻接矩阵节省时间。
在图存储在系统中后，我们有时还需要对图进行一些操作，如需要添加一个顶点，修改一个顶点，或者删除一个顶点，而这些操作都需要一图的深度优先及广度优先遍历为基础。
本系统将构建一个图，图的结点存储的是int型数据。
运行本系统可对该图进行链式结构输出、深度优先及广度优先遍历。
控制方法如下：表2-1 控制键的功能2.2要求(1)先任意创建一个图；(2)图的DFS,BFS的递归或非递归算法的实现(3)要求用有向图或无向图分别实现(4)要求用邻接矩阵、邻接表多种结构存储实现2.3 运行环境(1)WINDOWS 7系统(2)C++ 编译环境2.4 开发工具C++语言3.数据结构分析本课程设计是针对于图的，程序中采用邻接表进行数据存储。
在计算机科学中，邻接表描述一种紧密相关的数据结构，用于表征图。
在邻接表的表示中，对于图中的每个顶点，我们将保存所有其它与之相连的顶点（即“邻接表”）。
邻接表是一种顺序存储与链式存储相结合的存储方法，该存储方式在图比较稀疏是相对于图的邻接矩阵存储有明显优势。
设计实现了图的邻接表结构输出、深度有新遍历和广度优先遍历操作的实现。
3.1邻接表的结构：（1）、头结点结构（2）、邻接点的结构Nextarc：邻接点的指针域，指向下一个邻接点；在该程序中，除了邻接表结构以外，还有到了一个mark[]数组，它是用来标记结点Vi是否被访问。
若Vi被访问，则mark[i]=1，否则为0；它是一个比较简单的一维数组。
（注：在每次对图进行遍历之前mark[]都会被清零）3.2图的深度优先访问：从图中每个顶点V出发，访问此顶点，然后依次从V的未访问邻接点出发深度优先遍历图，直至所有与V有通路的顶点被访问，否则选择另外未访问点作为起点，重复上述过程。
3.3图的广度优先遍历：从图中每个顶点V出发，访问此顶点，然后依次访问V的未访问邻接点，并保证先被访问的结点的邻接点先于后被访问的结点，直至所有与V有通路的顶点被访问，否则选择另外未访问点作为起点，重复上述过程。
4.算法设计4.1结构体定义及函数的声明（1）首先，要定义头文件，在头文件中定义邻接点point、图的基本结点graph以及在广度优先搜索中会用到队列queue。
具体如下：struct point{int n; //邻接点的序号point *next; //指向下一条弧节点的地址};struct graph{int data; //表接点的数据struct point *f; //结点的指针域，给出自该结点发出的第一弧节点的地址};struct queue{int elem[d]; //队列的容量int front; //front为首指针，指向第一个元素int rear; //rear为最后一个元素，指向队尾元素的下一个位置}q;其次，在头文件中还需定义邻接表存储结构下图的抽象数据类型定义。
（2）编写源文件，进行图的初始化，首先要输入顶点信息，初始化顶点表，在输入点v的值时，同时构造v的邻接点。
输入邻接点的序号，最后生成一个邻接点链表。
子函数功能：1.void creatgraph(int m) //n表示节点的个数构造图的链表结构，在此函数中要输入图结点的值，邻接点的序号。
2.void print(struct graph a[],int m)将图a的链表结构打印出来,m为结点个数3.void dpv(struct graph a[],int v)对图进行深度优先遍历。
先访问指定的顶点v，从该顶点的未被访问的邻接点中选取一个顶点p,从p出发进行深度优先遍历。
重复以上的步骤，直至图中所有和v有路径相通的顶点都被访问到。
4.void wdv(struct graph a[],int v,queue &Q)从v点开始广度优先遍历a是连通图或是连通分量），先访问顶点v，依次访问v的各个未被访问的邻接点v1,v2,…,vk,分别从,v1,v2,…vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问的顶点”被访问，直至图中所有与顶点v有路径相通的顶点都被访问到。