实验三二叉树的基本操作实现及其应用

合集下载

实验三二叉树基本操作与应用实验

实验三二叉树基本操作与应用实验第一篇：实验三二叉树基本操作与应用实验实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容：1.二叉树基本操作实验；2.二叉树应用—赫夫曼树与赫夫曼编码实验。

基本操作包括存储结构建立和遍历算法，本文只给出部分参考程序，请大家尽量完成多数基本操作。

第一部分基本操作实验[问题描述] 二叉树采用二叉链表作存储结构，试编程实现二叉树的如下基本操作1．按先序序列构造一棵二叉链表表示的二叉树T；2．对这棵二叉树进行遍历：先序、中序、后序以及层次遍历序列，分别输出结点的遍历序列；3．求二叉树的深度，结点数目，叶结点数目； [数据描述] ／／二叉树的二叉链表存储表示先序遍历二叉树递归算法6.层次遍历二叉树的非递归算法7.求二叉树的深度[说明]1．按先序次序输入二叉树中结点的值，用‘#’表示空树，对每一个结点应当确定其左右子树的值(为空时必须用特定的空字符占位)，故执行此程序时，最好先在纸上画出你想建立的二叉树，每个结点的左右子树必须确定。

若为空，则用特定字符标出，然后再按先序输入这棵二叉树的字符序列。

2．为了简化程序的书写量，以及程序的清晰性，对结点的访问以一条输出语句表示，若有更复杂的或多种访问，可以将结点的访问编写成函数，然后通过函数指针进行函数的调用。

读者若有兴趣，可自行编写。

3．c语言函数参数传递，都是以“传值”的方式，故在设计函数时，必须注意参数的传递。

若想通过函数修改实际参数的值，则必须用指针变量作参数。

具体设计时；读者一定要把指针变量及指针变量指向的值等概念弄清楚。

4．完整参考程序只给出了部分遍历算法，对于其他算法，请读者参照示例，自行编程完成，以加深学习体会。

对于二叉链表的建立也是如此，示例中只是给出了先序法建立过程，读者可自行练习中序、后序二叉链表建立法，叶子结点或二叉树结点总数求法等。

第二部分二叉树应用实验---------郝夫曼树与郝夫曼编码[问题描述] 利用HuffMan编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。

二叉树实验报告

二叉树实验报告二叉树实验报告引言：二叉树作为一种常用的数据结构，在计算机科学领域中具有广泛的应用。

本实验旨在通过实际操作和观察，深入理解二叉树的特性和运用。

一、二叉树的基本概念1.1 二叉树的定义二叉树是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。

树的最顶层节点称为根节点。

1.2 二叉树的特点二叉树具有以下特点：- 每个节点最多有两个子节点，分别称为左子节点和右子节点；- 左子节点的值小于等于父节点的值，右子节点的值大于等于父节点的值；- 二叉树的左子树和右子树也是二叉树。

二、二叉树的遍历方式2.1 先序遍历先序遍历是指先访问根节点，然后按照先序遍历的方式依次访问左子树和右子树。

2.2 中序遍历中序遍历是指按照中序遍历的方式依次访问左子树，根节点和右子树。

2.3 后序遍历后序遍历是指按照后序遍历的方式依次访问左子树，右子树和根节点。

三、二叉树的实验操作3.1 二叉树的创建为了便于实验操作，我们选择使用Python编程语言来实现二叉树的创建和操作。

首先，我们需要定义一个二叉树节点的类，包含节点的值、左子节点和右子节点。

3.2 二叉树的插入在已有的二叉树中插入一个新的节点，需要遵循二叉树的规则。

如果插入的节点值小于当前节点的值，则将节点插入到当前节点的左子树；如果插入的节点值大于当前节点的值，则将节点插入到当前节点的右子树。

3.3 二叉树的查找在二叉树中查找一个特定的节点，需要遍历整个二叉树。

从根节点开始，如果要查找的节点值小于当前节点的值，则继续在左子树中查找；如果要查找的节点值大于当前节点的值，则继续在右子树中查找；如果要查找的节点值等于当前节点的值，则找到了目标节点。

3.4 二叉树的删除在二叉树中删除一个节点，需要考虑多种情况。

如果要删除的节点没有子节点，直接将其删除即可；如果要删除的节点只有一个子节点，将子节点替换为要删除的节点；如果要删除的节点有两个子节点，需要找到其右子树中的最小节点，将其值替换到要删除的节点，然后删除最小节点。

实验三--二叉树的基本运算

实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。

2、熟练掌握二叉树的各种遍历算法。

二、实验内容1、问题描述建立一棵二叉树，试编程实现二叉树的如下基本操作：(1). 按先序序列构造一棵二叉链表表示的二叉树T；(2). 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；(3). 求二叉树的深度/结点数目/叶结点数目；(选做)(4). 将二叉树每个结点的左右子树交换位置。

（选做）2、基本要求从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）。

3、测试数据如输入：abc00de0g00f000（其中ф表示空格字符）则输出结果为：先序：a->b->c->d->e->g->f中序：a->b->c->d->e->g->f后序：a->b->c->d->e->g->f三、程序代码#include<malloc.h>#include<iostream.h>#define OK 1#define ERROR -1typedef char TElemType;int i;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreateBiTree(BiTree&T) //创建二叉树{char a;cin>>a;if(a=='0') T=NULL;else{if(!(T=(BiTNode*)malloc(sizeof(BiTNode)))) {return ERROR;}T->data=a;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}return OK;}int PreOrderTraverse(BiTree&T) //先序遍历二叉树{if(T){//cout<<"此为先序遍历"<<endl;cout<<T->data<<"->";if(PreOrderTraverse(T->lchild))if(PreOrderTraverse(T->rchild))return OK;return ERROR;}else return OK;}int InOrderTraverse(BiTree&T) //中序遍历二叉树{if(T){//cout<<"此为中序遍历"<<endl;if(InOrderTraverse(T->lchild)){cout<<T->data<<"->";if(InOrderTraverse(T->rchild))return OK;}return ERROR;}else return OK;}int PostOrderTraverse(BiTree&T) //后序遍历二叉树{if(T){//cout<<"此为后序遍历"<<endl;if (PostOrderTraverse(T->lchild))if(PostOrderTraverse(T->rchild)){cout<<T->data<<"->";i++;return (OK);}return (ERROR);}elsereturn (OK);}int CountDepth(BiTree&T) //计算二叉树的深度{if(T==NULL){return 0;}else{int depl=CountDepth(T->lchild);int depr=CountDepth(T->lchild);if(depl>depr){return depl+1;}else{return depr+1;}}}void main() //主函数{BiTree T;cout<<"请输入二叉树节点的值以创建树"<<endl;CreateBiTree(T);cout<<"此为先序遍历";PreOrderTraverse(T);cout<<"end"<<endl;cout<<"此为中序遍历";InOrderTraverse(T);cout<<"end"<<endl;cout<<"此为后序遍历";PostOrderTraverse(T);cout<<"end"<<endl<<"此树节点数是"<<i<<endl<<"此树深度是"<<CountDepth(T)<<endl;}四、调试结果及运行界面：五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用，这次实验的的确确的加深了我对它的理解。

实验三二叉树的操作及应用

实验三二叉树的操作及应用实验课程名：数据结构与算法专业班级：15计科1班学号：201540410109 姓名：刘江实验时间：2016.10.24-10.31 实验地点：K4-102 指导教师：冯珊成绩:一、实验目的及要求1、进一步掌握指针变量、动态变量的含义。

2、掌握二叉树的结构特性，以及各种存储结构的特点和适用范围。

3、掌握用指针类型描述、访问和处理二叉树的运算。

二、实验内容任务一：完成下列程序，该程序以二叉链表作存储结构，构建如图1所示的二叉树，并依次进行二叉树的前序、中序、后序及层次遍历。

图1解答：（1）源代码：#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0typedef char DataType;/* 二叉树节点的存储类型 */typedef struct Node //define stricture BiTree{ DataType data;struct Node *lchild,*rchild;}Node, *BiTree;/*按先序序列建立一棵二叉树*/BiTree CreatBiTree(BiTree &T){DataType ch;scanf("%c",&ch);if(ch==' ') {T=NULL;}else{if(!(T=(Node*)malloc(sizeof(Node)))){printf("Overflow.\n") ;exit(0);}T->data =ch;CreatBiTree(T->lchild );CreatBiTree(T->rchild );}return T;}void PrintData(DataType x){printf("%c",x);}void PreOrder(BiTree T, void (*Visit)( DataType item))/*前序遍历二叉树T，访问操作为Visit()函数*/{if(T!= NULL){Visit(T->data);PreOrder(T->lchild, Visit);PreOrder(T->rchild, Visit);}}void InOrder(BiTree T, void (*Visit)( DataType item)) /*中序t */ {if(T!= NULL){InOrder(T->lchild, Visit);Visit(T->data);InOrder(T->rchild, Visit);}}void PostOrder(BiTree T, void (*Visit)( DataType item)) /*后序 */ {if(T!= NULL){PostOrder(T->lchild, Visit);PostOrder(T->rchild, Visit);Visit(T->data);}}int main(){int choice;BiTree root;printf("下面建立一棵二叉树，结点数据输入按先序次序。

数据结构实验3：二叉树的操作

TextFile中。

(4) P：打印代码文件(Print)。

将文件CodeFile以紧凑格式显示在终端上，每行50个代码。

同时将此字符形式的编码文件写入文件CodePrin中。

(5) T：打印哈夫曼树(Tree printing)。

将已在内存中的哈夫曼树以直观的方式显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。

3) 实现提示：(1) 文件CodeFile的基类型可以设为字节型。

(2) 用户界面可以设计为“菜单”方式：显示上述功能符号，再加上“Q”，表示退出运行Quit。

请用户键入一个选择功能符。

此功能执行完毕后再显示此菜单，直至某次用户选择了“E”为止。

(3) 在程序的一次执行过程中，第一次执行I、D或C命令之后，哈夫曼树已经在内存了，不必再读入。

每次执行中不一定执行I命令，因为文件hfmTree可能早已建好。

三、实验过程与实验结果实验3-01：以二叉链表为存储结构，实现二叉树的创建、遍历数据结构定义：typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介：本实验需要实现以下操作：二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。

2.利用非递归实现中序遍历，需要利用栈操作，按照中序遍历规则将节点依次入栈后出栈实现。

算法描述：图1 中序遍历（非递归）实现算法的实现和测试结果（参考OJ）实验3-02：编写算法交换二叉树中所有结点的左、右子树数据结构定义：typedef struct BiTNode{char data;BiTNode *lchild, *rchild;}BiTNode;typedef BiTNode *BiTree;算法设计思路简介：本实验需要实现以下操作：二叉树的初始化、前中后序遍历等基本操作1.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。

实验三—树的实现与应用实验报告

#include <conio.h>
#include <stack>
using namespace std;
typedef struct BiTNode{
char data;
BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T){
while(p||!s.empty()){
if(p)
{
s.push(p);
p=p->lchild;
}//根指针进栈，遍历左子树
else
{//根指针退栈，访问根结点，遍历右子树
p=s.top();
cout<<p->data<<" ";
s.pop();
p=p->rchild;
}//else
}//while
CreateBiTree(T->lchild);//构造左子树
CreateBiTree(T->rchild);//构造右子树
}
}//CreateBiTree
void InOrderTraverse(BiTree &T){
//采用非递归算法输出二叉树中的值
stack<BiTNode *> s;
BiTree p=T;
InOrderTraverse(T->lchild);
cout<<T->data<<" ";
InOrderTraverse(T->rchild);
}
}//InOrderTraverse

树和二叉树的实验报告

树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。

本实验旨在通过实际操作和观察，深入了解树和二叉树的特性和操作。

二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构，由节点和边组成。

每个节点可以有零个或多个子节点，其中一个节点没有父节点的称为根节点。

树的特点包括层次结构、唯一根节点和无环等。

2. 树的构建在本实验中，我们使用Python语言构建了一棵树。

通过定义节点类和树类，我们可以方便地创建树的实例，并添加节点和连接节点之间的边。

3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

我们在实验中实现了这三种遍历方式，并观察了它们的输出结果。

三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。

二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。

2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。

通过定义节点类和二叉树类，我们可以创建二叉树的实例，并实现插入节点、删除节点和查找节点等操作。

3. 二叉树的应用二叉树在实际应用中有很多用途。

例如，二叉搜索树可以用于实现快速查找和排序算法。

AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。

我们在实验中实现了这些应用，并通过实际操作验证了它们的效果。

四、实验结果与讨论通过实验，我们成功构建了树和二叉树的数据结构，并实现了它们的基本操作。

通过观察和分析实验结果，我们发现树和二叉树在各种算法和应用中的重要性和灵活性。

树和二叉树的特性使得它们适用于解决各种问题，例如搜索、排序、图算法等。

同时，我们也发现了一些问题和挑战，例如树的平衡性和节点的插入和删除操作等。

这些问题需要进一步的研究和优化。

五、总结本实验通过实际操作和观察，深入了解了树和二叉树的特性和操作。

数据结构二叉树实验报告

数据结构二叉树实验报告二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。

本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。

一、二叉树的定义和基本操作二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。

一个节点的左子节点称为左子树，右子节点称为右子树。

二叉树的示意图如下：```A/ \B C/ \D E```在二叉树中，每个节点可以有零个、一个或两个子节点。

如果一个节点没有子节点，我们称之为叶子节点。

在上面的示例中，节点 D 和 E 是叶子节点。

二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。

插入节点操作可以将一个新节点插入到二叉树中的合适位置。

删除节点操作可以将一个指定的节点从二叉树中删除。

查找节点操作可以在二叉树中查找指定的节点。

遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。

二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。

下面将介绍一些常见的应用场景。

1. 二叉搜索树二叉搜索树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的节点的值，小于其右子树中的节点的值。

二叉搜索树可以用来实现快速的查找、插入和删除操作。

它在数据库索引、字典等场景中有着重要的应用。

2. 堆堆是一种特殊的二叉树，它的每个节点的值都大于或小于其子节点的值。

堆可以用来实现优先队列，它在任务调度、操作系统中的内存管理等场景中有着重要的应用。

3. 表达式树表达式树是一种用来表示数学表达式的二叉树。

在表达式树中，每个节点可以是操作符或操作数。

表达式树可以用来实现数学表达式的计算，它在编译器、计算器等场景中有着重要的应用。

4. 平衡二叉树平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1。

平衡二叉树可以用来实现高效的查找、插入和删除操作。

它在数据库索引、自平衡搜索树等场景中有着重要的应用。

三、总结二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。

本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。

实验3 二叉树的操作及应用

实验3 二叉树的操作及应用PB13000818 焦孟娇实验目的：1. 熟练掌握递归程序设计的方法。

2. 掌握二叉树的特性和基本算法。

问题描述：二叉树是一种基本且常用的数据结构。

二叉树的很多基本算法都可以用递归的形式来表述。

本实验要求实现二叉树的如下操作：创建、销毁、复制、打印显示、先中后序遍历、查找元素、层序遍历、求二叉树的深度、宽度、结点数和叶子个数等。

实验内容：一、队列的抽象数据类型定义为：Queue operation{数据对象：数据关系：基本操作：InitQueue(&S)操作结果：构造一个空队列SQueueLength(S)初始条件：队列S已存在操作结果：返回S的元素个数，即队列的长度QueueEmpty(S)初始条件：队列S已存在操作结果：若S为空队列，则返回TRUE，否则FALSEEnQueue(&S, e)初始条件：队列S已存在操作结果：插入元素e为队列新元素DeQueue(&S, &e)初始条件：队列S已存在且非空操作结果：删除S的队头元素，并用e返回其值GetHead(S, &e)初始条件：队列S已存在且非空操作结果：用e返回S的队头元素ClearQueue(&S)初始条件：队列S已存在操作结果：将S清为空队列DeleteQueue(&S)初始条件：队列S已存在操作结果：队列S被销毁Print(S)初始条件：队列S已存在操作结果：输出队列S} Queue operationBiTree operation{InitBiTree( &T )// 操作结果：构造空二叉树T。

DestroyBiTree( &T )// 初始条件：二叉树T已存在。

// 操作结果：销毁二叉树T。

CreateBiTree( &T, definition )// 初始条件：definition给出二叉树T的定义。

// 操作结果：按definiton构造二叉树T。

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目，以及二叉树常用运算。

问题分析：二叉树树型结构是一类重要的非线性数据结构，对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义，所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题，我觉得应该：1、建立二叉树；2、通过递归方法来遍历（先序、中序和后序）二叉树；3、通过队列应用来实现对二叉树的层次遍历；4、借用递归方法对二叉树进行一些基本操作，如：求叶子数、树的深度宽度等；5、运用广义表对二叉树进行广义表形式的打印。

算法规定：输入形式：为了方便操作，规定二叉树的元素类型都为字符型，允许各种字符类型的输入，没有元素的结点以空格输入表示，并且本实验是以先序顺序输入的。

输出形式：通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印，再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能：实现对二叉树的先序、中序和后序遍历，层次遍历。

计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找，对二叉树的某个结点进行删除。

测试数据：输入一：ABC□□DE□G□□F□□□（以□表示空格）,查找5,删除E预测结果：先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A（B（C,D（E（,G）,F）））叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5，成功，查找的元素为E删除E后，以广义表形式打印A（B（C,D（,F）））输入二：ABD□□EH□□□CF□G□□□（以□表示空格）,查找10,删除B预测结果：先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A（B(D,E(H)),C(F(,G))）叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10，失败。

实验三二叉树的基本操作

实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。

2、熟练掌握二叉树的各种遍历算法。

二、实验内容题目一：二叉树的基本操作实现（必做题）[ 问题描述]建立一棵二叉树，试编程实现二叉树的如下基本操作：1. 按先序序列构造一棵二叉链表表示的二叉树T；2. 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；3. 求二叉树的深度/结点数目/叶结点数目；（选做）4. 将二叉树每个结点的左右子树交换位置。

（选做）[ 基本要求]从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立），[ 测试数据]如输入：AB（$巾D邱毋巾F巾巾巾（其中巾表示空格字符）则输出结果为先序：ABCDEGF中序：CBEGDFA后序：CGEFDBA层序：ABCDEFG[ 选作内容]采用非递归算法实现二叉树遍历三、算法设计1、主要思想：根据二叉树的图形结构创建出二叉树的数据结构, 用指针对树进行操作，重点掌握二叉树的结构和性质。

2、本程序包含四个模块：然后 (1)结构体定义(2) 创建二叉树(3) 对树的几个操作(4) 主函数四、调试分析这是一个比较简单程序，调试过程中并没有出现什么问题,思路比较清晰五、实验结果六、总结此次上机实验对二叉树进行了以一次实际操作，让我对二叉树有了更深的了解，对二叉树的特性有了更熟悉的认知，让我知道了二叉树的重要性和便利性，这对以后的编程有更好的帮助。

七、源程序#in clude <iostream>#in clude <queue>using namespacestd;#defi ne TElemType char#defi ne Status int#defi ne OK1#defi ne ERRORtypedef struct BiTNode{TEIemTypedata;struct BiTNode * Ichild, *rchild;} BiTNode,* BiTree ;Status CreateBiTree( BiTree &T) {TElemTypech;cin >> ch;if (ch == '#')T = NULLelse{if (!( T = ( BiTNode *)malloc( sizeof (BiTNode))))exit( OVERFLOW「>data = ch;CreateBiTree( T->lchild);CreateBiTree( T->rchild);}return OKStatus PreOrderTraverse( BiTree T){if ( T){cout << T->data;if (PreOrderTraverse( T->lchild))if (PreOrderTraverse( T->rchild))return OKreturn ERRQR}elsereturn OK}Status InOrderTraverse( BiTree T){if ( T) In OrderTraverse( T->lchild); cout << T->data;In OrderTraverse( T->rchild);}return OK}Status PostOrderTraverse( BiTree T){if ( T){PostOrderTraverse( T->lchild);PostOrderTraverse( T->rchild); cout << T->data;}return OK}Status leOrderTraverse( BiTree T){std:: queuevBiTree > Q;if ( T == NULI) return ERRQRelse {Q.push( T);while (!Q.empty()){T = Q.fron t();Q.pop()；NULI) cout << T->data;if ( T->lchild != NULLQ.push(T->lchild);if ( T->rchild != NULLQ.push( T->rchild);}}return OK}Status change( BiTree T){BiTree temp = NULLif ( T->lchild == NULL&& T->rchild ==return OKelse {temp = T->lchild;T->lchild = T->rchild;T->rchild = temp;if ( T->lchild)cha nge(「>lchild);if ( T->rchild)cha nge(「>rchild);return OK}:rchilddeep + 1; int FindTreeDeep( BiTree T){int deep = 0;if ( T){int lchilddeep = FindTreeDeep( T->lchild);int rchilddeep = FindTreeDeep( T->rchild);deep = lchilddeep >= rchilddeep ? lchilddeep + 1 }return deep;}int main(){BiTree T;CreateBiTree(T);cout << "先序遍历顺序为：";PreOrderTraverse(T);cout << en dl;cout << "中序遍历顺序为：”；InO rderTraverse(T);cout << en dl;cout << "后序遍历顺序为：”；PostOrderTraverse(T);cout << en dl;cout << "层序遍历顺序为：";leOrderTraverse(T);cout << en dl;cout << "二叉树深度为："<< Fi ndTreeDeep(T)«e ndl;cout << "左右子树交换后：";cha nge(T);cout << "先序遍历顺序为：";PreOrderTraverse(T); |cout << en dl;return 0;}。

实验三二叉树的基本操作实现及其应用

二叉树的基本操作实现及其应用一、实验目的1．熟悉二叉树结点的结构和对二叉树的基本操作。

2．掌握对二叉树每一种操作的具体实现。

3．学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

4.会用二叉树解决简单的实际问题。

二、实验内容设计程序实现二叉树结点的类型定义和对二叉树的基本操作。

该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。

1 按先序次序建立一个二叉树，2按（A:先序 B:中序 C:后序）遍历输出二叉树的所有结点以上比做，以下选做3求二叉树中所有结点数4求二叉树的深度三、实验步骤㈠、数据结构与核心算法的设计描述/* 定义DataType为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{ DataType data;struct BitNode *lchild,*rchild;}*BitTree;相关函数声明：1、/* 初始化二叉树，即把树根指针置空 */void BinTreeInit(BitTree *BT){BT=(BitTree)malloc(sizeof(BitNode));BT->data=NULL;cout<<"二叉树初始化成功!"<<endl;}2、/* 按先序次序建立一个二叉树*/int BinTreeCreat(BitTree &BT){char ch;cin>>ch;if(ch=='#') BT=NULL;else{if(!(BT=(BitTree)malloc(sizeof(BitNode))))exit(0);BT->data=ch;BinTreeCreat(BT->lchild);BinTreeCreat(BT->rchild);}return 0;}3、/* 检查二叉树是否为空 */void BinTreeEmpty(BitTree &BT){if(BT->data==NULL)cout<<"是空二叉树!"<<endl;elsecout<<"不是空二叉树!"<<endl;}4、/*按任一种遍历次序（包括按先序、中序、后序、按层次）输出二叉树中的所有结点 */void BinTraverse(BitTree &BT)//按先序序列建立二叉树{if(BT!=NULL){cout<<BT->data;BinTraverse(BT->lchild);BinTraverse(BT->rchild);}}5、/* 求二叉树的深度 */int BinTreeDepth(BitTree BT){int depthval;if(BT){int depthLeft=BinTreeDepth(BT->lchild);int depthRight=BinTreeDepth(BT->rchild);depthval=1+(depthLeft>depthRight?depthLeft:depthRight);}else depthval=0;return depthval;}6、/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT){int node;if(BT){int lchild=BinTreeCount(BT->lchild);int rchild=BinTreeCount(BT->rchild);node=lchild+rchild+1;}elsenode=0;return node;}㈡、函数调用及主函数设计㈢程序调试及运行结果分析测试数据： 1、初始化二叉树； 2、按先序序列建立二叉树；3、判断二叉树是否为空；4、先序序列遍历二叉树；5、求二叉树的深度；6、求二叉树节点的个数。

二叉树实验报告

二叉树实验报告1. 引言二叉树是一种常用的数据结构，广泛应用于计算机科学和信息技术领域。

本实验旨在通过对二叉树的理解和实现，加深对数据结构与算法的认识和应用能力。

本报告将介绍二叉树的定义、基本操作以及实验过程中的设计和实现。

2. 二叉树的定义二叉树是一个有序树，其每个节点最多有两个子节点。

树的左子节点和右子节点被称为二叉树的左子树和右子树。

3. 二叉树的基本操作3.1 二叉树的创建在实验中，我们通过定义一个二叉树的节点结构来创建一个二叉树。

节点结构包含一个数据域和左右指针，用于指向左右子节点。

创建二叉树的过程可以通过递归或者迭代的方式来完成。

3.2 二叉树的插入和删除二叉树的插入操作是将新节点插入到树中的合适位置。

插入时需要考虑保持二叉树的有序性。

删除操作是将指定节点从树中删除，并保持二叉树的有序性。

在实验中，我们可以使用递归或者循环的方式实现这些操作。

3.3 二叉树的遍历二叉树的遍历是指按照某种次序访问二叉树的所有节点。

常见的遍历方式包括前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点，然后按照左孩子-右孩子的顺序递归遍历左右子树。

中序遍历按照左孩子-根节点-右孩子的顺序递归遍历左右子树。

后序遍历按照左孩子-右孩子-根节点的顺序递归遍历左右子树。

3.4 二叉树的查找查找操作是指在二叉树中查找指定的值。

可以通过递归或者循环的方式实现二叉树的查找操作。

基本思路是从根节点开始，通过比较节点的值和目标值的大小关系，逐步向左子树或者右子树进行查找，直到找到目标节点或者遍历到叶子节点。

4. 实验设计和实现在本实验中，我们设计并实现了一个基于Python语言的二叉树类。

具体实现包括二叉树的创建、插入、删除、遍历和查找操作。

在实验过程中，我们运用了递归和迭代的方法实现了这些操作，并进行了测试和验证。

4.1 二叉树类的设计我们将二叉树的节点设计为一个类，其中包括数据域和左右子节点的指针。

另外，我们设计了一个二叉树类，包含了二叉树的基本操作方法。

二叉树基本操作--实验报告

⼆叉树基本操作--实验报告实验三⼆叉树的基本操作学院:物理与电⼦学院班级:电信1105班姓名:刘岩学号:29⼀、实验⽬的1、熟悉⼆叉树的基本操作，掌握⼆叉树的实现以及实际应⽤。

3、加深对于⼆叉树的理解，逐步培养解决实际问题的编程能⼒。

⼆、实验环境1台WINDOWS环境的PC机，装有Visual C++ 。

三、实验内容1、问题描述现需要编写⼀套⼆叉树的操作函数，以便⽤户能够⽅便的利⽤这些函数来实现⾃⼰的应⽤。

其中操作函数包括：1>创建⼆叉树CreateBTNode(*b,*str)：根据⼆叉树括号表⽰法的字符串*str⽣成对应的链式存储结构。

2>输出⼆叉树DispBTNode(*b)：以括号表⽰法输出⼀棵⼆叉树。

3>查找结点FindNode(*b,x)：在⼆叉树b中寻找data域值为x的结点,并返回指向该结点的指针。

4>求⾼度BTNodeDepth(*b)：求⼆叉树b的⾼度。

若⼆叉树为空,则其⾼度为0；否则,其⾼度等于左⼦树与右⼦树中的最⼤⾼度加l。

5>求⼆叉树的结点个数NodesCount(BTNode *b)6>先序遍历的递归算法：void PreOrder(BTNode *b)7>中序遍历的递归算法：void InOrder(BTNode *b)8>后序遍历递归算法：void PostOrder(BTNode *b)9>层次遍历算法void LevelOrder(BTNode *b)2、基本要求实现以上9个函数。

主函数中实现以下功能：创建下图中的树b输出⼆叉树b找到’H’节点，输出其左右孩⼦值输出b的⾼度输出b的节点个数输出b的四种遍历顺序3、程序编写上图转化为⼆叉树括号表⽰法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <>#include <>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩⼦*/struct node *rchild; /*指向右孩⼦*/} BTNode;void CreateBTNode(BTNode *&b,char *str);//创建BTNode *FindNode(BTNode *b,ElemType x);//查找节点int BTNodeHeight(BTNode *b);//求⾼度void DispBTNode(BTNode *b);//输出int NodesCount(BTNode *b);//⼆叉树的结点个数void PreOrder(BTNode *b);//先序遍历递归void InOrder(BTNode *b);//中序遍历递归void PostOrder(BTNode *b);//后序遍历递归void LevelOrder(BTNode *b);//层次遍历//创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':top++;St[top]=p;k=1;break;case ')':top--;break;case ',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode)); p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}//输出void DispBTNode(BTNode *b){if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL)printf(",");DispBTNode(b->rchild);printf(")");}}}//查找节点BTNode *FindNode(BTNode *b,ElemType x){ BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}//求⾼度int BTNodeHeight(BTNode *b){int lchildh,rchildh;if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild);rchildh=BTNodeHeight(b->rchild);return(lchildh>rchildh)(lchildh+1):(rchildh+1);}}//⼆叉树的结点个数int NodesCount(BTNode *b){if(b==NULL)return 0;elsereturn NodesCount(b->lchild)+NodesCount(b->rchild)+1; }//先序遍历递归void PreOrder(BTNode *b){ if(b!=NULL){printf("%c",b->data); PreOrder(b->lchild); PreOrder(b->rchild);}}//中序遍历递归void InOrder(BTNode *b){if(b!=NULL){InOrder(b->lchild);printf("%c",b->data); InOrder(b->rchild);}}//后序遍历递归void PostOrder(BTNode *b){ if(b!=NULL){PostOrder(b->lchild); PostOrder(b->rchild);printf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){ BTNode *p;BTNode *qu[MaxSize];int front,rear;front=rear=-1;rear++;qu[rear]=b;while(front!=rear){front=(front+1)%MaxSize;p=qu[front];printf("%c",p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->lchild;}if(p->rchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->rchild;}}}void main(){BTNode *b,*p,*lp,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";//根据树形图改写成的//⼆叉树括号表⽰法的字符串*str //char str[100];scanf("%s",&str);//⾃⾏输⼊括号表⽰的⼆叉树CreateBTNode(b,str); //创建树bprintf("\n");printf("输出⼆叉树:");//输出⼆叉树bDispBTNode(b);printf("\n");printf("'H'结点:");//找到'H'节点，输出其左右孩⼦值p=FindNode(b,'H');printf("\n");if (p!=NULL){printf("左孩⼦节点的值");printf("%c",p->lchild->data);printf("\n");printf("右孩⼦节点的值");printf("%c",p->rchild->data);printf("\n");//此处输出p的左右孩⼦节点的值}printf("\n");printf("⼆叉树b的深度:%d\n",BTNodeHeight(b));//输出b的⾼度printf("⼆叉树b的结点个数:%d\n",NodesCount(b));//输出b的节点个数printf("\n");printf(" 先序遍历序列:\n");//输出b的四种遍历顺序printf(" 算法:");PreOrder(b);printf("\n");printf(" 中序遍历序列:\n");printf(" 算法:");InOrder(b);printf("\n");printf(" 后序遍历序列:\n");printf(" 算法:");PostOrder(b);printf("\n");printf(" 层次遍历序列:\n");printf(" 算法:");LevelOrder(b); printf("\n");}四、实验⼼得与⼩结通过本次实验，我熟悉⼆叉树的基本知识内容，对课本的知识有了更加深刻的理解与掌握掌握。

二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构，在计算机科学领域中被广泛应用。

本实验将介绍二叉树的基本操作与实现，并给出相应的实验报告。

一、引言二叉树是一种特殊的树状结构，每个节点至多有两个子节点。

二叉树有许多重要的特性，如平衡二叉树、二叉树等，应用广泛。

在本实验中，我们将介绍二叉树的基本操作和实现。

二、实验目的1.掌握二叉树的基本概念和特性；2.熟悉二叉树的基本操作，包括创建、插入、删除、遍历等；3.学会使用编程语言实现二叉树的基本操作。

三、实验内容本实验主要包括以下内容：1.二叉树的定义和基本概念；2.二叉树的基本操作，包括创建、插入、删除、遍历等；3.使用编程语言实现二叉树的基本操作；4.测试和验证二叉树的基本操作的正确性。

四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构，每个节点至多有两个子节点。

二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。

二叉树的特性有很多，如完全二叉树、平衡二叉树、二叉树等。

2.二叉树的基本操作（1）创建二叉树：可以通过手动输入节点数据来创建二叉树，也可以通过读取文件中的数据来创建二叉树。

（2）插入节点：在指定位置插入一个新节点。

（3）删除节点：删除指定位置的节点。

（4）遍历二叉树：有前序遍历、中序遍历和后序遍历三种遍历方式。

3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。

我们可以定义一个二叉树的结构体，包含节点数据和指向左右子树的指针。

然后根据具体的需求，实现相应的操作函数。

4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后，我们可以编写测试代码来验证操作的正确性。

通过创建二叉树，并进行插入、删除和遍历操作，观察输出结果是否符合预期。

五、实验结果与分析在完成二叉树的基本操作后，我们可以进行测试和验证。

通过输出二叉树的遍历结果，比对预期结果来判断操作是否正确。

同时，我们还可以观察二叉树的结构和特性，如是否满足平衡二叉树或二叉树的条件。

二叉树的基本操作实验报告

二叉树的基本操作实验报告二叉树的基本操作实验报告引言：二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。

二叉树的基本操作包括创建、遍历、插入和删除等。

本实验旨在通过实践来深入了解二叉树的基本操作，并通过实验结果验证其正确性和有效性。

一、创建二叉树创建二叉树是二叉树操作中的第一步。

在本实验中，我们使用了递归算法来创建二叉树。

递归算法是一种重要的算法思想，通过将问题划分为更小的子问题来解决复杂的问题。

在创建二叉树时，我们首先创建根节点，然后递归地创建左子树和右子树。

二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

前序遍历先访问根节点，然后递归遍历左子树和右子树；中序遍历先递归遍历左子树，然后访问根节点，最后递归遍历右子树；后序遍历先递归遍历左子树和右子树，最后访问根节点。

三、插入节点插入节点是向二叉树中添加新节点的操作。

插入节点的过程需要遵循二叉树的特性，即左子节点的值小于父节点的值，右子节点的值大于父节点的值。

在插入节点时，我们需要找到合适的位置，将新节点插入到正确的位置上。

四、删除节点删除节点是从二叉树中移除节点的操作。

删除节点的过程相对复杂，需要考虑多种情况。

如果要删除的节点是叶子节点，直接删除即可。

如果要删除的节点只有一个子节点，将其子节点连接到父节点上。

如果要删除的节点有两个子节点，我们需要找到其后继节点或前驱节点来替代被删除的节点。

实验结果：通过实验，我们成功地实现了二叉树的基本操作。

创建二叉树的递归算法能够正确地创建出符合要求的二叉树。

遍历二叉树的算法能够按照指定的顺序遍历每个节点。

插入节点和删除节点的操作也能够正确地修改二叉树的结构。

讨论与总结：二叉树的基本操作是数据结构中的重要内容，对于理解和应用其他数据结构具有重要意义。

通过本次实验，我们深入了解了二叉树的创建、遍历、插入和删除等操作，并通过实验验证了其正确性和有效性。

实验报告实验三二叉排序树的建立和查找

实验三二叉排序树的建立和查找一、实验目的1．掌握二叉排序树的建立算法2．掌握二叉排序树查找算法。

二、实验环境操作系统和C语言系统三、预习要求复习二叉排序树的生成及查找算法，编写完整的程序。

四、实验内容实现二叉排序树上的查找算法。

具体实现要求：用二叉链表做存储结构，输入键值序列，建立一棵二叉排序树并在二叉排序树上实现查找算法。

五、参考算法#include <stdio.h>#include <stdlib.h>typedef int InfoType;typedef int KeyType; /*假定关键字类型为整数*/typedef struct node /*结点类型*/{KeyType key; /*关键字项*/InfoType otherinfo; /*其它数据域，InfoType视应用情况而定，下面不处理它*/struct node *lchild,*rchild; /*左右孩子指针*/}BSTNode;typedef BSTNode *BSTree; /*BSTree是二叉排序树的类型*/BSTNode *SearchBST(BSTree T,KeyType key){ /*在二叉排序树T上查找关键字为key的结点，成功时返回该结点位置，否则返回NULL*/if(T==NULL||key==T->key) /*递归的终结条件*/return T; /*若T为空，查找失败；否则成功，返回找到的结点位置*/if(key<T->key)return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /*继续在右子树中查找*/}void InsertBST(BSTree *T,int key){ /*插入一个值为key的节点到二叉排序树中*/BSTNode *p,*q;if((*T)==NULL){ /*树为空树*/(*T)=(BSTree)malloc(sizeof(BSTNode));(*T)->key=key;(*T)->lchild=(*T)->rchild=NULL;}else{p=(*T);while(p){q=p;if(p->key>key)p=q->lchild;else if(p->key<key)p=q->rchild;else{printf("\n 该二叉排序树中含有关键字为%d的节点!\n",key);return;}}p=(BSTree)malloc(sizeof(BSTNode));p->key=key;p->lchild=p->rchild=NULL;if(q->key>key)q->lchild=p;elseq->rchild=p;}}BSTree CreateBST(void){ /*输入一个结点序列，建立一棵二叉排序树，将根结点指针返回*/BSTree T=NULL; /*初始时T为空树*/KeyType key;scanf("%d",&key); /*读入一个关键字*/while(key){ /*假设key=0是输入结束标志*/ InsertBST(&T,key); /*将key插入二叉排序树T*/scanf("%d",&key); /*读入下一关键字*/}return T; /*返回建立的二叉排序树的根指针*/ }void ListBinTree(BSTree T) /*用广义表示二叉树*/{if(T!=NULL){printf("%d",T->key);if(T->lchild!=NULL||T->rchild!=NULL){printf("(");ListBinTree(T->lchild);if(T->rchild!=NULL)printf(",");ListBinTree(T->rchild);printf(")");}}}void main(){BSTNode *SearchBST(BSTree T,KeyType key);void InsertBST(BSTree *Tptr,KeyType key);BSTree CreateBST();void ListBinTree(BSTree T);BSTree T;BSTNode *p;int key;printf("请输入关键字（输入0为结束标志）：\n");T=CreateBST();ListBinTree(T);printf("\n");printf("请输入欲查找关键字:");scanf("%d",&key);p=SearchBST(T,key);if(p==NULL)printf("没有找到%d！\n",key);elseprintf("找到%d！\n",key);ListBinTree(p);printf("\n");}实验中出现的问题及对问题的解决方案输入数据时，总是不能得到结果，原因是在建立二叉树函数定义中，是对指针的值进行了修改。

二叉树实现及应用实验报告

二叉树实现及应用实验报告实验名称：二叉树实现及应用实验目的：1. 实现二叉树的创建、插入和删除操作。

2. 学习二叉树的遍历方法，并能够应用于实际问题。

3. 掌握二叉树在数据结构和算法中的一些常用应用。

实验内容：1. 实现二叉树的创建、插入和删除操作，包括二叉树的构造函数、插入函数和删除函数。

2. 学习二叉树的三种遍历方法：前序遍历、中序遍历和后序遍历，并应用于实际问题。

3. 掌握二叉树的一些常用应用，如二叉搜索树、平衡二叉树和哈夫曼树等。

实验步骤：1. 创建二叉树的结构体，包括树节点和树的根节点。

2. 实现二叉树的构造函数，用于创建二叉树的根节点。

3. 实现二叉树的插入函数，用于将元素插入到二叉树中的合适位置。

4. 实现二叉树的删除函数，用于删除二叉树中的指定元素。

5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。

6. 运用二叉树的遍历方法解决实际问题，如查找二叉树中的最大值和最小值。

7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。

实验结果：1. 成功创建、插入和删除二叉树中的元素，实现了二叉树的基本操作。

2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历，并能够正确输出遍历结果。

3. 通过二叉树的遍历方法成功解决了实际问题，如查找二叉树中的最大值和最小值。

4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构，丰富了对二叉树的理解。

实验分析：1. 二叉树是一种重要的数据结构，具有较好的数据存储和查找性能，广泛应用于计算机科学和算法领域。

2. 通过实验，我们深入了解了二叉树的创建、插入和删除操作，以及前序遍历、中序遍历和后序遍历的原理和应用。

3. 实际问题往往可以转化为二叉树的遍历问题进行求解，通过实验，我们成功应用了二叉树的遍历方法解决了实际问题。

4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用，对于提高我们在数据结构和算法方面的设计能力具有重要意义。

实验3 二叉树的应用

实验五：二叉树的应用一、实验预备知识1 树是一种非线性的结构，它具有递归特点。

2 二叉树有四种遍历方法，分别为：先根，后根、中根和层次。

掌握四种遍历的规则。

（每个结点都访问，并且只访问一次）二、实验目的1 掌握二叉树的逻辑结构特性，以及各种存储结构的特点及适用范围。

2 掌握用指针类型描述、访问和处理二叉树的各种运算的实现算法。

三、实验内容1 编写采用二叉链表形式存储的二叉树的创建算法。

2 编写二叉树的先序、中序、后序遍历的递归算法、先序和中序的非递归算法和按层遍历的算法。

2 编写将一棵二叉树的所有左右子树进行交换的算法。

3 编写统计二叉树中叶子结点的算法。

4编写一个主函数，将上面函数连在一起，构成一个完整的程序。

5将实验源程序调试并运行。

四、实验要求建立的二叉树为：AB CD E FG H#include<iostream>using namespace std;typedef char datatype;typedef struct node{datatype data;struct node *lchild,*rchild;}bintnode;typedef bintnode *bintree;typedef struct stack{bintree data[100];int tag[100];int top;}seqstack;创建二叉树算法：void CreateBinTree(bintree *t){char ch;if((ch=getchar())=='0')(*t)=NULL;else{*t=new bintnode ;(*t)->data=ch;CreateBinTree(&(*t)->lchild);CreateBinTree(&(*t)->rchild);}}前序遍历递归算法：void Preorder(bintree t){if(t){cout<<t->data<<" ";Preorder(t->lchild);Preorder(t->rchild);}}中序遍历递归算法：void Inorder(bintree t){if(t){Inorder(t->lchild);cout<<t->data<<" ";Inorder(t->rchild);}}后序遍历递归算法：void Postorder(bintree t){if(t){Postorder(t->lchild);Postorder(t->rchild);cout<<t->data<<" ";}}void Push(seqstack *s,bintree t) {s->data[++s->top]=t;}bintree Pop(seqstack *s){if(s->top!=-1){s->top--;return (s->data[s->top+1]);}elsereturn NULL;}前序遍历非递归算法：void Preorder1(bintree t){seqstack s;s.top=-1;while((t)||(s.top!=-1)){while(t){cout<<t->data<<" ";s.top++;s.data[s.top]=t;t=t->lchild;}if(s.top>-1){t=Pop(&s);t=t->rchild;}}}中序遍历非递归算法：void Inorder1(bintree t){seqstack s;s.top=-1;while((t!=NULL)||(s.top!=-1)){while(t){Push(&s,t);t=t->lchild;}if(s.top!=-1){t=Pop(&s);cout<<t->data<<" ";t->rchild;}}}层次遍历算法：void Levelorder(bintree t){bintree queue[100];int front,rear;if(t==NULL)return;front=-1;rear=0;queue[rear]=t;while(front!=rear){front++;cout<<queue[front]->data<<" ";if(queue[front]->lchild!=NULL){rear++;queue[rear]=queue[front]->lchild;}if(queue[front]->rchild!=NULL){rear++;queue[rear]=queue[front]->rchild;}}}遍历叶子节点算法：void CountLeaf(bintree t){if(!t)return;if(!(t->lchild||t->rchild))cout<<t->data<<" ";CountLeaf(t->lchild);CountLeaf(t->rchild);}交换左右子树算法：void SwapBinTree(bintree t){bintree s;if(t){SwapBinTree(t->lchild);SwapBinTree(t->rchild);s=t->lchild;t->lchild=t->rchild;t->rchild=s;}}主函数实现：void main(){bintree root;cout<<"***********************************************************"<<en dl;cout<<"请按前序遍历次序顺序读入所要生成的二叉树：";CreateBinTree(&root);cout<<"***********************************************************"<<en dl;cout<<"*******************************************"<<endl;cout<<"递归实现前序遍历结果：";Preorder(root);cout<<endl;cout<<"\n递归实现中序遍历结果：";Inorder(root);cout<<endl;cout<<"\n递归实现后序遍历结果：";Postorder(root);cout<<endl;cout<<"*******************************************"<<endl;cout<<"*******************************************"<<endl;cout<<"非递归实现前序遍历结果：";Preorder1(root);cout<<endl;cout<<"\n非递归实现中序遍历结果：";Inorder(root);cout<<endl;cout<<"\n层次遍历结果：";Levelorder(root);cout<<endl;cout<<"\n叶子结点为：";CountLeaf(root);cout<<endl;cout<<"*******************************************"<<endl;cout<<"*******************************************"<<endl;printf("交换左右子树后遍历如下：");cout<<endl;SwapBinTree(root);cout<<"\n递归实现前序遍历结果：";Preorder(root);cout<<endl;cout<<"\n递归实现中序遍历结果：";Inorder(root);cout<<endl;cout<<"\n递归实现后序遍历结果：";Postorder(root);cout<<endl;cout<<"*******************************************"<<endl; }五、实验结果：。

实验三二叉树及其操作算法实现

二叉树是由一个根结点和两棵分别称为左子树
和右子树的互不相交的二叉树构成。
满二叉树
种类：完全二叉树、非完全二叉树平衡二叉树、非平衡二叉树
二叉树的性质
1、二叉树的第i层上至多有2i-1(i>=1)个结点。
2、深度为h的二叉树中至多含有2h-1个结点。
3、在任意二叉树中，若有n0个叶子结点，n2
printf("The tree is:\n"); for(k=1;k<=N;k++) {printf("%d,%d,%d\n",v[k],l[k],r[k]);}
}
了二叉树中的一个结点i。在输出二叉树时
，只要输出此三个数组就行了。
五、算法
构造算法： 1、读入一个数据元素，建立一个新结点； 2、若二叉树为空，则新结点为根结点； 3、若二叉树非空，则将新结点与根结点值比较，如果小于根结点值，则插入到左子树中，否则插入到右子树中。
具体算法如下：
TH←0 FOR K=1 TO n DO { READ X; V(k)←X; L(k)←R(k)←0; i=TH IF i=0 THEN TH←k ELSE {WHILE (L(i)!=k) AND (R(i)!=k) DO {IF X<V(i) THEN [插入到左子树] {IF L(i)!=0 TEHN i←L(i) ELSE L(i)←k} ELSE [插入到右子树] {IF R(i)!=0 THEN i←R(i) ELSE R(i)←k} } } }
六、程序清单
#include <stdio.h> #include <math.h> #define N 10 main() {int i,j,k,tree; int a[N],v[N],l[N],r[N]; for(j=1;j<=N;j++) {a[j]=rand()%100;} printf("The numbers are:\n"); for(j=1;j<=N;j++) {printf("%d,",a[j]);} printf("\n");

实验三 二叉树的基本操作实现及其应用

实验三二叉树基本操作与应用实验

二叉树实验报告

实验三--二叉树的基本运算

实验三 二叉树的操作及应用

数据结构实验3：二叉树的操作

实验三—树的实现与应用实验报告

树和二叉树的实验报告

数据结构二叉树实验报告

实验3 二叉树的操作及应用

数据结构实验三——二叉树基本操作及运算实验报告

实验三二叉树的基本操作

实验三 二叉树的基本操作实现及其应用

二叉树实验报告

二叉树基本操作--实验报告

二叉树的基本操作与实现实验报告

二叉树的基本操作实验报告

实验报告 实验三 二叉排序树的建立和查找

二叉树实现及应用实验报告

实验3 二叉树的应用

实验三二叉树及其操作算法实现

实验三二叉树的基本操作实现及其应用

实验三二叉树的操作及应用

实验三二叉树的基本操作实现及其应用

实验报告实验三二叉排序树的建立和查找