数据结构实验五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

12
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");}四、设计性实验编程实现根据二叉树的先序遍历序列和中序遍历序列来建立两颗二叉树，并判断这两颗二叉树是否相等。

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;
}
}
}。