实验3 树和二叉树
数据结构树和二叉树实验报告
树和二叉树
小组合作
否
姓名
班级
学 号
一、实验目的
(1)掌握树的相关概念,包括树、结点的度、树的度、分支结点、叶子结点、儿子结点、双亲结点、树的深度、森林等定义。
(2)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。
(3)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码产生方法。
二．实验环境
return 0;
}
假设二叉树采用二叉树链式存储结构，设计一个算法输出从根结点到每个叶子结点的路径之逆（因为树中路径是从根结点到其他结点的结点序列，就是求叶子结点及其双亲结点、该双亲结点的双亲结点，直到根结点的序列，或者说求叶子结点及其所有祖先结点的序列）。要求采用后根遍历非递归算法。
#include "stdafx.h"
AllPath1(b);
return 0;
}
设计一个算法将二叉树的顺序存储结构转换成二叉链式存储结构。
#include "stdafx.h"
#include "exam7-14.cpp"
int main(int argc, char* argv[])
{
int i,n=10;
BTNode *b;
SqBTree a;
#include "exam7-12.cpp"
int main(int argc, char* argv[])
{
BTNode *b;
CreateBTNode(b,"A(B(D(,G)),C(E,F))");
printf("b:");DispBTNode(b);printf("\n");
实验三--二叉树的基本运算
实验三二叉树的基本运算一、实验目的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;}四、调试结果及运行界面：五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用，这次实验的的确确的加深了我对它的理解。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构实验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.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。
树和二叉树的建立和遍历-数据结构试验报告
实验报告一：预习要求预习树和二叉树的存储结构、以递归为基本思想的相应遍历操作。
二：实验目的1、通过实验，掌握二叉树的建立与存储方法。
2、掌握二叉树的结构特性，以及各种存储结构的特点和适用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
4、理解huffman编解码的算法三：实验内容以括号表示法输入一棵二叉树，编写算法建立二叉树的二叉链表结构；编写先序、中序、后序、层次遍历二叉树的算法；编写算法计算二叉树的结点数，叶子结点数，以及二叉树的深度。
四:实验原理及试验方法ADT BinaryTree{数据对象：D：D是具有相同特征的数据元素的集合数据结构：R：若D= 空集，则R=空集，称BinaryTree为空二叉树；若D不等于空集，则R={H}，H是如下二元关系：（1）在D中存在唯一的称为根的数据元素root，它在关系H下无前驱；（2）若D-{root}不等于空集，则存在D-{root}={D1,Dr},且D1∩Dr=空集；（3）若D1不等于空集，则D1中存在唯一的元素x1，<root,x1>∈H，且存在D1上的关系H1包含于H；若Dr≠空集，则Dr中存在唯一的元素xr,<root,xr>∈H，且存在Dr上的关系Hr包含于H；H={<root,x1>,<root,xr>,H1,Hr};（4） (D1,{H1})是一颗符合本定义的二叉树，称为根的左子树，（Dr,{Hr}）是一颗符合本定义的二叉树，称为根的右子树。
基本操作P：CreateBiTree(&T,definition);初始条件：definition给出二叉树的定义。
操作结果：按definition构造二叉树T。
PreOrderTraverse(T);初始条件：二叉树T存在。
操作结果：先序遍历T 。
InOrderTraverse(T);初始条件：二叉树T存在。
操作结果：中序遍历T。
PostOrderTraverse(T);初始条件：二叉树T存在。
树和二叉树的实验报告
《数据结构》实验报告题目: 树和二叉树一、用二叉树来表示代数表达式（一）需求分析输入一个正确的代数表达式, 包括数字和用字母表示的数, 运算符号+ - * / ^ =及括号。
系统根据输入的表达式建立二叉树, 按照先括号里面的后括号外面的, 先乘后除的原则, 每个节点里放一个数字或一个字母或一个操作符, 括号不放在节点里。
分别先序遍历, 中序遍历, 后序遍历此二叉树, 并输出表达式的前缀式, 中缀式和后缀式。
（二）系统设计1.本程序中用到的所有抽象数据类型的定义；typedef struct BiNode //二叉树的存储类型{char s[20];struct BiNode *lchild,*rchild;}BiTNode,*BiTree;2.主程序的流程以及各程序模块之间的层次调用关系, 函数的调用关系图:3. 列出各个功能模块的主要功能及输入输出参数void push(char cc)初始条件: 输入表达式中的某个符号操作结果: 将输入的字符存入buf数组中去BiTree Create_RTree()初始条件: 给出二叉树的定义表达式操作结果：构造二叉树的右子树, 即存储表达式等号右侧的字符组BiTree Create_RootTree()初始条件: 给出二叉树的定义表达式操作结果：构造存储输入表达式的二叉树, 其中左子树存储‘X’, 根节点存储‘：=’void PreOrderTraverse(BiTree T)初始条件: 二叉树T存在操作结果：先序遍历T, 对每个节点调用函数Visit一次且仅一次void InOrderTraverse(BiTree T)初始条件: 二叉树T存在操作结果：中序遍历T, 对每个节点调用函数Visit一次且仅一次void PostOrderTraverse(BiTree T)初始条件: 二叉树T存在操作结果：后序遍历T, 对每个节点调用函数Visit一次且仅一次int main()主函数, 调用各方法, 操作成功后返回0（三）调试分析调试过程中还是出现了一些拼写错误, 经检查后都能及时修正。
树和二叉树的实验报告
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察，深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构，由节点和边组成。
每个节点可以有零个或多个子节点，其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中，我们使用Python语言构建了一棵树。
通过定义节点类和树类，我们可以方便地创建树的实例，并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式，并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类，我们可以创建二叉树的实例，并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如，二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用，并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验，我们成功构建了树和二叉树的数据结构，并实现了它们的基本操作。
通过观察和分析实验结果，我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题，例如搜索、排序、图算法等。
同时，我们也发现了一些问题和挑战，例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察，深入了解了树和二叉树的特性和操作。
树与二叉树实验
#include<iostream.h>
#include<malloc.h>
#define Maxsize 100
typedef struct TREE{
struct TREE *lTree;
struct TREE *rTree;
char data;
}Tree;
void InitTree(Tree*);//初始化树
2、赫夫曼编码的生成：利用以建好的赫夫曼树，对报文文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中；
3、编码文件的译码：利用已建好的赫夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。
实
验
结
果
（
截
图
表
示
）
1、以二叉链表方式建立二叉树，并任选一种遍历方式输出结点的值
2、哈夫曼编码
【实验目的】
了解赫夫曼树的结构特点及有关概念，掌握赫夫曼树的建立和赫夫曼编码的设计
【问题描述】
使用二叉树进行赫夫曼编码的设计，要求对输入的一串电文字符实现赫夫曼编码，再对赫夫编码生成的代码串进行译码，输出电文字符串
【实验功能】
1、赫夫曼树的建立：从终端读入字符集大小n，以及n个字符和n个权值，建立赫夫曼树，并将它存于文件hfmtree中；
}
else
i=0;
}
}
if(top!=0)
p=stack[top]->rTree;
else
p=NULL;
}
}
}
int DepthTree(Tree *tree) //深度函数
{
int u,v;
树和二叉树实验报告
树和二叉树、实验目的1. 掌握二叉树的结构特征，以及各种存储结构的特点及适用范围。
2. 掌握用指针类型描述、访问和处理二叉树的运算。
、实验要求1. 认真阅读和掌握本实验的程序。
2. 上机运行本程序。
3. 保存和打印出程序的运行结果，并结合程序进行分析。
4. 按照二叉树的操作需要，重新改写主程序并运行，打印出文件清单和运行结果。
、实验内容1. 输入字符序列，建立二叉链表。
2. 按先序、中序和后序遍历二叉树（递归算法）。
3. 按某种形式输出整棵二叉树。
4. 求二叉树的高度。
5. 求二叉树的叶节点个数。
6. 交换二叉树的左右子树。
7. 借助队列实现二叉树的层次遍历。
8. 在主函数中设计一个简单的菜单，分别调试上述算法。
为了实现对二叉树的有关操作，首先要在计算机中建立所需的二叉树。
建立二叉树有各种不同的方法。
一种方法是利用二叉树的性质5来建立二叉树，输入数据时要将节点的序号（按满二叉树编号）和数据同时给出：（序号，数据元素0）。
另一种方法是主教材中介绍的方法，这是一个递归方法，与先序遍历有点相似。
数据的组织是先序的顺序，但是另有特点，当某结点的某孩子为空时以字符“#”来充当，也要输入。
若当前数据不为“#”则申请一个结点存入当前数据。
递归调用建立函数，建立当前结点的左右子树。
四、解题思路1、先序遍历：O访问根结点，G先序遍历左子树，C3先序遍历右子树2、中序遍历：O中序遍历左子树，C2访问根结点，。
中序遍历右子树3、后序遍历：O后序遍历左子树，C2后序遍历右子树，C3访问根结点4、层次遍历算法：采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。
因为队列的特点是先进后出，所以能够达到按层次遍历二叉树的目的。
五、程序清单#in clude<stdio.h>#in clude<stdlib.h>#defi ne M 100typedef char Etype; //定义二叉树结点值的类型为字符型typedef struct BiTNode {//树结点结构Etype data;struct BiTNode *lch,*rch;}BiTNode,*BiTree;BiTree que[M];int fron t=0,rear=0;//函数原型声明BiTNode *creat_bt1();BiTNode *creat_bt2();void preorder(BiTNode *p);void ino rder(BiTNode *p);void postorder(BiTNode *p);void enq ueue(BiTree);BiTree delqueue();void levorder(BiTree);int treedepth(BiTree);void prtbtree(BiTree,i nt);void excha nge(BiTree);in t leafco un t(BiTree);void pain tleaf(BiTree);BiTNode *t;int coun t=0;//主函数void mai n（） {char ch;int k;do{prin tf（"\n\n\n"）;prin tf（"\n=================== 主菜单==================="）;prin tf（"\n\n 1.建立二叉树方法1"）;prin tf（"\n\n 2.建立二叉树方法2"）;prin tf（"\n\n 3•先序递归遍历二叉树”）；prin tf（"\n\n 4•中序递归遍历二叉树”）；prin tf（"\n\n 5.后序递归遍历二叉树”）；printf（"\n\n 6.层次遍历二叉树”）；prin tf（"\n\n 7.计算二叉树的高度”）；prin tf（"\n\n 8.计算二叉树中叶结点个数”）；prin tf（"\n\n 9.交换二叉树的左右子树”）；printf（"\n\n 10.打印二叉树”）；printf（"\n\n 0.结束程序运行”）；prin tf（"\n============================================"）;printf（"\n 请输入您的选择（0,1,2,3,4,5,6,7,8,9,10）"）;sea nf("%d",&k);switch(k){case 1:t=creat_bt1( );break; //调用性质5建立二叉树算法case 2:pri ntf("\n 请输入二叉树各结点值:");fflush(stdi n);t=creat_bt2();break; //调用递归建立二叉树算法case 3:if(t){printf("先序遍历二叉树:");preorder(t);prin tf("\n");}else printf(” 二叉树为空!\n");break;case 4:if(t){printf("中序遍历二叉树:");ino rder(t);prin tf("\n");}else printf("二叉树为空!\n");break;case 5:if(t)postorder(t);{printf("后序遍历二叉树:");prin tf("\n");}else printf(” 二叉树为空!\n");break;case 6:if(t){printf("层次遍历二叉树：");levorder(t);prin tf("\n");}else printf("二叉树为空！\n");break;case 7:if(t){printf("二叉树的高度为：％d",treedepth(t));prin tf("\n");}else printf("二叉树为空！\n");break;case 8:if(t){printf("二叉树的叶子结点数为：%d\n",leafcount(t));prin tf("\n");printf("二叉树的叶结点为：");pai ntleaf(t);else printf(” 二叉树为空！\n");break;case 9:if(t){printf("交换二叉树的左右子树：\n");excha nge(t);prtbtree(t,0);prin tf("\n");}else printf("二叉树为空！\n");break;case 10:if(t){printf("逆时针旋转90度输出的二叉树:\n");prtbtree(t,0);prin tf("\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];i nt i,j;Etype e;/*输入结点的序号i、结点的数据e*/printf("\n请输入二叉树各结点的编号和对应的值(如1，a)：");sca nf("%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请继续输入二叉树各结点的编号和对应的值：”);scan f("%d,%c"，&i, &e);}return(t);}//creat_bt1;//模仿先序递归遍历方法，建立二叉树BiTNode *creat_bt2(){BiTNode *t;Etype e;scan f("%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){prin tf("%3c",p->data);preorder(p_>lch);preorder(p->rch);}} //preorder〃中序递归遍历二叉树void ino rder(BiTNode *p){if(p){ino rder(p->lch);prin tf("%3c",p->data);ino rder(p->rch);}} //ino rder//后序递归遍历二叉树void postorder(BiTNode *p){ if(p){ postorder(p->lch);postorder(p->rch);prin tf("%3c",p->data);}} //postorder void enq ueue(BiTree T){if(fron t!=(rear+1)%M){rear=(rear+1)%M;que[rear]=T;}}BiTree delqueue(){if(fron t==rear)return NULL;fron t=(fro nt+1)%M;return(que[fro nt]);}void levorder(BiTree T)//层次遍历二叉树{BiTree p;if(T){enq ueue(T);while(fro nt!=rear){p=delqueue( );prin tf("%3d",p->data);if(p->lch!=NULL)e nqueue(p->lch); if(p->rch!=NULL)e nq ueue(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,i nt level)形{int j;if(bt){prtbtree(bt->rch,level+1);for(j=0;j<=6*level;j++)pri ntf(" ”)；prin tf("%c\n",bt->data);prtbtree(bt->lch,level+1);}}//计算二叉树的高度〃逆时针旋转90度输出二叉树树void excha nge(BiTree bt) // 交换二叉树左右子树{BiTree p;if(bt){p=bt->lch;bt->lch=bt->rch;bt->rch=p;excha nge(bt->lch);excha nge(bt->rch);}}in t leafcou nt(BiTree bt) // 计算叶结点数{if(bt!=NULL){leafc oun t(bt->lch);leafc oun t(bt->rch);if((bt->lch==NULL) &&(bt->rch==NULL))coun t++;}return(co unt);void pai ntleaf(BiTree bt) // 输出叶结点{if(bt!=NULL) {if(bt->lch==NULL&&bt->rch==NULL)prin tf("%3c",bt->data);pain tleaf(bt->lch);pain tleaf(bt->rch);}}图11.2所示二叉树的输入数据顺序应该是：abd#g###ce#h##f##图11.2 二叉树示意图运行结果:=================王采单1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 1请输入二叉树各结点的编号和对应的值(如1，a)：1，a 请继续输入二叉树各结点的编号和对应的值：2，b请继续输入二叉树各结点的编号和对应的值：3，c请继续输入二叉树各结点的编号和对应的值：4,d请继续输入二叉树各结点的编号和对应的值：6，e请继续输入二叉树各结点的编号和对应的值：7，f请继续输入二叉树各结点的编号和对应的值：9，g请继续输入二叉树各结点的编号和对应的值：13，h请继续输入二叉树各结点的编号和对应的值:===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 3先序遍历二叉树：abdgcehf===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 4中序遍历二叉树：dgbaehcf===================主菜单===================")；1. 建立二叉树方法12. 建立二叉树方法23. 先序递归遍历二叉树4. 中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 5后序遍历二叉树：gdbhefca===================主菜单===================")；1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 6层次遍历二叉树：97 98 99100101102103104===================主菜单===================")；1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 7 二叉树的高度为：4王采单 1. 建立二叉树方法 12. 建立二叉树方法 23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 8 二叉树的叶子结点数为：3二叉树的叶结点为： g h f1. 建立二叉树方法 12. 建立二叉树方法 23. 先序递归遍历二叉树===================王采单"); ”);4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 9交换二叉树的左右子树：dgbaehc===================王采单");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 10 逆时针旋转90度输出的二叉树：dgbaehc王采单”);1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 2请输入二叉树各结点值：abd#g###ce#h##f##===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 0请按任意键继续•• •六、调试心得及收获建立二叉树有两种方法：一种方法是利用二叉树的性质5来建立二叉树；另一种方法是主教材中介绍的方法，这是一个递归方法，与先序遍历有点相似。
二叉树实验报告
实验报告实验：树和二叉树一、实验目的：1.掌握二叉树的存储实现2.掌握二叉树的遍历思想3.掌握二叉树的常见算法的程序实现二、实验内容：1.编写函数,输入字符序列,建立二叉树的二叉链表。
2.编写函数,实现二叉树的中序递归遍历算法。
(最好也能实现前缀和后缀遍历算法)3.编写函数,实现二叉树的中序非递归遍历算法。
4.编写函数,借助队列实现二叉树的层次遍历算法。
5.编写函数,求二叉树的高度。
6.编写函数,求二叉树的结点个数。
7.编写函数,求二叉树的叶子个数。
8.编写函数,交换二叉树每个结点的左子树和右子树。
9.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。
三、方法与步骤：详见源代码。
四、小结：1.注意并理解了递归算法的执行步骤，使得编写程序时比较顺利，而且得到同学的帮助，减少了发生错误的次数，才使得报告能够顺利完成。
2.注意字符类型数据在输入时的处理，使输入没有错误。
3.重点理解利用栈结构实现非递归算法。
五、实验结果：实验报告源代码：#include"stdio.h"#include"malloc.h"#include"math.h"#define maxsize 100typedef struct btnode{char data;struct btnode *lc,*rc;}bitree;bitree *creat_bitree(bitree *p){char a;scanf("%c",&a);if(a!='#'){ p=(bitree *)malloc(sizeof(bitree));p->data=a;p->lc=creat_bitree(p->lc);p->rc=creat_bitree(p->rc);}elsep=NULL;return p;}void print1_bitree1(bitree *p){if(p==NULL)return ;printf("%c",p->data);print1_bitree1(p->lc);print1_bitree1(p->rc);}void print1_bitree2(bitree *p){if(p==NULL)return ;print1_bitree2(p->lc);printf("%c",p->data);print1_bitree2(p->rc);}void print1_bitree3(bitree *p) {if(p==NULL)return ;print1_bitree3(p->lc);print1_bitree3(p->rc);printf("%c",p->data);}int print2_bitree(bitree *p){int top=-1;bitree *a[maxsize];if(p==NULL) return 0;while(p!=NULL||top!=-1){while(p!=NULL){a[++top]=p;p=p->lc;}if(top<0)return 0;else{p=a[top--];printf("%c",p->data);p=p->rc;}}return 1;}int print3_bitree(bitree *p){int front=-1,rear=0;bitree *b[maxsize];if(p==NULL)return 0;b[rear]=p;while(front!=rear){p=b[++front];printf("%c",p->data);if(p->lc!=NULL)b[++rear]=p->lc;if(p->rc!=NULL)b[++rear]=p->rc;}return 1;}int jiedian_bitree(bitree *p,int a){if(p==NULL)return a;a++;a=jiedian_bitree(p->lc,a);a=jiedian_bitree(p->rc,a);return a;}int yezi_bitree(bitree *p){if(p==NULL)return 0;if(p->lc==NULL&&p->rc==NULL)return 1;return (yezi_bitree(p->lc)+yezi_bitree(p->rc)); }int depth(bitree *p){if(!p)return 0;else{int m=depth(p->lc);int n=depth(p->rc);return (m>n?m:n)+1;}}void change(bitree *p){bitree *q;if(!p)return;else{q=p->lc;p->lc=p->rc;p->rc=q;change(p->lc);change(p->rc);}}int main(){int x=8,a=0,i,j=0;bitree *p;p=NULL;while(x==8){printf("建立二叉链树，请输入字符\n");if(j==1){getchar();j=0;}p=creat_bitree(p);x=0;while(x!=8){ printf("***************************************************** *************************\n");printf("1.递归遍历\t2.中序非递归遍历\t3.层次遍历\t\t4.二叉树高度\n5.结点个数\t6.叶子个数\t\t7.交换每个结点左右子树\t8.重建二叉链树\n9.退出\n");scanf("%d",&x);switch(x){case 1:printf("1.先序2.中序3.后序");printf("\n");scanf("%d",&x);if(x==1)print1_bitree1(p);if(x==2)print1_bitree2(p);if(x==3)print1_bitree3(p);break;case 2:print2_bitree(p);break;case 3:print3_bitree(p);break;case 4:i=depth(p);printf("%d",i);break;case 5:a=jiedian_bitree(p,a);printf("%d",a);break;case 6:i=yezi_bitree(p);printf("%d",i);break;case 7:change(p);break;case 8:j=1;break;}if(x==9)break;printf("\n\n");}}return 0;}。
第六章 树和二叉树实验指导
实验一:二叉树的三种遍历方法的非递归实现要求:1各种遍历方法的实现方法(前序、中序、后序)2对应的测试函数,要求建立二叉树3.按照树旋转90度后打印显示二叉树4直接按照树的形状打印显示二叉树(层次遍历算法)实验二二叉排序树要求：1建立二叉排序树2建立好的二叉排序树进行中序遍历实验三Huffman编码的实现要求：1根据Huffman编码的原理,编写一个程序,由用户输入结点值和权值,输出它的Huffman编码.实验四建立一棵树要求1输入树的边建立对应的树，2输出从树根到所有的叶子结点的路径，3．同时分层输出树中所有的边作业1求二叉树中位于先序序列中第K个位置结点的值作业2计算二叉树中叶子结点的数目作业3二叉树中所有结点的左右子树进行交换作业4二叉树中结点元素值为x为根结点的子树的深度作业5二叉树中删除结点元素值为x为根结点的子树作业6利用顺序存储的完全二叉树建立二叉链表作业7求一棵以孩子兄弟链表表示的树的度作业8求一棵以孩子兄弟链表表示的树的叶子个个数作业9输出一棵以孩子兄弟链表表示的树中所有的边作业10按层次顺序（从左到右）遍历二叉树作业11逆转90度按层次顺序打印二叉树作业12一个堆中插入一个元素后调整为堆作业13判定给定的二叉树是否为二叉排序树以下定义保存在bittree.h#ifndef bitree#define bitreetypedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;#endif以下定义保存在sqstack.h#include <iostream.h>const STACK_INIT_SIZE=100;const STACKINCREMENT=10;#include "bittree.h"typedef BiTNode* SElemType;typedef struct{SElemType *elem;int top;int stacksize;int increment;}SqStack;//1.初始化栈void InitStack(SqStack &S , int maxsize=STACK_INIT_SIZE,int incresize=STACKINCREMENT){ S.elem=new SElemType[STACK_INIT_SIZE];S.top=-1;S.stacksize=maxsize;S. increment=incresize; }//让栈顶元素出栈bool Pop(SqStack &S,SElemType &e) {if(S.top==-1) return false;e=S.elem[S.top]; S.top--; return true; }//4。
实验3树和二叉树
实验3树和二叉树实验3 树和二叉树实验性质：验证性实验学时：4学时一、实验目的1.掌握二叉树的特点、在计算机中的存储表示方法及其基本操作的实现；2.能够利用二叉树求解一些常见问题。
二、实验预备知识1.阅读并掌握二叉树二叉链表存储方法的类型定义及其创建、遍历等基本操作。
2.阅读并掌握赫夫曼树的创建、赫夫曼编码的求得等基本操作。
三、实验内容1.理解并用二叉链表的操作运行下列程序：#includeusing namespace std;#include "Status.h"typedef char ElemType;#include "BiTree.h"void main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为："<<depth(t)<<endl;< p="">cout<<"二叉树中结点个数为："<<nodecount(t)<<endl;< p="">cout<<"二叉树中叶子结点个数为："<<leavesnodecount(t)<<endl;< p="">cout<<"先序遍历：";PreOrderTraverse(T);cout<<"\n中序遍历：";InOrderTraverse(T);cout<<"\n后序遍历：";PostOrderTraverse(T);cout<<endl;< p="">}本题目说明：（1）头文件Status.h的内容同实验1。
数据结构实验三树与二叉树的操作实验指导
实验六树与二叉树6.1实验目的：（1）掌握二叉树链表的结构和二叉树的建立过程；（2）掌握二叉树的基本操作，加深对二叉树的理解，逐步培养解决实际问题的编程能力。
6.2实验要求：（1）复习课本中有关树与二叉树的知识；（2）用C语言完成算法和程序设计并上机调试通过；（3）撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
6.3基础实验[实验1] 二叉树的构造实验内容与要求:按先序序列构造一棵二叉链表表示的二叉树T；分析:二叉树是每个结点至多只有两棵子树，并有左、右之分，顺序不能任意颠倒的一种非线性结构。
二叉树常用的存储结构是二叉链表形式，二叉链表由一个数据项data（用于存放结点的值）和两个指针项lchild、rchild（分别指向该结点的左、右子树）。
结点及结构如图6-1所示：//- - - - - - 二叉树的二叉链表存储表示模型- - - - - - -typedef struct BiTNode{TElemType data;Struct BiTNode * lchild, * rchild; //左右孩子指针}BiTNode, * BiTree;将此结构定义放在一个头文件BiTNode.h里，可避免在后面的参考程序中代码重复书写，另外在该头文件里给出二叉链表的初始化及常量的定义。
实现提示按先序序列建立一棵二叉树，先构造根结点，再构造根的左、右子树；每一棵子树又都是一颗二叉树，所以构造一棵子树的过程与构造整棵二叉树的过程完全相同，按照先序序列，先构造根，再构造左子树，然后构造右子树；采用递归形式直到叶子结点为止。
以下是算法描述：Status CreateBiTree(BiTree &T)//按先序次序输入二叉树中结点的值（一个字符），＃字符表示空树，//构造二叉链表表示的二叉树T。
实验3树和二叉树
实验3树和二叉树
实验3 树和二叉树
实验目的：
1、通过对二叉树特点的分析，掌握二叉树的主要存储结构；
2、在二叉树具体的存储结构基础上，实现二叉树的基本操作；
3、能针对二叉树的具体应用选择相应的存储结构；
4、进一步掌握递归算法的设计方法。
实验内容
一、假定二叉树采用二叉链表存储结构，编写程序实现二叉树的各种基本运算，
并在此基础上设计一个主程序完成如下功能：
（1）初始化二叉树T；
（2）输入扩展先序序列AB#DF###C#E## ，创建二叉树；
（3）输出二叉树的深度；
（4）输出二叉树的先序遍历序列；
（5）输出二叉树的中序遍历序列；
（6）输出二叉树的后序遍历序列；
（7）输出二叉树的层次遍历序列；
（8）统计二叉树中叶子结点的个数，并输出所有的叶子结点；
（9）交换二叉树的左右子树；
（10）输出二叉树的先序遍历序列；
（11）输出二叉树的中序遍历序列；
（12）输出二叉树的后序遍历序列；
（13）输出二叉树的层次遍历序列；
二、编写程序实现赫夫曼树和赫夫曼编码的各种基本运算，并在此基础上设计一
个主程序完成如下功能：
（1）输入n个字符及其权值，建立赫夫曼树；
字符 A B C D E F G H
权值 5 29 7 8 14 23 3 11
（2）输出每个字符对应的赫夫曼编码；
（3）输入正文FACE，输出其编码；（4）输入编码101101111，输出其正文；。
实验报告 实验三 二叉排序树的建立和查找
实验三二叉排序树的建立和查找一、实验目的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.编写函数,实现二叉树的中序非递归遍历算法。
4.编写函数,借助队列实现二叉树的层次遍历算法。
5.编写函数,求二叉树的高度。
6.编写函数,求二叉树的结点个数。
7.编写函数,求二叉树的叶子个数。
8.编写函数,交换二叉树每个结点的左子树和右子树。
9.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。
●实验目的及要求：1.掌握二叉树的存储实现2.掌握二叉树的遍历思想3.掌握二叉树的常见算法的程序实现●实验内容、方法与步骤：（使用附页填写并附在本页后）见附页●实验结果：见附页●小结：通过本次实验，我基本掌握了二叉树的存储实现和二叉树的遍历思想，并且实现了二叉树的几种常见算法。
分数：批阅老师：200 年月日第 1 页/ 共13 页实验报告（附页）#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int status;typedef struct BiNode//二叉链表{char Data;struct BiNode* lChild;struct BiNode* rChild;}BiNode,*pBiNode;typedef struct SNode/*链栈的结点类型*/{pBiNode elem; /*栈中的元素是指向二叉链表结点的指针*/struct SNode *next;}SNode;struct link //队列链表{struct BiNode *p;struct link *next;};status CreateTree(BiNode** pTree);status PreOrderTraval(BiNode* pTree);//前序递归status InOrderTraval(BiNode* pTree);//中序递归status PostOrderTraval(BiNode* pTree);//后序递归status st_InOrderTraverse(BiNode* pTree);//中序非递归遍历void TreeLink(BiNode* pTree); //队列实现层次遍历int TreeHeight (BiNode* pTree);//二叉树的高度int Count(BiNode* pTree);//结点个数int TreeNumber(BiNode* pTree);//叶子个数void Exchange (BiNode* pTree);//交换左右子树status Visit(char Data);void Display(BiNode* pTree,int Level);BiNode *pRoot=NULL;status CreateTree(BiNode** pTree) /*Input Example: abd##e##cf##g##*/ {char ch;scanf("%c",&ch);if(ch=='#'){(*pTree)=NULL;}else{if(!((*pTree)=(BiNode*)malloc(sizeof(BiNode)))) {exit(OVERFLOW);}(*pTree)->Data=ch;CreateTree(&((*pTree)->lChild));CreateTree(&((*pTree)->rChild));}return OK;}status PreOrderTraval(BiNode* pTree)//前序递归{if(pTree){if(Visit(pTree->Data)){if(PreOrderTraval(pTree->lChild)){if(PreOrderTraval(pTree->rChild)){return OK;}}}return ERROR;}else{return OK;}}status InOrderTraval(BiNode* pTree)//中序递归{if(pTree){if(InOrderTraval(pTree->lChild)){if(Visit(pTree->Data)){if(InOrderTraval(pTree->rChild)){return OK;}}return ERROR;}return ERROR;}else{return OK;}}status PostOrderTraval(BiNode* pTree)//后序递归{if(pTree){if(PostOrderTraval(pTree->lChild)){if(PostOrderTraval(pTree->rChild)){if(Visit(pTree->Data)){return OK;}return ERROR;}}return ERROR;}else{return OK;}}status st_InOrderTraverse(BiNode* pTree)//中序非递归遍历{BiNode *p;SNode *q,*Stop=NULL; /*用不带头结点的单链表作为栈的存储结构*/ p=pTree;while(p!=NULL||Stop!=NULL) /*不是空树*/{if(p!=NULL){q=(SNode*)malloc(sizeof(SNode));if(q==NULL)return ERROR;q->next=Stop;q->elem=p;Stop=q; /*根结点指针入栈*/p=p->lChild; /*进入根的左子树*/}else{q=Stop;Stop=Stop->next; /*栈顶元素出栈*/printf("%c ",q->elem->Data);/*访问根结点*/p=q->elem->rChild; /*进入根的右子树*/free(q); /*释放原栈顶元素的结点空间*/}}return OK;}void TreeLink(BiNode* pTree) //队列实现层次遍历{struct link *head,*rear,*temp;head=(struct link *)malloc(sizeof(struct link));head->p=pTree;head->next=NULL;rear=head;do{if(head->p->lChild!=NULL){temp=(struct link *)malloc(sizeof(struct link));temp->p=head->p->lChild;temp->next=NULL;rear->next=temp;rear=temp;}if(head->p->rChild!=NULL){temp=(struct link *)malloc(sizeof(struct link));temp->p=head->p->rChild;temp->next=NULL;rear->next=temp;rear=temp;}temp=head;printf("%c ",head->p->Data);head=head->next;free(temp);}while(head!=NULL);}int TreeHeight(BiNode* pTree)//二叉树的高度{int hl ,hr ; //左右子树的高度if (pTree == NULL)return 0 ;elsehl = TreeHeight(pTree-> lChild);hr = TreeHeight (pTree-> rChild);if (hl>hr)return (hl +1);elsereturn (hr +1);}int Count(BiNode* pTree)//结点个数{return pTree == NULL ? 0 : Count(pTree->lChild) + Count(pTree->rChild) + 1;}int TreeNumber(BiNode* pTree)//叶子个数{if (pTree==NULL)return 0;if (pTree->lChild ==NULL && pTree->rChild == NULL)return 1;return TreeNumber(pTree->lChild)+TreeNumber(pTree->rChild);//+1就可以求出结点个数}void Exchange (BiNode* pTree )//交换左右子树{BiNode* temp;if ( pTree->lChild != NULL || pTree->rChild != NULL ){temp = pTree->lChild;pTree->lChild = pTree->rChild;pTree->rChild = temp;Exchange ( pTree->lChild );Exchange ( pTree->rChild );}}status Visit(char Data){printf("%c ",Data);return OK;}void Display(BiNode* pTree,int Level)//显示整个树{int i;if(pTree==NULL) return;Display(pTree->rChild,Level+1);for(i=0;i<Level-1;i++){printf(" ");}if(Level>=1){printf("--");}printf("%c\n",pTree->Data);Display(pTree->lChild,Level+1);}void CmdList() //显示命令列表{printf("\n_____________________________________________\n");printf(" 请选择操作: \n");printf(" 1.前序递归遍历\n"); //前序递归遍历printf(" 2.中序递归遍历\n"); //中序递归遍历printf(" 3.后序递归遍历\n"); //后序递归遍历printf(" 4.中序非递归遍历\n"); //中序非递归遍历printf(" 5.层次遍历\n"); //层次遍历printf(" 6.求二叉树高度\n"); //二叉树高度printf(" 7.求结点个数\n"); //二叉树的结点个数printf(" 8.求叶子个数\n"); //二叉树的叶子个数printf(" 9.交换左右子树\n"); //交换左右子树printf(" 0.退出程序\n"); //退出printf("\n______________________________________________\n");}void init(){system ("cls");printf("* * * * * * * * * * * * * * * * * * * * * * * * *\n");printf("实验三树和二叉树\n");printf("03计本3班\n");printf("樊海军 2B0324151138\n");printf("* * * * * * * * * * * * * * * * * * * * * * * * *\n");printf("本程序实现二叉树的常见算法。
实验三二叉树及其操作算法实现
和右子树的互不相交的二叉树构成。
满二叉树
种类： 完全二叉树、非完全二叉树 平衡二叉树、非平衡二叉树
二叉树的性质
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");
实验三 树和二叉树的建立和应用
实验三 二叉树的建立和应用
1、实验目的
（1）熟练掌握树的基本概念、二叉树的基本操作及在链式存储结构上的实现；
（2）重点掌握二叉树的生成、遍历及求叶子结点算法；
（3）掌握运用递归方式描述算法及编写递归C 程序的方法，提高算法分析和程序设计能力。
2、实验内容
1）按照已知二叉树，从键盘读入节点字符，建立二叉树（例如，ABD#G###CE##FH###） 2）分别采用先序、中序、后序及层次遍历该二叉树，分别输出遍历结果。
3）应用：求出该数的叶子结点数。
3、实验步骤
（1）仔细分析实验内容，给出其算法和流程图；
（2）用C 语言实现该算法；
（3）给出测试数据，并分析其结果；
（4）在实验报告册上写出实验过程。
4、测试数据 1）所创建的树如右图所示：
2）遍历结果： 先序序列： ABDGCEFH
中序序列： DGBAECHF
后序序列： GDBEHFCA 层次遍历：ABCDEFGH
3）叶子结点数：3
5、树的结点结构定义如下： typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
6、实验报告要求
实验三 二叉树的建立和应用
G H B C D E F A
姓名：班级：学号：日期：实验目的：
实验内容：
基本思想、原理和算法描述：
源程序：
运行结果分析：
实验总结：。
实习三 树与二叉树
实习三树与二叉树一、实习目的1.熟练掌握二叉树在二叉链表存储结构中的常用遍历方法：先序递归遍历、中序递归和非递归遍历、后序递归遍历。
了解二叉树的按层遍历、先序非递归遍历及后序递归遍历。
2.用树解决实际问题，如哈夫曼编码等。
加深对“数据结构+算法=程序”的理解和认识，提高编写较复杂程序的能力。
二、实例1. 二叉树的建立和遍历。
为了实现对二叉树的有关操作，首先要在计算机中建立所需的二叉树。
建立二叉树有各种不同的方法。
有一种方法利用二叉树的性质5来建立二叉树，输入数据时需要将结点的序号（按满二叉树编号）和数据同时给出：序号数据元素。
结合下图的二叉树数的输入据顺序应该是：1 1，2 2，3 3，4 4，6 5，7 6，11 7，12 8，13 9。
另一种算法是教材P58～P59介绍的方法，这是一个递归方法，与先序遍历有点相似。
数据的组织时先序的顺序，但是另有特点，当某结点的某孩子为空时以数据0来充当，也要输入。
结合下图的二叉树数的输入据顺序应该是：1 2 4 0 0 0 3 5 0 7 0 0 6 8 0 0 9 0 0。
若当前数据不为0，则申请一个结点存入当前数据。
递归调用建立函数，建立当前结点的左右子树。
下列程序中的统计二叉树结点的函数，是对二叉树遍历方法的应用，请认真理解然后模仿练习。
# include <stdio.h># include <stdlib.h>typedef int Etype;typedef struct BiTNode /* 树结点结构 */{ Etype data;struct BiTNode *lch,*rch;}BiTNode;/* 函数原形声明 */BiTNode *creat_bt1();BiTNode *creat_bt2()void inorder(BiTNode *p);void numb(BiTNode *p);BiTNode *t; int n,n0,n1,n2,;/* 主函数 */main(){ char ch; int k;do { printf("\n\n\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======================================");printf("\n 请输入您的选择 (1,2,3,4,5,6)"); scanf("%d",&k); switch(k){ case 1:t=creat_bt1( );break; /* 调用性质5建立二叉树算法 */case 2:t=creat_bt2( );break; /* 调用递归建立二叉树算法 */case 3: { inorder(t); /* 调用中序遍历 */printf("\n\n 打回车键，继续。
数据结构实验三二叉树实验报告
数据结构实验报告实验名称：实验三——二叉树学生姓名： 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)。
实验3 树和二叉树
实验性质：验证性
实验学时：4学时
一、实验目的
1.掌握二叉树的特点、在计算机中的存储表示方法及其基本操作的实现；
2.能够利用二叉树求解一些常见问题。
二、实验预备知识
1.阅读并掌握二叉树二叉链表存储方法的类型定义及其创建、遍历等基本操作。
2.阅读并掌握赫夫曼树的创建、赫夫曼编码的求得等基本操作。
三、实验内容
1.理解并用二叉链表的操作运行下列程序：
#include <iostream>
using namespace std;
#include "Status.h"
typedef char ElemType;
#include "BiTree.h"
void main()
{
BiTree T;
CreateBiTree(T);
cout<<"二叉树的深度为："<<Depth(T)<<endl;
cout<<"二叉树中结点个数为："<<NodeCount(T)<<endl;
cout<<"二叉树中叶子结点个数为："<<LeavesNodeCount(T)<<endl;
cout<<"先序遍历：";
PreOrderTraverse(T);
cout<<"\n中序遍历：";
InOrderTraverse(T);
cout<<"\n后序遍历：";
PostOrderTraverse(T);
cout<<endl;
}
本题目说明：
（1）头文件Status.h的内容同实验1。
（2）头文件BiTree.h（内容包括二叉树的二叉链表中结点的结构定义及二叉链表
基本操作的实现）。
（3）基本操作的补充：
LeavesNodeCount(T)：二叉树中叶子结点的个数。
int LeavesNodeCount(BiTree T)
{
if(!T) return 0;
else if(!T->lchild&&!T->rchild) return 1;
else return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);
}
2.已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05，0.29，0.07，
0.08，0.14，0.23，0.03，0.11，试编写算法求其赫夫曼编码。