实验二叉树及其应用(严选材料)
实验三二叉树基本操作与应用实验

实验三二叉树基本操作与应用实验第一篇:实验三二叉树基本操作与应用实验实验三二叉树基本操作与应用实验第三次实验主要包括两部分内容:1.二叉树基本操作实验;2.二叉树应用—赫夫曼树与赫夫曼编码实验。
基本操作包括存储结构建立和遍历算法,本文只给出部分参考程序,请大家尽量完成多数基本操作。
第一部分基本操作实验[问题描述] 二叉树采用二叉链表作存储结构,试编程实现二叉树的如下基本操作1.按先序序列构造一棵二叉链表表示的二叉树T;2.对这棵二叉树进行遍历:先序、中序、后序以及层次遍历序列,分别输出结点的遍历序列;3.求二叉树的深度,结点数目,叶结点数目; [数据描述] //二叉树的二叉链表存储表示先序遍历二叉树递归算法6.层次遍历二叉树的非递归算法7.求二叉树的深度[说明]1.按先序次序输入二叉树中结点的值,用‘#’表示空树,对每一个结点应当确定其左右子树的值(为空时必须用特定的空字符占位),故执行此程序时,最好先在纸上画出你想建立的二叉树,每个结点的左右子树必须确定。
若为空,则用特定字符标出,然后再按先序输入这棵二叉树的字符序列。
2.为了简化程序的书写量,以及程序的清晰性,对结点的访问以一条输出语句表示,若有更复杂的或多种访问,可以将结点的访问编写成函数,然后通过函数指针进行函数的调用。
读者若有兴趣,可自行编写。
3.c语言函数参数传递,都是以“传值”的方式,故在设计函数时,必须注意参数的传递。
若想通过函数修改实际参数的值,则必须用指针变量作参数。
具体设计时;读者一定要把指针变量及指针变量指向的值等概念弄清楚。
4.完整参考程序只给出了部分遍历算法,对于其他算法,请读者参照示例,自行编程完成,以加深学习体会。
对于二叉链表的建立也是如此,示例中只是给出了先序法建立过程,读者可自行练习中序、后序二叉链表建立法,叶子结点或二叉树结点总数求法等。
第二部分二叉树应用实验---------郝夫曼树与郝夫曼编码[问题描述] 利用HuffMan编码进行通信可以大大提高信道利用率,缩短信息传输时间,降低传输成本。
二叉树的遍历及其应用实验报告

实验报告题目:二叉树的遍历及应用院系:数学系专业:数学与应用数学学号: **********姓名:***一、实验名称:二叉树的遍历及应用二、实验日期:2012年11月14日三、实验要求:编程实现二叉树的建立并对其进行遍历四、实验目的:1、掌握二叉树链式存储结构的类型定义及实现;2、掌握二叉树链式存储结构的各类基本运算方法;3、掌握二叉树各个重要性质在解决实际问题中的应用;4、掌握二叉树的分析方法、解决方法,从而提高实际编程能力及程序调试能力。
五、实验内容1、创建二叉树;2、用递归方法实现二叉树的各种遍历。
六、程序代码#include<stdio.h>#include<malloc.h>#define TRUE 1#define FALSE 0#define Stack_Size 50typedef struct Node{char data;struct Node *LChild;struct Node *RChild;}BiTNode,*BiTree;typedef BiTree StackElementType;typedef struct{StackElementType elem[Stack_Size];int top;}SeqStack;//初始化void InitStack(SeqStack *S){S->top=-1;}//进栈int Push(SeqStack *S,StackElementType x) { if(S->top==Stack_Size-1) return(FALSE); S->top++;S->elem[S->top]=x;return(TRUE);}//出栈int Pop(SeqStack *S,StackElementType *x) {if(S->top==-1)return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}//先序遍历void PreOrder(BiTree root){if(root!=NULL){printf("%c",root->data);PreOrder(root->LChild);PreOrder(root->RChild);}}//中序遍历void InOrder(BiTree root) { if(root!=NULL){ InOrder(root->LChild); printf("%c",root->data); InOrder(root->RChild);}}//后序遍历void PostOrder(BiTree root) {if(root!=NULL){PostOrder(root->LChild); PostOrder(root->RChild); printf("%c",root->data);}}//创建二叉链表void CreateBiTree(BiTree *bt){char ch;ch=getchar();if(ch=='.') *bt=NULL;else{*bt=(BiTree)malloc(sizeof(BiTNode)); (*bt)->data=ch;CreateBiTree(&((*bt)->LChild)); CreateBiTree(&((*bt)->RChild));}}//后序遍历球二叉树高度int PostTreeDepth(BiTree bt){int hl,hr,max;if(bt!=NULL){hl=PostTreeDepth(bt->LChild);hr=PostTreeDepth(bt->RChild);max=hl>hr?hl:hr;return(max+1);}else return(0);}//横向打印二叉树void PrintTree(BiTree bt,int nLayer) {int i;if(bt==NULL) return;PrintTree(bt->RChild,nLayer+1);for( i=0;i<nLayer;i++)printf(" ");printf("%c\n",bt->data);PrintTree(bt->LChild,nLayer+1);}void main(){BiTree root;printf("请输入序列:\n"); CreateBiTree(&root);printf("输出结果为:\n");printf("先序遍历结果:\n"); PreOrder(root);printf("\n中序遍历结果:\n"); InOrder(root);printf("\n后序遍历结果:\n"); PostOrder(root);printf("\n二叉树的深度:\n");printf("%d",PostTreeDepth(root)); printf("\n横向打印二叉树结果:\n"); PrintTree(root,5);}七、成果展示。
二叉树 实验报告

二叉树实验报告二叉树实验报告引言:二叉树是一种常见的数据结构,它由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。
在本次实验中,我们将探索二叉树的基本概念、特性以及应用。
一、二叉树的定义与性质1.1 二叉树的定义二叉树是一种递归定义的数据结构,它可以为空,或者由一个根节点和两个二叉树组成,分别称为左子树和右子树。
1.2 二叉树的性质(1)每个节点最多有两个子节点,分别称为左子节点和右子节点。
(2)左子树和右子树也是二叉树。
(3)二叉树的子树之间没有关联性,它们是相互独立的。
二、二叉树的遍历方式2.1 前序遍历前序遍历是指先访问根节点,然后按照先左后右的顺序遍历左子树和右子树。
2.2 中序遍历中序遍历是指先遍历左子树,然后访问根节点,最后遍历右子树。
2.3 后序遍历后序遍历是指先遍历左子树,然后遍历右子树,最后访问根节点。
2.4 层次遍历层次遍历是指按照从上到下、从左到右的顺序遍历二叉树的每个节点。
三、二叉树的应用3.1 二叉搜索树二叉搜索树是一种特殊的二叉树,它的每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得二叉搜索树可以高效地进行查找、插入和删除操作。
3.2 哈夫曼树哈夫曼树是一种带权路径长度最短的二叉树,它常用于数据压缩中。
哈夫曼树的构建过程是通过贪心算法,将权值较小的节点放在离根节点较远的位置,从而实现最优编码。
3.3 表达式树表达式树是一种用于表示数学表达式的二叉树,它的叶节点是操作数,而非叶节点是操作符。
通过对表达式树的遍历,可以实现对表达式的求值。
结论:通过本次实验,我们对二叉树的定义、性质、遍历方式以及应用有了更深入的了解。
二叉树作为一种重要的数据结构,在计算机科学和算法设计中发挥着重要的作用。
在今后的学习和工作中,我们应该进一步探索二叉树的高级应用,并灵活运用于实际问题的解决中。
实验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。
数据结构实验报告-树(二叉树)

实验5:树(二叉树)(采用二叉链表存储)一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。
三、实验基本原理之前我们都是学习的线性结构,这次我们就开始学习非线性结构——树。
线性结构中结点间具有唯一前驱、唯一后继关系,而非线性结构中结点的前驱、后继的关系并不具有唯一性。
在树结构中,节点间关系是前驱唯一而后继不唯一,即结点之间是一对多的关系。
直观地看,树结构是具有分支关系的结构(其分叉、分层的特征类似于自然界中的树)。
四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值,空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为:" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为:" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为:" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1:创建二叉树--------------" << endl;cout << "--------------2:前序遍历----------------" << endl;cout << "--------------3:中序遍历----------------" << endl;cout << "--------------4:后序遍历----------------" << endl;cout << "--------------5:总结点数----------------" << endl;cout << "--------------6:叶子节点数--------------" << endl;cout << "--------------7:树的深度----------------" << endl;cout << "--------------8:树根到叶子的最长路径----" << endl;cout << "--------------9:交换所有节点左右子女----" << endl;cout << "--------------10:顺序存储---------------" << endl;cout << "--------------11:显示顺序存储-----------" << endl;cout << "--------------12:退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例:1.创建二叉树(二叉链表形式)2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验,我掌握了二叉树的顺序存储和链式存储,体会了二叉树的存储结构的特性,掌握了二叉树的树上相关操作。
实验6 二叉树及其应用

实验6 二叉树及其应用1.实验目的1)了解二叉树的特点、掌握二叉树的主要存储结构。
2)掌握二叉树的基本操作,能针对二叉树的具体应用选择相应的存储结构。
3)掌握递归算法的设计方法。
2.实验内容(1)二叉链表表示二叉树,建立一棵二叉树,实现下列基本操作,通过数据测试每个操作的正确性,包括:1. CreateBinTree(&T):按扩展二叉树的先序遍历结果构造二叉树。
2. BinTreeEmpty(T): 判断一棵二叉树是否为空树。
3. PreOrderTraverse(T): 先序遍历二叉树T,并输出节点序列。
4. InOrderTraverse(T): 中序遍历二叉树T,并输出节点序列。
5. PostOrderTraverse(T):后序遍历二叉树T,并输出节点序列。
6. LevelOrderTraverse(T):层次遍历二叉树T,并输出节点序列。
7. Value(T,e):查找值为e的节点,并返回该节点的地址。
8. BinTreeDepth(T):返回二叉树的深度。
9. Parent(T,e):查找二叉树T中值为e的节点的双亲,若e为根节点,操作失败。
10. LeftChild(T,e):查找二叉树T中值为e的节点的左孩子,若e没有左孩子,则操作失败。
11.RightChild(T,e):查找二叉树T中值为e的节点的右孩子,若e没有右孩子,则操作失败。
12. CountNode(T):计算二叉树中节点的个数。
13. Leaf(T): 计算二叉树中叶子节点的个数。
14. OneChild(T): 计算二叉树中度为1的节点个数。
3.实验要求(1)上机前编写实验源程序(要求手写,不允许打印),上机前老师检查,没有预先编写实验程序的同学不允许上实验课,按旷课一次处理。
旷课次数超过2次的同学实验成绩不及格,且没有补考资格。
(2)用一切你能想到的办法解决遇到的问题,培养解决问题的能力。
(3)实验报告(于下次实验时交)报告内容包括:实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。
二叉树实现及应用实验报告

二叉树实现及应用实验报告实验名称:二叉树实现及应用实验目的:1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法,并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容:1. 实现二叉树的创建、插入和删除操作,包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法:前序遍历、中序遍历和后序遍历,并应用于实际问题。
3. 掌握二叉树的一些常用应用,如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤:1. 创建二叉树的结构体,包括树节点和树的根节点。
2. 实现二叉树的构造函数,用于创建二叉树的根节点。
3. 实现二叉树的插入函数,用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数,用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题,如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果:1. 成功创建、插入和删除二叉树中的元素,实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历,并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题,如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构,丰富了对二叉树的理解。
实验分析:1. 二叉树是一种重要的数据结构,具有较好的数据存储和查找性能,广泛应用于计算机科学和算法领域。
2. 通过实验,我们深入了解了二叉树的创建、插入和删除操作,以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解,通过实验,我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用,对于提高我们在数据结构和算法方面的设计能力具有重要意义。
实验四:二叉树的基本操作和应用

while(1)
{
scanf("%d",&i);
if(i==1)
{
printf("Preorder :");
PreOrder(root);
printf("\n");
}
if(i==2)
{
struct Node * RChild;
}BiTree;
BiTree* BuildTree(BiTree *B)
{
char ch;
ch=getchar();
if(ch=='0')
B=NULL;
else
{
B=(BiTree *)malloc(sizeof(BiTree));
B->data=ch;
B->LChild=BuildTree(B->LChild);
{
PostOrder(root ->LChild);
PostOrder(root ->RChild);
printf("%c",root->data);
}
}
void End(BiTree *root)
{
printf("End");
}
void Set(BiTree *root)
{ int i;
printf("*********************************************\n");
B->RChild=BuildTree(B->RChild);
实验六 二叉树及应用的实验

实验六二叉树及应用的实验【实验目的】掌握二叉树的左右链存储实现,二叉树的建立方法,二叉树的遍历算法,哈夫曼树的程序实现。
【实验说明】1、存储结构定义及库文件# include <stdio.h># include <stdlib.h># define TRUE 1# define FALSE 0#define Stack_Size 50typedef char DataType;typedef struct node {DataType data;struct node *lchild,*rchild;}BiTNode,*BiTree;2、建立二叉树void CreateBiTree(BiTree *bt ){ char ch;ch=getchar();if(ch=='.') *bt=NULL;else{*bt=(BiTree)malloc(sizeof(BiTNode));(*bt)->data=ch;CreateBiTree(&((*bt)->lchild));CreateBiTree(&((*bt)->rchild));}}3、先序递归遍历二叉树void PreOrder(BiTree root)//root指向二叉树根结点{ if(root!=NULL){printf("%c",root->data);PreOrder(root->lchild);PreOrder(root->rchild);}}4、中序非递归遍历二叉树void inorder(BiTree root){BiTNode *p;int top;BiTree S[Stack_Size];top=0;p=root;//printf("ZYZ\n");do{while(p!=NULL){if(top>Stack_Size-1) {printf("栈满\n");return;}else {top=top+1;S[top]=p;p=p->lchild;};}if (top!=0){p=S[top];top=top-1;printf("%c",p->data);p=p->rchild;}}while(p!=NULL||top!=0);}4、主控菜单处理调试程序void main( ){BiTree T=NULL;int xz=1;char ch;while(xz) {printf(" 二叉树的建立及遍历\n");printf("==========================\n");printf(" 1、建立二叉树存储结构\n");printf(" 2、二叉树的前序遍历(递归)\n");printf(" 3、二叉树的中序遍历(非递归)\n");printf(" 0、退出系统\n");printf("===========================\n");printf(" 请选择:0--3 ");scanf("%d",&xz);switch(xz){ case 0: printf("再见!\n");return;case 1: ch=getchar();printf("按扩展先序遍历序列输入二叉树各结点值:");CreateBiTree(&T);printf("\n二叉树的链式存储结构建立完成!\n");printf("\n");break;case 2: printf("二叉树先序遍历序列为:");if(T) PreOrder(T);else printf("\n空树");printf("\n");printf("\n");break;case 3: printf("二叉树中序遍历序列为:");inorder(T);printf("\n");break;}}return;}//main【实验内容】⑴二叉树的遍历算法(非递归实现先序遍历,用递归实现中序遍历,用非递归实现后序遍历,层次遍历)⑵二叉树采用二叉链表方式存储,找到二叉树中度为0的结点个数。
二叉树基本操作--实验报告材料

实验三二叉树的基本操作学院:物理与电子学院班级:电信1105班姓名:刘岩学号:1404110729一、实验目的1、熟悉二叉树的基本操作,掌握二叉树的实现以及实际应用。
3、加深对于二叉树的理解,逐步培养解决实际问题的编程能力。
二、实验环境1台WINDOWS环境的PC机,装有Visual C++ 6.0。
三、实验内容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 <stdio.h>#include <malloc.h>#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");}四、实验心得与小结通过本次实验,我熟悉二叉树的基本知识内容,对课本的知识有了更加深刻的理解与掌握掌握。
实验5-二叉树的应用

实验5 二叉树的应用一、实验目的●了解并掌握二叉树的概念与定义●了解并掌握二叉树的先序、中序与后序遍历方法●了解唯一先序遍历,以及依据唯一先序遍历创建树的方法●掌握二叉树的节点查找方法●掌握二叉树的节点插入方法二、实验环境●个人计算机一台,CPU主频1GHz以上,1GB以上内存,2GB以上硬盘剩余空间。
●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本,英文版),或VC++ 6.0三、实验内容1.二叉树的创建与遍历由唯一先序遍历序列,创建二叉树,以二叉链表链表的形式存储;同时,对该二叉树进行先序、中序和后序遍历,并输出遍历序列。
例如,有以下这棵二叉树:其唯一先序遍历序列为:ABD00E0G00CF0H000其先序遍历序列为:ABDEGCFH其中序遍历序列为:DBEGAFHC其后序遍历序列为:DGEBHFCA源代码:ds13.c 2.节点的查找由二叉树的唯一先序遍历序列创建二叉树,并由用户输入一个字符,查找该字符是否在二叉树中。
例如,二叉树的其唯一先序遍历序列为:ABD00E0G00CF0H000,根据该序列创建二叉树。
若用户输入字符F,输出“Yes”;若用户输入“X”,输出“No”。
注:二叉树的创建可用第1题的程序。
源代码:ds14.c 3.节点的插入由二叉树的唯一先序遍历序列创建二叉树,并由用户输入两个字符ch1和ch2,以及插入标识flag(L或R)。
完成以下操作:(1)查找字符ch1是否为二叉树中某个节点的值,若不是,则输出“No found\n”;若是,转入(2)。
(2)若字符ch1是二叉树中节点p的值,则根据插入标识flag的值,进行操作:若flag的值为“L”,则以ch2为值创建一个新节点q,并将作为p的左子节点,原来的左子节点作为q的左子节点;若flag的值为“R”,,则以ch2为值创建一个新节点q,并将作为p的右子节点,原来的右子节点作为q的右子节点。
二叉树及其应用实验报告

实验地点:一号教学楼微机室
实验名称:二叉树及其应用
实验目的:熟悉各种存储结构及应用二叉树解决具体问题
实验环境:微机室、DEV-C++
实验步骤:1、确定基本思路和设计思想
2、确定程序主题
3、进行编程设计
4、调试程序
5、分析程序错误,编译调试
6、总结经验
实验体会:二叉树的存储、遍历等非常多,但只要实际掌握了二叉树的原理,在课堂上认真听老师讲课,在编程时其实可以减少好多工作量。只要认真思考,参考一些案例,也可以调试好自己的程序。
void preorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
printf("%3c",p->data);
preorder_btree(p->left);
preorder_btree(p->right);
}
}
/*中序遍历打印二叉排序树*/
void inorder_btree(b_tree root)
b_trБайду номын сангаасe p=root;
if(p!=null)
{
postorder_btree(p->left );
postorder_btree(p->right );
printf("%3c",p->data );
}
}
在调试程序的过程中,这几段关于二叉树遍历的原理其实老师都讲过,在调试程序的过程中,加深了对二叉树的遍历的理解,有助于更好地学习二叉树、应用二叉树。
{
b_tree p=root;
实验二 二叉树及其应用

实验二二叉树及其应用实验目的1. 加深对二叉树的结构特性的理解;2.熟练掌握二叉树的存储结构,特别是二叉链表结构的特点;3.熟练掌握二叉树的遍历算法原理及实现;4.学会编写实现二叉树的各种算法;5.掌握二叉树的应用方法;实验学时:建议2~4学时实验内容内容1:二叉树及其操作【问题描述】建立一棵以二叉链表结构存储的二叉树,并对其进行遍历。
求该二叉树中的结点个数等操作。
【基本要求】(1)建立二叉树的方法可以用教材中的先序方式建立,也可以根据二叉树的先序序列和中序序列来建立。
(2)对二叉树的遍历可采用递归或非递归的算法。
【实现提示】(1)二叉链表的结点结构描述typedef struct btnode{ // 定义结点类型ElemType data; //数据域struct btnode * lchild,* rchild; //左、右指针域/} *bitree; // btnode(2)可设计以下功能函数:bitree createbitree(); //建立二叉链表void preorder(bitree bt); //先序遍历二叉树int sum(bitree bt); //求二叉树中的结点个数算法可用递归或非递归实现。
建立二叉树可用以下两种算法实现:方案1:btnode * createBT ( ) //前序建树{ bitree T; char ch;cin >>ch ;if(ch==’#’) return NULL; //二叉树为空T=new BinTNode; //申请根结点T->data=ch;T->lchild=createBTpre(); //创建根的左子树T->rchild=createBTpre(); //创建根的右子树return T;}方案2:btnode* createBT ( char *preorder,char *midorder){ //由前序preorder和中序midorder建树,返回根指针if(strlen (preorder) ==0) return NULL; //空二叉树T= new Node; //建立根结点T->data=*preorder;k=locate(midorder,*preorder); //找根在中序中的位置lmidorder=fetch(midorder,0,k); //左子树的中序lpreorder =fetch(preorder,1,k); //左子树的前序rmidorder=fetch(midorder,k+1); //右子树的中序rpreorder =fetch(preorder, k+1); //右子树的前序T->lchild=createBT (lmidorder , lpreorder);//建根的左子树T->rchild=createBT(rmidorder , rpreorder); //建根的右子树return T;}int sum(bitree bt) //求二叉树中的结点个数{ if(!bt) return 0; //二叉树为空return sum(bt->lchild) + sum(bt->rchild) +1;}【选做内容】(1)对二叉树进行层次遍历算法。
二叉树的应用实验报告

二叉树的应用实验报告实验报告课程名称____数据结构上机实验__________实验项目______二叉树的应用 ____________实验仪器________PC机___________________系别____________________________专业_____________________________班级/学号____________________________学生姓名_____________________________实验日期_______________________成绩_______________________指导教师_______________________实验三.二叉树的应用1.实验目的:掌握二叉树的链式存储结构和常用算法。
利用哈夫曼树设计最优压缩编码。
2.实验内容:1)编写函数,实现建立哈夫曼树和显示哈夫曼树的功能。
2)编写函数,实现生成哈夫曼编码的功能。
3)编写主函数,从终端输入一段英文文本;统计各个字符出现的频率,然后构建哈夫曼树并求出对应的哈夫曼编码;显示哈夫曼树和哈夫曼编码。
选做内容:修改程序,选择实现以下功能:4)编码:用哈夫曼编码对一段英文文本进行压缩编码,显示编码后的文本编码序列;5)统计:计算并显示文本的压缩比例;6)解码:将采用哈夫曼编码压缩的文本还原为英文文本。
3.算法说明:1)二叉树和哈夫曼树的相关算法见讲义。
2)编码的方法是:从头开始逐个读取文本字符串中的每个字符,查编码表得到它的编码并输出。
重复处理直至文本结束。
3)解码的方法是:将指针指向哈夫曼树的树根,从头开始逐个读取编码序列中的每位,若该位为1则向右子树走,为0则向左子树走。
当走到叶子节点时,取出节点中的字符并输出。
重新将指针放到树根,继续以上过程直至编码序列处理完毕。
4)压缩比例的计算:编码后的文本长度为编码序列中的0和1,的个数,原文本长度为字符数*8。
LAB06 二叉树的操作及应用

Lab06.二叉树的操作及应用【实验目的和要求】1.掌握二叉树顺序存储表示的实现及其基本操作;2.掌握线索二叉树类型的定义方法,会按对称序线索化二叉树和周游对称序线索二叉树;3.掌握优先队列的实现及其基本操作;4.掌握构造哈夫曼树的基本思想和哈夫曼树的数据结构设计,能编程实现哈夫曼树的构造;5.掌握哈夫曼树的基本应用——哈夫曼编码。
【实验内容】1.二叉树按顺序存储表示,编写一个C源程序,计算给定二叉树的叶结点数,并给出它的先根序列,或后根序列,或对称序列。
2.编写一个C源程序,对给定的二叉树,按对称序线索化该二叉树,并按对称序周游该对称序线索二叉树。
3. 编写一个C源程序,恰当定义优先队列,并对给定的优先队列,实现插入和删除最小结点的操作。
4.简述构造哈夫曼树的基本思想和哈夫曼树的数据结构设计,并编程实现哈夫曼树的构造。
5.简述哈夫曼编码的原理和方法,编程实现哈夫曼编码与解码。
【实验仪器与软件】1.CPU主频在1GHz以上,内存在512Mb以上的PC;2.VC6.0,Word 2003及以上版本。
实验讲评:实验成绩:评阅教师:2012 年月日Lab06.二叉树的操作及应用一、顺序存储表示二叉树及其基本运算其顺序表示为:首先要对它进行扩充,增加一些并不存在的空结点,使之成为一棵完全二叉树,然后再用一维数组顺序存储。
其存储表示为:s t r u c t S e q B i n T r e e{/*顺序二叉树类型定义*/i n t M A X N U M/*完全二叉树中允许结点的最大个数*/i n t n;/*改造成完全二叉树后,结点的实际个数*/D a t a T y p e*n o d e l i s t;/*存放结点的数组*/};t y p e d e f s t r u c t S e q B i n T r e e*P S e q B i n T r e e;二、对称序线索化该二叉树及其周游的实现要按对称序周游对称序线索二叉树,首先找到对称序列中的第一个结点,然后依次找到结点的后继结点,直至其后继结点为空即可。
树和二叉树实验报告材料

树和二叉树一、实验目的1.掌握二叉树的结构特征,以及各种存储结构的特点及适用范围。
2.掌握用指针类型描述、访问和处理二叉树的运算。
二、实验要求1.认真阅读和掌握本实验的程序。
2.上机运行本程序。
3.保存和打印出程序的运行结果,并结合程序进行分析。
4.按照二叉树的操作需要,重新改写主程序并运行,打印出文件清单和运行结果。
三、实验内容1.输入字符序列,建立二叉链表。
2.按先序、中序和后序遍历二叉树(递归算法)。
3.按某种形式输出整棵二叉树。
4.求二叉树的高度。
5.求二叉树的叶节点个数。
6.交换二叉树的左右子树。
7.借助队列实现二叉树的层次遍历。
8.在主函数中设计一个简单的菜单,分别调试上述算法。
为了实现对二叉树的有关操作,首先要在计算机中建立所需的二叉树。
建立二叉树有各种不同的方法。
一种方法是利用二叉树的性质5来建立二叉树,输入数据时要将节点的序号(按满二叉树编号)和数据同时给出:(序号,数据元素0)。
另一种方法是主教材中介绍的方法,这是一个递归方法,与先序遍历有点相似。
数据的组织是先序的顺序,但是另有特点,当某结点的某孩子为空时以字符“#”来充当,也要输入。
若当前数据不为“#”,则申请一个结点存入当前数据。
递归调用建立函数,建立当前结点的左右子树。
四、解题思路1、先序遍历:○1访问根结点,○2先序遍历左子树,○3先序遍历右子树2、中序遍历:○1中序遍历左子树,○2访问根结点,○3中序遍历右子树3、后序遍历:○1后序遍历左子树,○2后序遍历右子树,○3访问根结点4、层次遍历算法:采用一个队列q,先将二叉树根结点入队列,然后退队列,输出该结点;若它有左子树,便将左子树根结点入队列;若它有右子树,便将右子树根结点入队列,直到队列空为止。
因为队列的特点是先进后出,所以能够达到按层次遍历二叉树的目的。
五、程序清单#include<stdio.h>#include<stdlib.h>#define M 100typedef char Etype; //定义二叉树结点值的类型为字符型typedef struct BiTNode //树结点结构{Etype data;struct BiTNode *lch,*rch;}BiTNode,*BiTree;BiTree que[M];int front=0,rear=0;//函数原型声明BiTNode *creat_bt1();BiTNode *creat_bt2();void preorder(BiTNode *p);void inorder(BiTNode *p);void postorder(BiTNode *p);void enqueue(BiTree);BiTree delqueue( );void levorder(BiTree);int treedepth(BiTree);void prtbtree(BiTree,int);void exchange(BiTree);int leafcount(BiTree);void paintleaf(BiTree);BiTNode *t;int count=0;//主函数void main(){char ch;int k;do{printf("\n\n\n");printf("\n===================主菜单===================");printf("\n\n 1.建立二叉树方法1");printf("\n\n 2.建立二叉树方法2");printf("\n\n 3.先序递归遍历二叉树");printf("\n\n 4.中序递归遍历二叉树");printf("\n\n 5.后序递归遍历二叉树");printf("\n\n 6.层次遍历二叉树");printf("\n\n 7.计算二叉树的高度");printf("\n\n 8.计算二叉树中叶结点个数");printf("\n\n 9.交换二叉树的左右子树");printf("\n\n 10.打印二叉树");printf("\n\n 0.结束程序运行");printf("\n============================================");printf("\n 请输入您的选择(0,1,2,3,4,5,6,7,8,9,10)");scanf("%d",&k);switch(k){case 1:t=creat_bt1( );break; //调用性质5建立二叉树算法case 2:printf("\n请输入二叉树各结点值:");fflush(stdin);t=creat_bt2();break; //调用递归建立二叉树算法case 3:if(t){printf("先序遍历二叉树:");preorder(t);printf("\n");}else printf("二叉树为空!\n");break;case 4:if(t){printf("中序遍历二叉树:");inorder(t);printf("\n");}else printf("二叉树为空!\n");break;case 5:if(t){printf("后序遍历二叉树:");postorder(t);printf("\n");}else printf("二叉树为空!\n");break;case 6:if(t){printf("层次遍历二叉树:");levorder(t);printf("\n");}else printf("二叉树为空!\n");break;case 7:if(t){printf("二叉树的高度为:%d",treedepth(t));printf("\n");}else printf("二叉树为空!\n");break;case 8:if(t){printf("二叉树的叶子结点数为:%d\n",leafcount(t));printf("二叉树的叶结点为:");paintleaf(t);printf("\n");}else printf("二叉树为空!\n");break;case 9:if(t){printf("交换二叉树的左右子树:\n");exchange(t);prtbtree(t,0);printf("\n");}else printf("二叉树为空!\n");break;case 10:if(t){printf("逆时针旋转90度输出的二叉树:\n");prtbtree(t,0);printf("\n");}else printf("二叉树为空!\n");break;case 0:exit(0);} //switch}while(k>=1&&k<=10);printf("\n再见!按回车键,返回…\n");ch=getchar();} //main//利用二叉树性质5,借助一维数组V建立二叉树BiTNode *creat_bt1(){ BiTNode *t,*p,*v[20];int i,j;Etype e;/*输入结点的序号i、结点的数据e*/printf("\n请输入二叉树各结点的编号和对应的值(如1,a):");scanf("%d,%c",&i,&e);while(i!=0&&e!='#') //当i为0,e为'#'时,结束循环{p=(BiTNode*)malloc(sizeof(BiTNode));p->data=e;p->lch=NULL;p->rch=NULL;v[i]=p;if(i==1)t=p; //序号为1的结点是根else{j=i/2;if(i%2==0)v[j]->lch=p; //序号为偶数,作为左孩子 else v[j]->rch=p; //序号为奇数,作为右孩子 }printf("\n请继续输入二叉树各结点的编号和对应的值:");scanf("%d,%c",&i,&e);}return(t);}//creat_bt1;//模仿先序递归遍历方法,建立二叉树BiTNode *creat_bt2(){BiTNode *t;Etype e;scanf("%c",&e);if(e=='#')t=NULL; //对于'#'值,不分配新结点else{t=(BiTNode *)malloc(sizeof(BiTNode));t->data=e;t->lch=creat_bt2(); //左孩子获得新指针值t->rch=creat_bt2(); //右孩子获得新指针值}return(t);} //creat_bt2//先序递归遍历二叉树void preorder(BiTNode *p){if(p){printf("%3c",p->data);preorder(p->lch);preorder(p->rch);}} //preorder//中序递归遍历二叉树void inorder(BiTNode *p){if(p){inorder(p->lch);printf("%3c",p->data);inorder(p->rch);}} //inorder//后序递归遍历二叉树void postorder(BiTNode *p){ if(p){ postorder(p->lch);postorder(p->rch);printf("%3c",p->data);}} //postordervoid enqueue(BiTree T){if(front!=(rear+1)%M){rear=(rear+1)%M;que[rear]=T;}}BiTree delqueue( ){if(front==rear)return NULL;front=(front+1)%M;return(que[front]);}void levorder(BiTree T) //层次遍历二叉树{BiTree p;if(T){enqueue(T);while(front!=rear){p=delqueue( );printf("%3d",p->data);if(p->lch!=NULL)enqueue(p->lch);if(p->rch!=NULL)enqueue(p->rch);}}}int treedepth(BiTree bt) //计算二叉树的高度{int hl,hr,max;if(bt!=NULL){ hl=treedepth(bt->lch);hr=treedepth(bt->rch);max=(hl>hr)?hl:hr;return (max+1);}else return (0);}void prtbtree(BiTree bt,int level) //逆时针旋转90度输出二叉树树形{int j;if(bt){prtbtree(bt->rch,level+1);for(j=0;j<=6*level;j++)printf(" ");printf("%c\n",bt->data);prtbtree(bt->lch,level+1);}}void exchange(BiTree bt) //交换二叉树左右子树{BiTree p;if(bt){p=bt->lch;bt->lch=bt->rch;bt->rch=p;exchange(bt->lch);exchange(bt->rch);}}int leafcount(BiTree bt) //计算叶结点数{if(bt!=NULL){leafcount(bt->lch);leafcount(bt->rch);if((bt->lch==NULL)&&(bt->rch==NULL))count++;}return(count);}void paintleaf(BiTree bt) //输出叶结点{if(bt!=NULL){if(bt->lch==NULL&&bt->rch==NULL)printf("%3c",bt->data);paintleaf(bt->lch);paintleaf(bt->rch);}}图11.2所示二叉树的输入数据顺序应该是:abd#g###ce#h##f##。
实验四二叉树的应用

实验四二叉树的应用一、实验目的1.进一步掌握指针变量的含义。
2.掌握二叉树的结构特征,以及各种存储结构的特点及使用范围。
3.掌握用指针类型描述、访问和处理二叉树的运算。
二、实验内容1,创建二叉树的二叉链表存储,并中序遍历显示。
参考下面提供的数据类型和函数。
typedef char elemtype;typedef struct BiTNode{elemtype data;struct BiTNode *lchild;*rchild; /*左右孩子指针*/}BiTNode,*BiTree;BiTree CreateBinTree(){/*以加入结点的先序序列输入,构造二叉链表*/BiTree T;elemtype ch;if(*s=='\0') T=NULL;ch=*s;s++;if (ch=='0') T=NULL; /*读入0时,将相应结点置空*/else {T=(BiTNode *)malloc(sizeof(BiTNode)); /*生成结点空间*/ T->data=ch;T->lchild=CreateBinTree(); /*构造二叉树的左子树*/T->rchild=CreateBinTree(); /*构造二叉树的右子树*/}return T;}2.统计其中结点数和叶子结点数;三、实验要求1. 写出C语言程序,并加注释。
2.按前序序列输入结点,AB00G000CE00F00,并说明0的作用;3. 按照你二叉树的操作需要,重新改写主程序并运行,打印出文件清单和运行结果4.收获体会。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验6:二叉树及其应用
一、实验目的
树是数据结构中应用极为广泛的非线性结构,本单元的实验达到熟悉二叉树的存储结构的特性,以及如何应用树结构解决具体问题。
二、问题描述
首先,掌握二叉树的各种存储结构和熟悉对二叉树的基本操作。
其次,以二叉树表示算术表达式的基础上,设计一个十进制的四则运算的计算器。
如算术表达式:a+b*(c-d)-e/f
三、实验要求
1、 如果利用完全二叉树的性质和二叉链表结构建立一棵二叉树,分别计算
a) 统计叶子结点的个数。
b) 求二叉树的深度。
2、 十进制的四则运算的计算器可以接收用户来自键盘的输入。
3、 由输入的表达式字符串动态生成算术表达式所对应的二叉树。
4、 自动完成求值运算和输出结果。
四、实验环境
PC 微机
DOS 操作系统或 Windows 操作系统
Turbo C 程序集成环境或 Visual C++ 程序集成环境
五、实验步骤
1、根据二叉树的各种存储结构建立二叉树;
2、设计求叶子结点个数算法和树的深度算法;
3、根据表达式建立相应的二叉树,生成表达式树的模块;
-
+
/
a
*
b
-
e
f
C
d
4、根据表达式树,求出表达式值,生成求值模块;
5、程序运行效果,测试数据分析算法。
六、功能分析
存储结构
typedef union{
int Operator; // 操作符
float Operand; // 操作数
}Int_Float;
//表达式树
typedef struct BinaryTreeNode{
Int_Float Data; //数据域
int IsOperator; //判断是不是操作数的标志位
struct BinaryTreeNode *RChild;//左子树
struct BinaryTreeNode *LChild;//右子树
}BiTreeNode, *lpBiTreeNode;
//栈的定义
typedef struct {
lpBiTreeNode *base;
lpBiTreeNode *top;
int stacksize;
}SqStack;
函数一览表
lpBiTreeNode GetTop( SqStack s );//取栈顶结点函数
int IsEmpty( SqStack s );//判空函数
int InitStack( SqStack &s );//初始化栈函数
int Pop( SqStack &s, lpBiTreeNode &e );//出栈函数
int Push( SqStack &s, lpBiTreeNode e );//入栈函数
int In( int c, int* op );// 判断c是否在op中
int Precede( int theta1, int theta2 );//比较运算符号的优先级
int isNum( int c );//判断是不是数
int GetInput(Int_Float *Result);//读入输入的数
lpBiTreeNode CreateBiTree();//创建二叉树
bool calculate(lpBiTreeNode Root, float *result);//计算二叉树化表达式的值int getLeafNum(lpBiTreeNode Root);//计算二叉树的叶子结点数
int getDepth(lpBiTreeNode Root);//计算二叉树的深度
计算叶子节点数的算法分析计算二叉树深度的算法分析
递归,核心在于
num=numleft+numright
Int num(二叉树 *p){
If(空树)return 0;
Else if(一个节点的树) return 1;
Else{
Return num(num(左子树)+num(右子树));}
}
递归,核心在于
depth=max(leftdepth,righydepth)+1
Int depth(二叉树 *p){
If(空树)return 0;
Else if(一个节点的树) return 1;
Else{
Return
max(depth(左子树),depth(右子树)+1);
}
}
七、程序代码
#include <stdio.h>
#include <malloc.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define ERROR 0
#define NUMBER 1
#define SIMBLE 2
int OP[8] = { '+', '-', '*', '/', '(', ')', '#', 0 };//运算符数组
//共用体
typedef union
{
int Operator; // 操作符
float Operand; // 操作数
}Int_Float;
//表达式树
typedef struct BinaryTreeNode
{
Int_Float Data; //数据域
int IsOperator; //判断是不是操作数的标志位
struct BinaryTreeNode *RChild;//左子树
struct BinaryTreeNode *LChild;//右子树
}BiTreeNode, *lpBiTreeNode;
//栈的定义
typedef struct {
lpBiTreeNode *base;
lpBiTreeNode *top;
int stacksize;
}SqStack;
//函数声明区
lpBiTreeNode GetTop( SqStack s );//取栈顶结点函数
int IsEmpty( SqStack s );//判空函数
int InitStack( SqStack &s );//初始化栈函数
int Pop( SqStack &s, lpBiTreeNode &e );//出栈函数
int Push( SqStack &s, lpBiTreeNode e );//入栈函数
int In( int c, int* op );// 判断c是否在op中
int Precede( int theta1, int theta2 );//比较运算符号的优先级
int isNum( int c );//判断是不是数
int GetInput(Int_Float *Result);//读入输入的数
lpBiTreeNode CreateBiTree();//创建二叉树
bool calculate(lpBiTreeNode Root, float *result);//计算二叉树化表达式的值int getLeafNum(lpBiTreeNode Root);//计算二叉树的叶子结点数
int getDepth(lpBiTreeNode Root);//计算二叉树的深度
int main()//主函数
{
lpBiTreeNode Root;//二叉树
float result; //表达式运算结果
if( Root = CreateBiTree() )//若创建二叉树失败则不会执行if操作
{
printf( "二叉树叶子数= %d\n", getLeafNum(Root) );。