数据结构课程设计实验报告二叉树的实现
数据结构实验报告3-二叉树
北京物资学院信息学院实验报告课程名数据结构(C++)实验实验名称二叉树算法的实现实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ _______ 学号___一、实验目的1.掌握二叉树的存储的结构;2. 掌握建立二叉树的算法;3. 掌握对二叉树的遍历算法;4. 掌握二叉搜索树的算法;5. 掌握建立哈夫曼树和哈夫曼编码的算法;二、实验内容基本部分1. 采用广义表形式建立二叉树(参考图5-11(a)和/或图5-13(a));2. 对已建立的二叉树,进行先、中、后序和按层遍历;3. 用广义表形式输出二叉树;4. 【习题5-3】1, 2 (2题选作)【提示:参考递归遍历算法】;特殊二叉树部分1.用插入算法建立一棵二叉搜索树,原始数据为:{30,50,20,40,25,70,54,23,80,92},并中序遍历该树、查找其中的元素;2. 构造一棵叶子结点权值分别为3,5,6,7,9,13,21的哈夫曼树;3. 对2题进行哈夫曼编码。
三、实验地点与环境3.1 实验地点(南实验楼教室)3.2实验环境(所用语言环境)四、实验步骤1.2.3.…五、实验结果与分析5.1 实验结果(原始数据,预期结果和运行结果)序号算法名称(函数名) 所在头文件名原始数据与与功能主函数所在文件名运行结果*1 函数名:功能:头文件:CPP文件:原始数据:运行结果:23* 如果不能按“原始数据”、“运行结果”列出数据则不列,必要时在“分析”部分说明5.2 分析(选择部分算法分析,包括函数参数说明、调试中所遇到的问题和解决方法、中间结果等,必要时给出函数和主函数的关键段落。
所选算法应是:重要的算法、有编程特点的算法等)六、小结(收获与心得)。
数据结构二叉树实验报告
一 、实验目的和要求(1)掌握树的相关概念,包括树、节点的度、树的度、分支节点、叶子节点、孩子节点、双亲节 点、树的深度、森林等定义。
(2)掌握树的表示,包括树形表示法、文氏图表示法、凹入表示法和括号表示法等。
(3)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。
(4)掌握二叉树的性质。
(5)重点掌握二叉树的存储结构,包括二叉树顺序存储结构和链式存储结构。
(6)重点掌握二叉树的基本运算和各种遍历算法的实现。
(7)掌握线索二叉树的概念和相关算法的实现。
(8)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码的产生方法。
(9)掌握并查集的相关概念和算法。
(10)灵活运用二叉树这种数据结构解决一些综合应用问题。
二、实验内容注:二叉树b 为如图7-123所示的一棵二叉树图7-123+实验7.1 编写一个程序algo7-1.cpp,实现二叉树的各种运算,并在此基础上设计一个程序exp7-1.cpp 完成如下功能:(1)输出二叉树b ;(2)输出H 节点的左、右孩子节点值; (3)输出二叉树b 的深度; (4)输出二叉树b 的宽度; (5)输出二叉树b 的节点个数;(6)输出二叉树b 的叶子节点个数。
实验7.2设计一个程序exp7-2.cpp,实现二叉树的先序遍历、中序遍历和后序遍历和非递归算法, 以及层次变量里的算法。
并对图7-123所示的二叉树b 给出求解结果。
b+ACF GIKL+NM+E+HdJD₄B臣1607-1.CPPif(b?-HULL)re3P4+;Qu[rear]-p-b;Qu[rear].1no=1;while(reart=front){Front++;b=Qu[front]-P;lnum-Qu[front].1no;if(b->Ichildt=NULL)rpar+t;Qu[rear]-p=b->1child;Qu[rear].Ino-lnun+1;if(D->rch11d?=NULL)1/根结点指针入队//根结点的层次编号为1 1/队列不为空1/队头出队1/左孩子入队1/右孩子入队redr+t;qu[rear]-p=b->rchild;Qu[rear].1no-lnun*1;}}nax-0;lnun-1;i-1;uhile(i<=rear){n=0;whdle(i<=rear ge Qu[1].1no==1num)n+t;it+;Inun-Qu[i].1n0;if(n>max)nax=n;}return max;田1607-1.CPPreturn max;}elsereturn o;口×int Modes(BTNode *D) //求二叉树D的结点个数int nun1,nun2;if(b==NULL)returng,else if(b->ichild==NULL&D->rchild==NULL)return 1;else{num1-Hodes(b->Ichild);num2=Nodes(b->rchild);return(num1+nun2+1);LeafNodes(BINode *D) //求二叉树p的叶子结点个数int num1,num2;1f(D==NULL)return 0;else if(b->1chi1d==NULLc& b->rch11d==NULL)return 1;else{num1-LeafModes(b->lchild);num2=LeafNodes(b->rchild);return(nun1+nun2);int程序执行结果如下:xCProrn FlslirosfViu l SudiollyPrjecslro7 LJebuglFoj7 ex<1)输出二叉树:A<B<D,E<H<J,K<L,M<,N>>>>),C<F,G<,I>>)<2)'H’结点:左孩子为J石孩子为K(3)二叉树b的深度:7<4)二叉树b的宽度:4(5)二叉树b的结点个数:14(6)二叉树b的叶子结点个数:6<?>释放二叉树bPress any key to continue实验7 . 2程序exp7-2.cpp设计如下:坠eTPT-2.EPP#include<stdio.h》winclude<malloc.h>deFn Masie 00typde chr ElemTyetypede sruct nde{ElemType data;stuc node *lclldstruct node rchild;》BTHode;extern vod reaeBNodeBTNode extrn void DispBTHode(BTNodeuoid ProrderBTNode *b)if(b?-NULL)- 回1 / 数据元素1 / 指向左孩子1 / 指向右孩子*eb car *str)xb1 / 先序遍历的递归算法1 / 访问根结点/ / 递归访问左子树1 7 递归访问右子树/ / 根结点入栈//栈不为空时循环/ / 退栈并访问该结点/ / 右孩子入栈{》v oidprintf(*c“,b->data); Preorder(b->lchild); Pre0rder(b->rchild);Preorder1(BTNode *b)BTNode xSt[Maxsize],*p;int top=-1;if(b!-HULL)top++;St[top]-b;uhle (op>-)p-St[top];top--;printf("%c“,p->data);if(p->rchild?-HULL)A约e程p7-2.CPPprintF(”后序逅历序列:\n");printf(" 递归算法=");Postorder(b);printf("\n");printf(“非递归算法:“);Postorder1(b);printf("\n");序执行结果如下:xCAPrograFleicsoftVisal SudlyrjecsProj 2Debuzlroj72ex"二叉树b:A(B(D,ECH<J,K(L,M<,N)>))),C(F,GC.I>))层次遍历序列:A B C D E F G H I J K L M N先序遍历序列:递归算法:A B D E H J K L M N C F G I非归算法:A B D E H J K L M N C F G I中序遍历序列:递归算法: D B J H L K M N E A F C G I非递归算法:D B J H L K M N E A F C G I后序遍历序列:递归算法: D J L N M K H E B F I G C A非递归算法:D J L N H K H E B F I G C APress any key to continue臼p7-3.CPP15Pp a t h[p a t h l e n]-b->d a t a;//将当前结点放入路径中p a t h l e n t+;/7路任长度培1Al1Path1(b->ichild,patn,pathlen);1/递归扫描左子树Al1Path1(b->rchild,path,pathlen); //递归扫描右子树pathlen-- ; //恢复环境uoid Longpath(BTNode *b,Elemtype path[1,int pathlen,Elemtype longpath[],int elongpatnien) int i;1f(b==NULL){if(pathlen>longpatnlen) //若当前路径更长,将路径保存在1ongpatn中for(i-pathlen-1;i>-8;i--)longpath[i]=path[1];longpathlen-pathlen;elsepath[pathlen]=b->data; pathlen4; //将当前结点放入路径中//路径长度增1iongPath(b->lchild,path₇pathlen,langpath,longpathien);//递归扫描左子树LongPath(b->rchiid,path,pathien,longpath,longpathien);//递归扫描石子树pathlen--; /7饮其环境oid DispLeaf(BTNode xb)- 口凶uoid DispLeaf(BTNode xb)iE(D!=NULL){ if(b->1child--HULL B& b->rchild--HULL)printf("3c“,b->data);elsepispLeaf(b->ichild);DispLeaf(b->rchild);oid nain()8TNodexb;ElenType patn[Maxsize],longpath[Maxsize];int i.longpathien-U;CreateBTNode(b,"A(B(D,E(H(J,K(L,H(,N))))),C(F,G(,I)))");printf("\n二灾树b:");DispBTNode(b);printf("\n\n*);printf(”b的叶子结点:");DispLeaf(b);printf("\n\n");printf("A11Path:");A11Path(b);printf("m");printf("AiiPath1:n");AliPath1(b.path.);printf("");LongPath(b,path,8,longpath,longpathlen);printf(”第一条量长路径长度=d\n”,longpathlen);printf(”"第一茶最长路径:");for(i=longpathlen;i>=0;i--)printf("c",longpatn[1]);printf("\n\n");。
华科数据结构二叉树实验报告
华科数据结构二叉树实验报告一、实验目的本实验旨在通过实践操作,加深对数据结构中二叉树的理解,掌握二叉树的基本操作和应用。
二、实验内容1. 实现二叉树的创建和初始化。
2. 实现二叉树的插入操作。
3. 实现二叉树的删除操作。
4. 实现二叉树的查找操作。
5. 实现二叉树的遍历操作:前序遍历、中序遍历、后序遍历。
6. 实现二叉树的层次遍历。
7. 实现二叉树的销毁操作。
8. 进行实验测试,并分析实验结果。
三、实验步骤1. 创建二叉树的数据结构,包括节点的定义和指针的初始化。
2. 实现二叉树的创建和初始化函数,根据给定的数据构建二叉树。
3. 实现二叉树的插入操作函数,将新节点插入到二叉树的合适位置。
4. 实现二叉树的删除操作函数,删除指定节点,并保持二叉树的结构完整。
5. 实现二叉树的查找操作函数,根据给定的值查找对应的节点。
6. 实现二叉树的遍历操作函数,包括前序遍历、中序遍历、后序遍历。
7. 实现二叉树的层次遍历函数,按照层次顺序遍历二叉树。
8. 实现二叉树的销毁操作函数,释放二叉树的内存空间。
9. 编写测试程序,对上述函数进行测试,并分析实验结果。
四、实验结果与分析经过测试,实验结果如下:1. 创建和初始化函数能够正确构建二叉树,并初始化节点的值和指针。
2. 插入操作函数能够将新节点插入到二叉树的合适位置,并保持二叉树的结构完整。
3. 删除操作函数能够正确删除指定节点,并保持二叉树的结构完整。
4. 查找操作函数能够根据给定的值找到对应的节点。
5. 遍历操作函数能够按照指定的顺序遍历二叉树,并输出节点的值。
6. 层次遍历函数能够按照层次顺序遍历二叉树,并输出节点的值。
7. 销毁操作函数能够释放二叉树的内存空间,防止内存泄漏。
根据实验结果分析,二叉树的基本操作和应用都能够正常实现,达到了预期的效果。
五、实验总结通过本次实验,我进一步加深了对数据结构中二叉树的理解,并掌握了二叉树的基本操作和应用。
通过实践操作,我更加熟悉了二叉树的创建、插入、删除、查找和遍历等操作,同时也学会了如何进行层次遍历和销毁二叉树。
数据结构实验:二叉树功能的实现-精简
实验名称:实验八二叉树使用功能的实现(实验报告)一.实验目的:1. 在实验7的基础上,扩展二叉树的功能,实现二叉树所有节点个数和所有叶子节点个数的统计2、编写测试程序,对二叉树的创建、遍历和统计节点、统计叶子节点功能进行验证分析二.实验内容:1. 实现二叉树所有节点个数和所有叶子节点个数的统计。
2、编写测试程序,对二叉树的创建、遍历和统计节点。
二、实验原理:1.统计二叉树中结点个数二叉树结点的个数= 左子树中所含结点的个数+ 右子树所含结点的个数+ 根结点。
int BiTreeCount(BiTreeLink r){ if(r==NULL) return 0;/*空二叉树的结点个数为0*/elsereturn BiTreeCount(r->left)+BiTreeCount(r->right)+1;}2.求二叉树的深度:二叉树的深度= 左子树的深度> 右子树的深度? 左子树的深度+1 :右子树的深度+1。
int BiTreeDepth(BiTreeLink r){int ld,rd;if(r==NULL) return 0;else{ld=BiTreeDepth(r->left);rd=BiTreeDepth(r->right);return ld>rd ? ld+1 : rd+1;}}2.实验流程:1、编辑主函数;2、通过函数调用完成程序设计;3、运行编译函数,查看结果四.程序代码:1.主程序#include "malloc.h"#include "stdio.h"#define MAXSIZE 100/*二叉链表的存储结构*/typedef char DataType;typedef struct Node{DataType data;struct Node *left;struct Node *right;}BTNode,*PBTNode,*BiTreeLink;/*创建二叉树*/BiTreeLink CreateBiTree(char *nodes,int pos,int num) {PBTNode p;if(nodes[pos]==' ' || pos>num)return NULL;p=(PBTNode)malloc(sizeof(BTNode));if(!p){printf("初始化链表错误!\n");return 0;}p->data=nodes[pos];p->left=CreateBiTree(nodes,2*pos,num);p->right=CreateBiTree(nodes,2*pos+1,num);return p;}/*求二叉树叶子节点的个数*/int LeafCount(BiTreeLink r){if(!r) return 0;else if (!r->left && !r->right )return 1;elsereturn LeafCount(r->left) +LeafCount(r->right); }/*统计二叉树中结点个数*/int BiTreeCount(BiTreeLink r){if(r==NULL) return 0;elsereturn BiTreeCount(r->left)+BiTreeCount(r->right)+1;}int main(int argc, char* argv[]){BiTreeLink root,p;int i;char nodes[]={1,2,3,4,5,6,7,8,9};root=CreateBiTree(nodes,1,10);printf("输入序列:\n");for(i=1;i<10;i++)printf("(%c)",nodes[i-1]);printf("\n二叉树节点个数: %d \n",BiTreeCount(root));printf("\n二叉树叶子结点个数: %d\n",LeafCount(root));return 0; }2.实验结果:结果分析:由实验结果可知,成功的完成了对二叉树的操作,可见能实现乘数的功能实现,实验基本成功。
数据结构实验报告二二叉树实验
实验报告课程名称:数据结构
第 1 页共4 页
五、实验总结(包括心得体会、问题回答及实验改进意见,可附页)
这次实验主要是建立二叉树,和二叉树的先序、中序、后续遍历算法。
通过这次实验,我巩固了二叉树这部分知识,从中体会理论知识的重要性。
在做实验之前,要充分的理解本次实验的理论依据,这样才能达到事半功倍的效果。
如果在没有真正理解实验原理之盲目的开始实验,只会浪费时间和精力。
例如进行二叉树的遍历的时候,要先理解各种遍历的特点。
先序遍历是先遍历根节点,再依次先序遍历左右子树。
中序遍历是先中序遍历左子树,再访问根节点,最后中序遍历右子树。
而后序遍历则是先依次后续遍历左右子树,再访问根节点。
掌握了这些,在实验中我们就可以融会贯通,举一反三。
其次要根据不光要懂得代码的原理,还要对题目有深刻的了解,要明白二叉树的画法,在纸上先进行自我演练,对照代码验证自己写的正确性。
第 3 页共4 页
第 4 页共4 页。
数据结构二叉树的实验报告
数据结构二叉树的实验报告数据结构二叉树的实验报告一、引言数据结构是计算机科学中非常重要的一个领域,它研究如何组织和存储数据以便高效地访问和操作。
二叉树是数据结构中常见且重要的一种,它具有良好的灵活性和高效性,被广泛应用于各种领域。
本实验旨在通过实际操作和观察,深入了解二叉树的特性和应用。
二、实验目的1. 理解二叉树的基本概念和特性;2. 掌握二叉树的创建、遍历和查找等基本操作;3. 通过实验验证二叉树的性能和效果。
三、实验过程1. 二叉树的创建在实验中,我们首先需要创建一个二叉树。
通过输入一系列数据,我们可以按照特定的规则构建一棵二叉树。
例如,可以按照从小到大或从大到小的顺序将数据插入到二叉树中,以保证树的有序性。
2. 二叉树的遍历二叉树的遍历是指按照一定的次序访问二叉树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历是先访问根节点,然后再依次遍历左子树和右子树;中序遍历是先遍历左子树,然后访问根节点,最后再遍历右子树;后序遍历是先遍历左子树,然后遍历右子树,最后访问根节点。
3. 二叉树的查找二叉树的查找是指在二叉树中寻找指定的节点。
常见的查找方式有深度优先搜索和广度优先搜索。
深度优先搜索是从根节点开始,沿着左子树一直向下搜索,直到找到目标节点或者到达叶子节点;广度优先搜索是从根节点开始,逐层遍历二叉树,直到找到目标节点或者遍历完所有节点。
四、实验结果通过实验,我们可以观察到二叉树的特性和性能。
在创建二叉树时,如果按照有序的方式插入数据,可以得到一棵平衡二叉树,其查找效率较高。
而如果按照无序的方式插入数据,可能得到一棵不平衡的二叉树,其查找效率较低。
在遍历二叉树时,不同的遍历方式会得到不同的结果。
前序遍历可以用于复制一棵二叉树,中序遍历可以用于对二叉树进行排序,后序遍历可以用于释放二叉树的内存。
在查找二叉树时,深度优先搜索和广度优先搜索各有优劣。
深度优先搜索在空间复杂度上较低,但可能会陷入死循环;广度优先搜索在时间复杂度上较低,但需要较大的空间开销。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构,它由节点和边构成,每个节点最多有两个子节点。
在本次实验中,我们将对二叉树的基本结构和基本操作进行实现和测试,并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作,包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构:我们将首先学习二叉树的定义,并实现二叉树的存储结构,包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化:我们将实现二叉树的创建和初始化操作,以便后续操作和测试使用。
3. 二叉树的遍历:我们将实现二叉树的前序、中序和后序遍历算法,并测试其正确性和效率。
4. 二叉树的查找:我们将实现二叉树的查找操作,包括查找节点和查找最大值、最小值等。
5. 二叉树的应用:我们将探讨二叉树在实际应用中的使用场景,如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构,它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类:满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构:采用节点定义和指针表示法,通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构:采用数组存储节点信息,通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构,我们需要自定义节点和指针,并通过节点的方式来构建二叉树。
对于顺序存储结构,我们需要定义数组和索引,通过索引计算来定位节点的位置。
一般来说,初始化一个二叉树可以使用以下步骤:1. 创建树根节点,并赋初值。
2. 创建子节点,并到父节点。
3. 重复步骤2,直到创建完整个二叉树。
数据结构二叉树的实验报告
数据结构实验报告1. 实验目的和内容:掌握二叉树基本操作的实现方法2. 程序分析2.1存储结构链式存储2.程序流程2.3关键算法分析算法一:Create(BiNode<T>* &R,T data[],int i,int n)【1】算法功能:创建二叉树【2】算法基本思想:利用顺序存储结构为输入,采用先建立根结点,再建立左右孩子的方法来递归建立二叉链表的二叉树【3】算法空间时间复杂度分析:O(n)【4】代码逻辑:如果位置小于数组的长度则{ 创建根结点将数组的值赋给刚才创建的结点的数据域创建左子树,如果当前结点位置为i,则左孩子位置为2i创建右子树,如果当前结点位置为i,则右孩子位置为2i+1}否则R为空算法二:CopyTree(BiNode<T>*sR,BiNode<T>* &dR))【1】算法功能:复制构造函数【2】算法基本思想:按照先创建根结点,再递归创建左右子树的方法来实现。
【3】算法空间时间复杂度分析:O(n)【4】代码逻辑:如果源二叉树根结点不为空则{创建根结点调用函数自身,创建左子树调用函数自身,创建右子树}将该函数放在复制构造函数中调用,就可以实现复制构造函数算法三:PreOrder(BiNode<T>*R)【1】算法功能:二叉树的前序遍历【2】算法基本思想:这个代码用的是优化算法,提前让当前结点出栈。
【3】算法空间时间复杂度分析:O(n)【4】代码逻辑(伪代码)如果当前结点为非空,则{访问当前结点当前结点入栈将当前结点的左孩子作为当前结点}如果为空{则栈顶结点出栈则将该结点的右孩子作为当前结点}反复执行这两个过程,直到结点为空并且栈空算法四:InOrder(BiNode<T>*R)【1】算法功能:二叉树的中序遍历【2】算法基本思想:递归【3】算法空间时间复杂度分析:未知【4】代码逻辑:如果R为非空:则调用函数自身遍历左孩子访问该结点再调用自身访问该结点的右孩子算法五:LevelOrder(BiNode<T>*R)【1】算法功能:二叉树的层序遍历【2】算法基本思想:【3】算法空间时间复杂度分析:O(n)【4】代码逻辑(伪代码):如果队列不空{对头元素出队访问该元素若该结点的左孩子为非空,则左孩子入队;若该结点的右孩子为非空,则右孩子入队;}算法六:Count(BiNode<T>*R)【1】算法功能:计算结点的个数【2】算法基本思想:递归【3】算法空间时间复杂度分析:未知【4】代码逻辑:如果R不为空的话{调用函数自身计算左孩子的结点数调用函数自身计算右孩子的结点数}template<class T>int BiTree<T>::Count(BiNode<T>*R){if(R==NULL)return 0;else{int m=Count(R->lchild);int n=Count(R->rchild);return m+n+1;}}算法七:Release(BiNode<T>*R)【1】算法功能:释放动态内存【2】算法基本思想:左右子树全部释放完毕后再释放该结点【3】算法空间时间复杂度分析:未知【4】代码逻辑:调用函数自身,释放左子树调用函数自身,释放右子树释放根结点释放二叉树template<class T>void BiTree<T>::Release(BiNode<T>*R) {if(R!=NULL){Release(R->lchild);Release(R->rchild);delete R;}}template<class T>BiTree<T>::~BiTree(){Release(root);}int main(){BiTree<int> BTree(a,10);BiTree<int>Tree(BTree);BTree.PreOrder(BTree.root);cout<<endl;Tree.PreOrder(Tree.root);cout<<endl;BTree.InOrder(BTree.root);cout<<endl;Tree.InOrder(Tree.root);cout<<endl;BTree.PostOrder(BTree.root);cout<<endl;Tree.PostOrder(Tree.root);cout<<endl;BTree.LevelOrder(BTree.root);cout<<endl;Tree.LevelOrder(Tree.root);cout<<endl;int m=BTree.Count(BTree.root);cout<<m<<endl;return 0;}3.测试数据:int a[10]={1,2,3,4,5};1 2 4 5 31 2 4 5 34 25 1 34 5 2 3 11 2 3 4 554.总结:4.1:这次实验大多用了递归的算法,比较好理解。
数据结构实验报告6二叉树的操作
if(!S.empty())
{
p=S.top();
S.pop();
cout<<p->data<<" ";
S.push(p->rchild);
}}
}
void PreOrder_Nonrecursive(BiTree T)
{
stack<BiTree> S;
BiTree p;
S.push(T);
#include <queue>
#include <stack>
#include <malloc.h>
#defineSIZE 100
using namespace std;
typedef struct BiTNode
{char data;
struct BiTNode *lchild,*rchild;
break;
default:flag=0;printf("程序运行结束,按任意键退出!\n");
}}
}
void CreateBiTree(BiTree &T)
{
char ch;
scanf("%c",&ch);
if(ch==' ') T=NULL;
else
{ T=(BiTNode *)malloc(sizeof(BiTNode));
PreOrder_Nonrecursive(T);
printf("\n");
}
else printf("二叉树为空!\n");
break;
数据结构之二叉树编程实验报告
实验报告:二叉树题目:建立一棵二叉树,数据以字符串形式从键盘输入,在此二叉树上完成:(1)前序、中序、后序遍历(2)求出叶子数(3)求树高(4)左右子树交换,输出交换后的前序、中序遍历序列分析:建树:输入的字符串序列为带有空节点的前序遍历序列(空节点用*表示)。
①:前序,中序,后序遍历:递归遍历②:求叶子数:当一个节点的左右孩子都是NULL时,此节点即为叶子节点。
③:求树高当前节点的树高等于其左右孩子树高大的加1。
④:左右子树交换:对于每个节点,将其左右孩子交换,再递归对其左右子树交换。
测试结果:附:源码#include <iostream>#include <stdlib.h>using namespace std;struct Bintree{char data;Bintree* lchild;Bintree* rchild;};Bintree *head;int sp;/* 已知一棵二叉树的前序序列,建立这棵树*/ void CreateTree(Bintree *&p,char a[]){Bintree *temp;if(a[sp]!=0){if(a[sp]=='*'){p=NULL;sp++;return ;}p=new Bintree;p->data=a[sp++];CreateTree(p->lchild,a);CreateTree(p->rchild,a);}else p=NULL;}/* 求一棵树的高度*/int Depth(Bintree *&t){int lh , rh ;if( t == NULL ){return 0 ;}else{lh = Depth( t->lchild ) ;rh = Depth( t->rchild ) ;return ( lh > rh ? lh : rh ) + 1 ;}}/* 将二叉树的左右子树互换*/ void Exchange1(Bintree *&t){Bintree *temp;if(t){Exchange1(t->lchild);Exchange1(t->rchild);temp=t->lchild;t->lchild=t->rchild;t->rchild=temp;}}/* 按照前序递归遍历二叉树*/ void Preorder1(Bintree *&t){if(t!=NULL){printf("%c",t->data);Preorder1(t->lchild);Preorder1(t->rchild);}}/* 按照中序递归遍历二叉树*/ void Inorder1(Bintree *&t){if(t!=NULL){Inorder1(t->lchild);printf("%c",t->data);Inorder1(t->rchild);}}/* 按照后序递归遍历二叉树*/void Posorder1(Bintree *&t){if(t!=NULL){Posorder1(t->lchild);Posorder1(t->rchild);printf("%c",t->data);}}/* 递归法求叶子结点个数*/int Leaves_Num1(Bintree *&t){if(t){if(t->lchild==NULL&&t->rchild==NULL){return 1;}return Leaves_Num1(t->lchild)+Leaves_Num1(t->rchild);}return 0;}/*******************************************/int main (){char a[100];memset(a,0,sizeof(a));cout<<"输入带有空节点的前序遍历序列(空节点用*表示)"<<endl;cin>>a;sp=0;CreateTree(head,a);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;cout<<"叶子数:"<<Leaves_Num1(head)<<endl;cout<<"树高:"<<Depth(head)<<endl;cout<<"左右子树交换后"<<endl;Exchange1(head);cout<<"前序遍历:"<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历:"<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历:"<<endl;Posorder1(head);cout<<endl;return 0;}。
数据结构实验报告-二叉树的实现与遍历
《数据结构》第六次实验报告学生姓名学生班级学生学号指导老师一、实验内容1) 采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作。
2) 输出树的深度,最大元,最小元。
二、需求分析遍历二叉树首先有三种方法,即先序遍历,中序遍历和后序遍历。
递归方法比较简单,首先获得结点指针如果指针不为空,且有左子,从左子递归到下一层,如果没有左子,从右子递归到下一层,如果指针为空,则结束一层递归调用。
直到递归全部结束。
下面重点来讲述非递归方法:首先介绍先序遍历:先序遍历的顺序是根左右,也就是说先访问根结点然后访问其左子再然后访问其右子。
具体算法实现如下:如果结点的指针不为空,结点指针入栈,输出相应结点的数据,同时指针指向其左子,如果结点的指针为空,表示左子树访问结束,栈顶结点指针出栈,指针指向其右子,对其右子树进行访问,如此循环,直至结点指针和栈均为空时,遍历结束。
再次介绍中序遍历:中序遍历的顺序是左根右,中序遍历和先序遍历思想差不多,只是打印顺序稍有变化。
具体实现算法如下:如果结点指针不为空,结点入栈,指针指向其左子,如果指针为空,表示左子树访问完成,则栈顶结点指针出栈,并输出相应结点的数据,同时指针指向其右子,对其右子树进行访问。
如此循环直至结点指针和栈均为空,遍历结束。
最后介绍后序遍历:后序遍历的顺序是左右根,后序遍历是比较难的一种,首先需要建立两个栈,一个用来存放结点的指针,另一个存放标志位,也是首先访问根结点,如果结点的指针不为空,根结点入栈,与之对应的标志位也随之入标志位栈,并赋值0,表示该结点的右子还没有访问,指针指向该结点的左子,如果结点指针为空,表示左子访问完成,父结点出栈,与之对应的标志位也随之出栈,如果相应的标志位值为0,表示右子树还没有访问,指针指向其右子,父结点再次入栈,与之对应的标志位也入栈,但要给标志位赋值为1,表示右子访问过。
数据结构实验报告—二叉树
数据结构实验报告—二叉树目录1. 引言1.1 背景1.2 目的2. 前期准备2.1 问题定义2.2 数据准备3. 算法设计3.1 插入节点3.2 删除节点3.3 查找节点3.4 遍历二叉树4. 实验过程4.1 实验环境4.2 实验步骤5. 实验结果与分析5.1 插入节点的结果 5.2 删除节点的结果 5.3 查找节点的结果5.4 遍历二叉树的结果6. 总结与讨论6.1 实验总结6.2 实验改进方向7. 结论8. 参考文献1. 引言1.1 背景介绍二叉树的概念和应用领域,以及在数据结构中的重要性。
1.2 目的明确本实验的目标,即设计一个能够实现插入、删除、查找和遍历二叉树的算法,并对其进行实验验证。
2. 前期准备2.1 问题定义对二叉树的基本操作进行定义,包括插入节点、删除节点、查找节点和遍历二叉树。
2.2 数据准备准备一组用于测试的数据集,包括插入节点、删除节点和查找节点时所需的数据。
3. 算法设计3.1 插入节点详细描述如何设计实现插入节点的算法,并分析算法的时间复杂度和空间复杂度。
3.2 删除节点详细描述如何设计实现删除节点的算法,并分析算法的时间复杂度和空间复杂度。
3.3 查找节点详细描述如何设计实现查找节点的算法,并分析算法的时间复杂度和空间复杂度。
3.4 遍历二叉树详细描述如何设计实现遍历二叉树的算法,并分析算法的时间复杂度和空间复杂度。
4. 实验过程4.1 实验环境描述实验所用的编程语言和相关工具的环境配置。
4.2 实验步骤详细描述实验的具体步骤,包括数据准备、算法实现、代码编写、实验运行和结果分析等。
5. 实验结果与分析5.1 插入节点的结果展示插入节点的实验结果,并对结果进行详细分析和讨论。
5.2 删除节点的结果展示删除节点的实验结果,并对结果进行详细分析和讨论。
5.3 查找节点的结果展示查找节点的实验结果,并对结果进行详细分析和讨论。
5.4 遍历二叉树的结果展示遍历二叉树的实验结果,并对结果进行详细分析和讨论。
二叉树实验报告总结(共10篇)
二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。
二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,并简要给出算法设计小结和心得。
四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。
用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。
3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。
五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。
华科数据结构二叉树实验报告
华科数据结构二叉树实验报告一、实验目的本次实验旨在通过实践操作,深入理解二叉树的基本概念、性质和操作,并掌握二叉树的遍历算法。
二、实验内容1. 实现二叉树的建立和遍历算法;2. 进行性能测试,比较不同遍历算法的效率。
三、实验原理1. 二叉树的定义二叉树是一种特殊的树结构,它的每个节点最多只有两个子节点,分别称为左子节点和右子节点。
二叉树的每个节点都可以看作是一个小的二叉树。
2. 二叉树的遍历算法二叉树的遍历是指按照某种规则依次访问二叉树中的每个节点。
常用的遍历算法有前序遍历、中序遍历和后序遍历。
- 前序遍历(Preorder Traversal):先访问根节点,然后递归地前序遍历左子树,最后递归地前序遍历右子树。
- 中序遍历(Inorder Traversal):先递归地中序遍历左子树,然后访问根节点,最后递归地中序遍历右子树。
- 后序遍历(Postorder Traversal):先递归地后序遍历左子树,然后递归地后序遍历右子树,最后访问根节点。
四、实验步骤1. 实现二叉树的建立算法根据给定的数据,使用递归的方式构建二叉树。
具体步骤如下:- 如果当前节点为空,将数据作为当前节点的值创建新节点;- 如果当前节点不为空,比较数据与当前节点的值的大小,如果小于当前节点的值,则递归地将数据插入到当前节点的左子树中;如果大于当前节点的值,则递归地将数据插入到当前节点的右子树中。
2. 实现二叉树的遍历算法根据前述的遍历算法原理,实现前序遍历、中序遍历和后序遍历算法。
具体步骤如下:- 前序遍历算法:先访问当前节点,然后递归地前序遍历左子树,最后递归地前序遍历右子树。
- 中序遍历算法:先递归地中序遍历左子树,然后访问当前节点,最后递归地中序遍历右子树。
- 后序遍历算法:先递归地后序遍历左子树,然后递归地后序遍历右子树,最后访问当前节点。
3. 进行性能测试使用不同的遍历算法对同一二叉树进行遍历,并记录遍历所需的时间。
数据结构实验报告—二叉树
《算法与数据结构》课程实验报告一、实验目的1、实现二叉树的存储结构2、熟悉二叉树基本术语的含义3、掌握二叉树相关操作的具体实现方法二、实验内容及要求1. 建立二叉树2. 计算结点所在的层次3. 统计结点数量和叶结点数量4. 计算二叉树的高度5. 计算结点的度6. 找结点的双亲和子女7. 二叉树前序、中序、后序遍历的递归实现和非递归实现及层次遍历8. 二叉树的复制9. 二叉树的输出等三、系统分析(1)数据方面:该二叉树数据元素采用字符char型,并且约定“#”作为二叉树输入结束标识符。
并在此基础上进行二叉树相关操作。
(2)功能方面:能够实现二叉树的一些基本操作,主要包括:1.采用广义表建立二叉树。
2.计算二叉树高度、统计结点数量、叶节点数量、计算每个结点的度、结点所在层次。
3.判断结点是否存在二叉树中。
4.寻找结点父结点、子女结点。
5.递归、非递归两种方式输出二叉树前序、中序、后序遍历。
6.进行二叉树的复制。
四、系统设计(1)设计的主要思路二叉树是的结点是一个有限集合,该集合或者为空,或者是由一个根节点加上两棵分别称为左子树和右子树、互不相交的二叉树组成。
根据实验要求,以及课上老师对于二叉树存储结构、基本应用的讲解,同时课后研究书中涉及二叉树代码完成二叉树模板类,并将所需实现各个功能代码编写完成,在建立菜单对功能进行调试。
(2)数据结构的设计二叉树的存储结构有数组方式和链表方式。
但用数组来存储二叉树有可能会消耗大量的存储空间,故在此选用链表存储,提高存储空间的利用率。
根据二叉树的定义,二叉树的每一个结点可以有两个分支,分别指向结点的左、右子树。
因此,二叉树的结点至少应包括三个域,分别存放结点的数据,左子女结点指针,右子女结点指针。
这将有利于查找到某个结点的左子女与右子女,但要找到它的父结点较为困难。
该实验采取二叉链表存储二叉树中元素,具体二叉树链表表示如下图所示。
图1二叉树的链表表示(3)基本操作的设计二叉树关键主要算法:利用广义表进行二叉树的建立。
二叉排序树实验报告
二叉排序树实验报告二叉排序树实验报告一、引言二叉排序树,也被称为二叉搜索树,是一种常见的数据结构,它具有快速的查找和插入操作的特点。
在本次实验中,我们将探索二叉排序树的原理和实现,并通过实际操作来验证其性能和效果。
二、实验目的本次实验的目的是通过实际操作,深入理解二叉排序树的原理和实现,并通过对比不同操作的时间复杂度,评估其性能和效果。
三、实验过程1. 实验环境的搭建在开始实验之前,我们需要搭建一个合适的实验环境。
我们可以选择使用C++或者其他编程语言来实现二叉排序树。
在本次实验中,我们选择使用C++来实现。
2. 二叉排序树的实现首先,我们需要定义一个二叉排序树的数据结构。
这个数据结构包含一个根节点,每个节点包含一个值和两个指针,分别指向左子树和右子树。
通过递归的方式,我们可以实现二叉排序树的插入、删除和查找操作。
3. 实验数据的准备为了验证二叉排序树的性能和效果,我们需要准备一组实验数据。
这组数据可以是随机生成的整数,也可以是具有特定规律的数据。
我们可以选择不同规模的数据集来进行实验,以评估二叉排序树在不同情况下的表现。
4. 实验操作的执行通过实验数据的准备,我们可以开始执行实验操作。
首先,我们将数据依次插入到二叉排序树中,并记录下插入操作的时间。
然后,我们可以执行查找操作,查找树中是否包含某个特定的值,并记录下查找操作的时间。
最后,我们可以执行删除操作,删除树中的某个节点,并记录下删除操作的时间。
5. 实验结果的分析通过实验操作的执行,我们可以得到一组实验结果。
我们可以通过对比不同操作的时间复杂度,来评估二叉排序树的性能和效果。
同时,我们还可以观察实验结果中树的结构,以验证二叉排序树的正确性。
四、实验结果与讨论通过实验操作的执行,我们得到了一组实验结果。
我们可以观察到,随着数据规模的增加,插入、查找和删除操作的时间逐渐增加。
这是因为二叉排序树的操作时间复杂度与树的高度相关,当树的高度增加时,操作的时间复杂度也会增加。
数据结构二叉树程序及实验报告
实验三树1.实验目的通过本实验,使学生加深对二叉树的基本概念的理解;掌握掌握二叉排序树的插入和生成;掌握二叉树遍历操作及应用。
2.实验内容创建一个二叉树,并进行先序遍历、中序遍历、后序遍历、层次遍历,打印二叉树的叶子结构,并统计叶子结点个数和总结点个数。
3.实验要求(1)设计一个程序实现上述过程。
(2)采用二叉链表存储结构。
4、实验步骤#include "stdio.h"#include "malloc.h"#define ELEMTYPE chartypedef struct BiTNode { ELEMTYPE data;struct BiTNode*lchild,*rchild; } BiTNode;BiTNode *bulid() /*建树*/{ BiTNode *q;BiTNode *s[20];int i,j; char x;printf("请按顺序输入二叉树的结点以输入0和*号结束\n");printf("请输入你要输入的为第几个结点i=\n");scanf("%d",&i); printf("请输入你要输入该结点的数为x=");getchar();scanf("%c",&x);while(i!=0&&x!='*'){q=(BiTNode*)malloc(sizeof(BiTNode));q->data=x; q->rchild=NULL;q->lchild=NULL; s[i]=q; if(i!=1){ j=i/2; if(i%2==0) s[j]->lchild=q; else s[j]->rchild=q; }printf("请输入你要输入的为第几个结点x=\n");scanf("%d",&i); printf("请输入你要输入该结点的数x=");getchar(); scanf("%c",&x);}return s[1]; }void preoder(BiTNode *bt) /*先序遍历*/{ if(bt!=NULL){ printf("%c\n",(bt->data)); preoder(bt->lchild); preoder(bt->rchild); }}void InOrder(BiTNode *bt) /*中序遍历*/{ if(bt!=NULL) { InOrder(bt->lchild); printf("%c\n",bt->data); InOrder(bt->rchild); }}void postOrder(BiTNode *bt) /*后序遍历*/{ if(bt!=NULL) { postOrder(bt->lchild); postOrder(bt->rchild); printf("%c\n",bt->data); }}Int main(){int a;BiTNode *bt; bt=bulid();k1:printf("需要先序遍历输出请输入1,中序遍历请输入2,后序遍历请输入3,结束输入0:"); scanf("%d",&a);switch(a){ case(1): preoder(bt); goto k1; case(2): InOrder(bt); goto k1; case(3): postOrder(bt); goto k1; case(0): break; }5、实验结果••••••••••••••••••【唯美句子】走累的时候,我就到升国旗哪里的一角台阶坐下,双手抚膝,再闭眼,让心灵受到阳光的洗涤。
数据结构二叉树实验报告(附代码)
一、【实验构思(Conceive)】(10%)(本部分应包括:描述实验实现的基本思路,包括所用到的离散数学、工程数学、程序设计、算法等相关知识)首先构造二叉树的存储结构,用data存储当前节点的值,分别用*lchild,*rchild 表示该节点的左右孩子。
然后应用BiTree Create函数,根据用户的输入构造二叉树,当输入#时表示没有孩子。
采用递归的思想构造Preorder,Inorder,Postorder函数,分别实现二叉树的先序,中序,和后序的遍历。
然后编写了Sumleaf,Depth函数,来求叶子节点的数目和二叉树的深度。
二、【实验设计(Design)】(20%)(本部分应包括:抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明,主程序模块与各子程序模块间的调用关系)二叉树的存储结构:typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;子程序模块:BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild);}return T;}void Preorder(BiTree T){if(T){printf("%c",T->data);Preorder(T->lchild);Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void Inorder(BiTree T) {if(T){Inorder(T->lchild); printf("%c",T->data); Inorder(T->rchild); }}void Postorder(BiTree T) {if(T){Postorder(T->lchild); Postorder(T->rchild); printf("%c",T->data); }}int Depth(BiTree T){int dep=0,depl,depr;if(!T)dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}主程序模块:int main(){BiTree T = 0;int sum,dep;printf("请输入你需要建立的二叉树\n");printf("例如输入序列ABC##DE#G##F###(其中的#表示空)\n并且输入过程中不要加回车\n输入完之后可以按回车退出\n");T=Create(T);printf("先序遍历的结果是:\n");Preorder(T);printf("\n");printf("中序遍历的结果是:\n");Inorder(T);printf("\n");printf("后序遍历的结果是:\n");Postorder(T);printf("\n");printf("统计的叶子数:\n");sum=Sumleaf(T);printf("%d",sum);printf("\n统计树的深度:\n");dep=Depth(T);printf("\n%d\n",dep);}三、【实现描述(Implement)】(30%)(本部分应包括:抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系,关键的程序流程图等,给出关键算法的时间复杂度分析。
数据结构实验三二叉树实验报告
数据结构实验报告实验名称:实验三——二叉树学生姓名: XX班级:班内序号:学号:日期:1.实验要求1.1实验目的通过选择下面两个题目之一进行实现,掌握如下内容:掌握二叉树基本操作的实现方法了解赫夫曼树的思想和相关概念学习使用二叉树解决实际问题的能力1.2实验内容根据二叉树的抽象数据类型的定义,使用二叉链表实现一个二叉树。
二叉树的基本功能:1、二叉树的建立2、前序遍历二叉树3、中序遍历二叉树4、后序遍历二叉树5、按层序遍历二叉树6、求二叉树的深度7、求指定结点到根的路径8、二叉树的销毁9、其他:自定义操作编写测试main()函数测试线性表的正确性2. 程序分析2.1 存储结构二叉树的结点结构二叉树的二叉链表存储示意图2.2 关键算法分析(1)创建一个二叉树伪代码实现:1.定义根指针,输入节点储存的data,若输入“#”,则该节点为空;2.申请一个新节点,判断它的父结点是否不为空,如果不为空在判断其为左或者右孩子,并把地址付给父结点,把data写入。
代码实现void BiTree::create(BiNode* &R,int data[],int i,int n)//创建二叉树{if(i<=n){R=new BiNode;R->data=data[i-1];create(R->lch,data,2*i,n);create(R->rch,data,2*i+1,n);}else R=NULL;}(2)前序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.打印起始节点的值,并先后在左子数右子数上递归调用打印函数代码实现void BiTree::preorder(BiNode* R)//前序遍历{if(R!=NULL){cout<<R->data;preorder(R->lch);preorder(R->rch);}}时间复杂度:O(n)(3)中序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.递归遍历左子树3.打印根节点数据域内容4.递归遍历右子树代码实现void BiTree::inorder(BiNode* R)//中序遍历{if(R!=NULL){inorder(R->lch);cout<<R->data;inorder(R->rch);}}时间复杂度:O(n)(4)后序遍历伪代码实现:1.设置递归边界条件:if root==null则停止递归2.递归遍历左子树3.递归遍历右子树4.访问根结点数据域代码实现void BiTree::postorder(BiNode* R)//后序遍历{if(R!=NULL){postorder(R->lch);postorder(R->rch);cout<<R->data;}}时间复杂度:O(n)(5)层序遍历伪代码实现1.队列Q及所需指针的定义和初始化2.如果二叉树非空,将根指针入队3.循环直到队列Q为空3.1 q=队列Q的队头元素出队3.2 访问节点q的数据域 cout<<q->data<<" ";3.3 若节点q存在左孩子,则将左孩子指针入队3.4若节点q存在右孩子,则将右孩子指针入队代码实现void BiTree::levelordre(BiNode* R)//层序遍历{BiNode*queue[maxsize];int f=0,r=0;if(R!=NULL)queue[++r]=R;while(f!=r){BiNode*p=queue[++f];cout<<p->data;if(p->lch!=NULL)queue[++r]=p->lch;if(p->rch!=NULL)queue[++r]=p->rch;}}时间复杂度:O(n)(6)计算二叉树深度伪代码实现:1. 定义和初始化计数深度的参数2.如果根节点为空,return03.如果根节点为非空,递归调用自身的到叶子节点到根的路径长度,输出其中较大的作为树的深度代码实现int BiTree::depth(BiNode* root)//求二叉树深度{int ld,rd;if (root!=NULL){ld = 1+depth(root->lch);rd = 1+depth(root->rch);return ld>rd?ld:rd;}else return 0;}时间复杂度:O(n)(7)输出指定结点到根结点的路径伪代码实现:1.建立一个存储路径结点结构,定义和初始化结构体的数组2.当root不为空或top为0时,进入循环3.当此时root所指的节点的数据不为指定数据时,将root指向它的左孩子4.当此时root所指的节点的数据为指定数据时,访问其数据域并输出代码实现bool BiTree::printPath(BiNode* root, int data)//打印指定结点到根节点的路径{if (root == NULL)return false;if (root->data == data || printPath(root->lch,data) ||printPath(root->rch,data)){cout<<root->data;return true;}return false;}3. 程序运行结果3.1测试主函数流程图:3.2测试条件对如下二叉树: 补全后的二叉树:按层序遍历的输入方法为:ABC#EFGH###I###J###@ 3.3程序运行结果为:4. 总结出现的问题及改进:刚开始编译正确但是输出结果异常,纪念馆仔细检查发现二叉树创建有问题,经过仔细修改,发现形参表示错误,*&,指针的引用,作为输入时,既把指针的值传入函数内部,又可以将指针的关系传递到函数内部;作为输出,由于算法中修改了指针的值,可以将新值传入到函数内部。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
《数据结构》实验报告题目:_二叉树的实现学号:___ ____姓名:____ ___东南大学成贤学院计算机系实验题目一、实验目的1.掌握二叉树的基本操作,理解递归算法。
二、实验内容1.将下图所示二叉树采用二叉链表进行存储,然后进行各种操作测试。
三、实验步骤1.启动:开始菜单→程序→Microsoft Visual Studio 6.0 →2.建立工程:文件(File)→新建(new)→在弹出的对话框中选择工程标签(Project)→选中选项:Win32 Console Application(不能选别的)→输入工程名(Project Name)→选择工程的存放位置(Location)→单击“确定”按钮(OK)→在弹出的对话框中选中选项:An Empty Project→单击“完成”按钮(Finish)→在弹出的对话框中单击“确定”按钮( OK )。
3.创建头文件:文件(File)→新建(new)→在弹出的对话框中选择文件标签(Files)→选中选项:C/C++ Header File→输入头文件名(此处定义为“”)→单击“确定”按钮(OK)。
内容如下:// 二叉树结点类模板template <class ElemType>struct BinTreeNode{// 数据成员:ElemType data; // 数据域BinTreeNode<ElemType> *leftChild; // 左孩子BinTreeNode<ElemType> *rightChild; // 右孩子};4.创建头文件:文件(File)→新建(new)→在弹出的对话框中选择文件标签(Files)→选中选项:C/C++ Header File→输入头文件名(此处定义为“”)→单击“确定”按钮(OK)。
定义了链队的类模板,代码如下:#ifndef __BINNARY_TREE_H__#define __BINNARY_TREE_H__// 二叉树类模板template <class ElemType>class BinaryTree{private:// 二叉树的数据成员:BinTreeNode<ElemType> *root;// 二叉树的私有函数:void PreOrderHelp(BinTreeNode<ElemType> *r); // 先序遍历void InOrderHelp(BinTreeNode<ElemType> *r); // 中序遍历void PostOrderHelp(BinTreeNode<ElemType> *r);// 后序遍历void Creat(BinTreeNode<ElemType> *r,int flag, ElemType empty, ElemType end);//递归创建子树BinTreeNode<ElemType> *GetRoot(); //返回根指针BinTreeNode<ElemType> *Locate(BinTreeNode<ElemType> *r,ElemType e); //查找元素值为e的结点,返回指针.BinTreeNode<ElemType>* LeftChild(ElemType e);//定位指定元素的左孩子,返回其指针。
BinTreeNode<ElemType>* Parent(BinTreeNode<ElemType>*r,ElemType e); //定位指定元素的父结点BinTreeNode<ElemType>* LeftSibling(ElemType e);//定位指定元素的左兄弟int Size(BinTreeNode<ElemType> *r);int Depth(BinTreeNode<ElemType> *r);int Leaf(BinTreeNode<ElemType> *r); //统计并返回叶子结点个数void Clear(BinTreeNode<ElemType> *r);void DisplayTreeeHelp(BinTreeNode<ElemType> *r, int level);// 按树状形式显示以r为根的二叉树,level为层次数,可设根结点的层次数为1public:// 二叉树公共方法声明:BinaryTree( );void CreateBiTree();// 构造二叉树B void InOrder(); // 二叉树的中序遍历void PreOrder(); // 二叉树的先序遍历void PostOrder(); // 二叉树的后序遍历void LevelOrder(); //按层遍历int Locate(ElemType e); //查找元素值为e的结点。
int GetLeft(ElemType e, ElemType &c);//读取指定元素的左孩子int GetParent(ElemType e, ElemType &f);//读取指定元素的父元素int GetLeftSibling(ElemType e, ElemType &s);//读取指定元素的左兄弟int InsertChild(ElemType e,ElemType x,ElemType y);//为指定元素 e 插入左、右孩子int SetElem(ElemType e, ElemType x);//更新指定元素int Size( );int Depth( );int Leaf( ); //统计并返回叶子结点个数virtual ~BinaryTree();// 销毁二叉树void DisplayTree();};函数实现由学生自己完成#endif5. 创建源程序文件main.cpp:文件(File)→新建(new)→在弹出的对话框中选择文件标签(Files)→选中选项:C++ Source File→输入源程序文件名(main)→单击“确定”按钮(OK)。
文件内容如下:#include "binary_tree.h" // 二叉树类int main(void){利用swtich构造菜单,对二叉树操作进行测试。
(初始化,构造二叉树,图形显示,前序,中序,后序遍历结果,求结点个数,二叉树深度,叶子结点树,查找结点,找指定结点的左孩子,双亲,左兄弟,插入新的左、右孩子。
}注意:1.在编程过程中注意及时保存编写内容。
四、实验结果1.的代码2.的代码3.运行结果截图(可以有多张)1、#pragma once#include ””using namespace std;// 二叉树类模板template <class ElemType>class BinaryTree{private:// 二叉树的数据成员:BinTreeNode<ElemType> *root;// 二叉树的私有函数:void PreOrderHelp(BinTreeNode<ElemType> *r); // 先序遍历void InOrderHelp(BinTreeNode<ElemType> *r); // 中序遍历void PostOrderHelp(BinTreeNode<ElemType> *r);// 后序遍历void Creat(BinTreeNode<ElemType> *r,int flag, ElemType empty, ElemType end);//递归创建子树BinTreeNode<ElemType> *GetRoot(); //返回根指针BinTreeNode<ElemType> *Locate(BinTreeNode<ElemType> *r, ElemType e); //查找元素值为e的结点,返回指针.BinTreeNode<ElemType>* LeftChild(ElemType e);//定位指定元素的左孩子,返回其指针。
BinTreeNode<ElemType>* Parent(BinTreeNode<ElemType>*r, ElemType e); //定位指定元素的父结点BinTreeNode<ElemType>* LeftSibling(ElemType e);//定位指定元素的左兄弟int Size(BinTreeNode<ElemType> *r);int Depth(BinTreeNode<ElemType> *r);int Leaf(BinTreeNode<ElemType> *r); //统计并返回叶子结点个数void Clear(BinTreeNode<ElemType> *r);void DisplayTreeeHelp(BinTreeNode<ElemType> *r, int level);// 按树状形式显示以r为根的二叉树,level为层次数,可设根结点的层次数为1int size;public:// 二叉树公共方法声明:BinaryTree(); // 无参数的构造函数模板void CreateBiTree();// 构造二叉树//BinTreeNode<ElemType> *GetRoot(); // 返回二叉树的根void InOrder(); // 二叉树的中序遍历void PreOrder(); // 二叉树的先序遍历void PostOrder(); // 二叉树的后序遍历void LevelOrder(); //按层遍历int Locate(ElemType e); //查找元素值为e的结点。
int GetLeft(ElemType e, ElemType &c);//读取指定元素的左孩子int GetParent(ElemType e, ElemType &f);//读取指定元素的父元素int GetLeftSibling(ElemType e, ElemType &s);//读取指定元素的左兄弟int InsertChild(ElemType e, ElemType x, ElemType y);//为指定元素 e 插入左、右孩子int SetElem(ElemType e, ElemType x);//更新指定元素int Size();int Depth();int Leaf(); //统计并返回叶子结点个数virtual ~BinaryTree();// 销毁二叉树void DisplayTree();};template <class ElemType>void BinaryTree<ElemType>::PreOrderHelp(BinTreeNode<ElemType> *r) // private{if (r != NULL){cout << r->data << " "; // 访问根结点PreOrderHelp(r->leftChild); // 遍历左子树PreOrderHelp(r->rightChild); // 遍历右子树}}template <class ElemType>void BinaryTree<ElemType>::PreOrder() // public{PreOrderHelp(root);}template <class ElemType>void BinaryTree<ElemType>::InOrderHelp(BinTreeNode<ElemType> *r) // private{if (r != NULL){InOrderHelp(r->leftChild); // 遍历左子树cout << r->data << " "; // 访问根结点InOrderHelp(r->rightChild); // 遍历右子树}}template <class ElemType>void BinaryTree<ElemType>::InOrder() // public{InOrderHelp(root);}template <class ElemType>void BinaryTree<ElemType>::PostOrderHelp(BinTreeNode<ElemType> *r) // private{if (r != NULL){PostOrderHelp(r->leftChild); // 遍历左子树PostOrderHelp(r->rightChild); // 遍历右子树cout << r->data << " "; // 访问根结点}}template <class ElemType>void BinaryTree<ElemType>::PostOrder() // public{PostOrderHelp(root);}template <class ElemType>void BinaryTree<ElemType>::LevelOrder(){LinkQueue<BinTreeNode<ElemType> *> q;BinTreeNode<ElemType> *t = root;if (t != NULL) (t); // 如果根非空,则入队while (!()){(t);cout << t->data << " "; //if (t->leftChild != NULL) // 左孩子非空(t->leftChild); // 左孩子入队if (t->rightChild != NULL) // 右孩子非空(t->rightChild); // 右孩子入队}}template <class ElemType>BinaryTree<ElemType>::BinaryTree(){root = NULL;}template <class ElemType>void BinaryTree<ElemType>::CreateBiTree(){BinTreeNode<ElemType>* r;ElemType end, empty, x;cout <<"按先序序列的顺序输入一棵二叉树"<< endl;cout <<"输入的结束标志是:";cin >> end;cout <<"输入的空结点标志是:";cin >> empty;cout <<"请开始输入:"<< endl;cin >> x;r = new BinTreeNode<ElemType>;r->data = x;r->leftChild = r->rightChild = NULL;root = r;Creat(r, 0, empty, end); //创建根结点的左子树Creat(r, 1, empty, end); //创建根结点的右子树}template <class ElemType>void BinaryTree<ElemType>::Creat(BinTreeNode<ElemType> *r,int flag, ElemType empty, ElemType end){BinTreeNode<ElemType> *p; ElemType x;cin >> x;if (x != end&&x != empty){p = new BinTreeNode<ElemType>; p->data = x;p->leftChild = p->rightChild = NULL;if (flag == 0) r->leftChild = p; //p为左子树else r->rightChild = p; //p为右子树size++;Creat(p, 0, empty, end); //递归创建左子树Creat(p, 1, empty, end); //递归创建右子树}}template <class ElemType>BinTreeNode<ElemType>*BinaryTree<ElemType>::GetRoot(){return root;}template <class ElemType>BinTreeNode<ElemType>*BinaryTree<ElemType>::Locate(BinTreeNode<ElemType> *r, ElemType e) //private{if (r == NULL) return NULL;if (r->data == e) return r;BinTreeNode<ElemType> *p = Locate(r->leftChild, e);if (p == NULL) p = Locate(r->rightChild, e);return p;}template <class ElemType>int BinaryTree<ElemType>::Locate(ElemType e) //public{if (Locate(root, e) == NULL)return false;elsereturn true;}template <class ElemType>BinTreeNode<ElemType>*BinaryTree<ElemType>::LeftChild(ElemType e) //private{BinTreeNode<ElemType>* ep = Locate(root, e);if (ep == NULL) return NULL; //找不到结点eif (ep->leftChild == NULL) //e无左孩子return NULL;return ep->leftChild; //返回e左孩子的指针}template <class ElemType>int BinaryTree<ElemType>::GetLeft(ElemType e, ElemType &c) //Public{BinTreeNode<ElemType>* p = LeftChild(e);if (p == NULL) return false; //e无左孩子c = p->data;return true;}template <class ElemType>BinTreeNode<ElemType>* BinaryTree<ElemType>::Parent(BinTreeNode<ElemType>*r, ElemType e) //private{BinTreeNode<ElemType>* p;if (r == NULL)return NULL;if ((r->leftChild != NULL&&r->leftChild->data == e) ||(r->rightChild != NULL&&r->rightChild->data == e))return r; //r是e的父结点,返回结点r的指针p = Parent(r->leftChild, e); //递归调用r的左子树if (p == NULL) p = Parent(r->rightChild, e);return p;}template <class ElemType>int BinaryTree<ElemType>::GetParent(ElemType e, ElemType &f) //public {if (root == NULL || root->data == e)return false;BinTreeNode<ElemType> *p = Parent(root, e);if (p == NULL) return false; //树中无元素ef = p->data;return true;}template <class ElemType>BinTreeNode<ElemType>* BinaryTree<ElemType>::LeftSibling(ElemType e) //private{if (root->data == e) return NULL;BinTreeNode<ElemType> *p = Parent(root, e);if (p == NULL)return NULL; //无e结点if (p->leftChild->data == e) //e是其父亲的左孩子return NULL;return p->leftChild; //返回e的左兄弟指针}template <class ElemType>int BinaryTree<ElemType>::GetLeftSibling(ElemType e, ElemType &s){if (root->data == e)return false; //根结点无兄弟BinTreeNode<ElemType> *p = LeftSibling(e);if (p == NULL)return false; //e无左兄弟s = p->data;return true;}template <class ElemType>int BinaryTree<ElemType>::InsertChild(ElemType e, ElemType x, ElemType y){BinTreeNode<ElemType> *ep, *xp, *yp;ep = Locate(root, e); //定位元素eif (ep == NULL) return false; //找不到元素exp = new BinTreeNode<ElemType>;xp->data = x;xp->rightChild = NULL;yp = new BinTreeNode<ElemType>;yp->data = y;yp->leftChild = NULL;xp->leftChild = ep->leftChild;ep->leftChild = xp; //结点x置为结点e的左孩子yp->rightChild = ep->rightChild;ep->rightChild = yp; //结点y置为结点e的右孩子size = size + 2;return true;}template <class ElemType>int BinaryTree<ElemType>::SetElem(ElemType e, ElemType x){BinTreeNode<ElemType> *p = Locate(root, e);if (p == NULL) return false;p->data = x;return true;}template <class ElemType>int BinaryTree<ElemType>::Size() //public{return Size(root);}template <class ElemType>int BinaryTree<ElemType>::Size(BinTreeNode<ElemType> *r) //private{if (r == NULL) return 0;elsereturn Size(r->leftChild) + Size(r->rightChild) + 1;//二叉树的结点总数为左右子树的结点数之和加1}template <class ElemType>int BinaryTree<ElemType>::Depth() //public{return Depth(root);}template <class ElemType>int BinaryTree<ElemType>::Depth(BinTreeNode<ElemType> *r) //private {if (r == NULL) return 0;else{int leftD, rightD;leftD = Depth(r->leftChild);rightD = Depth(r->rightChild);return 1 + (leftD > rightD ? leftD : rightD); //二叉树的深度为左右子树的深度的最大值加1}}template <class ElemType>int BinaryTree<ElemType>::Leaf() //public{return Leaf(root);}template <class ElemType>int BinaryTree<ElemType>::Leaf(BinTreeNode<ElemType> *r) //private{if (r == NULL)return 0;if (r->leftChild == NULL&&r->rightChild == NULL)return 1;return Leaf(r->leftChild) + Leaf(r->rightChild);//递归遍历左子树和右子树}template <class ElemType>void BinaryTree<ElemType>::Clear(BinTreeNode<ElemType> *r) //private{if (r != NULL){Clear(r->leftChild); //后序递归Clear(r->rightChild);delete r;size--;}}template <class ElemType>BinaryTree<ElemType>:: ~BinaryTree(){Clear(root);root = NULL;}template <class ElemType>void BinaryTree<ElemType>::DisplayTreeeHelp(BinTreeNode<ElemType> *r, int level){if (r != NULL){DisplayTreeeHelp(r->rightChild, level + 1);//显示右子树cout << endl; //显示新行for (int i = 0; i < level - 1; i++)cout <<" "; //确保在第level列显示结点cout << r->data; //显示结点DisplayTreeeHelp(r->leftChild, level + 1);}}template <class ElemType>void BinaryTree<ElemType>::DisplayTree(){DisplayTreeeHelp(root, 1);cout << endl;}#endif2、#pragma once#include""#include""#include""#include<iostream>#include<cstdlib>3、main.cpp#include""using namespace std;int main() {BinaryTree<int> bt;int c = 0;int tmp1,tmp2,tmp3;while (c != 15) {cout << endl <<"1. 创建二叉树";cout << endl <<"2. 中序遍历";cout << endl <<"3. 先序遍历";cout << endl <<"4. 后序遍历";cout << endl <<"5. 按层遍历";cout << endl <<"6. 查找节点";cout << endl <<"7. 读取左孩子"; cout << endl <<"8. 读取父元素"; cout << endl <<"9. 读取左兄弟"; cout << endl <<"10. 插入左右孩子"; cout << endl <<"11. 更新元素"; cout << endl <<"12. 叶子结点个数"; cout << endl <<"13. 图形显示"; cout << endl <<"14. 销毁二叉树"; cout << endl <<"15. 退出";cout << endl <<"选择功能(1~15):"; cin >> c;switch (c){case 1:();break;case 2:();break;case 3:();break;case 4:();break;case 5:();break;case 6:cout <<"输入查找节点:";cin >> tmp1;if ((tmp1)) {cout <<"存在";break;}cout <<"不存在";break;case 7:cout <<"输入元素:";cin >> tmp1;if ((tmp1,tmp2)) {cout <<"左孩子为:"<< tmp2;break;}cout <<"不存在";case 8:cout <<"输入元素:";cin >> tmp1;if ((tmp1,tmp2)) {cout <<"父元素为:"<< tmp2;break;}cout <<"不存在";break;case 9:cout <<"输入元素:";cin >> tmp1;if ((tmp1,tmp2)) {cout <<"左兄弟为:"<< tmp2;break;}cout <<"不存在";break;case 10:cout <<"输入元素:";cin >> tmp1;cout <<"输入左孩子:";cin >> tmp2;cout <<"输入右孩子:";cin >> tmp3;if ((tmp1,tmp2,tmp3)) {cout <<"修改完成" ;break;}cout <<"修改失败";break;case 11:cout <<"输入元素:";cin >> tmp1;cout <<"修改为:";cin >> tmp2;if ((tmp1, tmp2)) {cout <<"修改成功";break;}cout <<"修改失败";break;case 12:cout <<"叶子结点个数:"<< ();break;case 13:();break;case 14:bt.~BinaryTree();cout <<"销毁成功";break;case 15:exit(0);}}return 0;}。