数据结构实验五A
2012版《数据结构A》课程实验指导书
2012版《数据结构A》课程实验指导书《数据结构A》课程实验指导书Data Structure Course Design课程编号：06311360 学时：15 学分：1先修课程：程序设计基础、⾯向对象程序设计适⽤专业：计算机科学与技术、⽹络⼯程、软件⼯程⼀、实验⽬的《数据结构A》课程是计算机科学与技术及其相关专业的⼀门重要的专业基础课。
在课堂教学中，⽐较全⾯、概括性地讲述数据结构学科中⼀些基础性知识、重要概念及各种算法，通过该实验教学和学⽣的上机实践，将这些基础性知识、重要概念及各种算法，在计算机上编程实现，使学⽣能够达到以下实验教学⽬标：1.掌握计算机处理数据的基本⽅法；2.了解算法的时间及空间分析⽅法；3.能够为实际应⽤所涉及的数据选择适当的逻辑结构、存储结构及相应的算法；4.通过在计算机上编程实现课程中介绍的各种算法，在程序设计能⼒⽅⾯得到提升。
⼆、上机实验总体要求1.每位同学准备⼀个实验本，上机前作好充分的准备⼯作，预习本次实验的内容，事先熟悉与实验有关的软硬件环境，编写好程序代码，供上机时使⽤。
2.实验时遵守实验室的规章制度，爱护实验设备，原则上每⼈固定实验设备，对于实验设备出现的问题，要及时向指导⽼师汇报。
3.编程序过程中要注意多存盘，避免由于死机等原因造成的不必要的重复录⼊。
4.内部⽂档要求：每个源⽂件和头⽂件都必须在⽂件⾸部的注释中注明设计者姓名，项⽬名（即我们的上机题⽬名），创建⽇期和最近⼀次修改⽇期。
包含main()函数的源⽂件必须在⾸部注释后另加⼀段注释，简要描述⼀下程序的⽬的和⽤到的主要数据结构。
⽂件注释格式如下：⽂件名称：项⽬名称：创建者：创建时间：最后修改时间：功能：⽂件中的函数名称和简单功能描述：⽂件中定义的全局变量和简单功能描述：⽂件中⽤到的他处定义的全局变量及其出处：与其他⽂件的依赖关系：◆每个类必须包含⾸部注释块，适度地描述这个类的⽬的。
类的⾸部注释应该紧挨着放在类的声明（⼀般在头⽂件⾥）前⾯。
数据结构实验五实验报告
数据结构实验报告实验五图子系统实验题目：图的遍历问题专业班级：网络工程 1002班组长：王星（30）组员：郭坤铭（43）张磊（44）2012年 5月 18日实验报告实验类型__综合__实验室_软件实验室二__一、实验题目图的遍历问题二、实验目的和要求1、掌握图的存储思想及其存储实现2、掌握图的深度、广度优先遍历算法思想及其程序实现3、掌握图的常见应用算法的思想及其程序实现三、需求分析本演示程序用c++6.0编写，完成用户用键盘输入以下结点数据：太原、成都、北京、上海、天津、大连、河北。
（1）建立一个有向图或无向图（自定）的邻接表并输出该邻接表。
（2）在图的邻接表的基础上计算各顶点的度，并输出。
（3）以有向图的邻接表为基础实现输出它的拓扑排序序列。
（4）采用邻接表存储实现无向图的深度优先遍历。
（5）采用邻接表存储实现无向图的广度优先遍历。
（6）采用邻接矩阵存储实现无向图的最小生成树的 PRIM 算法。
最后，在主函数中设计一个简单的菜单，分别调试上述算法。
四、概要设计为了实现上述程序功能，需要定义如下内容基本数据类型定义如下：typedef struct node{ //边表结点int adj; //边表结点数据域struct node *next;}node;typedef struct vnode //顶点表结点{ char name[20];node *fnext;}vnode,AList[20];typedef struct{ AList List; //邻接表int v,e; //顶点树和边数}*Graph;Graph CreatDG(){ } //建立无向邻接表Graph CreatAG(){ } //有向邻接图void Print(Graph G){} //输出图的邻接表void CreateAN(AGraph *G1){} //构造邻接矩阵结构的图G void Du(Graph G){} //输出各顶点的度数void DFSTravel(Graph G){} //深度优先遍历void BFSTravel(Graph G){} //广度优先遍历五、详细设计#include<stdio.h>#include<stdlib.h>#include<string.h>typedef struct node{//边表结点int adj;//边表结点数据域struct node *next;}node;typedef struct vnode{//顶点表结点char name[20];node *fnext;}vnode,AList[20];typedef struct{AList List;//邻接表int v,e;//顶点树和边数}*Graph;//建立无向邻接表Graph CreatDG(){Graph G;int i,j,k;node *s;G=malloc(20*sizeof(vnode));printf("请输入图的顶点数和边数(空格隔开)：");scanf("%d%d",&G->v,&G->e);//读入顶点数和边数for(i=0;i<G->v;i++){printf("请输入图中第%d元素：",i+1);scanf("%s",G->List[i].name);//读入顶点信息G->List[i].fnext=NULL;//边表置为空表}for(k=0;k<G->e;k++){printf("请请输入第%d条边的两顶点序号(空格隔开)：",k+1);scanf("%d%d",&i,&j);//读入边（Vi,Vj）的顶点对序号;s=(node *)malloc(sizeof(node));//生成边表结点s->adj=j;s->next=G->List[i].fnext;G->List[i].fnext=s;//将新结点*s插入顶点Vi的边表头部s=(node *)malloc(sizeof(node));s->adj=i;//邻接点序号为is->next=G->List[j].fnext;G->List[j].fnext=s;// 将新结点*s插入顶点Vj的边表头部}return G;}//有向邻接图Graph CreatAG(){Graph G;int i,j,k;node *q;G=malloc(20*sizeof(vnode));printf("请输入图的顶点数和边数【空格隔开】：");scanf("%d%d",&G->v,&G->e);for (i=0;i<G->v;i++){printf("请输入图中第%d元素：",i+1);scanf("%s",&G->List[i].name); //读入顶点信息G->List[i].fnext=NULL;}for (k=0;k<G->e;k++){printf("请请输入第%d边的两顶点序号【空格隔开】：",k+1);scanf("%d%d",&i,&j);q=(node *)malloc(sizeof(node)); //生成新边表结点sq->adj=j; //邻接点序号为jq->next=G->List[i].fnext;G->List[i].fnext=q;}return G;}//输出图的邻接表void Print(Graph G){int i;node *p;printf("\t=======邻接表========\n");for(i=0;i<G->v;i++){p=G->List[i].fnext;printf("%d | %3s",i,G->List[i].name);while(p){printf("->%3s",G->List[p->adj].name);printf("->%d",p->adj);p=p->next;}printf("\n");}}typedef struct {char vex[20];}Lists[20];typedef struct{Lists l;int edge[20][20];//邻接矩阵int v1,e1;//顶点数和弧数}AGraph;typedef struct{int data; /* 某顶点与已构造好的部分生成树的顶点之间权值最小的顶点 */int lowcost; /* 某顶点与已构造好的部分生成树的顶点之间的最小权值 */}ClosEdge[20]; /* 用普里姆算法求最小生成树时的辅助数组 */ void CreateAN(AGraph *G1){/* 构造邻接矩阵结构的图G */int i,j,k,w;printf("请输入图的顶点数和边数（空格隔开）：");scanf("%d%d",&G1->v1,&G1->e1);//读入顶点数和边数for(i=1;i<=G1->v1;i++){printf("请输入图%d号元素：",i);scanf("%s",&G1->l[i].vex);//读入顶点信息}for(i=1;i<=G1->v1;i++)//初始化邻接矩阵for(j=1;j<=G1->v1;j++)G1->edge[i][j] = 9;for(k=1;k<=G1->e1;k++){printf("请输入两顶点及边的权值（空格隔开）：");scanf("%d%d%d",&i,&j,&w);G1->edge[i][j]=w;G1->edge[j][i]=w;}}void PrintAN(AGraph *G1){int i,j;printf("\t=======邻接矩阵========\n");for(i=1;i<=G1->v1;i++){for(j=1;j<=G1->v1;j++)printf("%3d",G1->edge[i][j]);printf("\n");}}//输出各顶点的度数void Du(Graph G){int i,j;printf("\n<----各点度数---->\n");for(i=0;i<G->v;i++){p=G->List[i].fnext;printf("顶点%2s的度为：",G->List[i].name);j=0;while(p){j++;p=p->next;}printf("%d\n",j);}}//栈typedef struct stack{int x;struct stack *next;}stack;int push(stack *s,int i){stack *p;p=(stack *)malloc(sizeof(stack));p->x=i;p->next=s->next;s->next=p;return 1;}int pop(stack *s,int j){stack *p=s->next;//保存栈顶指针j=p->x;s->next=p->next; //将栈顶元素摘下free(p);//释放栈顶空间return j;}//拓扑排序void Topo(Graph G,stack *s){int i,k, count;int j=0;int indegree[20]={0};for(i=0;i<G->v;i++){p=G->List[i].fnext;;while(p!=NULL){indegree[p->adj]++;p=p->next;}}for(i=0;i<G->v;i++)if(indegree[i]==0)push(s,i);count=0;while(s->next!=NULL){i=pop(s,j);printf("%2s ",G->List[i].name);++count;for(p=G->List[i].fnext;p!=NULL;p=p->next){ k=p->adj;if(!(--indegree[k]))push(s,k);}}if(count<G->v) printf("有回路!");}void DFS(Graph G,int i,int flag[]){node *p;printf("%2s ",G->List[i].name);flag[i]=1;p=G->List[i].fnext;while(p){if(!flag[p->adj])DFS(G,p->adj,flag);p=p->next;}}//深度优先遍历void DFSTravel(Graph G){int i;int flag[20];//标志数组for(i=0;i<G->v;i++)flag[i]=0;for(i=0;i<G->v;i++)if(!flag[i])DFS(G,i,flag);}//建立队列typedef struct{int *elem;int front, rear;}*Queue;//队列初始化void InitQueue(Queue Q){Q->elem=(int *)malloc(20*sizeof(int));if(!Q->elem)exit(0);Q->front=Q->rear=0;}//入队void Enter(Queue Q, int e){if((Q->rear + 1)%20!= Q->front)Q->elem[Q->rear ]=e;elseprintf("队列满!\n");Q->rear=(Q->rear+1)%20;}//出队void Leave(Queue Q, int e){if(Q->rear != Q->front)e=Q->elem[Q->front];elseprintf("队列空!\n");Q->front=(Q->front+1)%20;}//广度优先遍历void BFSTravel(Graph G){Queue Q;node *p;int i,j=0;int flag[20];//标志数组Q=malloc(sizeof(20));InitQueue(Q);for(i=0;i<G->v;i++)flag[i]=0;for(i=0;i<G->v;i++)if(flag[i]==0){flag[i]=1;printf("%2s",G->List[i].name);Enter(Q,i);while(Q->front!=Q->rear){Leave(Q,j);//队头元素出队并置为jp=G->List[j].fnext;while(p!=NULL){if(flag[p->adj]==0){printf("%2s ",G->List[p->adj].name);flag[p->adj]=1;Enter(Q,p->adj);}p=p->next;}}}}int minimum(ClosEdge cl,int vnum){int i;int w,p;w=1000;for(i=1;i<=vnum;i++)if(cl[i].lowcost!=0&&cl[i].lowcost<w){w=cl[i].lowcost;p=i;}return p;}void Prim(AGraph *G1,int u){ClosEdge closedge;int i,j,k;for(j=1;j<=G1->v1;j++) /* 辅助数组初始化 */if(j!=u){closedge[j].data=u;closedge[j].lowcost=G1->edge[u][j];}closedge[u].lowcost=0; /* 初始，U={u} */for(i=1;i<G1->v1;i++){k=minimum(closedge,G1->v1); /* 求出生成树的下一个顶点*/printf("%d-----%d\n",closedge[k].data,k); /* 输出生成树的边 */closedge[k].lowcost=0; /* 第k顶点并入U集 */for(j=1;j<=G1->v1;j++) /* 新顶点并入U后，修改辅助数组*/if(G1->edge[k][j]<closedge[j].lowcost){closedge[j].data=k;closedge[j].lowcost=G1->edge[k][j];}}}//菜单列表void menu(){printf("\t**********************图的遍历问题**********************\n");printf("\t\t------- 1.建立无向邻接图---------\n");printf("\t\t------- 2.建立有向邻接图---------\n");printf("\t\t------- 3.建立无向邻接矩阵---------\n");printf("\t\t------- 4.输出各顶点的度---------\n");printf("\t\t------- 5.拓扑排序---------\n");printf("\t\t------- 6.深度优先遍历---------\n");printf("\t\t------- 7.广度优先遍历---------\n");printf("\t\t------- 8.prim算法生成最小生成树---------\n");printf("\t\t------- 9-退出---------\n");printf("\t********************************************** **********\n");}//主函数void main(){Graph G;AGraph G1;int choice,u;stack *s=(stack *)malloc(sizeof(stack));s->next =NULL;while(1){menu();printf("请输入选择:");scanf("%d",&choice);switch(choice){case1:G=CreatDG();Print(G);printf("\n\n");break;case2:G=CreatAG();Print(G);printf("\n\n");break;case3:CreateAN(&G1);PrintAN(&G1);printf("\n\n");break; case4:Du(G);printf("\n\n");break;case5:printf("拓扑排序:");Topo(G,s);printf("\n\n");break;case6:printf("深度优先遍历:");DFSTravel(G);printf("\n\n");break;case7:printf("广度优先遍历:");BFSTravel(G);printf("\n\n");break;case 8:printf("请输入起点序号:");scanf("%d",&u);printf("Prim算法:\n");Prim(&G1,u);printf("\n");break;case 9: exit(0);default: printf("输入错误,请重新输入：\n\n ");}}}六、使用说明1、程序名为实验5.exe，运行坏境为DOS.程序执行后显示如图所示：2、建立无向邻接图3、输出各顶点的度4、进行深度优先遍历5、进行广度优先遍历6、建立有向邻接图7、拓扑排序8、建立无向邻接矩阵9、prim算法生成最小生成树七、实验总结本次实验对我们来说有不小的难度，花费了很长的时间，在大家的商量讨论和共同努力下，最终完成了实验的内容，组长在此过程中很认真负责，使组员一步一步前进。
数据结构 实验
数据结构实验数据结构实验1. 实验目的通过本次实验，掌握数据结构的基本概念，了解常见的数据结构和其应用。
2. 实验内容本次实验主要包括以下内容：1. 数组：了解数组的概念、特点和基本操作；掌握数组的存储方式和访问方法；基于数组实现常见数据结构（如栈、队列）。
2. 链表：理解链表的概念及其不同类型（如单向链表、双向链表）；学习链表的插入、删除和查找操作；比较链表和数组的优缺点。
3. 树：了解树的基本概念及其特点；学习树的存储方式和遍历方法；掌握二叉树的特点和基本操作（如插入、删除、查找）。
4. 图：理解图的基本概念和相关术语；学习图的存储方式和遍历方法；掌握图的常见算法（如深度优先搜索、广度优先搜索）。
3. 实验步骤根据实验内容，按以下步骤进行实验：3.1 数组1. 了解数组的概念和特点，例如数组是一种线性表数据结构，用于存储连续的元素。
2. 学习数组的基本操作，如创建数组、访问数组元素、修改数组元素的值。
3. 理解数组的存储方式，例如元素在内存中是连续存储的。
4. 实现栈和队列的基本功能，并使用数组作为底层数据结构。
3.2 链表1. 理解链表的概念及其不同类型，如单向链表和双向链表。
2. 学习链表的插入、删除和查找操作，例如在链表中插入一个节点、删除一个节点、查找指定值的节点。
3. 比较链表和数组的优缺点，例如链表的插入和删除操作效率更高，但访问元素的效率较低。
4. 实现链表的基本功能，如创建链表、插入节点、删除节点、查找节点。
3.3 树1. 了解树的基本概念和特点，如树由节点和边组成，每个节点最多有一个父节点和多个子节点。
2. 学习树的存储方式，如链式存储和数组存储。
3. 掌握二叉树的特点和基本操作，如二叉树是每个节点最多有两个子节点的树结构。
4. 实现二叉树的基本功能，如插入节点、删除节点、查找节点。
3.4 图1. 理解图的基本概念和相关术语，如图由顶点和边组成。
2. 学习图的存储方式，如邻接矩阵和邻接表。
数据结构实验报告
数据结构实验报告数据结构实验报告1-引言本实验旨在深入理解数据结构的基本知识，并通过实践掌握相关算法和数据结构的应用。
本报告详细描述了实验的背景、目的、实验环境、实验内容和实验结果分析等内容。
2-实验背景介绍数据结构的概念和作用，解释为什么数据结构在计算机科学中至关重要。
同时，介绍本次实验所涉及的具体数据结构和算法，如数组、链表、栈、队列、二叉树等。
3-实验目的明确本次实验的目标，如掌握数据结构的基本操作，理解不同数据结构的适用场景，评估不同算法的时间和空间复杂度等。
4-实验环境描述实验所使用的软硬件环境，包括计算机配置、操作系统、编程语言和相关的开发工具等。
5-实验内容详细描述实验的具体步骤和要求，包括以下几个部分：5-1 数据结构的创建和初始化：例如，创建一个数组或链表，并初始化数据。
5-2 数据结构的插入和删除操作：例如，在数组中插入一个元素或删除一个元素。
5-3 数据结构的遍历和搜索：例如，遍历树的节点或搜索链表中指定的元素。
5-4 数据结构的排序和查找：例如，对数组进行排序或在有序链表中查找指定元素。
5-5 实验的额外要求：例如，优化算法的实现、分析不同数据结构的性能等。
6-实验结果分析对实验的结果进行详细的分析和解释，包括各个数据结构和算法的性能比较、时间复杂度和空间复杂度的评估等。
7-结论总结本次实验的主要内容和收获，归纳实验结果，并对实验过程中遇到的问题和不足进行反思和改进。
附件：随报告一同提交的附件包括：源代码、实验数据集等相关文件。
法律名词及注释：1-版权：指作品的创作权、发表权和署名权等综合权利。
2-侵权：指未经权利人允许，在未向权利人支付报酬的情况下，使用受版权保护的作品的行为。
3-知识产权：包括著作权、商标权、专利权等，是指人们在创造性劳动中创造出的精神财富所享有的权利。
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，如链表、栈、队列、树和图等，并通过实际编程实现，提高对数据结构的操作和应用能力。
同时，培养解决实际问题的思维和编程能力，提高代码的可读性、可维护性和效率。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用：括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用：排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表：首先定义一个链表节点结构体，包含数据域和指向下一个节点的指针域。
然后通过动态内存分配创建链表节点，并将节点逐个连接起来，形成链表。
插入节点：根据插入位置的不同，分为在表头插入、在表尾插入和在指定位置插入。
在指定位置插入时，需要先找到插入位置的前一个节点，然后进行节点的连接操作。
删除节点：同样需要根据删除位置的不同进行处理。
删除表头节点时，直接将头指针指向下一个节点；删除表尾节点时，找到倒数第二个节点，将其指针置为空；删除指定位置节点时，找到要删除节点的前一个节点，然后调整指针。
遍历链表：通过从链表头开始，依次访问每个节点，输出节点的数据。
2、栈的实现与应用用数组实现栈：定义一个固定大小的数组作为栈的存储空间，同时用一个变量记录栈顶位置。
入栈操作时，先判断栈是否已满，如果未满则将元素放入栈顶位置，并更新栈顶位置；出栈操作时，先判断栈是否为空，如果不空则取出栈顶元素，并更新栈顶位置。
用链表实现栈：与链表的操作类似，将新元素添加在链表头部作为栈顶。
括号匹配：输入一个包含括号的字符串，使用栈来判断括号是否匹配。
遇到左括号入栈，遇到右括号时与栈顶的左括号进行匹配，如果匹配成功则出栈，否则括号不匹配。
数据结构 5数组和广义表A
1 Status Locate(Array A,va_list ap,int &off) 2{ 3 //若ap指示的各下标值合法，则求出该元素在A中，相对地
址off
4 off=0; 5 for(i=0;i<A.dim;++i) 6 { 7 ind=va_arg(ap,int); 8 if(ind<0||ind>A.bounds[i]) return OVERFLOW; 9 off+=A.constants[i] *ind; 10 } 11 return OK; 12 }
行数 总列数，即 第2维长度 元素个数
ij
补充：计算二维数组元素地址的通式
设一般的二维数组是A[c1..d1, c2..d2]，这里c1,c2不一定是0。
单个元素 长度
二维数组列优先存储的通式为： LOC(aij)=LOC(ac1，c2)+[(j-c2)*(d1-c1+1)+i-c1)]*L
6
例1〖软考题〗：一个二维数组A[1..6, 0..7]，每个数组元素
16
5.4
1、定义：
广义表的定义
广义表是线性表的推广，也称为列表（lists） 记为： LS = ( a1 , a2 , ……， an ) 广义表名 表头(Head） 表尾 (Tail) n是表长
在广义表中约定：
① 第一个元素是表头，而其余元素组成的表称为表尾； ② 用小写字母表示原子类型，用大写字母表示列表。
13
1 Status Value(Array A,ElemType &e,…){ 2 //A是n维数组，e为元素变量，随后是n个下标值，若各下
标不超界，则e赋值为所指定的A的元素值，即将指定元素值 读到e变量中。
数据结构与算法实验报告5-查找与排序
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法；
2.了解树表查找思想；
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法；
二、实验内容
查找部分
1.实现顺序查找的两个算法（P307）, 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果；
2.实现对有序表的二分查找；
3.实现散列查找算法(链接法)，应能够解决冲突；
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
（描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落）
五、实验结果
六、总结
（说明实验过程中遇到的问题及解决办法；个人的收获；未解决的问题等）。
数据结构C语言版实验五报告
数据结构C语言版实验五报告实验五一、实验目的1、理解二叉树的类型定义域性质。
2、掌握二叉树的二叉链表储存结构的表示和实现方法。
3、掌握二叉树遍历操作的算法实现。
4、熟悉二叉树遍历操作的应用。
二、实验内容1、建立二叉树的二叉链表储存结构。
2、实现二叉树的先序、中序和后序三种遍历操作（验证性内容）。
3、应用二叉树的遍历操作来实现判断儿科二叉树是否相等的操作（设计性内容）。
4、求从二叉树根结点到指定结点P之间的路径（应用性设计内容）。
三、验证性实验1、实验要求编程实现如下功能：（1）假如二叉树的结点值是字符，根据输入的一颗二叉树的完整先序遍历序列建立一颗以二叉树链表表示的二叉树。
（2）对二叉树进行先序、中序和后序遍历操作，并输出表里序列，观察输出的序列是否与逻辑上的序列一致。
（3）主程序中要求设计一个菜单，允许用户通过菜单来多次选择执行哪一种遍历操作。
2、参考代码：#include#includetypedef struct Bitnode{char data;struct Bitnode *lchild,*rchild;}Bitnode,*Bitree;Bitree create(Bitree T)//创建树{char x;scanf("%c",&x);if(x=='#')T=NULL;else{T=(Bitree)malloc(sizeof(Bitnode));T->data=x;T->lchild=create(T->lchild);T->rchild=create(T->rchild);}return T;Bitree preorder(Bitree T)//前序{if(T!=NULL){printf("%c",T->data);T->lchild=preorder(T->lchild);T->rchild=preorder(T->rchild);}return T;}Bitree InOrderTraverse(Bitree T)//中序{if(T!=NULL){T->lchild=InOrderTraverse(T->lchild); printf("%c",T->data);T->rchild=InOrderTraverse(T->rchild); }return T;}Bitree PostOrderTraverse(Bitree T)//后序{if(T!=NULL){T->lchild=PostOrderTraverse(T->lchild); T->rchild=PostOrderTraverse(T->rchild); printf("%c",T->data);}return T;}int first=0,last=0;Bitree a[10];int Enter(Bitree a[],Bitree e){last=last%10;a[last++]=e;return 0;}Bitree Exit(Bitree a[])first=first%10;return a[first++];}void LeveOrderTraverse(Bitree T)//层序{Enter(a,T);if(T)while(first!=last){K=Exit(a);printf("%c",K->data);if(K->lchild)Enter(a,K->lchild);if(K->rchild)Enter(a,K->rchild);}}void main(){int i=1;char x,y;Bitree T=NULL;printf("create two tree\n");T=create(T);int i;printf("1----前序遍历\n2----中序遍历\n3----后序遍历\n4----层序遍历\n");scanf("%d",&i);if(i==1)preorder(T);if(i==2)InOrderTraverse(T);if(i==3)PostOrderTraverse(T);LeveOrderTraverse(T);printf("\n");}四、设计性实验编程实现根据二叉树的先序遍历序列和中序遍历序列来建立两颗二叉树，并判断这两颗二叉树是否相等。
数据结构试验报告-图的基本操作
中原工学院《数据结构》实验报告学院：计算机学院专业：计算机科学与技术班级：计科112姓名：康岩岩学号：201100814220 指导老师：高艳霞2012-11-22实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。
2、熟练掌握图的存储结构。
3、熟练掌握图的两种遍历算法。
二、实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。
[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。
以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
【测试数据】由学生依据软件工程的测试技术自己确定。
三、实验前的准备工作1、掌握图的相关概念。
2、掌握图的逻辑结构和存储结构。
3、掌握图的两种遍历算法的实现。
四、实验报告要求1、实验报告要按照实验报告格式规范书写。
2、实验上要写出多批测试数据的运行结果。
3、结合运行结果，对程序进行分析。
【设计思路】【代码整理】#include "stdafx.h"#include <iostream>#include <malloc.h>using namespace std;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW -1#define MAX_SIZE 20typedef enum{DG,DN,UDG,UDN}Kind;typedef struct ArcNode{int adjvex; //顶点位置struct ArcNode *nextarc; //下一条弧int *info; //弧信息};typedef struct{char info[10]; //顶点信息ArcNode *fistarc; //指向第一条弧}VNode,AdjList[MAX_SIZE];typedef struct{AdjList vertices;int vexnum,arcnum; //顶点数，弧数int kind; //图的种类，此为无向图}ALGraph;//这是队列的节点，仅用于广度优先搜索typedef struct Node{int num;struct Node* next;};//队列的头和尾typedef struct{Node * front;Node *rear;}PreBit;int LocateV ex(ALGraph G,char info[]);//定位顶点的位置Status addArcNode(ALGraph &G,int adjvex); //图中加入弧Status CreatGraph(ALGraph&G);//创建图的邻接表Status DFSTraverse(ALGraph G);//深度优先搜索Status BFSTraverse(ALGraph G);//广度优先搜索Status DFS(ALGraph G,int v);//深度优先搜索中的数据读取函数，用于递归bool visited[MAX_SIZE]; // 访问标志数组//初始化队列Status init_q(PreBit&P_B){P_B.front=P_B.rear=(Node*)malloc(sizeof(Node));if(!P_B.front){exit(OVERFLOW);}P_B.front->next=NULL;}//将数据入队Status en_q(PreBit & P_B,int num){Node *p=(Node*)malloc(sizeof(Node));if(!p){exit(OVERFLOW);}p->num=num;p->next=NULL;P_B.rear->next=p;P_B.rear=p;return OK;}//出队Status de_q(PreBit & P_B){if(P_B.front==P_B.rear){return ERROR;}Node* p=P_B.front->next;P_B.front->next=p->next;if(P_B.rear==p){P_B.rear=P_B.front;}free(p);return OK;}Status CreatGraph(ALGraph&G){cout<<"请输入顶点数目和弧数目"<<endl;cin>>G.vexnum>>G.arcnum;//依次输入顶点信息for(int i=0;i<G.vexnum;i++){cout<<"请输入顶点名称"<<endl;cin>>G.vertices[i].info;G.vertices[i].fistarc=NULL;}//依次输入弧信息for(int k=1;k<=G.arcnum;k++){char v1[10],v2[10]; //用于表示顶点名称的字符数组int i,j; //表示两个顶点的位置BACK: //返回点cout<<"请输入第"<<k<<"条弧的两个顶点"<<endl;cin>>v1>>v2;i=LocateV ex(G,v1); //得到顶点v1的位置j=LocateV ex(G,v2); //得到顶点v2的位置if(i==-1||j==-1){ //头信息不存在则返回重输cout<<"不存在该节点!"<<endl;goto BACK; //跳到BACK 返回点}addArcNode(G,i); //将弧的顶点信息插入表中addArcNode(G,j);}return OK;}//倒序插入弧的顶点信息Status addArcNode(ALGraph &G,int adjvex){ArcNode *p; //弧节点指针p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=adjvex;p->nextarc=G.vertices[adjvex].fistarc;//指向头结点的第一条弧G.vertices[adjvex].fistarc=p; //头结点的第一条弧指向p，即将p作为头结点的第一条弧return OK;}//定位顶点的位置int LocateV ex(ALGraph G,char info[]){for(int i=0;i<G.vexnum;i++){if(strcmp(G.vertices[i].info,info)==0){ //头结点名称与传入的信息相等，证明该头节点存在return i; //此时返回位置}}return -1;}//深度优先搜索Status DFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int i;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;i=LocateV ex(G,v1);if(i==-1){cout<<"不存在该节点!"<<endl;goto BACK;}DFS(G,i);return OK;}//深度优先搜索递归访问图Status DFS(ALGraph G,int v){visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息ArcNode *p;p=G.vertices[v].fistarc; //向头节点第一条while(p) //当弧存在{if(!visited[p->adjvex]){DFS(G,p->adjvex); //递归读取}p=p->nextarc;}return OK;}//广度优先搜索Status BFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int v;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;v=LocateV ex(G,v1);if(v==-1){cout<<"不存在该节点!"<<endl;goto BACK;}PreBit P_B;init_q(P_B);ArcNode *p;visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息en_q(P_B,v); //将头位置v入队while(P_B.front!=P_B.rear){//当队列不为空时，对其进行访问int w=P_B.front->next->num;//读出顶点位置de_q(P_B);//顶点已经访问过，将其出队列p=G.vertices[w].fistarc;//得到与顶点相关的第一条弧while(p){if(!visited[p->adjvex]){en_q(P_B,p->adjvex);//将弧入队，但不读取，只是将其放在队尾}p=p->nextarc;}}return OK;}int _tmain(int argc, _TCHAR* argv[]){ALGraph G;CreatGraph(G);cout<<"深度优先搜索图:"<<endl;DFSTraverse(G);cout<<endl;cout<<"广度优先搜索图:"<<endl;BFSTraverse(G);cout<<endl;system("pause");return 0;}。
数据结构实训实验报告
一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题，提高算法设计能力。
3. 培养团队合作精神，提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。
（2）实现线性表的插入、删除、查找等操作。
2. 栈与队列（1）实现栈的顺序存储和链式存储。
（2）实现栈的入栈、出栈、判断栈空等操作。
（3）实现队列的顺序存储和链式存储。
（4）实现队列的入队、出队、判断队空等操作。
3. 树与图（1）实现二叉树的顺序存储和链式存储。
（2）实现二叉树的遍历、查找、插入、删除等操作。
（3）实现图的邻接矩阵和邻接表存储。
（4）实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。
（2）实现二分查找算法。
（3）设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求，明确实验目的和内容。
2. 编写代码实现实验内容，对每个数据结构进行测试。
3. 对实验结果进行分析，总结实验过程中的问题和经验。
4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。
（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。
2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。
（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。
3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。
数据结构 实验报告
数据结构实验报告数据结构实验报告一、引言数据结构是计算机科学中非常重要的一门课程，它涉及到数据的存储、组织和管理等方面。
通过实验学习，我们可以更好地理解和掌握不同的数据结构，提升我们在编程中解决实际问题的能力。
二、实验目的本次实验的主要目的是通过实际操作，加深对数据结构的理解，学习并掌握不同数据结构的特点和应用场景，提高编程能力。
三、实验内容1. 实验环境的搭建在开始实验之前，我们需要搭建相应的实验环境。
首先，我们选择合适的集成开发环境（IDE），如Eclipse或IntelliJ IDEA，并安装好Java Development Kit（JDK）。
然后，根据实验要求，下载并安装相应的数据结构库或框架。
2. 实验一：线性表线性表是最基本且最常用的数据结构之一，它可以用于存储一系列具有相同数据类型的元素。
实验中，我们需要实现一个线性表的基本操作，包括插入、删除、查找、修改等。
3. 实验二：栈和队列栈和队列是两种常用的数据结构，它们都是线性表的衍生结构，但在操作上有一些特殊的限制。
实验中，我们需要实现栈和队列的基本操作，并比较它们在不同场景下的优劣。
4. 实验三：树和二叉树树是一种非线性的数据结构，它以分层的方式存储数据。
二叉树是树的一种特殊情况，其中每个节点最多只有两个子节点。
实验中，我们需要实现树和二叉树的构建和遍历算法，并掌握它们在实际问题中的应用。
5. 实验四：图图是一种非线性的数据结构，由节点和边组成。
实验中，我们需要实现图的构建和遍历算法，并应用它们解决实际的图相关问题。
四、实验结果与分析通过实验，我们得到了以下结果和分析：1. 在线性表实验中，我们成功实现了插入、删除、查找和修改等基本操作，并验证了其正确性和效率。
2. 在栈和队列实验中，我们对比了它们在不同场景下的应用，发现栈适用于后进先出（LIFO）的情况，而队列适用于先进先出（FIFO）的情况。
3. 在树和二叉树实验中，我们掌握了树和二叉树的构建和遍历算法，并应用它们解决了一些实际问题，如树形结构的存储和搜索。
数据结构实验实训报告单
一、实验名称：数据结构实验实训二、实验时间：2023年10月25日三、实验地点：计算机实验室四、实验目的：1. 理解并掌握数据结构的基本概念和常用算法；2. 学会使用C++语言实现数据结构的操作；3. 提高编程能力和问题解决能力；4. 加深对数据结构在实际应用中的理解。
五、实验内容：1. 实验一：线性表（1）实验内容：实现线性表的基本操作，如插入、删除、查找、排序等。
（2）实验步骤：a. 定义线性表的数据结构；b. 实现线性表的插入、删除、查找、排序等操作；c. 编写测试程序，验证实验结果。
2. 实验二：栈与队列（1）实验内容：实现栈和队列的基本操作，并分析其时间复杂度和空间复杂度。
（2）实验步骤：a. 定义栈和队列的数据结构；b. 实现栈和队列的入栈、出栈、入队、出队等操作；c. 分析栈和队列的时间复杂度和空间复杂度；d. 编写测试程序，验证实验结果。
3. 实验三：链表（1）实验内容：实现链表的基本操作，如插入、删除、查找、排序等。
（2）实验步骤：a. 定义链表的数据结构；b. 实现链表的插入、删除、查找、排序等操作；c. 编写测试程序，验证实验结果。
4. 实验四：树与二叉树（1）实验内容：实现二叉树的基本操作，如插入、删除、查找、遍历等。
（2）实验步骤：a. 定义二叉树的数据结构；b. 实现二叉树的插入、删除、查找、遍历等操作；c. 编写测试程序，验证实验结果。
5. 实验五：图（1）实验内容：实现图的基本操作，如图的创建、添加边、查找路径等。
（2）实验步骤：a. 定义图的数据结构；b. 实现图的创建、添加边、查找路径等操作；c. 编写测试程序，验证实验结果。
六、实验心得：1. 通过本次实验，我对数据结构的基本概念和常用算法有了更深入的理解，为今后的学习和工作打下了坚实的基础。
2. 在实验过程中，我学会了使用C++语言实现数据结构的操作，提高了自己的编程能力。
3. 通过对数据结构在实际应用中的分析，我认识到数据结构在计算机科学中的重要地位，为今后的职业发展指明了方向。
数据结构实验
数据结构实验
数据结构实验是计算机科学专业的必修课程之一，旨在通过实践来让学生掌握数据结
构的基本概念、操作及应用等知识，提高程序设计能力和算法实现能力。
以下是数据结构
实验的相关内容。
一、实验目的
1. 理解基本数据结构及其操作的实现方法。
2. 掌握数据结构中各种算法的实现方式，如顺序查找、二分查找、快速排序等。
3. 学会通过编程实现各种数据结构和算法，并能解决各种实际问题。
二、实验内容
1. 数组和链表的操作实现。
2. 栈和队列的实现。
3. 二叉树和图的操作实现。
4. 常见查找算法的实现，如顺序查找、二分查找等。
5. 常见排序算法的实现，如冒泡排序、选择排序、插入排序、快速排序等。
6. 哈希表和堆的实现。
三、实验步骤
1. 数组和链表的操作实现
在这个实验中，我们将学习如何使用数组和链表来存储数据，并实现一些基本的操作，如查找、添加、删除等。
4. 常见查找算法的实现
顺序查找、二分查找等是常见的算法，我们将通过编程来实现这些算法，并掌握其原
理和使用方法。
5. 常见排序算法的实现
冒泡排序、选择排序、插入排序、快速排序等是常见的排序算法，在本实验中，我们
将通过编程来实现这些算法，并学习如何调用这些算法来解决实际问题。
6. 哈希表和堆的实现
哈希表和堆是常用的高效数据结构，在本实验中，我们将学习如何使用哈希表和堆来解决实际问题，并学习哈希算法及堆操作的实现方法。
四、实验结果。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统：Windows 102.2 编程语言：C++2.3 开发工具：Visual Studio3. 实验内容3.1 实验一：线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二：栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三：树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法（前序、中序、后序遍历）3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一：实验源代码附件二：实验数据7. 法律名词及注释7.1 版权：著作权法规定的对原创作品享有的权利7.2 专利：国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标：作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告--
数据结构实验报告--实验一、线性表的实现线性表是常用的数据结构之一，其中最常用的是顺序存储结构。
本实验使用C语言实现了顺序存储结构的线性表。
首先，定义了一个结构体来表示线性表：```#define MAXSIZE 100 //线性表最大长度typedef struct {int data[MAXSIZE]; //存放线性表元素int length; //线性表当前长度} SqList; //线性表类型定义```其中，data数组存放线性表元素，length表示线性表当前长度。
接着，定义了三个基本操作：1. 初始化线性表```void InitList(SqList *L) {L->length = 0;}```2. 插入元素```bool ListInsert(SqList *L, int i, int e) {if (i < 1 || i > L->length + 1) { //插入位置不合法}if (L->length >= MAXSIZE) { //线性表已满return false;}for (int j = L->length; j >= i; j--) { //将第i个位置之后的所有元素后移一位L->data[j] = L->data[j - 1];}L->data[i - 1] = e; //将元素e插入到第i个位置L->length++; //线性表长度加1return true;}```3. 删除元素以上三个操作就是线性表的基本操作，通过这三个操作就能完成线性表的所有操作。
实验二、栈和队列的实现2.1 栈的实现栈是一种后进先出(Last In First Out)的数据结构。
我们可以用线性表来实现栈，只需要对线性表的插入和删除操作进行限制就行了。
具体实现如下：void InitStack(Stack *S) {S->top = -1; //初始化栈顶指针}bool Push(Stack *S, int e) {if (S->top == STACK_SIZE - 1) { //栈已满，无法插入元素}S->top++; //栈顶指针加1S->data[S->top] = e; //插入元素e到栈顶return true;}以上代码实现了栈的初始化、入栈和出栈操作。
数据结构实验报告 实验五
数据结构实验报告实验五一.实验内容：实现哈夫曼编码的生成算法。
二.实验目的：1、使学生熟练掌握哈夫曼树的生成算法。
2、熟练掌握哈夫曼编码的方法。
三.问题描述：已知n个字符在原文中出现的频率，求它们的哈夫曼编码。
1、读入n个字符，以及字符的权值，试建立一棵Huffman 树。
2、根据生成的Huffman树，求每个字符的Huffman编码。
并对给定的待编码字符序列进行编码，并输出。
四.问题的实现(1)郝夫曼树的存储表示typedef struct{unsigned int weight;unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; //动态分配数组存储郝夫曼树郝夫曼编码的存储表示typedef char* *HuffmanCode;//动态分配数组存储郝夫曼编码(2)主要的实现思路：a.首先定义郝夫曼树的存储形式，这里使用了数组b.用select()遍历n个字符，找出权值最小的两个c.构造郝夫曼树HT，并求出n个字符的郝夫曼编码HC总结1.基本上没有什么太大的问题，在调用select()这个函数时，想把权值最小的两个结点的序号带回HuffmanCoding()，所以把那2个序号设置成了引用。
2.在编程过程中，在什么时候分配内存，什么时候初始化花的时间比较长3.最后基本上实现后，发现结果仍然存在问题，经过分步调试，发现了特别低级的输入错误。
把HT.weight=HT.weight+HT.weight;中的s2写成了i 附：//动态分配数组存储郝夫曼树typedef struct{int weight; //字符的权值int parent,lchild,rchild;}HTNode,*HuffmanTree;//动态分配数组存储郝夫曼编码typedef char* *HuffmanCode;//选择n个(这里是k=n)节点中权值最小的两个结点void Select(HuffmanTree &HT,int k,int &s1,int &s2) { int i;i=1;while(i //下面选出权值最小的结点，用s1指向其序号s1=i;for(i=1;i {if(HT.parent==0&&HT.weight}//下面选出权值次小的结点，用s2指向其序号for(i=1;i {if(HT.parent==0&&i!=s1)break;}s2=i;for(i=1;i {if(HT.parent==0&&i!=s1&&HT.weight}}//构造Huffman树，求出n个字符的编码void HuffmanCoding(HuffmanTree &HT,HuffmanCode&HC,int *w,int n)int m,c,f,s1,s2,i,start;char *cd;if(n m=2*n-1; //n个叶子n-1个结点HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode)); //0号单元未用，预分配m+1个单元HuffmanTree p=HT+1;w++; //w的号单元也没有值，所以从号单元开始for(i=1;i {p->weight=*w;p->parent=p->rchild=p->lchild=0;}for(;i {p->weight=p->parent=p->rchild=p->lchild=0;}for(i=n+1;i {Select(HT,i-1,s1,s2); //选出当前权值最小的HT.parent=i;HT.parent=i;HT.lchild=s1;HT.rchild=s2;HT.weight=HT.weight+HT.weight;//从叶子到根逆向求每个字符的郝夫曼编码HC=(HuffmanCode)malloc((n+1)*sizeof(char*)); //分配n个字符编码的头指针变量cd=(char*)malloc(n*sizeof(char)); //分配求编码的工作空间cd='';//编码结束符for(i=1;i {start=n-1; //编码结束符位置for(c=i,f=HT.parent;f!=0;c=f,f=HT.parent) //从叶子到根逆向求编码{if(HT.lchild==c)cd='0';elsecd='1';}HC=(char*)malloc((n-start)*sizeof(char)); //为第i个字符编码分配空间strcpy(HC,&cd);//从cd复制编码到HC}free(cd); //释放工作空间}void main(){ int n,i;int* w; //记录权值char* ch; //记录字符HuffmanTree HT;HuffmanCode HC;cout cin>>n;w=(int*)malloc((n+1)*sizeof(int)); //记录权值，号单元未用ch=(char*)malloc((n+1)*sizeof(char));//记录字符，号单元未用cout for(i=1;i {cout }。
数据结构 实验报告五
实验小结：通过本次实验，我学会了掌握查找的不同方法，并能用高级语言 实现查找算法；基本上掌握顺序表的查找方法和有序顺序表的折半查找算法以及 静态查找树的构造方法和查找算法；对于二叉排序树的生成、插入、删除、输出 运算有了初步的了解。
教师评语： 1. 实验结果及解释：（ 准确合理、 较准确、 不合理 ）；占 30% 2. 实验步骤的完整度：（ 完整、 中等、 不完整 ）；占 30% 3. 实验程序的正确性：（ 很好、 较好、 中等、 较差、 很差 ）；占 30% 4. 卷面整洁度：（ 很好、 较好、 中等、 较差、 很差 ）；占 10%
if(cmd=='c'||cmd=='C')
{cout<<"请输入你所要创建的二叉树的结点的值，以-1 结束：\n";
root=creatut<<"中序遍历二叉树："<<endl;
inorder_btree(root);
cout<<"\n 请选择你要对这棵二叉树所做的操作:查找:S.插入:I.删除:D.退出:Q"<<endl;
{BSTree t=NULL;
KeyType key;
cin>>key;
while(key!=-1)
{t=insertBST(t,key);
cin>>key;}
return t;}
void inorder_btree(BSTree root)
{BSTree p=root;
if(p!=NULL){
inorder_btree(p->left );
else return searchBST(t->right,key); }
数据结构实验报告实验5
数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构，通过实际编程实现和操作，提高对数据结构的应用能力和编程技巧。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容1、线性表的基本操作实现线性表的创建、插入、删除、查找等基本操作。
对不同操作的时间复杂度进行分析和比较。
2、栈和队列的应用利用栈实现表达式求值。
使用队列模拟银行排队系统。
3、二叉树的遍历实现二叉树的先序、中序、后序遍历算法。
分析不同遍历算法的特点和应用场景。
4、图的表示和遍历采用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历算法。
四、实验步骤及结果1、线性表的基本操作首先，定义了一个线性表的结构体，包含数据域和指针域。
创建线性表时，动态分配内存空间，并初始化表头和表尾指针。
插入操作分为表头插入、表尾插入和指定位置插入。
在指定位置插入时，需要先找到插入点的前一个节点，然后进行插入操作。
删除操作同样需要找到要删除节点的前一个节点，然后释放删除节点的内存空间，并调整指针。
查找操作通过遍历线性表，逐个比较数据值来实现。
经过测试，不同操作的时间复杂度如下：创建操作的时间复杂度为 O(1)。
插入操作在表头和表尾插入的时间复杂度为 O(1)，在指定位置插入的时间复杂度为 O(n)。
删除操作的时间复杂度为 O(n)。
查找操作的平均时间复杂度为 O(n)。
2、栈和队列的应用表达式求值：将表达式转换为后缀表达式，然后利用栈进行计算。
遇到操作数则入栈，遇到操作符则从栈中弹出两个操作数进行计算，并将结果入栈。
最后栈顶元素即为表达式的结果。
银行排队系统：使用队列模拟客户的排队过程。
客户到达时入队，服务窗口空闲时从队列头部取出客户进行服务。
实验结果表明，栈和队列能够有效地解决相关问题，提高程序的效率和可读性。
3、二叉树的遍历先序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
数据结构实验报告5
宜宾学院实验报告
EnQueue(lQueue, c);//字符入队列
scanf("%c",&c);
}//分别向堆栈与队列中存入该字符串
lQueue.front=lQueue.front->next;
while(!(s.top==s.base))
{
char a,b;
pop(s,a); //字符出栈
DeQueue(lQueue,b); //字符出队列
if(a!=b)
{
printf("该字符串不是回文字\n"); //不是回文字
exit(0);
}//两字符进行比较
}//将堆栈与队列中的元素出栈，并进行比较，判断该字符串是否为回文字
printf("该字符串是回文字\n"); //输出判断结果,是回文字
return 0;
}//主程序，完成回文字符串的判定，并输出判定结果
4.编译运行程序，若有错，调试程序
五、实验过程和结果（记录实验过程和结果、以及所出现的问题和解决方法）
运行结果如下：
六、实验总结和思考（填写收获和体会，分析成功或失败的原因）
通过这次实验，我们要学会灵活运用栈和队列的结构解决生活中的实际问题，一切离不开实际，编程行业也是这样，学了很多基础的东西最后都要运用到实际问题的解决中去，不然就学成了书呆子，对社会无益。
通过前面几次实验的积累和扎实基础，我更深刻的理解了栈和队列这两种常用的数据结构。
并能够将其应用到实际问题的解决中来。
数据结构实验五
第五次实验报告1 实验目的1. 掌握二叉树的定义；2. 掌握二叉树的基本操作，如二叉树的建立，遍历，结点个数统计，树的深度计算等；3. 掌握哈夫曼树和哈夫曼编码算法的实现。
2 Part 12.1 实验内容用递归的方法实现以下算法：1. 以二叉链表表示二叉树，建立一棵二叉树2. 输出二叉树的中序遍历结果3. 输出二叉树的前序遍历结果4. 输出二叉树的后序遍历结果5. 计算二叉树的深度6. 统计二叉树的结点个数7. 统计二叉树的叶结点个数8. 统计二叉树的度为1的结点个数9. 输出二叉树中从每个叶子结点到根结点的路径2.2 算法流程1.采用先序序列的方式递归建立二叉树。
先输入根结点的值，然后再依次建立根结点的左孩子和根结点的右孩子。
当输入“#”字符的时候即代表该根结点的该方向上的孩子不存在，即终止该方向的输入和建立，转向下一个方向建立子树。
注意到叶子结点处需要输入两次'#'，且总输入的'#'数量应为所有结点数量+1。
2.采用递归的方式输出中序遍历的结果。
中序遍历是先根结点，再左节点和右节点，所以在遇到结点为空的时候直接返回，否则在遍历根结点之后再依次遍历左子树和右子树。
3.采用递归的方式输出前序遍历的结果。
前序遍历是先左结点，再根结点和右结点。
所以在遇到结点为空的时候直接返回，否则先遍历左子树，然后输出根结点的值，最后再遍历右子树。
4.采用递归的方式输出后序遍历的结果。
后序遍历是先左结点，再右节点和根结点。
所以在遇到结点为空的时候直接返回，否则先遍历左子树，然后遍历右子树，最后再输出根结点的值。
5.采用递归的方式获取二叉树的深度。
在遇到空结点的时候返回其深度为0，而在遇到有孩子的结点时递归比较其左子树和右子树的深度大小。
其深度实际上就是两者较大者加上该结点所体现的深度，即两者较大者加上1。
6.采用递归的方式获取二叉树的结点个数。
当遇到空结点的时候返回0，否则返回其左子树中结点的个数加上右子树中结点的个数再加上该结点本身，即为二叉树中结点的个数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构与算法分析》
实验报告书
学期：2014 － 2015 学年第 2 学期
班级：信息管理与信息系统2班
学号： 1310030217 姓名：田洪斌
实验类别：（★）基础型（）设计型
实验时间：
成绩：
信息管理系
一、实验内容
实现程序，按满二叉树给元素编号并输入的方式构造二叉树。
二、实验目的
1、掌握二叉树的静态及操作特点；
2、掌握二叉树的各种遍历方法；
3、掌握二叉树的存储、线索化等在C语言环境中的实现方法；
4、掌握哈夫曼树的构造方法及编码方法。
三、需求分析
用二叉树结构表示来完成输入、编辑、调试、运行的全过程。
并规定：
a.手动输入数字建立二叉树
b.程序可以输入、调试、运行、显示、遍历
c.测试数据：用户手动输入的数据
四、系统设计
1．数据结构设计
在本程序中对二叉树的存储主要用的是顺序存储结构，将二叉树存储在一个一维数组中。
数据的输入输出都是采用整型数据进行。
在主函数中只是定义数据类型，程序的实现功能化主要是在主函数中通过给要调用的函数参数来实现程序要求的功能。
2．程序结构设计
（1）程序中主要函数功能：
main()/////////////////////////////////////////////主函数
menu()/////////////////////////////////////////////菜单
BiTree CreateBiTree()///////////////////////先序建立二叉树
（2）函数调用关系
见图4-1。
图4-1 函数关系图
五、 调试分析
1.算法和函数中出现了一些系统无法识别的变量，照成程序出现了错 误。
原因是没有注意算法与源程序的区别。
算法是简单的对源程序进行描述
的，是给人阅读的，所以有些变量没有定义我们就能看懂。
而程序中的变量一定要先定义才能够被引用，才能被计算机识别。
2.在调试过程中遇到问题是利用C++程序进行调试的，找出错误并改正。
3.数据输出函数运行不正常，经检查程序，发现是定义错误，更改后错误排除；
六、 测试结果
1．运行时输入正确密码进入主界面，系统根据输入的数字选项来调用相应的函数。
主要实现“功能选择”的界面，在这个界面里有显示系统的五大功能，根据每个功能前面的序号进行选择。
以下为该界面：
main
BiTree CreateB iTree()
meun()
图4-2 主界面2.当选择1建立完成输入时，运行结果如下图：
图4-3 二叉树的建立
3.当建立完成输入二叉树的输出时，运行结果如下图：
图4-4二叉树的输出
测试中，分别录入2,5,8,3,7,9,1,0,7,3,8,0作为顺序表的初始值，输出数据后显示正常；经测试，本程序达到了预期的设计功能，具有一定的健壮性。
七、经验和体会
本次试验利用C语言编程，完成了二叉树中的建立、输出等功能，提升了我的C语言编程能力，同时也加深了我对数据结构中关于二叉树结构有关基础概念、基本算法的理解，同时，通过程序的调试及观察分析程序运行的情况，也进一步增加了我调试程序的经验，并使我认识到了二叉树的结构。
八、程序源代码
#include <stdio.h>
#define ElemType char
//二叉树的二叉链表存储表示
typedef struct BiTNode{
int data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//先序建立二叉树
BiTree CreateBiTree()
{
int x;
BiTree T;
printf("\n请输入数字\n");
scanf("%d",&x);
if(x==0)
T=NULL;
else{
T = (BiTree)malloc(sizeof(BiTNode));
T->data = x;
T->lchild = CreateBiTree();
T->rchild = CreateBiTree();
}
return T;//返回根节点
}
//先序遍历二叉树
void PreOrderTraverse(BiTree T){
if(T){
printf("%d",T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
//中序遍历
void InOrderTraverse(BiTree T){
if(T){
PreOrderTraverse(T->lchild);
printf("%d",T->data);
PreOrderTraverse(T->rchild);
}
}
//后序遍历
void PostOrderTraverse(BiTree T){ if(T){
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
printf("%d",T->data);
}
}
/////////////////////菜单
void menu()
{
printf("\n\t\t**********【菜单】**********\n");
printf("\n\t[1]:二叉树的建立\n");
printf("\n\t[2]:二叉树的输出\n");
printf("\n\t[3]:二叉树的先序遍历\n");
printf("\n\t[4]:二叉树的中序遍历\n");
printf("\n\t[5]:二叉树的后序遍历\n");
printf("\n\t[6]:退出系统\n");
}
/////////////////////主函数
void main()
{
int x,y=1;
BiTree T;
while(y)
{
menu();
printf("\n\t请选择菜单\n");
scanf("%d",&x);
switch(x)
{
case 1: T = CreateBiTree();break;
case 2:PreOrderTraverse(T);break;
case 3:PreOrderTraverse(T);break;
case 4:InOrderTraverse(T);break;
case 5:PostOrderTraverse(T);break;
case 6:y=0;
}
}
}。