实验5 二叉树建立及应用
数据结构-实验五-二叉树的操作
数据结构实验报告实验五二叉树的操作班级：12卓越6班学号：***********名：***任课教师：***计算机与信息工程学院2014年5月13 日实验五二叉树的操作一、实验目的1．进一步掌握指针变量、动态变量的含义；2．掌握二叉树的结构特征，以及各种存储结构的特点及适用范围；3．掌握用指针类型描述、访问和处理二叉树的运算。
二、实验要求1．按实验内容编写实验的程序，主程序以菜单形式运行。
2．上机调试运行本程序。
3．保存和打印出程序的运行结果，并结合程序进行分析。
4．提交源程序和运行结果。
三、实验内容1．创建以二叉链表作存储结构的二叉树；2．按中序遍历二叉树；3．按层次遍历二叉树；4．计算二叉树的单枝结点数；5．交换二叉树的左右子树。
解：//声明类BiTree及定义结构BiNode,文件名为bitree.h#ifndef BITREE_H#define BITREE_H//int num;template <class T>struct BiNode //二叉树的结点结构{T data;BiNode<T> *lchild, *rchild;};template <class T>class BiTree{public:BiTree( ); //构造函数，初始化一棵二叉树，其前序序列由键盘输入~BiTree(void); //析构函数，释放二叉链表中各结点的存储空间BiNode<T>* Getroot(); //获得指向根结点的指针void PreOrder(BiNode<T> *root); //前序遍历二叉树void InOrder(BiNode<T> *root); //中序遍历二叉树void PostOrder(BiNode<T> *root); //后序遍历二叉树void LeverOrder(BiNode<T> *root); //层序遍历二叉树int depth(BiNode<T> *root); //求二叉树的深度void nodenum(BiNode<T> *root); //求二叉树的结点个数void leafnum(BiNode<T> *root); //求二叉树的叶子结点个数void empty( ); //判断二叉树是否为空int printnum( ); // 输出（全部、叶子或单分支）结点数void sbnodenum(BiNode<T> *root); //求二叉树的单分支结点个数void exchangetree(BiNode<T> *root); //交换二叉树的左右子树private:BiNode<T> *root; //指向根结点的头指针BiNode<T> *p;BiNode<T> *Creat( ); //有参构造函数调用void Release(BiNode<T> *root); //析构函数调用int num;};#endif//定义类中的成员函数，文件名为bitree.cpp#include<iostream>#include<string>#include"bietree.h"using namespace std;/**前置条件：二叉树不存在*输入：无*功能：构造一棵二叉树*输出：无*后置条件：产生一棵二叉树*/template<class T>BiTree<T>::BiTree( ){this->num=0;this->root = Creat( );}/**前置条件：二叉树已存在*输入：无*功能：释放二叉链表中各结点的存储空间*输出：无*后置条件：二叉树不存在*/template<class T>BiTree<T>::~BiTree(void){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>::LeverOrder(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;}}}/**前置条件：空二叉树*输入：数据ch;*功能：初始化一棵二叉树,构造函数调用*输出：无*后置条件：产生一棵二叉树*/template <class T>BiNode<T>* BiTree<T>::Creat( ){BiNode<T>* root;T ch;cout<<"请输入创建一棵二叉树的结点数据"<<endl;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>void BiTree<T>::Release(BiNode<T>* root){if (root != NULL){Release(root->lchild); //释放左子树Release(root->rchild); //释放右子树delete root;}}/**前置条件：二叉树已经存在*输入：无*功能：求二叉树的深度*输出：二叉树的深度*后置条件：二叉树不变*/template<class T>int BiTree<T>::depth(BiNode<T> *root){int n,m;if(root==NULL) return 0;else{n=depth(root->lchild); //左子树的深度m=depth(root->rchild); //右子树的深度if (n>m)return n+1;elsereturn m+1;}}/**前置条件：二叉树已经存在*输入：无*功能：求二叉树的结点个数*输出：二叉树的结点个数*后置条件：二叉树不变*/template<class T>void BiTree<T>::nodenum(BiNode<T> *root){if(root==NULL) return;else{num++;nodenum(root->lchild); //左子树的结点个数nodenum(root->rchild); //右子树的结点个数}}*前置条件：二叉树已经存在*输入：无*功能：求二叉树2 的叶子结点个数*输出：二叉树的叶子结点个数*后置条件：二叉树不变*/template<class T>void BiTree<T>::leafnum(BiNode<T> *root){if(root==NULL) return;else{if(!(root->lchild) && !(root->rchild)) //判断是否为叶子结点num++;leafnum(root->lchild); //左子树中的叶子结点个数leafnum(root->rchild); //右子树中的叶子结点个数}}/*将全局变量num初始化为0*/template<class T>void BiTree<T>::empty( ){num=0;}输出全局变量num的值*/template<class T>int BiTree<T>::printnum( ){return num;}/**前置条件：二叉树已经存在*输入：无*功能：求二叉树的单分支结点个数*输出：二叉树的单分支结点个数*后置条件：二叉树不变*/template<class T>void BiTree<T>::sbnodenum(BiNode<T> *root){if(root==NULL) return;else{if((!(root->lchild) && (root->rchild))||((root->lchild) && !(root->rchild))) //判断是否为叶子结点num++;sbnodenum(root->lchild); //左子树中的叶子结点个数sbnodenum(root->rchild); //右子树中的叶子结点个数}}/**前置条件：二叉树已经存在*输入：无*功能：交换二叉树的左右子树*输出：无*后置条件：二叉树左右子树交换*/template<class T>void BiTree<T>::exchangetree(BiNode<T> *root){if(root==NULL) return;else{if((root->rchild)&&(root->lchild)) //判断左右叶子结点都存在{ p=root->lchild;root->lchild=root->rchild;root->rchild=p;}exchangetree(root->lchild); //左子树中的叶子结点个数exchangetree(root->rchild); //右子树中的叶子结点个数}}/* BiNode<T> * Q[20];BiNode<T> *q;int front=-1;int rear=-1;int n=0;int m=0;Q[++rear]=root;if(root==NULL)cout<<0;else{while(front!=rear){q=Q[++front];if(q->lchild==NULL && q->rchild!=NULL)m++;if(q->lchild!=NULL && q->rchild==NULL)n++;if(q->lchild!=NULL) Q[++rear]=q->lchild;if(q->rchild!=NULL) Q[++rear]=q->rchild;}}cout<<"单分支节点的个数为:"<<m+n<<endl;*///二叉树的主函数，文件名为bitreemain.cpp#include<iostream>#include<string>#include"bietree.cpp"using namespace std;void main(){BiTree<string> bt; //创建一棵树BiNode<string>* root = bt.Getroot( ); //获取指向根结点的指针int s=-1;while(s!=0){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<<"0.退出"<<endl;cin>>s;switch(s){ case 1:bt.PreOrder(root);cout<<endl;break;case 2:bt.InOrder(root);cout<<endl;break;case 3:bt.PostOrder(root);cout<<endl;break;case 4:bt.LeverOrder(root);cout<<endl;break;case 5:cout<<"树的深度为："<<bt.depth(root)<<endl;break;case 6:bt.empty();bt.leafnum(root);cout<<"叶子结点个数为："<<bt.printnum()<<endl;break;case 7:bt.empty();bt.sbnodenum(root);cout<<"单分支结点个数为："<<bt.printnum()<<endl;break;case 8:bt.empty();bt.exchangetree(root);cout<<"左右子树交换后的结果：";bt.PreOrder(root);cout<<endl;break;case 0:exit(0);}}}。
二叉树实验报告
二叉树实验报告二叉树实验报告引言：二叉树作为一种常用的数据结构，在计算机科学领域中具有广泛的应用。
本实验旨在通过实际操作和观察，深入理解二叉树的特性和运用。
一、二叉树的基本概念1.1 二叉树的定义二叉树是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。
树的最顶层节点称为根节点。
1.2 二叉树的特点二叉树具有以下特点：- 每个节点最多有两个子节点，分别称为左子节点和右子节点；- 左子节点的值小于等于父节点的值，右子节点的值大于等于父节点的值；- 二叉树的左子树和右子树也是二叉树。
二、二叉树的遍历方式2.1 先序遍历先序遍历是指先访问根节点，然后按照先序遍历的方式依次访问左子树和右子树。
2.2 中序遍历中序遍历是指按照中序遍历的方式依次访问左子树，根节点和右子树。
2.3 后序遍历后序遍历是指按照后序遍历的方式依次访问左子树，右子树和根节点。
三、二叉树的实验操作3.1 二叉树的创建为了便于实验操作，我们选择使用Python编程语言来实现二叉树的创建和操作。
首先，我们需要定义一个二叉树节点的类，包含节点的值、左子节点和右子节点。
3.2 二叉树的插入在已有的二叉树中插入一个新的节点，需要遵循二叉树的规则。
如果插入的节点值小于当前节点的值，则将节点插入到当前节点的左子树；如果插入的节点值大于当前节点的值，则将节点插入到当前节点的右子树。
3.3 二叉树的查找在二叉树中查找一个特定的节点，需要遍历整个二叉树。
从根节点开始，如果要查找的节点值小于当前节点的值，则继续在左子树中查找；如果要查找的节点值大于当前节点的值，则继续在右子树中查找；如果要查找的节点值等于当前节点的值，则找到了目标节点。
3.4 二叉树的删除在二叉树中删除一个节点，需要考虑多种情况。
如果要删除的节点没有子节点，直接将其删除即可；如果要删除的节点只有一个子节点，将子节点替换为要删除的节点；如果要删除的节点有两个子节点，需要找到其右子树中的最小节点，将其值替换到要删除的节点，然后删除最小节点。
数据结构实验五(二叉树的建立及遍历)题目和源程序
实验5：二叉树的建立及遍历（第十三周星期三7、8节）一、实验目的1．学会实现二叉树结点结构和对二叉树的基本操作。
2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
二、实验要求1．认真阅读和掌握和本实验相关的教材内容。
2．编写完整程序完成下面的实验内容并上机运行。
3．整理并上交实验报告。
三、实验内容1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。
2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
四、思考与提高1．如何计算二叉链表存储的二叉树中度数为1的结点数？2．已知有—棵以二叉链表存储的二叉树，root指向根结点，p指向二叉树中任一结点，如何求从根结点到p所指结点之间的路径?/*----------------------------------------* 05-1_递归遍历二叉树.cpp -- 递归遍历二叉树的相关操作* 对递归遍历二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>typedef char ElemType;using namespace std;typedef struct BiTNode {ElemType data;//左右孩子指针BiTNode *lchild, *rchild;}BiTNode, *BiTree;//动态输入字符按先序创建二叉树void CreateBiTree(BiTree &T) {char ch;ch = cin.get();if(ch == ' ') {T = NULL;}else {if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！" << endl;}else {//生成根结点T = (BiTNode * )malloc(sizeof(BiTNode));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);}}}//输出e的值ElemType PrintElement(ElemType e) { cout << e << " ";return e;}//先序遍历void PreOrderTraverse(BiTree T) { if (T != NULL) {//打印结点的值PrintElement(T->data);//遍历左孩子PreOrderTraverse(T->lchild);//遍历右孩子PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T) {if (T != NULL) {//遍历左孩子InOrderTraverse(T->lchild);//打印结点的值PrintElement(T->data);//遍历右孩子InOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T) { if (T != NULL) {//遍历左孩子PostOrderTraverse(T->lchild);//遍历右孩子PostOrderTraverse(T->rchild);//打印结点的值PrintElement(T->data);}}//按任一种遍历次序输出二叉树中的所有结点void TraverseBiTree(BiTree T, int mark) {if(mark == 1) {//先序遍历PreOrderTraverse(T);cout << endl;}else if(mark == 2) {//中序遍历InOrderTraverse(T);cout << endl;}else if(mark == 3) {//后序遍历PostOrderTraverse(T);cout << endl;}else cout << "选择遍历结束！" << endl;}//输入值并执行选择遍历函数void ChoiceMark(BiTree T) {int mark = 1;cout << "请输入，先序遍历为1，中序为2，后序为3，跳过此操作为0：";cin >> mark;if(mark > 0 && mark < 4) {TraverseBiTree(T, mark);ChoiceMark(T);}else cout << "此操作已跳过！" << endl;}//求二叉树的深度int BiTreeDepth(BiTNode *T) {if (T == NULL) {//对于空树，返回0并结束递归return 0;}else {//计算左子树的深度int dep1 = BiTreeDepth(T->lchild);//计算右子树的深度int dep2 = BiTreeDepth(T->rchild);//返回树的深度if(dep1 > dep2)return dep1 + 1;elsereturn dep2 + 1;}}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;bt = NULL; //将树根指针置空cout << "输入规则：" << endl<< "要生成新结点，输入一个字符，""不要生成新结点的左孩子，输入一个空格，""左右孩子都不要，输入两个空格，""要结束，输入多个空格（越多越好）,再回车！"<< endl << "按先序输入：";CreateBiTree(bt);cout << "树的深度为：" << BiTreeDepth(bt) << endl;ChoiceMark(bt);return 0;}/*----------------------------------------* 05-2_构造二叉树.cpp -- 构造二叉树的相关操作* 对构造二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05-2.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>#define STACK_INIT_SIZE 100 //栈的存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef char ElemType; //元素类型using namespace std;typedef struct BiTNode {ElemType data; //结点值BiTNode *lchild, *rchild; //左右孩子指针}BiTNode, *BiTree;typedef struct {BiTree *base; //在栈构造之前和销毁之后，base的值为空BiTree *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位}SqStack;//构造一个空栈void InitStack(SqStack &s) {s.base = (BiTree *)malloc(STACK_INIT_SIZE * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base;s.stacksize = STACK_INIT_SIZE;}//插入元素e为新的栈顶元素void Push(SqStack &s, BiTree e) {//栈满，追加存储空间if ((s.top - s.base) >= s.stacksize) {s.base = (BiTree *)malloc((STACK_INIT_SIZE+STACKINCREMENT) * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base + s.stacksize;s.stacksize += STACK_INIT_SIZE;}*s.top++ = e;}//若栈不空，则删除s的栈顶元素，并返回其值BiTree Pop(SqStack &s) {if(s.top == s.base)cout << "栈为空，无法删除栈顶元素！" << endl;s.top--;return *s.top;}//按先序输入字符创建二叉树void CreateBiTree(BiTree &T) {char ch;//接受输入的字符ch = cin.get();if(ch == ' ') {//分支结束T = NULL;} //if' 'endelse if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！（接着输入）" << endl;} //if'\n'endelse {//生成根结点T = (BiTNode * )malloc(sizeof(BiTree));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);} //Create end}//输出e的值，并返回ElemType PrintElement(ElemType e) {cout << e << " ";return e;}//中序遍历二叉树的非递归函数void InOrderTraverse(BiTree p, SqStack &S) {cout << "中序遍历结果：";while(S.top != S.base || p != NULL) {if(p != NULL) {Push(S,p);p = p->lchild;} //if NULL endelse {BiTree bi = Pop(S);if(!PrintElement(bi->data))cout << "输出其值未成功！" << endl;p = bi->rchild;} //else end} //while endcout << endl;}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;SqStack S;InitStack(S);bt = NULL; //将树根指针置空cout << "老师要求的二叉树序列（‘空’表示空格）：""12空空346空空空5空空，再回车！"<< endl << "请按先序输入一个二叉树序列（可另输入，但要为先序），""无左右孩子则分别输入空格。
实验五 数据结构 二叉树基本操作实验报告(汽院)
班级：
教师批阅处：
一、实验名称
二叉树基本操作的编程实现
二、实验目的
二叉树基本操作的编程实现，掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，存储结构主要采用链接结构。
三、实验内容
本次实验的内容有三种模式，我选择了第三种模式：用c进行程序的改进和提高，把下面的程序源码进行输入和改写，调试，直到成功。
1、补充三种递归遍历的方法
先根遍历：若二叉树不为空，先访问根节点，然后访问根节点的左子树，最后访问根节点的右子树。
中根遍历：若二叉树不为空，先访问根节点的左子树，然后访问根节点，最后访问根节点的右子树。
后跟遍历：若二叉树不为空，先访问根节点的左子树，然后访问根节点的右子树，最后访问根节点。
三种遍历的效果截图如下：
{
if(pnow!=NULL)
{
if (top<Maxsize-1)
{
top++;
stack[top].link=pnow;
stack[top].flag=1;
pnow=pnow->lchild;
}
else
{ return overflow; }
}
else
{
pnow=stack[top].link;
cout<<",";
else
cout<<")";
pnow=NULL;
}
}
}
cout<<endl;
return success;
}
3、补充层次遍历的方法
若二叉树不为空，从根节点开始从上至下逐层访问，同一层中从左到右逐个结点访问。效果截图如下：
二叉树的各种基本运算的实现实验报告
二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算，通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。
二、实验内容
1、构造一个二叉树。
我们首先用一定的节点来构建一棵二叉树，包括节点的左子节点和右子节点。
2、实现查找二叉树中的节点。
在查找二叉树中的节点时，我们根据二叉树的特点，从根节点开始查找，根据要查找的节点的值与根节点的值的大小的关系，来决定接下来查找的方向，直到找到要查找的节点为止。
3、实现删除二叉树中的节点。
在删除二叉树节点时，我们要做的是找到要删除节点的父节点，然后让父节点的链接指向要删除节点的子节点，有可能要删除节点有一个子节点，有可能有两个极点，有可能没有子节点，我们要根据每种情况进行处理，来保持二叉树的结构不变。
4、对二叉树进行遍历操作。
二叉树的遍历有多种方法，本实验使用的是先序遍历。
首先从根节点出发，根据先序遍历的顺序，先访问左子树，然后再访问右子树，最后访问根节点。
三、实验步骤
1、构建二叉树：
我们用一个数组代表要构建的二叉树，第一项为根节点，第二项和第三项是根节点的子节点。
实验五：二叉树的定义及基本操作
实验五：二叉树的定义及基本操作（必做：基本2学时，扩展4学时）一、实验目的：.熟练掌握二叉树的二叉链表存储结构.掌握二叉树的非线性和递归性特点.熟练掌握二叉树的递归遍历操作的实现方法，掌握二叉树的非递归遍历操作的实现.掌握线索二叉树的定义和基本操作.加深对二叉树结构和性质的理解，逐步培养解决实际问题的编程能力二、实验内容:（一）基本实验内容：.定义二叉树的链式存储结构；.实现二叉树的基本操作：建空树、销毁二叉树、生成二叉树(先序,中序或后序)、判二叉树是否为空、求二叉树的深度、求二叉树的根等基本算法；.实现二叉树的递归(先序、中序或后序)遍历算法；1．问题描述：利用二叉树的链式存储结构，设计一组输入数据（假定为一组整数或一组字符），能够对二叉树进行如下操作：.创建一棵空二叉树；.对一棵存在的二叉树进行销毁；.根据输入某种遍历次序输入二叉树中结点的值，依序建立二叉树；.判断某棵二叉树是否为空；.求二叉树的深度；.求二叉树的根结点，若为空二叉树，则返回一特殊值；.二叉树的遍历，即按某种方式访问二叉树中的所有结点，并使每个结点恰好被访问一次；.编写主程序，实现对各不同的算法调用；其他算法的描述省略，参见实现要求说明。
2．实现要求：.“构造空二叉树算法”操作结果：构造一个空二叉树T；.“销毁二叉树算法”初始条件:二叉树T存在；操作结果:销毁二叉树T；.“创建二叉树算法”初始条件:可以根据先序、中序和后序输入二叉树中结点的值（可为字符型或整型）；操作结果:以选择的某种次序建立二叉树T；.“判二叉树是否为空算法”初始条件:二叉树T存在；操作结果:若T为空二叉树,则返回TRUE,否则FALSE；.“求二叉树的深度算法”初始条件:二叉树T存在；操作结果:返回T的深度；.“求二叉树的根算法”初始条件:二叉树T存在；操作结果:返回T的根；.“先序递归遍历算法”初始条件:二叉树T存在,Visit是对结点操作的应用函数；操作结果:先序递归遍历T,对每个结点调用函数Visit一次且仅一次；.“中序递归遍历算法”初始条件:二叉树T存在,Visit是对结点操作的应用函数；操作结果:中序递归遍历T,对每个结点调用函数Visit一次且仅一次；.“后序递归遍历算法”初始条件:二叉树T存在,Visit是对结点操作的应用函数；操作结果:后序递归遍历T,对每个结点调用函数Visit一次且仅一次；（二）扩展实验内容：利用二叉树的链式存储结构，设计一组输入数据（假定为一组整数或一组字符），能够对二叉树进行如下操作：.求某一个结点的双亲结点,求某一个结点的左孩子（或右孩子）结点；求某一个结点的左兄弟（或右兄弟）算法；.利用栈，实现二叉树的非递归(先序、中序或后序)遍历算法；.利用队列，实现层序递归遍历二叉树；.定义线索二叉树的链式存储结构，建立线索二叉树，实现线索二叉树的插入和删除操作；1．问题描述：.求二叉树中某个指定结点的父结点，当指定结点为根时，返回一特殊值；.求二叉树中某个指定结点的左孩子结点，当指定结点没有左孩子时，返回一特殊值；.求二叉树中某个指定结点的右孩子结点，当指定结点没有右孩子时，返回一特殊值；.实现中序非递归遍历二叉树算法一定采用二叉链表存储结构，并且仿照递归算法执行过程中递归工作栈的状态变化状况直接实现栈的操作，写出相应的非递归算法；中序和后序类似；.编写主程序，实现对各不同的算法调用。
树和二叉树的实验报告
树和二叉树的实验报告树和二叉树的实验报告一、引言树和二叉树是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。
本实验旨在通过实际操作和观察，深入了解树和二叉树的特性和操作。
二、树的构建与遍历1. 树的概念和特性树是一种非线性的数据结构，由节点和边组成。
每个节点可以有零个或多个子节点，其中一个节点没有父节点的称为根节点。
树的特点包括层次结构、唯一根节点和无环等。
2. 树的构建在本实验中，我们使用Python语言构建了一棵树。
通过定义节点类和树类，我们可以方便地创建树的实例，并添加节点和连接节点之间的边。
3. 树的遍历树的遍历是指按照一定顺序访问树中的所有节点。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
我们在实验中实现了这三种遍历方式，并观察了它们的输出结果。
三、二叉树的实现与应用1. 二叉树的概念和特性二叉树是一种特殊的树，每个节点最多有两个子节点，分别称为左子节点和右子节点。
二叉树的特点包括唯一根节点、每个节点最多有两个子节点和子节点的顺序等。
2. 二叉树的实现我们使用Python语言实现了二叉树的数据结构。
通过定义节点类和二叉树类，我们可以创建二叉树的实例，并实现插入节点、删除节点和查找节点等操作。
3. 二叉树的应用二叉树在实际应用中有很多用途。
例如，二叉搜索树可以用于实现快速查找和排序算法。
AVL树和红黑树等平衡二叉树可以用于高效地插入和删除操作。
我们在实验中实现了这些应用，并通过实际操作验证了它们的效果。
四、实验结果与讨论通过实验，我们成功构建了树和二叉树的数据结构，并实现了它们的基本操作。
通过观察和分析实验结果，我们发现树和二叉树在各种算法和应用中的重要性和灵活性。
树和二叉树的特性使得它们适用于解决各种问题，例如搜索、排序、图算法等。
同时，我们也发现了一些问题和挑战，例如树的平衡性和节点的插入和删除操作等。
这些问题需要进一步的研究和优化。
五、总结本实验通过实际操作和观察，深入了解了树和二叉树的特性和操作。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构，它由节点和边构成，每个节点最多有两个子节点。
在本次实验中，我们将对二叉树的基本结构和基本操作进行实现和测试，并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作，包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构：我们将首先学习二叉树的定义，并实现二叉树的存储结构，包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化：我们将实现二叉树的创建和初始化操作，以便后续操作和测试使用。
3. 二叉树的遍历：我们将实现二叉树的前序、中序和后序遍历算法，并测试其正确性和效率。
4. 二叉树的查找：我们将实现二叉树的查找操作，包括查找节点和查找最大值、最小值等。
5. 二叉树的应用：我们将探讨二叉树在实际应用中的使用场景，如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类：满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构：采用节点定义和指针表示法，通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构：采用数组存储节点信息，通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构，我们需要自定义节点和指针，并通过节点的方式来构建二叉树。
对于顺序存储结构，我们需要定义数组和索引，通过索引计算来定位节点的位置。
一般来说，初始化一个二叉树可以使用以下步骤：1. 创建树根节点，并赋初值。
2. 创建子节点，并到父节点。
3. 重复步骤2，直到创建完整个二叉树。
数据结构二叉树实验报告
数据结构二叉树实验报告二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。
一、二叉树的定义和基本操作二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
一个节点的左子节点称为左子树，右子节点称为右子树。
二叉树的示意图如下：```A/ \B C/ \D E```在二叉树中，每个节点可以有零个、一个或两个子节点。
如果一个节点没有子节点，我们称之为叶子节点。
在上面的示例中，节点 D 和 E 是叶子节点。
二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。
插入节点操作可以将一个新节点插入到二叉树中的合适位置。
删除节点操作可以将一个指定的节点从二叉树中删除。
查找节点操作可以在二叉树中查找指定的节点。
遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。
二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。
下面将介绍一些常见的应用场景。
1. 二叉搜索树二叉搜索树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的节点的值，小于其右子树中的节点的值。
二叉搜索树可以用来实现快速的查找、插入和删除操作。
它在数据库索引、字典等场景中有着重要的应用。
2. 堆堆是一种特殊的二叉树，它的每个节点的值都大于或小于其子节点的值。
堆可以用来实现优先队列，它在任务调度、操作系统中的内存管理等场景中有着重要的应用。
3. 表达式树表达式树是一种用来表示数学表达式的二叉树。
在表达式树中，每个节点可以是操作符或操作数。
表达式树可以用来实现数学表达式的计算，它在编译器、计算器等场景中有着重要的应用。
4. 平衡二叉树平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1。
平衡二叉树可以用来实现高效的查找、插入和删除操作。
它在数据库索引、自平衡搜索树等场景中有着重要的应用。
三、总结二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。
本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。
二叉树实验报告
二叉树实验报告1. 引言二叉树是一种常用的数据结构，广泛应用于计算机科学和信息技术领域。
本实验旨在通过对二叉树的理解和实现，加深对数据结构与算法的认识和应用能力。
本报告将介绍二叉树的定义、基本操作以及实验过程中的设计和实现。
2. 二叉树的定义二叉树是一个有序树，其每个节点最多有两个子节点。
树的左子节点和右子节点被称为二叉树的左子树和右子树。
3. 二叉树的基本操作3.1 二叉树的创建在实验中，我们通过定义一个二叉树的节点结构来创建一个二叉树。
节点结构包含一个数据域和左右指针，用于指向左右子节点。
创建二叉树的过程可以通过递归或者迭代的方式来完成。
3.2 二叉树的插入和删除二叉树的插入操作是将新节点插入到树中的合适位置。
插入时需要考虑保持二叉树的有序性。
删除操作是将指定节点从树中删除，并保持二叉树的有序性。
在实验中，我们可以使用递归或者循环的方式实现这些操作。
3.3 二叉树的遍历二叉树的遍历是指按照某种次序访问二叉树的所有节点。
常见的遍历方式包括前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点，然后按照左孩子-右孩子的顺序递归遍历左右子树。
中序遍历按照左孩子-根节点-右孩子的顺序递归遍历左右子树。
后序遍历按照左孩子-右孩子-根节点的顺序递归遍历左右子树。
3.4 二叉树的查找查找操作是指在二叉树中查找指定的值。
可以通过递归或者循环的方式实现二叉树的查找操作。
基本思路是从根节点开始，通过比较节点的值和目标值的大小关系，逐步向左子树或者右子树进行查找，直到找到目标节点或者遍历到叶子节点。
4. 实验设计和实现在本实验中，我们设计并实现了一个基于Python语言的二叉树类。
具体实现包括二叉树的创建、插入、删除、遍历和查找操作。
在实验过程中，我们运用了递归和迭代的方法实现了这些操作，并进行了测试和验证。
4.1 二叉树类的设计我们将二叉树的节点设计为一个类，其中包括数据域和左右子节点的指针。
另外，我们设计了一个二叉树类，包含了二叉树的基本操作方法。
二叉树的基本操作与实现实验报告
二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构，在计算机科学领域中被广泛应用。
本实验将介绍二叉树的基本操作与实现，并给出相应的实验报告。
一、引言二叉树是一种特殊的树状结构，每个节点至多有两个子节点。
二叉树有许多重要的特性，如平衡二叉树、二叉树等，应用广泛。
在本实验中，我们将介绍二叉树的基本操作和实现。
二、实验目的1.掌握二叉树的基本概念和特性；2.熟悉二叉树的基本操作，包括创建、插入、删除、遍历等；3.学会使用编程语言实现二叉树的基本操作。
三、实验内容本实验主要包括以下内容：1.二叉树的定义和基本概念；2.二叉树的基本操作，包括创建、插入、删除、遍历等；3.使用编程语言实现二叉树的基本操作；4.测试和验证二叉树的基本操作的正确性。
四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构，每个节点至多有两个子节点。
二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。
二叉树的特性有很多，如完全二叉树、平衡二叉树、二叉树等。
2.二叉树的基本操作（1）创建二叉树：可以通过手动输入节点数据来创建二叉树，也可以通过读取文件中的数据来创建二叉树。
（2）插入节点：在指定位置插入一个新节点。
（3）删除节点：删除指定位置的节点。
（4）遍历二叉树：有前序遍历、中序遍历和后序遍历三种遍历方式。
3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。
我们可以定义一个二叉树的结构体，包含节点数据和指向左右子树的指针。
然后根据具体的需求，实现相应的操作函数。
4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后，我们可以编写测试代码来验证操作的正确性。
通过创建二叉树，并进行插入、删除和遍历操作，观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后，我们可以进行测试和验证。
通过输出二叉树的遍历结果，比对预期结果来判断操作是否正确。
同时，我们还可以观察二叉树的结构和特性，如是否满足平衡二叉树或二叉树的条件。
数据结构实验报告-树(二叉树)
实验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.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验，我掌握了二叉树的顺序存储和链式存储，体会了二叉树的存储结构的特性，掌握了二叉树的树上相关操作。
二叉树的基本操作实验报告
二叉树的基本操作实验报告二叉树的基本操作实验报告引言：二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作，并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中，我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想，通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时，我们首先创建根节点，然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点，然后递归遍历左子树和右子树；中序遍历先递归遍历左子树，然后访问根节点，最后递归遍历右子树；后序遍历先递归遍历左子树和右子树，最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性，即左子节点的值小于父节点的值，右子节点的值大于父节点的值。
在插入节点时，我们需要找到合适的位置，将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂，需要考虑多种情况。
如果要删除的节点是叶子节点，直接删除即可。
如果要删除的节点只有一个子节点，将其子节点连接到父节点上。
如果要删除的节点有两个子节点，我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果：通过实验，我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结：二叉树的基本操作是数据结构中的重要内容，对于理解和应用其他数据结构具有重要意义。
通过本次实验，我们深入了解了二叉树的创建、遍历、插入和删除等操作，并通过实验验证了其正确性和有效性。
二叉树及其应用
实验5：二叉树及其应用一、实验目的树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。
二、问题描述首先，掌握二叉树的各种存储结构和熟悉对二叉树的基本操作。
其次，以二叉树表示算术表达式的基础上，设计一个十进制的四则运算的计算器。
如算术表达式：a+b*(c-d)-e/f三、实验要求1、 如果利用完全二叉树的性质和二叉链表结构建立一棵二叉树，分别计算 a) 统计叶子结点的个数。
b) 求二叉树的深度。
2、 十进制的四则运算的计算器可以接收用户来自键盘的输入。
3、 由输入的表达式字符串动态生成算术表达式所对应的二叉树。
4、 自动完成求值运算和输出结果。
四、实验环境PC 微机DOS 操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五、实验步骤1、根据二叉树的各种存储结构建立二叉树；2、设计求叶子结点个数算法和树的深度算法；1、 根据表达式建立相应的二叉树，生成表达式树的模块； 4、根据表达式树，求出表达式值，生成求值模块； 1、 程序运行效果，测试数据分析算法。
-+/a*b-efCd六、测试数据1、输入数据：2.2*（3.1+1.20）-7.5/3正确结果：6.962、输入数据：(1+2)*3+(5+6*7);正确输出：56七、实验报告要求实验报告应包括以下几个部分：1、设计算术表达式树的存储结构；2、给出二叉树中叶子结点个数算法和树的深度算法描述；3、给出生成表达式树算法和求解算法描述；4、相应的程序要给出足够的注释部分；5、给出程序的测试结果；6、实验总结。
八、思考题1、分析利用完全二叉树的性质和二叉链表存储有什么不同？分析其优缺点。
2、增加输入表达式进行语法判错的功能。
实验源代码：#include<stdio.h>#include<iostream>#include<malloc.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define ERROR 0#define NUMBER 1#define SIMBLE 2using namespace std;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;// 栈int InitStack( SqStack &s ){s.base = (lpBiTreeNode *)malloc( STACK_INIT_SIZE*sizeof(lpBiTreeNode) );if(!s.base)return 0;s.top = s.base;s.stacksize = STACK_INIT_SIZE;return 1;}int Push( SqStack &s, lpBiTreeNode e ){if( s.top - s.base >= s.stacksize ){s.base = (lpBiTreeNode *)realloc( s.base, (s.stacksize + STACKINCREMENT)*sizeof(lpBiTreeNode) );if(!s.base)return 0;s.top = s.base + s.stacksize;s.stacksize += STACKINCREMENT;}*s.top = e;s.top ++;return 1;}int Pop( SqStack &s, lpBiTreeNode &e ){if( s.top == s.base )return 0;s.top --;e = *s.top;return 1;}lpBiTreeNode GetTop( SqStack s ){lpBiTreeNode e;if( s.top == s.base )return NULL;e = *(s.top -1);return e;}int IsEmpty( SqStack s ){if( s.top == s.base )return 1;elsereturn 0;}int In( int c, int* op ){ // 判断c 是否在op 中，op为以结尾的数组while( *op != 0 ){if( c == *op )return 1;op ++;}return 0;}int Precede( int theta1, int theta2 ){int i, j;int op_look[7][7] ={ { '>', '>', '<', '<', '<', '>', '>' },{ '>', '>', '<', '<', '<', '>', '>' },{ '>', '>', '>', '>', '<', '>', '>' },{ '>', '>', '>', '>', '<', '>', '>' },{ '<', '<', '<', '<', '<', '=', ' ' },{ '>', '>', '>', '>', ' ', '>', '>' },{ '<', '<', '<', '<', '<', ' ', '=' }};switch( theta1 ){case'+':i = 0;break;case'-':i = 1;break;case'*':i = 2;break;case'/':i = 3;break;case'(':i = 4;break;case')':i = 5;break;case'#':i = 6;break;default:return 0;}switch( theta2 ){case'+':j = 0;break;case'-':j = 1;break;case'*':j = 2;case'/':j = 3;break;case'(':j = 4;break;case')':j = 5;break;case'#':j = 6;break;default:return 0;}return op_look[i][j];}int isNum( int c ){if( c >= '0' && c <= '9' )return 1;else return 0;}int GetInput(Int_Float *Result){ // 返回值：无，1数字，2符号static int buffer = 0; // 缓存存储数字后的符号int c;Int_Float result;int IsNumber = 0; // 是否为数字int IsFloat = 0; // 是否为小数int i,t=1;result.Operand = 0;if(In(buffer, OP)){ // 缓存中有符号，返回result.Operator = buffer;buffer = 0;Result->Operator = result.Operator;return SIMBLE; // 符号}// 去前导空格c = getchar();while ( c == ' ' && c != 10 ){c = getchar();}while( c != ' ' && c != 10 ){ // 不是空格和回车if(isNum(c)){ // 是数字IsNumber = 1;c = c - 48; // 字符到整型if(IsFloat == 0)result.Operand = result.Operand*10 + c;result.Operand = result.Operand*10 + c;IsFloat ++;}}else if(c == '.'){if(IsFloat != 0){// 两个小数点Result->Operand = 0;return ERROR;}elseIsFloat = 1;}else if (In(c, OP)) {if(IsNumber){ // 数字后接符号if(IsFloat == 1){Result->Operand = 0;return ERROR;}else{buffer = c;for(i=0; i<IsFloat-1; i++)t*=10;Result->Operand = result.Operand/(float)t;return NUMBER; // 数字}}else {Result->Operator = c;return SIMBLE; // 符号}}c = getchar();}buffer = 0;if(IsNumber){if(IsFloat == 1){Result->Operand = 0;return ERROR;}else{for(i=0; i<IsFloat-1; i++)t*=10;Result->Operand = result.Operand/(float)t;return NUMBER;}}else if(result.Operand == 0){Result->Operand = 0;return ERROR;}else{Result->Operator = result.Operator;return SIMBLE;}}lpBiTreeNode CreateBiTree(){SqStack Operand; // 操作数SqStack Operator; // 操作符lpBiTreeNode pNode;lpBiTreeNode theta,a,b;Int_Float c;printf("输入算式");int r = GetInput(&c);InitStack(Operand);InitStack(Operator);pNode = (lpBiTreeNode)malloc(sizeof(BiTreeNode));pNode->Data.Operator = '#';pNode->IsOperator = 1;pNode->LChild = NULL;pNode->RChild = NULL;Push( Operator, pNode );while( !( r == SIMBLE && c.Operator == '#') || GetTop(Operator)->Data.Operator != '#' ){if(r == ERROR)return NULL;if( r == NUMBER ) {// 是数字pNode = (lpBiTreeNode)malloc(sizeof(BiTreeNode));pNode->Data.Operand = c.Operand;pNode->IsOperator = 0;pNode->LChild = NULL;pNode->RChild = NULL;Push(Operand,pNode);r = GetInput(&c);}else if( r == SIMBLE ) {// 是符号switch( Precede(GetTop(Operator)->Data.Operator, c.Operator) ){case'<': // 栈顶元素优先权低pNode = (lpBiTreeNode)malloc(sizeof(BiTreeNode));pNode->Data.Operator = c.Operator;pNode->IsOperator = 1;pNode->LChild = NULL;pNode->RChild = NULL;Push( Operator, pNode );r = GetInput(&c);break;case'=': // '(', ')'相遇，脱括号Pop( Operator, pNode );r = GetInput(&c);break;case'>': // 栈顶元素优先权高, 退栈并将运算结果入栈Pop( Operator, theta );Pop( Operand, b);Pop( Operand, a);theta->LChild = a;theta->RChild = b;Push(Operand, theta);break;}}}return GetTop(Operand);}bool calculate(lpBiTreeNode Root, float *result){float resultLchild;float resultRchild;if( Root != NULL ){if(Root->LChild == NULL && Root->RChild == NULL){*result = Root->Data.Operand;return true;}else if(Root->LChild == NULL || Root->RChild == NULL)return false;else{switch (Root->Data.Operator){case'+':if( calculate(Root->LChild, &resultLchild)==false )return false;if( calculate(Root->RChild, &resultRchild)==false )return false;*result = resultLchild + resultRchild;break;case'-':if( calculate(Root->LChild, &resultLchild)==false )return false;if( calculate(Root->RChild, &resultRchild)==false )return false;*result = resultLchild - resultRchild;break;case'*':if( calculate(Root->LChild, &resultLchild)==false )return false;if( calculate(Root->RChild, &resultRchild)==false )return false;*result = resultLchild * resultRchild;break;case'/':if( calculate(Root->LChild, &resultLchild)==false )return false;if( calculate(Root->RChild, &resultRchild)==false )return false;*result = resultLchild / resultRchild;break;}}}return true;}int getLeafNum(lpBiTreeNode Root){int LeafnumLchild;int LeafnumRchild;if( Root != NULL ){if(Root->LChild == NULL && Root->RChild == NULL)return 1;else{LeafnumLchild = getLeafNum(Root->LChild);LeafnumRchild = getLeafNum(Root->RChild);return LeafnumLchild + LeafnumRchild;}}return 0;}int getDepth(lpBiTreeNode Root){int LeafDepthL;int LeafDepthR;if( Root != NULL ){if(Root->LChild == NULL && Root->RChild == NULL)return 0;else{LeafDepthL = getDepth(Root->LChild);LeafDepthR = getDepth(Root->RChild);return 1 + (LeafDepthL>LeafDepthR?LeafDepthL:LeafDepthR);}}return 0;}void main(){lpBiTreeNode Root;float result;if( Root = CreateBiTree() ){printf( "叶子数: %d\n", getLeafNum(Root) );printf( "深度: %d\n", getDepth(Root) );if( calculate(Root, &result) ){printf("Result: %0.2f\n", result);}elseprintf("ERROR");}elseprintf("INPUT ERROR\n");system("pause");}实验截图。
二叉树实现及应用实验报告
二叉树实现及应用实验报告实验名称：二叉树实现及应用实验目的：1. 实现二叉树的创建、插入和删除操作。
2. 学习二叉树的遍历方法，并能够应用于实际问题。
3. 掌握二叉树在数据结构和算法中的一些常用应用。
实验内容：1. 实现二叉树的创建、插入和删除操作，包括二叉树的构造函数、插入函数和删除函数。
2. 学习二叉树的三种遍历方法：前序遍历、中序遍历和后序遍历，并应用于实际问题。
3. 掌握二叉树的一些常用应用，如二叉搜索树、平衡二叉树和哈夫曼树等。
实验步骤：1. 创建二叉树的结构体，包括树节点和树的根节点。
2. 实现二叉树的构造函数，用于创建二叉树的根节点。
3. 实现二叉树的插入函数，用于将元素插入到二叉树中的合适位置。
4. 实现二叉树的删除函数，用于删除二叉树中的指定元素。
5. 学习并实现二叉树的前序遍历、中序遍历和后序遍历函数。
6. 运用二叉树的遍历方法解决实际问题，如查找二叉树中的最大值和最小值。
7. 学习并应用二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构。
实验结果：1. 成功创建、插入和删除二叉树中的元素，实现了二叉树的基本操作。
2. 正确实现了二叉树的前序遍历、中序遍历和后序遍历，并能够正确输出遍历结果。
3. 通过二叉树的遍历方法成功解决了实际问题，如查找二叉树中的最大值和最小值。
4. 学习并熟练应用了二叉搜索树、平衡二叉树和哈夫曼树等常用二叉树结构，丰富了对二叉树的理解。
实验分析：1. 二叉树是一种重要的数据结构，具有较好的数据存储和查找性能，广泛应用于计算机科学和算法领域。
2. 通过实验，我们深入了解了二叉树的创建、插入和删除操作，以及前序遍历、中序遍历和后序遍历的原理和应用。
3. 实际问题往往可以转化为二叉树的遍历问题进行求解，通过实验，我们成功应用了二叉树的遍历方法解决了实际问题。
4. 熟练掌握二叉搜索树、平衡二叉树和哈夫曼树的原理和应用，对于提高我们在数据结构和算法方面的设计能力具有重要意义。
二叉树的创建与应用实例
二叉树的创建与应用实例一、引言二叉树是一种非常常见的数据结构，它在很多领域都有着广泛的应用，如文件系统、计算机科学、数据挖掘等。
了解和掌握二叉树的结构和应用，对于深入理解数据结构和算法是非常有帮助的。
本篇文档将详细介绍二叉树的创建以及应用实例。
二、二叉树的基本概念二叉树是一种递归定义的数据结构，它由一个根节点和两个子节点（分别称为左子树和右子树）组成。
二叉树的每个节点最多有两个子节点，这使得二叉树具有高度优化和紧凑性的特点。
三、二叉树的创建创建二叉树通常有两种方式：手动创建和通过算法创建。
1.手动创建：手动创建二叉树需要按照二叉树的定义规则，逐个创建节点并连接它们。
这种方式的优点是直观易懂，缺点是手动创建大量的节点会比较繁琐。
2.算法创建：算法创建二叉树通常使用递归的方式，通过特定的算法步骤逐个构建节点。
这种方式可以自动化地创建大量的二叉树，而且效率较高。
四、二叉树的应用实例1.文件系统：文件系统中的目录结构可以看作是一种特殊的二叉树，其中根节点是整个文件系统的入口，左子节点表示子目录，右子节点表示文件。
通过二叉树可以方便地管理和查找文件。
2.计算机科学：在计算机科学中，二叉树常用于表示程序的执行路径，如决策树、堆栈等。
此外，二叉树也常用于数据压缩和哈希算法等。
3.数据挖掘：在数据挖掘中，二叉树常用于分类和聚类算法，如决策树、k-means等。
通过构建二叉树，可以将数据集划分为不同的类别，从而更好地理解和分析数据。
五、应用实例代码展示下面是一个简单的Python代码示例，展示了如何手动创建一个简单的二叉搜索树（BinarySearchTree,BST）：```pythonclassNode:def__init__(self,key):self.left=Noneself.right=Noneself.val=keydefinsert(root,key):ifrootisNone:returnNode(key)else:ifroot.val<key:root.right=insert(root.right,key)else:root.left=insert(root.left,key)returnrootdefinorder(root):ifroot:inorder(root.left)print(root.val),inorder(root.right)r=Node(50)r=insert(r,30)r=insert(r,20)r=insert(r,40)r=insert(r,70)r=insert(r,60)r=insert(r,80)print("Inordertraversalofthegiventree")inorder(r)#Output:20304050607080```六、总结本篇文档详细介绍了二叉树的创建以及应用实例，包括二叉树的基本概念、创建方式以及在文件系统、计算机科学、数据挖掘等领域的应用。
实验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的右子节点。
二叉树的建立实验报告
二叉树的建立实验报告二叉树的建立实验报告引言：二叉树是计算机科学中常用的数据结构之一，它具有良好的组织和查找性能。
本实验旨在通过建立二叉树的过程，深入理解二叉树的概念和操作，并通过实际操作验证其性能。
实验目的：1. 掌握二叉树的基本概念和性质；2. 熟悉二叉树的建立和遍历操作；3. 了解二叉树在实际应用中的作用。
实验过程：1. 二叉树的定义与性质二叉树是一种特殊的树状结构，每个节点最多有两个子节点。
根据节点的位置关系，可以分为左子树和右子树。
二叉树的性质包括：每个节点最多有两个子节点、左子树和右子树也是二叉树、二叉树可以为空。
2. 二叉树的建立为了验证二叉树的性质，我们首先需要建立一个二叉树。
在本实验中，我们选择使用数组来表示二叉树。
具体建立过程如下：- 定义一个数组，用于存储二叉树的节点；- 根据二叉树的性质，按照特定规则将节点填充到数组中；- 通过数组索引的方式，建立节点之间的关联关系。
3. 二叉树的遍历二叉树的遍历是指按照一定顺序访问二叉树中的节点。
常用的遍历方式包括前序遍历、中序遍历和后序遍历。
在本实验中，我们选择中序遍历来验证二叉树的建立是否正确。
中序遍历的过程如下：- 从根节点开始，递归地遍历左子树；- 访问当前节点；- 递归地遍历右子树。
4. 实验结果与分析经过建立和遍历操作，我们得到了一个完整的二叉树。
通过中序遍历，我们可以观察到二叉树节点的有序性，证明了二叉树的建立正确性。
此外，我们还可以通过其他遍历方式来验证二叉树的结构和性质。
实验总结：通过本次实验，我们深入了解了二叉树的概念和操作，并通过实际操作验证了二叉树的性质。
二叉树作为一种常用的数据结构，具有良好的组织和查找性能，在实际应用中发挥着重要的作用。
通过进一步学习和实践，我们可以更加熟练地运用二叉树，并将其应用于解决实际问题中。
参考文献：1. 《数据结构与算法分析》（C语言版），Mark Allen Weiss 著，机械工业出版社，2012年。
二叉树的操作实验报告
二叉树的操作实验报告
实验报告：二叉树的操作
引言：
二叉树是计算机科学中最基础、最重要的数据结构之一，它不仅在算法设计与分析中被广泛应用，而且也在计算机系统和软件工程领域被广泛使用。
在这次实验中，我们将学习和实现二叉树的基本操作，包括二叉树的建立、遍历、查找和删除等。
实验过程：
1. 二叉树的建立
2. 二叉树的遍历
3. 二叉树的查找
4. 二叉树的删除
实验结果：
1. 建立一颗二叉树，根节点为A，左子树B，右子树C，B的左子树D，右子树E，C的左子树F，右子树G。
结构如下：
A
/ \
B C
/ \ / \
D E F G
2. 对上述二叉树先进行中序遍历：DBEAFCG，再进行前序遍历：ABDECFG，最后进行后序遍历：DEBFGCA。
3. 在上述二叉树中查找元素G，并输出其父节点元素C。
4. 删除上述二叉树中的元素F，再对其进行中序遍历，结果为DBEACG。
结论：
通过这次实验，我们掌握了二叉树的基本操作方法，对于理解和分析算法、编写系统和软件工程都具有重要的意义。
同时，在实践中我们也深刻地认识到了二叉树操作的复杂性和局限性，这需要我们在实际应用中加以考虑和综合利用，才能发挥其最大的价值和作用。
二叉树建立及应用
二叉树建立及应用二叉树是一种重要的数据结构，它的建立和应用在计算机科学中具有广泛的应用。
本文将从建立二叉树和二叉树的应用两个方面进行详细介绍。
首先，我们来看如何建立二叉树。
二叉树由节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。
建立二叉树的方法有多种，包括静态建立和动态建立。
静态建立二叉树是指在编写程序时指定二叉树的结构和内容，通常使用数组或链表表示。
例如，定义一个数组arr存储二叉树的节点值，数组的索引表示节点的位置，数组元素存储节点的值。
则节点i的左子节点为2 * i，右子节点为2 * i + 1。
通过遍历数组，我们可以获取二叉树的结构和内容。
动态建立二叉树是指在程序运行时根据具体情况动态地添加节点。
动态建立二叉树的常用方法是使用递归。
例如，我们定义一个函数buildTree，接收一个数组arr和数组的长度n作为参数，返回一个指向二叉树的根节点的指针。
在buildTree函数中，首先判断数组是否为空，如果为空，则返回空指针。
否则，我们找到数组的中间元素作为根节点，并将数组分为左右两个子数组。
然后，递归调用buildTree函数，分别构建左子树和右子树，并将左子树和右子树连接到根节点上。
最后，返回根节点的指针。
建立二叉树后，我们可以利用二叉树进行各种应用。
下面列举几个常见的应用。
1. 二叉树的遍历：二叉树的遍历分为前序遍历、中序遍历和后序遍历。
前序遍历是指先访问根节点，然后先序遍历左子树，再先序遍历右子树。
中序遍历是指先中序遍历左子树，然后访问根节点，再中序遍历右子树。
后序遍历是指先后序遍历左子树，然后后序遍历右子树，最后访问根节点。
二叉树的遍历可以帮助我们按照一定顺序获取节点的值，用于实现各种功能。
2. 二叉搜索树：二叉树中的每个节点都有一个键值，且满足左子树中所有节点的键值小于根节点的键值，右子树中所有节点的键值大于根节点的键值。
这种二叉树称为二叉搜索树。
二叉搜索树的一个重要应用是查找操作，通过比较节点的键值，我们可以快速地定位目标节点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验五二叉树建立及应用
一、实验目的
1．熟悉二叉树的存贮结构及遍历方式，掌握有关算法的实现。
2．能够利用二叉树解决具体问题。
二、实验环境
⒈硬件：每个学生需配备计算机一台。
操作系统：DOS或Windows；
⒉软件：DOS或Windows操作系统+Turbo C；
三、实验要求
⒈要求采用二叉链表作为存贮结构，完成二叉树的建立、先序、中序、和后序遍历的
操作。
⒉输入数据：树中每个结点的数据类型设定为字符型。
3．设计一棵二叉树，输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树，求出先序、中序和后序遍历，求该二叉树所有叶子结点总数。
四、实验内容
附：参考程序为类C语言程序，非标准C语言程序，需要进行相应的修改。
二叉链表结构如下：P134
typedef struct lnode
{char data;
struct lnode *lchild,*rchild;
}lnode,*tree;
1．建树子函数P137
status creat(tree &t)
{//按先序次序输入二叉树中结点的值，’.’字符表示空树
scanf(&ch);
if(ch=='.')
t=null;
else
{t=(tree)malloc(sizeof(lnode));
t->data=ch;
creat(t->lchild);
creat(t->rchild);}
return ok;
}
2．先序遍历子函数P136
preorder(tree t)
{
if(t!=null)
{printf(t->data);
preorder(t->lchild);
preorder(t->rchild);
}
}
3．后序遍历子函数P136
postorder(tree t)
{if(t!=null)
{postorder(t->lchild);
postorder(t->rchild);
printf(t->data);
}
}
五、思考题
1. 已知二叉树先序和中序序列，唯一地构造一棵二叉树并且验证其正确性。
2. 建立一个二叉树，并且按层次遍历操作。
六、报告要求
1．报告要求用专门的实验报告纸书写，字迹清晰，格式规范。
2．报告中应写清姓名、学号、实验日期、实验题目、实验目的、实验要求。
3．报告中应书写源程序，且源程序中要有注释。
4．报告中应包含运行结果及结果分析。
如调试通过，请注明‘通过’并写出输入的数据及运行结果；如未调试通过或结果不正确，试分析原因。
5．报告最后包含实验总结和体会。
七、对综合性实验的说明
实验五是一个综合性的实验，实验中的数据元素采用二叉链表作为存储结构。
该实验要求学生完成建树、遍历、统计叶子结点等多项要求，集成了树、二叉链表、递归等多个知识点。