数据结构实验三-二叉树的实现2017
数据结构实验报告3-二叉树
北京物资学院信息学院实验报告课程名数据结构(C++)实验实验名称二叉树算法的实现实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ _______ 学号___一、实验目的1.掌握二叉树的存储的结构；2. 掌握建立二叉树的算法；3. 掌握对二叉树的遍历算法；4. 掌握二叉搜索树的算法；5. 掌握建立哈夫曼树和哈夫曼编码的算法；二、实验内容基本部分1. 采用广义表形式建立二叉树(参考图5-11(a)和/或图5-13(a))；2. 对已建立的二叉树，进行先、中、后序和按层遍历；3. 用广义表形式输出二叉树；4. 【习题5-3】1, 2 (2题选作)【提示：参考递归遍历算法】；特殊二叉树部分1．用插入算法建立一棵二叉搜索树，原始数据为：{30,50,20,40,25,70,54,23,80,92}，并中序遍历该树、查找其中的元素；2. 构造一棵叶子结点权值分别为3，5，6，7，9，13，21的哈夫曼树；3. 对2题进行哈夫曼编码。
三、实验地点与环境3.1 实验地点(南实验楼教室)3.2实验环境(所用语言环境)四、实验步骤1.2.3.…五、实验结果与分析5.1 实验结果(原始数据，预期结果和运行结果)序号算法名称(函数名) 所在头文件名原始数据与与功能主函数所在文件名运行结果*1 函数名：功能：头文件：CPP文件：原始数据：运行结果：23* 如果不能按“原始数据”、“运行结果”列出数据则不列，必要时在“分析”部分说明5.2 分析（选择部分算法分析，包括函数参数说明、调试中所遇到的问题和解决方法、中间结果等，必要时给出函数和主函数的关键段落。
所选算法应是：重要的算法、有编程特点的算法等）六、小结（收获与心得）。
实验三 二叉树
实验三二叉树
一、实验目的
1．掌握二叉树的链式存储结构及其相关操作的实现。
2．掌握二叉树的先序、中序、后序的递归遍历算法。
3．理解二叉树的各种非递归遍历算法的实现。
二、实验要求
1．实验前做好充分准备，包括复习第六章所学内容，事先预习好本次实验内容。
2．实验时记录实验结果，按要求完成各题。
3．实验结束后，给出实验总结与分析并及时给出本次实验的实验报告。
三、实验题目
本次实验给出的选定题目如下表所示。
说明：
（1）实验内容1）为必做内容。
（2）实验内容2）与实验内容3）为选做内容。
四、实验内容与要求
1、实验题目一：（1）二叉树的创建、递归遍历及其它基本操作的实现。
要求：定义用二叉链表表示的二叉树，并实现二叉树的创建、遍历（先序、中序后序）的递归算法及求深度操作等，并对其进行验证。
2、实验题目二：二叉树非递归遍历算法的实现
要求：在题目一的基础上，实现二叉树的非递归遍历算法（先序、中序、后序或按层），并对其进行验证。
3、实验题目三：哈夫曼树及哈夫曼编码的算法实现
要求：编程实现哈夫曼树的创建及利用哈夫曼树求解哈夫曼编码。
实验三--二叉树的基本运算
实验三二叉树的基本运算一、实验目的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;}四、调试结果及运行界面：五、实验心得通过这次程序上机实验让我认识到了以前还不太了解的二叉树的性质和作用，这次实验的的确确的加深了我对它的理解。
数据结构实验3二叉树
}
else
{
Q->front=(Q->front+1)%MAXSIZE;
*x=Q->data[Q->front];
return1;
}
}
voiddestory_seqqueue(Pseqqueue*Q)
{
if(*Q)
free(*Q);
*Q=NULL;
}
voidPreOrder(BTreet)
一、 实验目的
1． 进一步掌握指针变量的含义。
2． 掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。
3． 掌握用指针类型描述、访问和处理二叉树的运算。
二、 实验要求
1． 认真阅读和掌握本实验的参考程序。
2． 按照对二叉树的操作需要，在创建好二叉树后再通过遍历算法验证创建结果。
3． 保存程序的运行结果，并结合程序进行分析。
}SeqStack,*PSeqStack;
PSeqStackInit(void)
{
PSeqStackS;
S=((PSeqStack)malloc(sizeof(SeqStack)));
if(S)
{
S->top=-1;
returnS;
}
}
intEmpty(PSeqStackS)
{
if(S->top==-1)
{
inth1,h2;
if(t==NULL) return 0;
else
{
h1=Height(t->lchild);
h2=Height(t->rchild);
if(h1>h2) return h1+1;
数据结构实验报告 二叉树
数据结构实验报告二叉树数据结构实验报告：二叉树引言：数据结构是计算机科学中的重要基础，它为我们提供了存储和组织数据的方式。
二叉树作为一种常见的数据结构，广泛应用于各个领域。
本次实验旨在通过实践，深入理解二叉树的概念、性质和操作。
一、二叉树的定义与性质1.1 定义二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树可以为空树，也可以是由根节点和左右子树组成的非空树。
1.2 基本性质（1）每个节点最多有两个子节点；（2）左子树和右子树是有顺序的，不能颠倒；（3）二叉树的子树仍然是二叉树。
二、二叉树的遍历2.1 前序遍历前序遍历是指首先访问根节点，然后按照先左后右的顺序遍历左右子树。
在实际应用中，前序遍历常用于复制一颗二叉树或创建二叉树的副本。
2.2 中序遍历中序遍历是指按照先左后根再右的顺序遍历二叉树。
中序遍历的结果是一个有序序列，因此在二叉搜索树中特别有用。
2.3 后序遍历后序遍历是指按照先左后右再根的顺序遍历二叉树。
后序遍历常用于计算二叉树的表达式或释放二叉树的内存。
三、二叉树的实现与应用3.1 二叉树的存储结构二叉树的存储可以使用链式存储或顺序存储。
链式存储使用节点指针连接各个节点，而顺序存储则使用数组来表示二叉树。
3.2 二叉树的应用（1）二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树上的节点都小于根节点，右子树上的节点都大于根节点。
二叉搜索树常用于实现查找、插入和删除等操作。
（2）堆：堆是一种特殊的二叉树，它满足堆序性质。
堆常用于实现优先队列，如操作系统中的进程调度。
（3）哈夫曼树：哈夫曼树是一种带权路径最短的二叉树，常用于数据压缩和编码。
四、实验结果与总结通过本次实验，我成功实现了二叉树的基本操作，包括创建二叉树、遍历二叉树和查找节点等。
在实践中，我进一步理解了二叉树的定义、性质和应用。
二叉树作为一种重要的数据结构，在计算机科学中有着广泛的应用，对于提高算法效率和解决实际问题具有重要意义。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构实验 二叉树的操作
实验三二叉树的操作一、实验目的1、掌握二叉树的逻辑结构；2、掌握二叉树的二叉链表存储结构；3、掌握基于二叉链表存储的二叉树的遍历操作的实现。
二、实验内容1、采用二叉链表存储建立一棵含有n个结点的二叉树；2、前序打印该二叉树的所有叶子结点；3、统计该二叉树的结点个数；4、计算该二叉树的深度；5、交换该二叉树的所有左右子树。
三、程序实现1、二叉链表结点类型BiNode.htemplate<class T>struct BiNode{T data;BiNode<T> *lchild,*rchild;};2、二叉树的建立及操作BiTree.htemplate<class T>struct BiNode{T data;BiNode<T> *lchild,*rchild;};template <class T>class BiTree{public:BiTree( ); //构造函数，初始化一棵二叉树，其前序序列由键盘输入~BiTree(); //析构函数，释放二叉链表中各结点的存储空间BiNode<T>* Getroot(); //获得指向根结点的指针void PreOrder(BiNode<T> *root); //前序遍历二叉树void InOrder(BiNode<T> *root); //中序遍历二叉树void PostOrder(BiNode<T> *root); //后序遍历二叉树void LevelOrder(BiNode<T> *root); //层序遍历二叉树private:BiNode<T> *root; //指向根结点的头指针BiNode<T>* Creat(); //有参构造函数调用void Release(BiNode<T> *root); //析构函数调用};template<class T>BiTree<T>::BiTree(){cout<<"请按前根序输入该二叉树的各个结点(#号表示为空):\n";this->root=Creat();}template <class T>BiNode<T>* BiTree<T>::Creat(){BiNode<T> *root;T ch;cin>>ch;if (ch=='#') root = NULL;else{root = new BiNode<T>; //生成一个结点root->data=ch;root->lchild=Creat(); //递归建立左子树root->rchild=Creat(); //递归建立右子树}return root;}template<class T>BiTree<T>::~BiTree(){Release(root);}template<class T>BiNode<T>* BiTree<T>::Getroot( ){return root;}template<class T>void BiTree<T>::PreOrder(BiNode<T> *root){if(root==NULL) return;else{cout<<root->data<<" ";PreOrder(root->lchild);PreOrder(root->rchild);}}template <class T>void BiTree<T>::InOrder (BiNode<T> *root){if (root==NULL) return; //递归调用的结束条件else{InOrder(root->lchild); //中序递归遍历root的左子树cout<<root->data<<" "; //访问根结点的数据域InOrder(root->rchild); //中序递归遍历root的右子树}}template <class T>void BiTree<T>::PostOrder(BiNode<T> *root){if (root==NULL) return; //递归调用的结束条件else{PostOrder(root->lchild); //后序递归遍历root的左子树PostOrder(root->rchild); //后序递归遍历root的右子树cout<<root->data<<" "; //访问根结点的数据域}}template <class T>void BiTree<T>::LevelOrder(BiNode<T> *root){const int MaxSize = 100;int front = 0;int rear = 0; //采用顺序队列，并假定不会发生上溢BiNode<T>* Q[MaxSize];BiNode<T>* q;if (root==NULL) return;else{Q[rear++] = root;while (front != rear){q = Q[front++];cout<<q->data<<" ";if (q->lchild != NULL) Q[rear++] = q->lchild;if (q->rchild != NULL) Q[rear++] = q->rchild;}}}template<class T>void BiTree<T>::Release(BiNode<T>* root){if (root != NULL){Release(root->lchild); //释放左子树Release(root->rchild); //释放右子树delete root;}}3、主程序实现#include<iostream.h>#include "BiTree.h"int SumNode(BiNode<char> *root)//统计二叉树结点个数{int sum;if(root==NULL)return 0;else{sum=SumNode(root->lchild)+1;sum+=SumNode(root->rchild);return sum;}}void PrePrint(BiNode<char> *root)//前序打印二叉树叶子结点{if(root==NULL) return;else{if(root->lchild==NULL&&root->rchild==NULL)cout<<root->data<<' ';PrePrint(root->lchild);PrePrint(root->rchild);}}int TreeDeepth(BiNode<char> *root)//计算二叉树的深度{int deepth;if(root==NULL) return 0;else{deepth=(TreeDeepth(root->lchild)+1)>(TreeDeepth(root->rchild)+1)?(TreeDeepth(root->lchi ld)+1):(TreeDeepth(root->rchild)+1);return deepth;}}void Changechild(BiNode<char> *root)//交换二叉树的所有左右子树{BiNode<char> *temp;if(root==NULL||(root->lchild==NULL&&root->rchild==NULL)) return;else{Changechild(root->lchild);Changechild(root->rchild);if(root->lchild==NULL){root->lchild=root->rchild;root->rchild=NULL;}if(root->rchild==NULL){root->rchild=root->lchild;root->lchild=NULL;}else{temp=root->lchild;root->lchild=root->rchild;root->rchild=temp;}}}void main(){BiTree<char> Q;int deepth,sum;cout<<"Q的前序遍历为:\n";Q.PreOrder(Q.Getroot());cout<<"\nQ的中序遍历为:\n";Q.InOrder(Q.Getroot());cout<<"\nQ的后序遍历为:\n";Q.PostOrder(Q.Getroot());cout<<"\nQ的层序遍历为:\n";Q.LevelOrder(Q.Getroot());sum=SumNode(Q.Getroot());cout<<"\n结点个数为:"<<sum<<endl;deepth=TreeDeepth(Q.Getroot());cout<<"该二叉树的深度为:"<<deepth<<endl;cout<<"该二叉树叶子结点的前序打印顺序为:"<<'\n';PrePrint(Q.Getroot());cout<<"\n交换前二叉树的层序遍历为:\n";Q.LevelOrder(Q.Getroot());Changechild(Q.Getroot());cout<<"\n交换后二叉树的层序遍历为:\n";Q.LevelOrder(Q.Getroot());cout<<endl;}四、运行结果输入的二叉树结点的前根序序列为：ABDG##H##E#I##CF#J###二叉树形式为 AB CD E FG H I运行结果：五、实验心得体会通过本次实验过程，自己熟悉了二叉树的一些基本操作，掌握二叉树的逻辑结构；二叉树的二叉链表存储结构；熟悉了基于二叉链表存储的二叉树的遍历操作。
数据结构课程设计实验报告二叉树的实现
《数据结构》实验报告题目:_二叉树的实现学号:___ ____姓名:____ ___东南大学成贤学院计算机系实验题目一、实验目的1.掌握二叉树的基本操作，理解递归算法。
二、实验内容1．将下图所示二叉树采用二叉链表进行存储，然后进行各种操作测试。
三、实验步骤1.启动：开始菜单→程序→Microsoft Visual Studio 6.0 →2.建立工程：文件（File）→新建（new）→在弹出的对话框中选择工程标签（Project）→选中选项：Win32 Console Application（不能选别的）→输入工程名（Project Name）→选择工程的存放位置（Location）→单击“确定”按钮（OK）→在弹出的对话框中选中选项：An Empty Project→单击“完成”按钮（Finish）→在弹出的对话框中单击“确定”按钮（ OK ）。
3.创建头文件：文件（File）→新建（new）→在弹出的对话框中选择文件标签（Files）→选中选项：C/C++ Header File→输入头文件名（此处定义为“”）→单击“确定”按钮（OK）。
内容如下：// 二叉树结点类模板template <class ElemType>struct BinTreeNode{// 数据成员:ElemType data; // 数据域BinTreeNode<ElemType> *leftChild; // 左孩子BinTreeNode<ElemType> *rightChild; // 右孩子};4.创建头文件：文件（File）→新建（new）→在弹出的对话框中选择文件标签（Files）→选中选项：C/C++ Header File→输入头文件名（此处定义为“”）→单击“确定”按钮（OK）。
定义了链队的类模板，代码如下：#ifndef __BINNARY_TREE_H__#define __BINNARY_TREE_H__// 二叉树类模板template <class ElemType>class BinaryTree{private:// 二叉树的数据成员:BinTreeNode<ElemType> *root;// 二叉树的私有函数:void PreOrderHelp(BinTreeNode<ElemType> *r); // 先序遍历void InOrderHelp(BinTreeNode<ElemType> *r); // 中序遍历void PostOrderHelp(BinTreeNode<ElemType> *r);// 后序遍历void Creat(BinTreeNode<ElemType> *r,int flag, ElemType empty, ElemType end);//递归创建子树BinTreeNode<ElemType> *GetRoot(); //返回根指针BinTreeNode<ElemType> *Locate(BinTreeNode<ElemType> *r,ElemType e); //查找元素值为e的结点,返回指针.BinTreeNode<ElemType>* LeftChild(ElemType e);//定位指定元素的左孩子，返回其指针。
数据结构实验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.利用递归实现前后序遍历，思路简洁，仅需要调整递归体的执行顺序即可实现。
数据结构实验报告3-二叉树
使用微机、Java开发环境
三、实验内容及步骤〔包含简要的实验步骤流程〕
采用二叉树的二叉链存储构造，完成如下功能：
（1）编写一个Java程序，设计并实现二叉树的结点类。
（2）编写一个Java程序，在二叉树的结点类的根底上，设计并实现二叉树类,其中包含由先根遍历序列和中根遍历序列建立二叉树的算法。
（5）屡次运行程序，对不同的二叉树验证程序的运行结果。
四、实验结果〔包括程序或图表、结论陈述、数据记录及分析等，可附页〕
成功编译。
五、实验总结〔包括心得体会、问题答复及实验改进意见，可附页〕
答:通过这次试验，我充分理解二叉树的二叉链存储构造，掌握在这种存储构造下二叉树的构造及各种根本操作的实现。
六、教师评语
1．完ቤተ መጻሕፍቲ ባይዱ所有规定的实验内容，实验步骤正确，结果正确；
2．完成绝大部份规定的实验内容，实验步骤正确，结果正确；
3．完成绝大部份规定的实验内容，实验步骤根本正确，结果根本正确；
4．根本完成规定的实验内容，实验步骤根本正确，所完成的结果根本正确；
5．未能很好地完成规定的实验内容或实验步骤不正确或结果不正确。
实验报告
课程名称：数据构造
实验编号
及实验名称
实验三：二叉树实验
系 别
计科系
姓 名
学 号
班 级
实验地点
实验日期
实验时数
4
指导教师
同组其他成员
成 绩
一、实验目的及要求
在二叉链存储构造下，设计二叉树结点类，并在此根底上设计二叉树类，再通过调用二叉树类的成员函数，构造并遍历二叉树。从而充分理解二叉树的二叉链存储构造，掌握在这种存储构造下二叉树的构造及各种根本操作的实现。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为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，失败。
数据结构实验三树与二叉树的操作实验指导
实验六树与二叉树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。
实验报告 实验三 二叉排序树的建立和查找
实验三二叉排序树的建立和查找一、实验目的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. 层次遍历：按照从上到下、从左到右的顺序遍历二叉树的节点。
二、二叉树的实现在本次实验中，我们使用C++语言实现了二叉树的基本操作，包括创建二叉树、插入节点、删除节点、查找节点等。
通过这些操作，我们可以方便地对二叉树进行增删改查。
三、二叉树的遍历二叉树的遍历是指按照某种顺序访问二叉树的所有节点。
常用的遍历方式有三种：前序遍历、中序遍历和后序遍历。
1. 前序遍历：先访问根节点，然后依次递归遍历左子树和右子树。
2. 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
3. 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
四、二叉树的应用二叉树在计算机科学和算法设计中有广泛的应用。
以下是一些常见的应用场景：1. 二叉搜索树：二叉搜索树是一种特殊的二叉树，它的左子树的值都小于根节点的值，右子树的值都大于根节点的值。
它可以高效地支持插入、删除和查找操作，常用于有序数据的存储和检索。
2. 堆：堆是一种特殊的二叉树，它的每个节点的值都大于（或小于）其子节点的值。
堆常用于实现优先队列等数据结构。
3. 表达式树：表达式树是一种用二叉树表示数学表达式的方法。
通过对表达式树的遍历，可以实现对数学表达式的计算。
4. 平衡树：平衡树是一种特殊的二叉树，它的左右子树的高度差不超过1。
数据结构二叉树实验报告
实验三二叉树的遍历一、实验目的１、熟悉二叉树的结点类型和二叉树的基本操作。
２、掌握二叉树的前序、中序和后序遍历的算法。
3、加深对二叉树的理解，逐步培养解决实际问题的编程能力。
二、实验环境运行Ｃ或VC++的微机。
三、实验内容1、依次输入元素值，以链表方式建立二叉树，并输出结点的值。
2、分别以前序、中序和后序遍历二叉树的方式输出结点内容。
四、设计思路1. 对于这道题，我的设计思路是先做好各个分部函数，然后在主函数中进行顺序排列，以此完成实验要求2．二叉树采用动态数组3.二叉树运用9个函数，主要有主函数、构建空二叉树函数、建立二叉树函数、访问节点函数、销毁二叉树函数、先序函数、中序函数、后序函数、范例函数，关键在于访问节点五、程序代码#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef struct TNode//结构体定义{-int data; //数据域struct TNode *lchild,*rchild; // 指针域包括左右孩子指针}TNode,*Tree;void CreateT(Tree *T)//创建二叉树按,依次输入二叉树中结点的值{int a;scanf("%d",&a);if(a==00) // 结点的值为空*T=NULL;else // 结点的值不为空{*T=(Tree)malloc(sizeof(TNode));if(!T){printf("分配空间失败！！TAT");exit(ERROR);}(*T)->data=a;CreateT(&((*T)->lchild)); // 递归调用函数，构造左子树CreateT(&((*T)->rchild)); // 递归调用函数，构造右子树}}void InitT(Tree *T)//构建空二叉树{T=NULL;}void DestroyT(Tree *T)//销毁二叉树{if(*T) // 二叉树非空{DestroyT(&((*T)->lchild)); // 递归调用函数，销毁左子树DestroyT(&((*T)->rchild)); // 递归调用函数，销毁右子树free(T);T=NULL;}}void visit(int e)//访问结点{printf("%d ",e);}-void PreOrderT(Tree *T,void(*visit)(int))//先序遍历T{if(*T) // 二叉树非空{visit((*T)->data); // 先访问根结点PreOrderT(&((*T)->lchild),visit); // 递归调用函数，先序遍历左子树PreOrderT(&((*T)->rchild),visit); // 递归调用函数，先序遍历右子树}}void InOrderT(Tree *T,void(*visit)(int)){if(*T){InOrderT(&((*T)->lchild),visit); // 递归调用函数，中序遍历左子树visit((*T)->data); // 访问根结点InOrderT(&((*T)->rchild),visit); // 递归调用函数，中序遍历右子树}}void PostOrderT(Tree *T,void(*visit)(int)){if(*T){PostOrderT(&((*T)->lchild),visit); // 递归调用函数,后序遍历左子树PostOrderT(&((*T)->rchild),visit); // 递归调用函数,序遍历右子树visit((*T)->data); // 访问根结点}}void example(){int i;printf("如果你想建立如图所示的二叉树\n");printf("\n");printf(" 1 \n");printf(" / \\ \n");printf(" 3 3 \n");printf(" / \\ \\ \n");printf(" 4 5 7 \n");printf("\n");printf("请输入：1 3 4 00 00 5 00 00 3 00 7 00 00\n");printf("\n按先序次序输入二叉树中结点的值(输入00表示节点为空)\n");for(i=0;i<71;i++)printf("*");printf("\n");}int main (){Tree T;printf("**************欢迎使用！**************潘俊达\n"); example();printf("\n请输入所要建立的二叉树:\n");CreateT(&T);InitT(&T);int i;printf("先序遍历二叉树：\n");PreOrderT(&T,visit);printf("\n");printf("\n中序遍历二叉树：\n");InOrderT(&T,visit);printf("\n");printf("\n后序遍历二叉树：\n");PostOrderT(&T,visit);printf("\n");system("PAUSE");return 0;}六、程序截图1.范例函数显示，并输入先序二叉树节点值2．先序遍历二叉树3.中序遍历二叉树3.后序遍历二叉树。
实验三二叉树
实验三二叉树实验三二叉树操作实验目的掌握二叉树的定义、性质及存储方式，各种遍历算法。
实验要求：采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。
示例程序：#include"stdio.h"#include"string.h"#include#include#define Max 20 //结点的最大个数typedef struct node{char data;struct node *lchild,*rchild;}BinTNode; //自定义二叉树的结点类型typedef BinTNode *BinTree; //定义二叉树的指针int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数//==========基于先序遍历算法创建二叉树==============//=====要求输入先序序列，其中加入虚结点"#"以示空指针的位置========== BinTree CreatBinTree(void){BinTree T;char ch;if((ch=getchar())=='#')return(NULL); //读入#，返回空指针else{T=(BinTNode *)malloc(sizeof(BinTNode)); // 生成结点T->data=ch;T->lchild=CreatBinTree(); //构造左子树T->rchild=CreatBinTree(); //构造右子树return(T);}}//========NLR 先序遍历=============void Preorder(BinTree T){if(T) {printf("%c",T->data); //访问结点Preorder(T->lchild); //先序遍历左子树Preorder(T->rchild); //先序遍历右子树}}//========LNR 中序遍历===============//==========LRN 后序遍历============//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法======== int TreeDepth(BinTree T){int hl,hr,max;if(T){hl=TreeDepth(T->lchild); //求左深度hr=TreeDepth(T->rchild); //求右深度（1）//取左右深度的最大值（2）//求结点数if(hl==0&&hr==0)（3）//若左右深度为0，即为叶子。
实验三二叉树及其操作算法实现
和右子树的互不相交的二叉树构成。
满二叉树
种类： 完全二叉树、非完全二叉树 平衡二叉树、非平衡二叉树
二叉树的性质
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");
数据结构实验三二叉树实验报告
数据结构实验报告实验名称：实验三——二叉树学生姓名： XX班级：班内序号：学号：日期：1．实验要求1.1实验目的通过选择下面两个题目之一进行实现，掌握如下内容：掌握二叉树基本操作的实现方法了解赫夫曼树的思想和相关概念学习使用二叉树解决实际问题的能力1.2实验内容根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。
二叉树的基本功能：1、二叉树的建立2、前序遍历二叉树3、中序遍历二叉树4、后序遍历二叉树5、按层序遍历二叉树6、求二叉树的深度7、求指定结点到根的路径8、二叉树的销毁9、其他：自定义操作编写测试main()函数测试线性表的正确性2. 程序分析2.1 存储结构二叉树的结点结构二叉树的二叉链表存储示意图2.2 关键算法分析（1）创建一个二叉树伪代码实现：1.定义根指针，输入节点储存的data，若输入“#”，则该节点为空；2.申请一个新节点，判断它的父结点是否不为空，如果不为空在判断其为左或者右孩子，并把地址付给父结点，把data写入。
代码实现void BiTree::create(BiNode* &R,int data[],int i,int n)//创建二叉树{if(i<=n){R=new BiNode;R->data=data[i-1];create(R->lch,data,2*i,n);create(R->rch,data,2*i+1,n);}else R=NULL;}（2）前序遍历伪代码实现：1.设置递归边界条件：if root==null则停止递归2．打印起始节点的值，并先后在左子数右子数上递归调用打印函数代码实现void BiTree::preorder(BiNode* R)//前序遍历{if(R!=NULL){cout<<R->data;preorder(R->lch);preorder(R->rch);}}时间复杂度：O(n)（3）中序遍历伪代码实现：1.设置递归边界条件：if root==null则停止递归2.递归遍历左子树3.打印根节点数据域内容4.递归遍历右子树代码实现void BiTree::inorder(BiNode* R)//中序遍历{if(R!=NULL){inorder(R->lch);cout<<R->data;inorder(R->rch);}}时间复杂度：O(n)（4）后序遍历伪代码实现：1.设置递归边界条件：if root==null则停止递归2.递归遍历左子树3.递归遍历右子树4.访问根结点数据域代码实现void BiTree::postorder(BiNode* R)//后序遍历{if(R!=NULL){postorder(R->lch);postorder(R->rch);cout<<R->data;}}时间复杂度：O(n)（5）层序遍历伪代码实现1.队列Q及所需指针的定义和初始化2.如果二叉树非空，将根指针入队3.循环直到队列Q为空3.1 q=队列Q的队头元素出队3.2 访问节点q的数据域 cout<<q->data<<" ";3.3 若节点q存在左孩子，则将左孩子指针入队3.4若节点q存在右孩子，则将右孩子指针入队代码实现void BiTree::levelordre(BiNode* R)//层序遍历{BiNode*queue[maxsize];int f=0,r=0;if(R!=NULL)queue[++r]=R;while(f!=r){BiNode*p=queue[++f];cout<<p->data;if(p->lch!=NULL)queue[++r]=p->lch;if(p->rch!=NULL)queue[++r]=p->rch;}}时间复杂度：O(n)（6）计算二叉树深度伪代码实现：1. 定义和初始化计数深度的参数2．如果根节点为空，return03．如果根节点为非空，递归调用自身的到叶子节点到根的路径长度，输出其中较大的作为树的深度代码实现int BiTree::depth(BiNode* root)//求二叉树深度{int ld,rd;if (root!=NULL){ld = 1+depth(root->lch);rd = 1+depth(root->rch);return ld>rd?ld:rd;}else return 0;}时间复杂度：O(n)（7）输出指定结点到根结点的路径伪代码实现：1.建立一个存储路径结点结构，定义和初始化结构体的数组2.当root不为空或top为0时，进入循环3.当此时root所指的节点的数据不为指定数据时，将root指向它的左孩子4.当此时root所指的节点的数据为指定数据时，访问其数据域并输出代码实现bool BiTree::printPath(BiNode* root, int data)//打印指定结点到根节点的路径{if (root == NULL)return false;if (root->data == data || printPath(root->lch,data) ||printPath(root->rch,data)){cout<<root->data;return true;}return false;}3. 程序运行结果3.1测试主函数流程图：3.2测试条件对如下二叉树： 补全后的二叉树：按层序遍历的输入方法为：ABC#EFGH###I###J###@ 3.3程序运行结果为：4. 总结出现的问题及改进：刚开始编译正确但是输出结果异常，纪念馆仔细检查发现二叉树创建有问题，经过仔细修改，发现形参表示错误，*&，指针的引用，作为输入时，既把指针的值传入函数内部，又可以将指针的关系传递到函数内部；作为输出，由于算法中修改了指针的值，可以将新值传入到函数内部。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告
课程名称数据结构实验名称二叉树的实现
系别专业班级指导教师
学号姓名实验日期实验成绩
一、实验目的
(1)掌握二叉树的逻辑结构；
(2)掌握二叉树的二叉链表存储结构；
(3)验证二叉树的二叉链表存储及遍历操作。
二、实验内容
(1)建立一棵含有n个结点的二叉树，采用二叉链表存储；结点序列由键盘输入！
(2)输出前序、中序和后序遍历该二叉树的遍历结果。
(3)输出二叉树的叶子个数及叶子名称。
三、设计与编码
1.本实验用到的理论知识
2.算法设计
3.编码。