数据结构课程设计-图的遍历和生成树的求解实现说明书

合集下载

数据结构中的树与图算法教程

数据结构中的树与图算法教程第一章树的基本概念与遍历算法树是一种非线性数据结构，它由若干个节点组成，这些节点以层级的方式连接，形成分支的结构。

树中的一个节点被称为根节点，它没有父节点；其他节点可以有一个或多个父节点，这些节点被称为子节点。

树具有分支，但没有循环。

1.1 具体树的概念在树的结构中，每个节点可以有零个或者多个子节点，但是只能有一个父节点。

树具有层级关系，通过连接节点的边表示。

1.2 树的分类常见的树包括二叉树、二叉搜索树、红黑树等。

其中，二叉树是一种特殊的树结构，它的每个节点最多可以有两个子节点。

1.3 树的遍历算法树的遍历算法主要有前序遍历、中序遍历和后序遍历。

前序遍历是以根节点、左子树、右子树的顺序进行遍历；中序遍历是以左子树、根节点、右子树的顺序进行遍历；后序遍历是以左子树、右子树、根节点的顺序进行遍历。

第二章树的存储结构与常见应用2.1 树的存储结构树的存储结构有两种常见的实现方式，分别是链表实现和数组实现。

链表实现利用指针进行节点的连接，数组实现则使用数组的索引来表示节点之间的关系。

2.2 平衡二叉树平衡二叉树是一种自平衡的二叉搜索树，它的左右子树的高度差不超过1。

平衡二叉树的插入和删除操作都可以通过旋转操作进行平衡。

2.3 哈夫曼树哈夫曼树是一种特殊的二叉树，用于编码和解码数据。

哈夫曼树中出现频率高的字符距离根节点较近，而出现频率低的字符距离根节点较远，以实现编码的高效率。

第三章图的基本概念与遍历算法3.1 图的基本概念图是由节点和边组成的非线性数据结构。

节点表示实体，边表示节点之间的关系。

图可以分为有向图和无向图两种类型，有向图的边是有方向的，无向图的边没有方向。

3.2 图的存储结构图的存储结构有邻接矩阵和邻接表两种常见的方式。

邻接矩阵是一个二维数组，用于表示节点之间的连接关系；邻接表是由链表或者数组实现的，用于表示每个节点相邻节点的信息。

3.3 图的遍历算法图的遍历算法主要有深度优先搜索（DFS）和广度优先搜索（BFS）。

数据结构实验报告图的遍历讲解

数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。

图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。

图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。

本文将详细讲解图的遍历算法及其应用。

二、图的遍历算法1. 深度优先搜索（DFS）深度优先搜索是一种常用的图遍历算法，其基本思想是从一个顶点出发，沿着一条路径向来向下访问，直到无法继续为止，然后回溯到前一个顶点，再选择此外一条路径继续访问。

具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问。

（2）从v出发，选择一个未被访问的邻接顶点w，将w标记为已访问，并将w入栈。

（3）如果不存在未被访问的邻接顶点，则出栈一个顶点，继续访问其它未被访问的邻接顶点。

（4）重复步骤（2）和（3），直到栈为空。

2. 广度优先搜索（BFS）广度优先搜索是另一种常用的图遍历算法，其基本思想是从一个顶点出发，挨次访问其所有邻接顶点，然后再挨次访问邻接顶点的邻接顶点，以此类推，直到访问完所有顶点。

具体步骤如下：（1）选择一个起始顶点v，将其标记为已访问，并将v入队。

（2）从队首取出一个顶点w，访问w的所有未被访问的邻接顶点，并将这些顶点标记为已访问，并将它们入队。

（3）重复步骤（2），直到队列为空。

三、图的遍历应用图的遍历算法在实际应用中有广泛的应用，下面介绍两个典型的应用场景。

1. 连通分量连通分量是指图中的一个子图，其中的任意两个顶点都是连通的，即存在一条路径可以从一个顶点到达另一个顶点。

图的遍历算法可以用来求解连通分量的个数及其具体的顶点集合。

具体步骤如下：（1）对图中的每一个顶点进行遍历，如果该顶点未被访问，则从该顶点开始进行深度优先搜索或者广度优先搜索，将访问到的顶点标记为已访问。

（2）重复步骤（1），直到所有顶点都被访问。

2. 最短路径最短路径是指图中两个顶点之间的最短路径，可以用图的遍历算法来求解。

图的遍历和生成树求解说明书Word版

*******************实践教学*******************兰州理工大学计算机与通信学院2012年春季学期算法与数据结构课程设计题目：______________专业班级：_______________姓名：_______________学号：指导教师：李睿成绩：_______________目录摘要 (2)1．采用类C语言定义相关数据类型 (2)2．各模块流程图及伪码算法 (3)3．函数的调用关系图 (10)4．调试分析 (11)5．测试结果 (12)6.源程序（见附录） (18)设计总结 (19)参考文献 (20)致谢 (20)附件Ⅰ任务一源程序代码 (21)摘要很多涉及图上操作的算法都是以图的遍历操作为基础的，该设计要求写一个程序，演示出图遍历的过程，并给出图的生成树（网的最小代价生成树）。

通过该题目的设计过程，可以加深理解图数据结构及队列的逻辑结构、存储结构及图的深度优先和广度优先遍历过程，掌握图数据据结构上基本运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构，学会如何把学到的知识用于解决实际问题，培养动手能力。

关键字：图；深度优先遍历；广度优先遍历；生成树1．采用类C语言定义相关数据类型图存储结构的定义：1）顺序存储（邻接矩阵）#define MAX_VERTEX_NUM 30 //最大顶点个数Typedef enum{DG,DN,UDG,UDN} GraphKind; //图的种类：有向图、有向网、无向图、无向网ArcTypeAdjMtrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //ArcType 是顶点关系类型，对无权图，用0和1表示是否相邻，对于网，则为权值类型typedef struct {VertexType vex[MAX_VERTEX_NUM]; //顶点数组AdjMtrix arc; //邻接矩阵int vexnum,arcnum; //图中的顶点数和边数GraphKind kind; //图的种类}GraphMtrix;（2）邻接表的存储#define MAX_VERTEX_NUM 30 //最大顶点个数typedef struct EdgeNode{ //表结点int adjvex; //边或弧依赖的顶点序号InfType *info; //弧或边的相关信息，在网中则为权值struct EdgeNode *next;}EdgeNode;typedef struct VexNode{ //顶点元素VertexType vextex;EdgeNode *link;}VexNode,AdjList[MAX_VERTEX_NUM];typedef struct{ //邻接表AdjList vertices;int vexnum,arcnum; //图中的顶点数和边数GraphKind kind; //图的种类} AdjListGrap2．各模块流程图及伪码算法(1) 遍历算法a.深度优先遍历void DFS(AdjListGraph G,int v)//图G采用邻接表存储结构，v是遍历起始点在邻接表中的下标值，其下标从0开始{visited[v]=1; //置已访问标志visite(G.vertices[v].vextex); //访问顶点for (p = G.vertices[v].link; p; p = p->next)if (!visited[p->adjvex])DFS(G,p->adjvex);//当前顶点未访问，继续深度优先遍历} // DFSb.广度优先遍历void BFS(AdjListGrap G,intv)//图G采用邻接表存储结构，v是遍历起始点在邻接表中的下标，邻接表中下标从0开始，以队列作为基本辅助数据结构{InitQueue(Q); //初始化队列Qvisited[v]=1; //置已访问标志visite(G.vertices[v]. vextex); //访问顶点EnQueue(Q,v); //被访问顶点入队while (!QueueEmpty(Q)){DeQueue(Q,v); //出队列for (p = G.vertices[v].link; p; p = p->next) //找所有和v相邻接的顶点if (!visited[p->adjvex]){visited[p->adjvex]=1;visite(G.vertices [p->adjvex].vextex);EnQueue(Q,p->adjvex);} //if} //while} // BFS(2)流程图a.深度优先遍历dfstrab.广度优先遍历Bfstrac.Prim算法(3) 程序的伪代码算法：a.广度优先遍历：void dfstra (MGraph *G，int i){ /*以vi为出发点对邻接矩阵表示的图G进行DFS搜索，设邻接矩阵是0,l矩阵*/整型 j；打印 ("visit vertex：％c"，G->vexs[i])；/*访问顶点vi*/ visited[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为新出发点}DFSM*/说明：对于具有n个顶点和e条边的无向图或有向图，遍历算法DFSTraverse对图中每顶点至多调用一次DFS或DFSM。

图的遍历及生成树

• •邻接表的DFS算法
void DFS(ALGraph G, int v) { ArcNode *p;
visited[v] = 1; /*置已访问标记*/ printf("%d ", v); /*输出被访问顶点的编号*/ p = G.vertices[v].firstarc; /*p指向顶点v的第一个邻接点*/ while (p!=NULL) {
•v11
•v1,
•v2
•v3
•v2,
•v4,
•v5
•v8,
•v4
•v6
•v7
•v5,
•v3,
•v8
•v6,
•v7
•
•图的DFS算法一般描述
•int visited[MAXVEX]; //访问标志数组
•void DFSTraverse(Graph G)
•{ //对图G作深度优先遍历
• for( v=0; v<G.vexnum; ++v ) visited[v]=FALSE;
•} // DFS1
•G.arcs[v][j] ＝1
•有邻接点
•visited [n]=0
•未访问过
•
分析：
在遍历图时，对图中每个顶点至多调用一次DFS函数，因为一旦某个顶点被标志成已被访问，就不再从它出发进行搜索。
因此，遍历图的过程实质上是对每个顶点查找其邻接点的过程。其耗费的时间则取决于所采用的存储结构。如果用邻接矩阵来表示图，遍历图中每一个顶点都要从头扫描该顶点所在行，因此遍历全部顶点所需的时间为 O(n2)。如果用邻接表来表示图，虽然有 2e 个表结点，但只需扫描 e 个结点即可完成遍历，加上访问 n个头结点的时间，因此遍历图的时间复杂度为O(n+e)。

数据结构课程设计说明书-排序二叉树的建立及遍历的实现

课程设计任务书学生姓名： XXX 专业班级：计算机0502指导教师： XXX 工作单位：计算机科学与技术学院题目: 二叉排序树的建立及遍历的实现初始条件：理论：学习了《数据结构》课程，掌握了基本的数据结构和常用的算法；实践：计算机技术系实验室提供计算机及软件开发环境。

要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1、系统应具备的功能：（1）建立二叉排序树；（2）中序遍历二叉排序树并输出排序结果；2、数据结构设计；3、主要算法设计；4、编程及上机实现；5、撰写课程设计报告，包括：（1）设计题目；（2）摘要和关键字；（3）正文，包括引言、需求分析、数据结构设计、算法设计、程序实现及测试、设计体会等；（4）结束语；（5）参考文献。

时间安排：2007年7月2日－7日（第18周）7月2日查阅资料7月3日系统设计，数据结构设计，算法设计7月4日-5日编程并上机调试7月6日撰写报告7月7日验收程序，提交设计报告书。

指导教师签名： 2007年7月2日系主任（或责任教师）签名： 2007年7月2日排序二叉树的建立及其遍历的实现摘要：我所设计的课题为排序二叉树的建立及其遍历的实现，它的主要功能是将输入的数据组合成排序二叉树，并进行，先序，中序和后序遍历。

设计该课题采用了C语言程序设计，简洁而方便，它主要运用了建立函数，调用函数，建立递归函数等等方面来进行设计。

关键字：排序二叉树，先序遍历，中序遍历，后序遍历0．引言我所设计的题目为排序二叉树的建立及其遍历的实现。

排序二叉树或是一棵空树；或是具有以下性质的二叉树：（1）若它的左子树不空，则作子树上所有的结点的值均小于它的根结点的值；（2）若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；(3）它的左，右子树也分别为二叉排序树。

对排序二叉树的建立需知道其定义及其通过插入结点来建立排序二叉树，遍历及其输出结果。

该设计根据输入的数据进行建立排序二叉树。

数据结构课程设计python

数据结构课程设计python一、课程目标知识目标：1. 理解数据结构的基本概念，掌握常用数据结构如列表、元组、字典和集合的特点及应用场景。

2. 学习并掌握栈和队列的操作原理及其在Python中的实现方法。

3. 掌握树和图的基本概念，了解二叉树、遍历算法及图的表示方法。

技能目标：1. 能够运用Python语言实现基本数据结构，并对其进行增、删、改、查等操作。

2. 能够利用栈和队列解决实际问题，如递归、函数调用栈、任务调度等。

3. 能够运用树和图解决实际问题，如查找算法、路径规划等。

情感态度价值观目标：1. 培养学生严谨的逻辑思维，提高分析问题和解决问题的能力。

2. 激发学生对数据结构和算法的兴趣，培养良好的编程习惯。

3. 引导学生认识到数据结构在实际应用中的重要性，增强学习热情和责任感。

课程性质：本课程为高年级数据结构课程，旨在使学生掌握Python语言实现数据结构的方法，提高编程能力和解决问题的能力。

学生特点：学生具备一定的Python编程基础，具有较强的逻辑思维能力，对数据结构有一定的了解。

教学要求：结合实际案例，采用任务驱动法，引导学生通过实践掌握数据结构的基本原理和应用方法。

注重培养学生的动手能力和团队协作精神，提高学生的综合素质。

通过本课程的学习，使学生能够具备独立设计和实现小型项目的能力。

二、教学内容1. 数据结构基本概念：介绍数据结构的概念、作用和分类，结合Python语言特点，分析各类数据结构在实际应用中的优势。

- 列表、元组、字典和集合的原理与应用- 栈与队列的操作原理及实现2. 线性表：讲解线性表的概念，重点掌握顺序表和链表的操作方法。

- 顺序表和链表的实现及操作- 线性表的查找和排序算法3. 树与二叉树：介绍树的基本概念，重点讲解二叉树的结构及其遍历算法。

- 树的基本概念和表示方法- 二叉树的性质、存储结构、遍历方法4. 图：讲解图的基本概念，掌握图的存储结构及遍历方法。

- 图的基本概念和表示方法- 图的遍历算法（深度优先搜索、广度优先搜索）- 最短路径和最小生成树算法5. 算法分析与设计：结合实例，分析算法性能，掌握基本的算法设计方法。

图的遍历和生成树求解实现的课程结构设计

图是一种较线性表和树更为复杂的数据结构。

在线性表中,数据元素之间仅有线性关系,每一个数据元素惟独一个直接前驱和一个直接后继；在树形结构中, 数据元素之间有着明显的层次关系,并且每一层上的数据元素可能和下一层中多个元素〔及其孩子结点相关但只能和上一层中一个元素〔即双亲结点相关；而在图形结构中,节点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。

生成树求解主要利用普利姆和克雷斯特算法求解最小生成树,惟独强连通图才有生成树。

1> 先任意创建一个图；2> 图的 DFS,BFS 的递归和非递归算法的实现3> 最小生成树〔两个算法的实现,求连通分量的实现4> 要求用邻接矩阵、邻接表等多种结构存储实现输入数据类型为整型和字符型,输出为整型和字符a.图的邻接矩阵存储：根据所建无向图的结点数 n,建立n*n 的矩阵,其中元素全是无穷大〔int_max,再将边的信息存到数组中。

其中无权图的边用 1 表示, 无边用 0 表示；有全图的边为权值表示,无边用∞表示。

b.图的邻接表存储：将信息通过邻接矩阵转换到邻接表中,即将邻接矩阵的每一行都转成链表的形式将有边的结点进行存储。

c.图的广度优先遍历：假设从图中的某个顶点 v 出发,在访问了 v 之后挨次访问 v 的各个未曾经访问过的邻接点,然后再访问此邻接点的未被访问的邻接点, 并使"先被访问的顶点的邻接点"先于"后被访问的顶点的邻接点"被访问,直至图中所有已被访问的顶点的邻接点都被访问到。

若此时图中还有未被访问的,则另选未被访问的重复以上步骤,是一个非递归过程。

d.图的深度优先遍历：假设从图中某顶点 v 出发,依挨次访问 v 的邻接顶点, 然后再继续访问这个邻接点的系一个邻接点,如此重复,直至所有的点都被访问, 这是个递归的过程。

e.图的连通分量：这是对一个非强连通图的遍历,从多个结点出发进行搜索, 而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其连通分量的顶点集。

图的遍历及生成树.ppt

• 首先访问出发顶点v0 • 选择一个与v0相邻接的且末访问过的顶点w访问 • 再从w开始,按深度优先搜索…..
• 每当到达一个其所相邻接的顶点都已被访问过的顶点,则从最后所访问的顶点开始,依次退回到尚有邻接顶点末曾访问过的顶点u,并从u开始进行深序优先搜索…..
• 直到所有顶点都访问过或从任何一个已访问过的顶点出发,再也无法到达末曾访问过的顶点
int ver2;} E_NODE; L_NODE *head[MAXN]; int visit[MAXN]; E_NODE e[MAXN]; int n,m,u;
void creat_adj_list(head,n,e,m) L_NODE *head[ ]; E_NODE e[ ]; int n,m; {int i,u,v; L_NODE *p; for (i=1;i<=n;i++) head[i]=NULL; for(i=0;i<m;i++) { u=e[i].ver1; v=e[i]=ver2; p=(L_NODE*)moalloc(sizeof(L_NODE)); p->ver=v; p->link=head[u];head[u]=p; p=(L_NODE*)moalloc(sizeof(L_NODE)); p->ver=u; p->link=head[v];head[v]=p;} }
}
求图的连通分量
• 对图的每一个顶点进行检验
– 若被访问过,则该顶点落在已被求出的连通分量上
– 若末被访问过,则从该顶点出发遍历图,便可求得图的另一个连通分量
生成树和最小生成树
• 生成树:
设G是一个连通无向图,若G’是包含G中所有顶点的一个无回路的连通子图,则称G’是G的一棵生成树

《数据结构》课程设计

《数据结构》课程设计一、课程目标《数据结构》课程旨在帮助学生掌握计算机科学中基础的数据组织、管理和处理方法，培养其运用数据结构解决实际问题的能力。

课程目标如下：1. 知识目标：（1）理解基本数据结构的概念、原理和应用，如线性表、栈、队列、树、图等；（2）掌握常见算法的设计和分析方法，如排序、查找、递归、贪心、分治等；（3）了解数据结构在实际应用中的使用，如操作系统、数据库、编译器等。

2. 技能目标：（1）能够运用所学数据结构解决实际问题，具备良好的编程实践能力；（2）掌握算法分析方法，能够评价算法优劣，进行算法优化；（3）能够运用数据结构进行问题建模，提高问题解决效率。

3. 情感态度价值观目标：（1）激发学生对计算机科学的兴趣，培养其探索精神和创新意识；（2）培养学生团队合作意识，学会与他人共同解决问题；（3）增强学生的责任感和使命感，使其认识到数据结构在信息技术发展中的重要性。

本课程针对高中年级学生，结合学科特点和教学要求，将目标分解为具体的学习成果，为后续教学设计和评估提供依据。

课程注重理论与实践相结合，旨在提高学生的知识水平、技能素养和情感态度价值观。

二、教学内容《数据结构》教学内容依据课程目标进行选择和组织，确保科学性和系统性。

主要包括以下部分：1. 线性表：- 线性表的定义、特点和基本操作；- 顺序存储结构、链式存储结构及其应用；- 线性表的相关算法，如插入、删除、查找等。

2. 栈和队列：- 栈和队列的定义、特点及基本操作；- 栈和队列的存储结构及其应用；- 栈和队列相关算法，如进制转换、括号匹配等。

3. 树和二叉树：- 树的定义、基本术语和性质；- 二叉树的定义、性质、存储结构及遍历算法；- 线索二叉树、哈夫曼树及其应用。

4. 图：- 图的定义、基本术语和存储结构；- 图的遍历算法，如深度优先搜索、广度优先搜索；- 最短路径、最小生成树等算法。

5. 排序和查找：- 常见排序算法，如冒泡、选择、插入、快速等；- 常见查找算法，如顺序、二分、哈希等。

课程设计任务书8-图的遍历与应用算法设计与实现

完善设计；
1月11日：撰写设计说明书，准备答辩；
1月12日：答辩。
四、主要参考资料
1.严蔚敏，吴伟民.数据结构.清华大学出版社，2007
2.苏仕华.数据结构课程设计.机械工业出版社，2010
3.滕国文.数据结构课程设计.清华大学出版社，2010
指导教师（签名）：
1、用C语言或者C++语言进行程序设计，实现算法的功能。注重算法效率，代码要有适当的注释。
2、撰写课程设计说明书一份，不少于2000字。课程设计说明书应包括封面、任务书、成绩评定表、正文（设计思路、设计步骤等）、参考文献（资料）等内容。
三、进程安排
1月8日：进行需求分析，确定算法的主要功能和算法思路；进行详细设计，确定各模块的算法思路；
数据结构课程设计任务书
一、设计题目、内容及要求
1、设计题目：图的遍历与应用算法设计与实现。
2、设计内容及要求：
（1）使用邻接表建立图的存储结构。
（2）实现图的深度优先和广度优先遍历。
（3）实现图的两种应用算法，如判断图中两个顶点之间是否有路径，有向图的拓扑排序、无向图的最小生成树等应用算法。
二、要求的设计成果（课程设计说明书、设计实物、图纸等）
教研室主任（签名）：

数据结构40-图的遍历和生成树.

3﹑深度优先遍历生成树图的所有顶点加上遍历中经过的边所构成的子图叫图的生成树。
3﹑深度优先遍历算法分析对于连通图，在dfstravel函数中只要调用一次dfs，即可遍历图中所有顶点。对于非连通图，有几个连通分量，则调用几次。由此，也知道了如何求连通分量的个数。当用二维数组表示邻接矩阵作图的存储结构时，查找每个顶点的邻接点所需时间为O(n2)，其中n为图中顶点数。而当以邻接表作图的存储结构时，找邻接点所需时间为O(e)，其中e为无向图的边数或有向图的弧数。由此，当以邻接表作存储结构时，深度优先遍历图的时间复杂度为0(n+e)。
数
据
结
Hale Waihona Puke 构第四十课图的遍历和生成树
第三十二课图的遍历和生成树
本课主题：图的遍历和生成树的概念教学目的：图的遍历和生成树的概念教学重点：深度优先遍历﹑宽度优先遍历和生成树的概念教学难点：深度优先遍历﹑宽度优先遍历和生成树的概念授课内容：
一﹑图的遍历
图的遍历指，从图的某顶点出发，访问图的各顶点，使每个顶点被访问一次，且只被访问一次。访问的含义可以是输出个顶点的值，查询顶点，修改顶点等等。为了遍历方便，设辅助数组visited，初始时，数组元素的值均为0或false，表示未被遍历，一旦遍历，就置为1 或true。
1﹑深度优先遍历深度优先遍历的思想在图中从任意一个顶点（设为v0）开始，进行遍历, 接着找v0的第一邻接点，若该邻接点未被遍历，则遍历之，再找该邻接点的第一邻接点，若该第一邻接点已被遍历，则找其下一邻接点。若下一邻接点未被遍历，则遍历，再找它的第一邻接点
就这样递归向下进行。若遇到第一邻接点不存在，或下一邻接点也不存在时，则退回到调用的上一层。如此下去，若不能遍历完所有顶点（说明不是连通图），则再选一个未遍历的顶点，重新开始以上过程，直至所有顶点遍历完毕。

数据结构课程设计-图的遍历和构建

摘要图(Gｒaph)是一种复杂的非线性结构。

图可以分为无向图、有向图。

若将图的每条边都赋上一个权，则称这种带权图网络。

在人工智能、工程、数学、物理、化学、计算机科学等领域中，图结构有着广泛的应用。

在图结构中，对结点（图中常称为顶点)的前趋和后继个数都是不加以限制的,即结点之间的关系是任意的。

图中任意两个结点之间都可能相关。

图有两种常用的存储表示方法:邻接矩阵表示法和邻接表表示法。

在一个图中，邻接矩阵表示是唯一的，但邻接表表示不唯一。

在表示的过程中还可以实现图的遍历（深度优先遍历和广度优先遍历）及求图中顶点的度。

当然对于图的广度优先遍历还利用了队列的五种基本运算(置空队列、进队、出队、取队头元素、判队空)来实现。

这不仅让我们巩固了之前学的队列的基本操作，还懂得了将算法相互融合和运用。

目录第一章课程设计目的..................................................................................... 错误!未定义书签。

第二章课程设计内容和要求....................................................................... 错误!未定义书签。

2．1课程设计内容.................................................................................. 错误!未定义书签。

2.1.1图的邻接矩阵的建立与输出ﻩ错误!未定义书签。

2．１.２图的邻接表的建立与输出............................................... 错误!未定义书签。

2.1.3图的遍历的实现.................................................................... 错误!未定义书签。

数据结构实验指导(实验三：图的遍历生成树)

实验三：图的遍历生成树
实验项目：修改已有的先深、先广遍历程序,求先深、先广遍历生成树
实验类型: 设计性
实验目的：
1、学会把图转化为程序能识别的邻接矩阵；
2、透彻理解图的两种遍历方法及对应的生成树。

涉及的知识点：图的表示法、生成树的概念、图的深度优先、广度优先遍历算法实验内容：
1．问题的描述
该程序是对树进行先深、先广遍历，请在此基础上，改为处理指定图，求该图从指定结点出发的先深、先广遍历生成树。

原有主程序输入的图：
要求改为输入下图：
实验步骤：
1、读懂教师给定的程序；
2、把主程序中输入的图改为指定的图；
3、把显示遍历序列改为显示先深、先广遍历生成树，要求输出结果是：
完成以上功能之后，选做：
无向图的每条边当成有向图的两条边，要输入两次。

如何改进程序变成只需输入一次？在实验报告的“五、实验过程原始记录：”中指出头文件、主程序修改的地方，打印修改后的源代码。

2．实验报告的书写：
二、实验原理：
填写程序改动的方法、依据
五、实验过程原始记录：
打印与自己改写的源代码相关的程序段，附加注解
六、实验结果及分析：
打印屏幕输入、输出结果。

注意：除了从顶点1出发之外，再选择另一个结点，即打印两组测试数据（均使用上面指定输入的图，而不是源程序中的图！）。

数据结构图的遍历课程设计报告书

课程设计报告课程名称数据结构课题名称图的遍历专业网络工程班级学号姓名指导教师陈淑红、张晓清、黄哲2015年 6 月25 日湖南工程学院课程设计任务书课程名称数据结构课题图的遍历专业班级网络工程学生姓名学号指导老师陈淑红、张晓清、黄哲审批任务书下达日期2015 年 3 月 1 日任务完成日期2015 年6月25 日目录一、设计内容与设计要求 (2)1.1设计内容---------------------------------------------------------------------------------------2 1.2选题方案---------------------------------------------------------------------------------------2 1.3设计要求---------------------------------------------------------------------------------------21.4进度安排---------------------------------------------------------------------------------------5二、需求分析 (5)2.1程序功能---------------------------------------------------------------------------------------52.2输入输出要求---------------------------------------------------------------------------------5三、概要设计 (5)3.1流程图------------------------------------------------------------------------------------------5 3.2数据结构---------------------------------------------------------------------------------------63.3函数的调用关系图，主要函数的流程---------------------------------------------------9四、详细设计 (14)4.1定义图------------------------------------------------------------------------------------------14 4.2自动生成无向图------------------------------------------------------------------------------14 4.3手动生成无向图------------------------------------------------------------------------------16 4.4广度优先遍历---------------------------------------------------------------------------------174.5深度优先遍历---------------------------------------------------------------------------------20五、调试运行 (22)5.1 测试数据--------------------------------------------------------------------------------------22 5.2运行程序---------------------------------------------------------------------------------------22 5.3自动生成图操作------------------------------------------------------------------------------235.4手动生成图操作------------------------------------------------------------------------------26六、心得体会 (29)七、源代码 (29)八、评分表 (38)第一章设计内容与设计要求1.1设计内容1.1.1 算术24游戏演示由系统随机生成4张扑克牌，用户利用扑克牌的数字及运算符号“+”、“—”、“*”、“/”及括号“（”和“）”从键盘上输入一个计算表达式，系统运行后得出计算结果，如果结果等于24，则显示“Congratulation!”，否则显示“Incorrect!”设计思路：从键盘输入中缀表达式，然后将中缀表达式转换为后缀表达式，利用后缀表达式求值。

数据结构课程设计报告模板_图的遍历分解

数据结构课程设计报告书设计题目图遍历的演示姓名专业班级学号指导教师成绩评语2014年6月20日目录目录 (1)一、功能需求 (2)（一）原始数据 (2)（二）系统功能 (2)三、程序总体设计 (2)（一）数据结构 (2)(二) 函数原形清单 (3)（三）程序总体框架 (4)（四）详细代码 (4)四、程序清单 (15)五、总结 (18)一、功能需求以邻接多重表为存储结构，实现连通无向图的深度优先和广度优先遍历。

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

二、系统功能和原始数据（一）原始数据设图的顶点不超过20个，每个顶点用一个编号表示（如果一个图有n个顶点，则它们的编号分别为1,2，…，n）。

通过输入图的全部边输入一个图，每条边为一对整数，可以对边的输入顺序作某种限制。

注意，生成树的边是有向边，端点顺序不能颠倒。

（二）系统功能1.创建无向图2.打印无向图3.深度优先搜索4.广度优先搜索三、程序总体设计（一）数据结构typedef struct EBox{int mark;//访问标记,1代表已访问，0代表未访问int ivex,jvex;//该边依附的两个顶点的位置struct EBox *ilink,*jlink;//分别指向依附这两个顶点的下一条边//InfoType *info;//该边信息指针}EBox;typedef struct VexBox{VertexType data;EBox *firstedge;//指向第一条依附该顶点的边}VexBox;typedef struct{VexBox adjmulist[NUM];int vexnum,edgenum;//无向图的当前顶点数和边数}AMLGraph;//---------------------------------------------------队列的定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front,rear;}LinkQueue;(二) 函数原形清单int LocateVex(AMLGraph G,VertexType u)//寻找输入的数据在图中的位置,若不存在则返回-1int CreateGraph(AMLGraph &G)//采用邻接多重表存储表示，构造无向图GVertexType* GetVex(AMLGraph G,int v) //返回V的值int FirstAdjVex(AMLGraph G,VertexType v)//返回V的第一个邻接点的序号，若没有则返回-1int NextAdjVex(AMLGraph G,VertexType v,VertexType w)//返回V的(相对于W)的下一个邻接结点的序号，若W是V的最后一个邻接结点，则返回-1void DFS(AMLGraph G,int v)//深度优先搜索//深度优先遍历图void DFSTraverse(AMLGraph G,int(*Visit)(VertexType))int InitQueue(LinkQueue *Q) //队列的初始化int QueueEmpty(LinkQueue Q)//判断队列是否为空，为空则返回1，否则返回0int EnQueue(LinkQueue *Q,QElemType e) //向队列中插入元素int DeQueue(LinkQueue *Q,QElemType *e) //若队列不为空，则删除对头元素，并返回1；否则返回 0 void BFSTraverse(AMLGraph G ,int(*Visit)(VertexType)) //广度优先非递归遍历图G void MarkUnVisited(AMLGraph G) //把边的访问标记设置为0，即未被访问 void Display(AMLGraph G) //显示构造的无向图(包括定点数、顶点、边数、边)（三）程序总体框架（四）详细代码#include <iostream> using namespace std;//--------------------------------------------------------无向图的邻接多重表存储结构的定义 const int NUM=20;const int Data_Num=2;//每个顶点所表示的数据开始创建无向图打印无向图深度优先搜索创建无向图结束typedef char VertexType[Data_Num];typedef struct EBox{int mark;//访问标记,1代表已访问，0代表未访问int ivex,jvex;//该边依附的两个顶点的位置struct EBox *ilink,*jlink;//分别指向依附这两个顶点的下一条边}EBox;typedef struct VexBox{VertexType data;EBox *firstedge;//指向第一条依附该顶点的边}VexBox;typedef struct{VexBox adjmulist[NUM];int vexnum,edgenum;//无向图的当前顶点数和边数}AMLGraph;//---------------------------------------------------队列的定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front,rear;}LinkQueue;//寻找输入的数据在图中的位置,若不存在则返回-1int LocateVex(AMLGraph G,VertexType u){int i;for(i=0;i<G.vexnum;i++)if(strcmp(u,G.adjmulist[i].data)==0)return i;return -1;}//采用邻接多重表存储表示，构造无向图Gint CreateGraph(AMLGraph &G){cout<<"请输入图的顶点数、边数:";cin>>G.vexnum;//输入图当前的顶点数cin>>G.edgenum;//输入图当前的边数cout<<"请输入每个顶点所对应的值:"<<endl;for(int i=0;i<G.vexnum;i++){cin>>G.adjmulist[i].data;//输入顶点值G.adjmulist[i].firstedge=NULL;//初始化指针}VertexType v1,v2;EBox *p;int j;//每条弧所关联的两个结点for(int k=0;k<G.edgenum;k++){cout<<"请输入第"<<k<<"边的始点和终点:";cin>>v1;cin>>v2;i=LocateVex(G,v1);j=LocateVex(G,v2);//确定v1和v2在图G中的位置p=(EBox *)malloc(sizeof(EBox));//对弧结点进行赋值(*p).mark=0;(*p).ivex=i;(*p).jvex=j;(*p).ilink=G.adjmulist[i].firstedge;(*p).jlink=G.adjmulist[j].firstedge;G.adjmulist[i].firstedge=G.adjmulist[j].firstedge=p;}return 1;}//返回V的值VertexType* GetVex(AMLGraph G,int v){if(v>G.vexnum||v<0)exit(0);return &G.adjmulist[v].data;}//返回V的第一个邻接点的序号，若没有则返回-1int FirstAdjVex(AMLGraph G,VertexType v){int i;i=LocateVex(G,v);if(i<0)return -1;if(G.adjmulist[i].firstedge)//V有邻接结点if(G.adjmulist[i].firstedge->ivex==i)return G.adjmulist[i].firstedge->jvex;elsereturn G.adjmulist[i].firstedge->ivex;elsereturn -1;}//返回V的(相对于W)的下一个邻接结点的序号，若W是V的最后一个邻接结点，则返回-1 int NextAdjVex(AMLGraph G,VertexType v,VertexType w){int i,j;EBox *p;i=LocateVex(G,v);j=LocateVex(G,w);if(i<0||j<0)return -1;p=G.adjmulist[i].firstedge;while(p)if(p->ivex==i&&p->jvex!=j)p=p->ilink;else if(p->jvex==i&&p->ivex!=j)p=p->jlink;elsebreak;if(p&&p->ivex==i&&p->jvex==j){p=p->ilink;if(p&&p->ivex==i)return p->jvex;else if(p&&p->jvex==i)return p->jvex;}if(p&&p->ivex==j&&p->jvex==i){p=p->jlink;if(p&&p->ivex==i)return p->jvex;else if(p&&p->jvex==i)return p->jvex;}return -1;}//------------------------------------队列的操作int visite[NUM];//访问标志数组int (*VisitFunc)(VertexType v);void DFS(AMLGraph G,int v){int j;EBox *p;VisitFunc(G.adjmulist[v].data);visite[v]=1;//该顶点已经被访问p=G.adjmulist[v].firstedge;while(p){j=p->ivex==v?p->jvex:p->ivex;if(!visite[j])DFS(G,j);p=p->ivex==v?p->ilink:p->jlink;}}//深度优先遍历图void DFSTraverse(AMLGraph G,int(*Visit)(VertexType)) {int v,start;VisitFunc=Visit;for(v=0;v<G.vexnum;v++)visite[v]=0;cout<<"请输入你要开始进行查找的位置：";cin>>start;cout<<"按广深度优先搜索的结果是:"<<endl;for(v=start;v<G.vexnum;v++){if(v>=G.vexnum){for(v=0;v<G.vexnum;v++){if(!visite[v])DFS(G,v);}//内层for}//ifelse{if(!visite[v])DFS(G,v);}//else}//外层forcout<<"\b\b\b ";cout<<endl;}//队列的初始化int InitQueue(LinkQueue *Q){(*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));if(!(*Q).front)exit(0);(*Q).front->next=NULL;return 1;}//判断队列是否为空，为空则返回1，否则返回0int QueueEmpty(LinkQueue Q){if(Q.front==Q.rear)return 1;elsereturn 0;}//向队列中插入元素int EnQueue(LinkQueue *Q,QElemType e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(0);p->data=e;p->next=NULL;(*Q).rear->next=p;(*Q).rear=p;return 1;}//若队列不为空，则删除对头元素，并返回1；否则返回0 int DeQueue(LinkQueue *Q,QElemType *e){QueuePtr p;if((*Q).front==(*Q).rear)return 0;p=(*Q).front->next;*e=p->data;(*Q).front->next=p->next;if((*Q).rear==p)(*Q).rear=(*Q).front;free(p);return 1;}//广度优先非递归遍历图Gvoid BFSTraverse(AMLGraph G,int(*Visit)(VertexType)){int u,v,w,start=0;VertexType w1,u1;LinkQueue Q;for(v=0;v<G.vexnum;v++)visite[v]=0;InitQueue(&Q);cout<<"请输入你要开始进行查找的位置：";cin>>start;cout<<"按广度优先搜索的结果是:"<<endl;for(v=start;v<G.vexnum;v++){if(!visite[v]){visite[v]=1;Visit(G.adjmulist[v].data);EnQueue(&Q,v);//v入队列while(!QueueEmpty(Q)){DeQueue(&Q,&u);strcpy(u1,*GetVex(G,u));for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))if(!visite[w]){visite[w]=1;Visit(G.adjmulist[w].data);EnQueue(&Q,w);}}}}//forInitQueue(&Q);for(v=0;v<start;v++){if(!visite[v]){visite[v]=1;Visit(G.adjmulist[v].data);EnQueue(&Q,v);//v入队列while(!QueueEmpty(Q)){DeQueue(&Q,&u);strcpy(u1,*GetVex(G,u));for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w))))if(!visite[w]){visite[w]=1;Visit(G.adjmulist[w].data);EnQueue(&Q,w);}}}}//forcout<<"\b\b\b ";cout<<endl;}//把边的访问标记设置为0，即未被访问void MarkUnVisited(AMLGraph G){int i;EBox *p;for(i=0;i<G.vexnum;i++){p=G.adjmulist[i].firstedge;while(p){p->mark=0;if(p->ivex==i)p=p->ilink;elsep=p->jlink;}}}//显示构造的无向图(包括定点数、顶点、边数、边)void Display(AMLGraph G){int i;EBox *p;MarkUnVisited(G);cout<<G.vexnum<<"个顶点：";for(i=0;i<G.vexnum;i++)cout<<G.adjmulist[i].data<<" ";cout<<"; "<<G.edgenum<<"条边:"<<endl;for(i=0;i<G.vexnum;i++){p=G.adjmulist[i].firstedge;while(p)if(p->ivex==i){if(!p->mark){cout<<G.adjmulist[i].data<<"-->"<<G.adjmulist[p->jvex].data<<" ";p->mark=1;//已经被访问过了}p=p->ilink;}else{if(!p->mark){cout<<G.adjmulist[p->ivex].data<<"-->"<<G.adjmulist[i].data<<" ";p->mark=1;//已经被访问过了}p=p->jlink;}cout<<endl;}}int Visit(VertexType v){cout<<v<<"-->";return 1;}int main(){int flag=1,control,YES=0;AMLGraph g;while(flag){cout<<"\t\t-----------------------------------------------------"<<endl;cout<<"\t\t-------------请输入你要进行的操作：------------------"<<endl;cout<<"\t\t-----------1.创建无向图||2.打印无向图||----------"<<endl;cout<<"\t\t-----------3.深度优先搜索||4.广度优先搜索||----------"<<endl;cout<<"\t\t-----------0.退出系统--------------------------------"<<endl;cout<<"\t\t-----------------------------------------------------"<<endl;cin>>control;switch(control){case 1:YES=CreateGraph(g);break;case 2:if(YES)Display(g);else{cout<<"请先创建无向图，再选择此项"<<endl;}break;case 3:if(YES){DFSTraverse(g,Visit);}else{cout<<"请先创建无向图，再选择此项"<<endl;}break;case 4:if(YES){BFSTraverse(g,Visit);}else{cout<<"请先创建无向图，再选择此项"<<endl;}break;case 0:flag=0;break;}//switch}//whilereturn 0;}四、程序清单代码运行结果截图：主页面：1.创建无向图：输入6个顶点、9条边，如图：2.打印无向图：3.深度优先搜索4.广度搜索五、总结参考资料[1] 殷人昆 .《数据结构（用面向对象方法与c++语言描述）》清华大学出版社[2] 严蔚敏、吴伟民.《数据结构（C语言版）》清华大学出版社。

图的遍历和生成树求解实现（邻接矩阵、邻接表―图的深度广度遍历

图的遍历和生成树求解实现（邻接矩阵、邻接表―图的深度广度遍历算法的实现和最小生成树PRIM和KRUSCAL算法的实现）图的遍历和生成树求解实现（邻接矩阵、邻接表―图的深度广度遍历算法的实现和最小生成树PRIM和KRUSCAL算法的实现）#inc lude <iostream>#inc lude <malloc.h>using namespace std;#define int_max 10000#define inf 9999#define max 20//…………………………………………邻接矩阵定义……………………typedef struct ArcCell{int adj;char *info;}ArcCell,AdjMatrix[20][20];typedef struct{char vexs[20];AdjMatr ix arcs;int vexnum,arcnum;}MGraph_L;//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^int localvex(MGraph_L G,char v)//返回V的位置{int i=0;w hile(G.vexs[i]!=v){++i;}return i;}int creatMGr aph_L(MGraph_L &G)//创建图用邻接矩阵表示{char v1,v2;int i,j,w;cout<<"…………创建无向图…………"<<endl<<"请输入图G顶点和弧的个数:(4 6)不包括“()”"<<endl; cin>>G.vexnum>>G.arcnum;for(i=0;i!=G.vexnum;++i){cout<<"输入顶点"<<i<<endl;cin>>G.vexs[i];}for(i=0;i!=G.vexnum;++i)for(j=0;j!=G.vexnum;++j){G.arcs[i][j].adj=int_max;G.arcs[i][j].info=NULL;}for(int k=0;k!=G.arcnum;++k){cout<<"输入一条边依附的顶点和权:(a b 3)不包括“()”"<<endl;cin>>v1>>v2>>w;//输入一条边依附的两点及权值i=localvex(G,v1);//确定顶点V1和V2在图中的位置j=localvex(G,v2);G.arcs[i][j].adj=w;G.arcs[j][i].adj=w;}cout<<"图G邻接矩阵创建成功！"<<endl;return G.vexnum;}void ljjzprint(MGraph_L G){int i,j;for(i=0;i!=G.vexnum;++i){for(j=0;j!=G.vexnum;++j)cout<<G.arcs[i][j].adj<<" ";cout<<endl;}}int vis ited[max];//访问标记int w e;typedef struct arcnode//弧结点{int adjvex;//该弧指向的顶点的位置struct arcnode *nextarc;//弧尾相同的下一条弧char *info;//该弧信息}arcnode;typedef struct vnode//邻接链表顶点头接点{char data;//结点信息arcnode *firstarc;//指向第一条依附该结点的弧的指针}vnode,adjlist;typedef struct//图的定义{adjlist vertices[max];int vexnum,arcnum;int kind;}algraph;//…………………………………………队列定义……………………typedef struct qnode{int data;struct qnode *next;}qnode,*queueptr;typedef struct{queueptr front;queueptr rear;}linkqueue;//………………………………………………………………………typedef struct acr{int pre;//弧的一结点int bak;//弧另一结点int w eight;//弧的权}edg;int creatadj(algraph &gra,MGr aph_L G)//用邻接表存储图{int i=0,j=0;arcnode *arc,*tem,*p;for(i=0;i!=G.vexnum;++i){gra.vertices[i].data=G.vexs[i];gra.vertices[i].firstarc=NULL;}for(i=0;i!=G.vexnum;++i){for(j=0;j!=G.vexnum;++j){if(gra.vertices[i].firstarc==NULL){if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum){arc=(arcnode *)malloc(sizeof(arcnode));arc->adjvex=j;gra.vertices[i].firstarc=arc;arc->nextarc=NULL;p=arc;++j;w hile(G.arcs[i][j].adj!=int_max&&j!=G.vexnum) {tem=(arcnode *)malloc(sizeof(arcnode));tem->adjvex=j;gra.vertices[i].firstarc=tem;tem->nextarc=arc;arc=tem;++j;}--j;}}else{if(G.arcs[i][j].adj!=int_max&&j!=G.vexnum){arc=(arcnode *)malloc(sizeof(arcnode));arc->adjvex=j;p->nextarc=arc;arc->nextarc=NULL;p=arc;}}}}gra.vexnum=G.vexnum;gra.arcnum=G.arcnum;/*for(i=0;i!=gra.vexnum;++i){arcnode *p;cout<<i<<" ";p=gra.vertices[i].firstarc;w hile(p!=NULL){cout<<p->adjvex;p=p->nextarc;}cout<<endl;}*/cout<<"图G邻接表创建成功！"<<endl;return 1;}void adjpr int(algraph gra){int i;for(i=0;i!=gra.vexnum;++i){arcnode *p;cout<<i<<" ";p=gra.vertices[i].firstarc;w hile(p!=NULL){cout<<p->adjvex;p=p->nextarc;}cout<<endl;}}int firstadjvex(algraph gra,vnode v)//返回依附顶点V的第一个点 //即以V为尾的第一个结点{if(v.firstarc!=NULL)return v.firstarc->adjvex;int nextadjvex(algraph gra,vnode v,int w)//返回依附顶点V的相对于W的下一个顶点{arcnode *p;p=v.firstarc;w hile(p!=NULL&&p->adjvex!=w){p=p->nextarc;}if(p->adjvex==w&&p->nextarc!=NULL){p=p->nextarc;return p->adjvex;}if(p->adjvex==w&&p->nextarc==NULL)return -10;}int initqueue(linkqueue &q)//初始化队列{q.rear=(queueptr)malloc(sizeof(qnode));q.front=q.rear;if(!q.front)return 0;q.front->next=NULL;return 1;}int enqueue(linkqueue &q,int e)//入队{queueptr p;p=(queueptr)malloc(sizeof(qnode));if(!p)return 0;p->data=e;p->next=NULL;q.rear->next=p;q.rear=p;return 1;}int dequeue(linkqueue &q,int &e)//出队{queueptr p;if(q.front==q.r ear)return 0;p=q.front->next;e=p->data;q.front->next=p->next;if(q.rear==p)q.rear=q.front;free(p);return 1;}int queueempty(linkqueue q)//判断队为空{if(q.front==q.r ear)return 1;return 0;}void bfstra(algraph gra)//广度优先遍历{int i,e;linkqueue q;for(i=0;i!=gra.vexnum;++i)visited[i]=0;initqueue(q);for(i=0;i!=gra.vexnum;++i)if(!visited[i]){ visited[i]=1;cout<<gr a.vertices[i].data;enqueue(q,i);w hile(!queueempty(q)){dequeue(q,e);// cout<<" "<<e<<" ";for(w e=firstadjvex(gra,gra.vertices[e]);w e>=0;w e=nextadjvex(gra,gra.vertices[e],w e)) {if(!v isited[w e]){visited[w e]=1;cout<<gra.vertices[w e].data;enqueue(q,w e);}}}}}int dfs(algraph gra,int i);//声明DFSint dfstra(algraph gra){int i,j;for(i=0;i!=gra.vexnum;++i){visited[i]=0;}for(j=0;j!=gra.vexnum;++j){if(visited[j]==0)dfs(gra,j);}return 0;}int dfs(algraph gra,int i){visited[i]=1;int w e1;// cout<<i<<visited[i]<<endl;cout<<gra.vertices[i].data;// cout<<endl;for(w e=firstadjvex(gra,gra.vertices[i]);w e>=0;w e=nextadjvex(gra,gra.vertices[i],w e)) {// cout<<w e<<visited[w e]<<endl;w e1=w e;// cout<<nextadjvex(gra,gra.vertices[i],w e)<<endl;if(visited[w e]==0)// cout<<dfs(gra,w e);//<<endl;// cout<<i<<w e1<<endl;w e=w e1;// cout<<nextadjvex(gra,gra.vertices[i],w e)<<endl;}return 12;}int bfstra_fen(algr aph gra)//求连通分量{int i,j;for(i=0;i!=gra.vexnum;++i){visited[i]=0;}for(j=0;j!=gra.vexnum;++j){if(visited[j]==0){dfs(gra,j);cout<<endl;}}return 0;}typedef struct{int adjvex;int low cost;}closedge;/*int minimum(c losedge *p);int minispantree(MGraph_L G,char u){int k,j,i;closedge closedge_a[20];k=localvex(G,u);// cout<<k<<endl;for(j=0;j!=G.vexnum;++j){if(j!=k){closedge_a[j].adjvex=u;closedge_a[j].low cost=G.arcs[k][j].adj;}for(i=1;i!=G.vexnum;++i){k=minimum(closedge_a);cout<<k;cout<<closedge_a[k].adjvex<<" "<<G.vexs[k]<<endl; closedge_a[k].low cost=0;for(j=0;j!=G.vexnum;++j)if(G.arcs[k][j].adj<closedge_a[j].low cost){closedge_a[j].adjvex=G.vexs[k];closedge_a[j].low cost=G.arcs[k][j].adj;}}}return 0;}int minimum(closedge *p){int s=10000;for(;p!=NULL;++p){if(s>p->lowcost)s=p->low cost;}return s;}*/int pr im(int g[][max],int n) //最小生成树PRIM算法{int low cost[max],prevex[max]; //LOWCOST[]存储当前集合U分别到剩余结点的最短路径 //prevex[]存储最短路径在U中的结点int i,j,k,min;for(i=2;i<=n;i++) //n个顶点，n-1条边{low cost[i]=g[1][i]; //初始化prevex[i]=1; //顶点未加入到最小生成树中}low cost[1]=0; //标志顶点1加入U集合for(i=2;i<=n;i++) //形成n-1条边的生成树{min=inf;k=0;for(j=2;j<=n;j++) //寻找满足边的一个顶点在U,另一个顶点在V的最小边if((lowcost[j]<min)&&(low cost[j]!=0)){min=low cost[j];k=j;}printf("(%d,%d)%d\t",prevex[k]-1,k-1,min);low cost[k]=0; //顶点k加入Ufor(j=2;j<=n;j++) //修改由顶点k到其他顶点边的权值if(g[k][j]<low cost[j]){low cost[j]=g[k][j];prevex[j]=k;}printf("\n");}return 0;}int acrvisited[100];//kruscal弧标记数组int find(int acrvisited[],int f){w hile(acrvisited[f]>0)f=acrvisited[f];return f;}void kruscal_arc(MGraph_L G,algraph gra) {edg edgs[20];int i,j,k=0;for(i=0;i!=G.vexnum;++i)for(j=i;j!=G.vexnum;++j){if(G.arcs[i][j].adj!=10000){edgs[k].pre=i;edgs[k].bak=j;edgs[k].w eight=G.arcs[i][j].adj;++k;}}int x,y,m,n;int buf,edf;for(i=0;i!=gra.arcnum;++i)acrvisited[i]=0;for(j=0;j!=G.arcnum;++j){m=10000;for(i=0;i!=G.arcnum;++i){if(edgs[i].w eight<m){m=edgs[i].w eight;x=edgs[i].pre;y=edgs[i].bak;n=i;}}// cout<<x<<y<<m;// cout<<endl;buf=find(acrvisited,x);edf=find(acrvisited,y);// cout<<buf<<" "<<edf<<endl;edgs[n].w eight=10000;if(buf!=edf){acrvisited[buf]=edf;cout<<"("<<x<<","<<y<<")"<<m;cout<<endl;}}}void main(){algraph gr a;MGraph_L G;int i,d,g[20][20];char a='a';d=creatMGr aph_L(G);creatadj(gra,G);vnode v;cout<<endl<<"……####注意：若该图为非强连通图(含有多个连通分量)时"<<endl <<" 最小生成树不存在,则显示为非法值。

数据结构课程设计-二叉树

《数据结构》课程设计说明书二叉平衡树算法实现班级组别：二指导老师：完成时间：2019.6.19 组长：学号：05 组员1：学号：33 组员2：学号：组员3：学号：成绩：目录目录一、课题设计任务 (2)二、任务分析 (2)1. 数据逻辑结构（算法描述） (2)2. 关键算法思想 (3)三、概要设计（总体设计） (3)四、详细设计 (4)1. 数据存储结构 (4)2. 各模块流程图及算法 (5)3. 算法效率分析 (9)五、测试 (10)1. 删除 (10)2. 查找 (10)3. 遍历 (10)六、课程设计心得 (10)七、参考文献 (11)八、附录 (11)一、课题设计任务针对给定的序列建立存储结构，实现各种遍历；实现树的生成，实现数据的查找、插入、删除，输出各种遍历。

二、任务分析1.数据逻辑结构（算法描述）//中序--递归void InorderTra(PNode root) {if (root) {InorderTra(root->leftChild); //中序遍历左子树printf("%d\t", root->keyValue); //访问根节点InorderTra(root->rightChild); //中序遍历右子数}}//前序--递归void PreOrderTra(PNode root) {if (root != NULL) {printf("%d\t", root->keyValue); //访问根节点PreOrderTra(root->leftChild); //前序遍历左子树PreOrderTra(root->rightChild); //前序遍历右子数}}//后序--递归void PostOrderTra(PNode root) {if (root) {PostOrderTra(root->leftChild); //后序遍历左子树PostOrderTra(root->rightChild); //后序遍历右子树printf("%d\t", root->keyValue); //访问根节点}}//求树的最大深度int getDeep(PNode root) {if (!root) {return 0;}int leftDeep = getDeep(root->leftChild) + 1;int rightDeep = getDeep(root->rightChild) + 1;return leftDeep > rightDeep ? leftDeep : rightDeep;}//从根节点开始打印出所有层void printByLevel(PNode root, int deep) {for (int i = 0; i < deep; i++) {LevelOrderTra(root, i);}printf("\n");}2.关键算法思想树的生成过程保持左右平衡，插入删除过程中保证树的平衡。

数据结构课程设计-图的遍历和生成树的求解实现说明书

*******************实践教学*******************兰州理工大学计算机与通信学院2012年春季学期算法与数据结构课程设计题目：图的遍历和生成树的求解实现专业班级：计算机科学与技术姓名：***学号：1234567指导教师：****成绩：目录摘要 (3)前言 (4)正文 (5)1.问题描述： (5)2.采用类C语言定义相关的数据类型 (5)3．各模块流程图及伪码算法 (6)4．函数的调用关系图 (8)5．调试分析 (9)1.调试中遇到的问题及对问题的解决方法 (9)2.算法的时间复杂度和空间复杂度 (9)6.测试结果 (10)参考文献 (14)图是一种复杂的非线性数据结构，一个图G（Grah）由两个集合V和E构成，图存在两种遍历方式，深度优先遍历和广度优先遍历，广度优先遍历基本思路是假设从图中某顶点U出发，在访问了顶点U之后依次访问U的各个未访问的领接点，然后分别从这些领接点出发依次访问他们的领接点，并使先访问的顶点的领接点先于后访问的顶点被访问。

直至所有领接点被访问到。

深度优先的基本思路是从某个顶点出发，访问此顶点，然后依次从V的未被访问的领接点出发深度优先检索土。

直至图中所有顶点都被访问到。

PRIM算法—KRUSKAL算法；可以对图形进行最小生成树的求解。

主要问题是：（1）当给出一个表达式时，如何创建图所表达的树，即相应的逻辑结构和存储结构？（2）表达式建立好以后，如何求出其遍历？深度优先和广度优先遍历。

（3）计算它的最小生成树？主要是prim算法和kruscal算法两种形式。

很多涉及图的操作的算法都是以图的遍历操作为基础，通过遍历的演示，方便在学习中更好的理解突地遍历的过程。

通过对图的深度优先遍历和广度优先遍历的演示，分别两种遍历的不同与其优缺点。

我们在对一些问题进行求解时，会发现有些问题很难找到规律，或者根本无规律可寻。

对于这样的问题，可以利用计算机运算速度快的特点，先搜索查找所有可能出现的情况，再根据题目条件从所有可能的情况中，删除那些不符合条件的解。