二叉树的基本操作实验
(完整版)C++二叉树基本操作实验报告
一、实验目的选择二叉链式存储结构作为二叉树的存储结构,设计一个程序实现二叉树的基本操作(包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等)二、实验开发环境Windows 8.1 中文版Microsoft Visual Studio 6.0三、实验内容程序的菜单功能项如下:1------建立一棵二叉树2------前序遍历递归算法3------前序遍历非递归算法4------中序遍历递归算法5------中序遍历非递归算法6------后序遍历递归算法7------后序遍历非递归算法8------求树高9------求叶子总数10-----输出二叉树11-----退出四、实验分析1、建立一棵二叉树2、输入二叉树各节点数据cout<<"请按正确顺序输入二叉树的数据:";cin.getline(t,1000); //先把输入的数据输入到一个t数组3、递归前序遍历void BL1(ECS_data *t){if(NULL!=t){cout<<t->data<<",";BL1(t->l);BL1(t->r);}}4、非递归前序遍历void preOrder2(ECS_data *t){stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){cout<<p->data<<" ";s.push(p);p=p->l;}if(!s.empty()){p=s.top();s.pop();p=p->r;}}}5、递归中序遍历void BL2(ECS_data *t){if(NULL!=t){BL2(t->l);cout<<t->data<<",";BL2(t->r);}}6、非递归中序遍历void inOrder2(ECS_data *t) //非递归中序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){s.push(p);p=p->l;}if(!s.empty()){p=s.top();cout<<p->data<<" ";s.pop();p=p->r;}}}7、递归后序遍历void BL3(ECS_data *t){if(NULL!=t){BL3(t->l);BL3(t->r);cout<<t->data<<",";}}8、非递归后序遍历void postOrder3(ECS_data *t){stack<ECS_data*> s;ECS_data *cur; //当前结点ECS_data *pre=NULL; //前一次访问的结点s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop();pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}9、求树高int Height (ECS_data *t){if(t==NULL) return 0;else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1);}}10、求叶子总数int CountLeaf(ECS_data *t){static int LeafNum=0;//叶子初始数目为0,使用静态变量if(t)//树非空{if(t->l==NULL&&t->r==NULL)//为叶子结点LeafNum++;//叶子数目加1else//不为叶子结点{CountLeaf(t->l);//递归统计左子树叶子数目CountLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum;}五、运行结果附:完整程序源代码://二叉树链式存储的实现#include<iostream>#include<cstring>#include <stack>using namespace std;struct ECS_data //先定义好一个数据的结构{char data;ECS_data *l;ECS_data *r;};class ECS{private://int level; //树高int n; //表示有多少个节点数int n1; //表示的是数组的总长度值,(包括#),因为后面要进行删除判断ECS_data *temp[1000];public:ECS_data *root;ECS() //初始化{ECS_data *p;char t[1000];int i;int front=0,rear=1; //front表示有多少个节点,rear表示当前插入的点的父母cout<<"请按正确顺序输入二叉树的数据:";cin.getline(t,1000); //先把输入的数据输入到一个t数组//cout<<t<<" "<<endl;int n1=strlen(t); //测量数据的长度n=0;for(i=0;i<n1;i++){if(t[i]!='#'){p=NULL;if(t[i]!=',') //满足条件并开辟内存{n++;p=new ECS_data;p->data=t[i];p->l=NULL;p->r=NULL;}front++;temp[front]=p;if(1 == front){root=p;}else{if((p!=NULL)&&(0==front%2)){temp[rear]->l=p;//刚开始把这里写成了==}if((p!=NULL)&&(1==front%2)){temp[rear]->r=p;}if(1==front%2)rear++; //就当前的数据找这个数据的父母}}}}~ECS() //释放内存{int i;for(i=1;i<=n;i++)if(temp[i]!=NULL)delete temp[i];}void JS() //记录节点的个数{int s;s=n;cout<<"该二叉树的节点数为:"<<s<<endl;}void BL1(ECS_data *t)//递归前序遍历{if(NULL!=t){cout<<t->data<<",";BL1(t->l);BL1(t->r);}}void preOrder2(ECS_data *t) //非递归前序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){cout<<p->data<<" ";s.push(p);p=p->l;}if(!s.empty()){p=s.top();s.pop();p=p->r;}}}void BL2(ECS_data *t)//递归中序遍历{if(NULL!=t){BL2(t->l);cout<<t->data<<",";BL2(t->r);}}void inOrder2(ECS_data *t) //非递归中序遍历{stack<ECS_data*> s;ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){s.push(p);p=p->l;}if(!s.empty()){p=s.top();cout<<p->data<<" ";s.pop();p=p->r;}}}void BL3(ECS_data *t)//递归后序遍历{if(NULL!=t){BL3(t->l);BL3(t->r);cout<<t->data<<",";}}void postOrder3(ECS_data *t) //非递归后序遍历{stack<ECS_data*> s;ECS_data *cur; //当前结点ECS_data *pre=NULL; //前一次访问的结点s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop();pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}int Height (ECS_data *t) //求树高{if(t==NULL) return 0;else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1);}}int CountLeaf(ECS_data *t) //求叶子总数{static int LeafNum=0;//叶子初始数目为0,使用静态变量if(t)//树非空{if(t->l==NULL&&t->r==NULL)//为叶子结点LeafNum++;//叶子数目加1else//不为叶子结点{CountLeaf(t->l);//递归统计左子树叶子数目CountLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum;}};int main(){ECS a;a.JS();cout<<"递归前序遍历:";a.BL1(a.root);cout<<endl;cout<<"非递归前序遍历:";a.preOrder2(a.root);cout<<endl;cout<<"递归中序遍历:";a.BL2(a.root);cout<<endl;cout<<"非递归中序遍历:";a.inOrder2(a.root);cout<<endl;cout<<"递归后序遍历:";a.BL3(a.root);cout<<endl;cout<<"非递归后序遍历:";a.postOrder3(a.root);cout<<endl;cout<<"树高为:"<<a.Height(a.root)<<endl;cout<<"叶子总数为:"<<a.CountLeaf(a.root)<<endl;return 0;}。
二叉树基本操作经典实例
二叉树基本操作经典实例二叉树是一种常见的数据结构,它由节点和指向左右子节点的指针组成。
二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点等。
在实际应用中,我们经常需要对二叉树进行基本操作,下面将介绍一些经典的例子。
一、插入节点插入节点是指向二叉树中添加一个新的节点。
在二叉树中插入节点的基本操作可以使用递归或者迭代的方法来实现。
下面是一个使用递归方法的示例代码:```public class TreeNodeint val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }public TreeNode insertNode(TreeNode root, int val)if (root == null)return new TreeNode(val);}if (val < root.val)root.left = insertNode(root.left, val);} else if (val > root.val)root.right = insertNode(root.right, val);}return root;```在上述代码中,通过递归的方式判断要插入的值和当前节点的大小关系,并将值插入到左子树或者右子树中,最后返回根节点。
二、删除节点删除节点是从二叉树中移除一个节点。
删除节点的基本操作可以分为三种情况:删除叶子节点、删除只有一个子节点的节点和删除有两个子节点的节点。
(1)删除叶子节点:如果要删除的节点是叶子节点,直接将该节点的父节点的指针指向空即可。
(2)删除只有一个子节点的节点:如果要删除的节点只有一个子节点,将该节点的子节点连接到该节点的父节点即可。
(3)删除有两个子节点的节点:如果要删除的节点有两个子节点,可以使用该节点右子树中的最小节点或者左子树中的最大节点来替代。
下面是一个使用递归方法的示例代码:```public TreeNode deleteNode(TreeNode root, int key) if (root == null)return root;}if (key < root.val)root.left = deleteNode(root.left, key);} else if (key > root.val)root.right = deleteNode(root.right, key);} elseif (root.left == null)return root.right;} else if (root.right == null)return root.left;}TreeNode minNode = findMin(root.right);root.val = minNode.val;root.right = deleteNode(root.right, minNode.val); }return root;private TreeNode findMin(TreeNode node)while (node.left != null)node = node.left;}return node;```在上述代码中,通过递归的方式判断要删除的值和当前节点的大小关系,并根据不同情况进行处理。
二叉树的基本操作实验报告
二叉树的基本操作实验报告学号姓名实验日期 2012-12-26实验室计算机软件技术实验指导教师设备编号 401实验内容二叉树的基本操作一实验题目实现二叉树的基本操作的代码实现二实验目的1、掌握二叉树的基本特性2、掌握二叉树的先序、中序、后序的递归遍历算法3、通过求二叉树的深度、度为2的结点数和叶子结点数等算法三实习要求(1)认真阅读书上给出的算法(2)编写程序并独立调试四、给出二叉树的抽象数据类型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,且存在上的关系Hr ?H;H={<root,x1>,<root,xr>,H1,Hr};// (4)(D1,{H1})是一棵符合本定义的二叉树,称为根的左子树;(Dr,{Hr})是一棵符合本定义的二叉树,称为根的右子树。
//基本操作:CreateBiTree( &T, definition ) // 初始条件:definition给出二叉树T的定义。
// 操作结果:按definiton构造二叉树T。
BiTreeDepth( T )// 初始条件:二叉树T存在。
// 操作结果:返回T的深度。
PreOrderTraverse( T, visit() ) // 初始条件:二叉树T存在,Visit是对结点操作的应用函数。
(完整版)C++二叉树基本操作实验报告
、实验目的选择二叉链式存储结构作为二叉树的存储结构,设计一个程序实现二叉树的基本操作(包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等)二、实验开发环境Windows 8.1 中文版Microsoft Visual Studio 6.0三、实验内容程序的菜单功能项如下:1 -- 建立一棵二叉树2 -- 前序遍历递归算法3 -- 前序遍历非递归算法4 -- 中序遍历递归算法5 -- 中序遍历非递归算法6 ---- 后序遍历递归算法7 ---- 后序遍历非递归算法8 ---- 求树高9 -- 求叶子总数10 - 输出二叉树11 - 退出四、实验分析1、建立一棵二叉树2、输入二叉树各节点数据coutvv"请按正确顺序输入二叉树的数据:";cin.getline(t,1000); //先把输入的数据输入到一个t 数组3、递归前序遍历void BL1(ECS_data *t) {if(NULL!=t){cout<<t->data<<",";BL1(t->l);BL1(t->r);}}4、非递归前序遍历void preOrder2(ECS_data *t){ stack<ECS_data*> s; ECS_data *p=t; while(p!=NULL||!s.empty()) { while(p!=NULL){cout<<p->data<<" ";s.push(p); p=p->l;} if(!s.empty()){p=s.top(); s.pop(); p=p->r;}}}5、递归中序遍历void BL2(ECS_data *t) {if(NULL!=t){BL2(t->l);cout<<t->data<<",";BL2(t->r);}}6、非递归中序遍历void inOrder2(ECS_data *t) //非递归中序遍历{stack<ECS_data*> s;ECS_data *p=t; while(p!=NULL||!s.empty()){while(p!=NULL){s.push(p);p=p->l;}if(!s.empty()){p=s.top(); cout<<p->data<<" "; s.pop();p=p->r;}7、递归后序遍历void BL3(ECS_data *t) {if(NULL!=t){BL3(t->l);BL3(t->r); cout<<t->data<<",";8、非递归后序遍历void postOrder3(ECS_data *t){stack<ECS_data*> s;ECS_data *cur; //当前结点ECS_data *pre=NULL; // 前一次访问的结点s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop();pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}9、求树高int Height (ECS_data *t) {if(t==NULL) return 0; else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1); }10、求叶子总数int CountLeaf(ECS_data *t){static int LeafNum=O;//叶子初始数目为0,使用静态变量if(t)// 树非空{if(t->l==NULL&&t->r==NULL)// 为叶子结点LeafNum++;// 叶子数目加 1 else//不为叶子结点{Cou ntLeaf(t->l);//递归统计左子树叶子数目 Cou ntLeaf(t->r);//递归统计右子树叶子数目 }}return LeafNum; }五、运行结果附:完整程序源代码: 〃二叉树链式存储的实现#in cludeviostream> #in clude<cstri ng>#in elude <stack> using n ames pace std; struct ECS_data //先定义好一个数据的结构 {char data;ECS_data *l; ECS_data *r; };" //树高//表示有多少个节点数〃表示的是数组的总长度值,(包括#),因为后面要class ECS {P rivate://in t level; int n; int n1;} }ECS_data *temp[1000];public: ECS_data *root; ECS() // 初始化 {ECS_data *p; char t[1000];int i; int front=0,rear=1;入的点的父母 //front 表示有多少个节点, rear 表示当前插 coutvv"请按正确顺序输入二叉树的数据:"; cin.getline(t,1000); //cout<<t<<" "<<endl;int n1=strlen(t); n=0; for(i=0;i<n1;i++) {if(t[i]!='#') {//先把输入的数据输入到一个 t 数组 //测量数据的长度p=NULL;if(t[i]!=',') {n++;p=new ECS_data; p->data=t[i]; p->l=NULL; p->r=NULL; } front++;temp[front]=p; if(1 ==front){root=p;} else{//满足条件并开辟内存if((p!=NULL)&&(0==front%2)) {temp[rear]->l=p;// 刚开始把这里写成了 == }if((p!=NULL)&&(1==front%2)) {temp[rear]->r=p; }if(1==front%2)rear++;//就当前的数据找这个数据的父母}} }}~ECS(){int i;for(i=1;i<=n;i++) if(temp[i]!=NULL) delete temp[i]; } void JS() {int s; s=n;coutvv"该二叉树的节点数为:"vvsvvendl; }void BL1(ECS_data *t)// 递归前序遍历 {if(NULL!=t){cout<<t->data<<","; BL1(t->l); BL1(t->r);}void preOrder2(ECS_data *t) //非递归前序遍历{stack<ECS_data*> s; ECS_data *p=t;while(p!=NULL||!s.empty()){while(p!=NULL){cout<<p->data<<" "; s.push(p); p=p->l;}if(!s.empty()){p=s.top(); s.pop(); p=p->r;//释放内存//记录节点的个数if(NUL匚丛)宀BL2(e_)-coufAvdafaAfr BL2(g-voidino ‘de ‘2(Ecslda応J )二卅融丘甘甸壷逗宀sfackAECSIdafa*vs 八 ECSIdafa *P H Cwhi-e(p一 hnul匚-一 s.empfyo) 宀wh=e(p一"NULL)宀s.push(p)八PHP —vrif (一s.empfyo)宀PHSlopucoufAAP —vdafaAAs.popwPHP*voidBL3(Ecsldafa *U 1融&训引筍已宀if(NUL匚丛)宀BL3(e_)- BL3(g- coufAAf —vdafaAdrvoidposfo ‘de ‘3(Ecsldafa *0&可甸壷逗 宀sfackAECSIdafa*vs 八ECSIdafa*cucm 遡璋、的ECSIdafa*p‘eHNUF二遡—舟曲亘兼叫、的s.push(t);while(!s.empty()){cur=s.top();if((cur->l==NULL&&cur->r==NULL)||(pre!=NULL&&(pre==cur->l||pre==cur->r))){ cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过s.pop(); pre=cur;}else{if(cur->r!=NULL)s.push(cur->r);if(cur->l!=NULL)s.push(cur->l);}}}int Height (ECS_data *t) //求树高{if(t==NULL) return 0; else{int m = Height ( t->l );int n = Height(t->r);return (m > n) ? (m+1) : (n+1);}}int CountLeaf(ECS_data *t) //求叶子总数{static int LeafNum=0;//叶子初始数目为0,使用静态变量if(t)//树非空{if(t->l==NULL&&t->r==NULL)// 为叶子结点LeafNum++;//叶子数目加1else//不为叶子结点{CountLeaf(t->l);// 递归统计左子树叶子数目Cou ntLeaf(t->r);//递归统计右子树叶子数目}}return LeafNum; }};int main(){ECS a;a.JS();coutvv"递归前序遍历:";a.BL1(a.root);cout<<endl;coutvv"非递归前序遍历:";a.preOrder2(a.root);coutvvendl;coutvv"递归中序遍历:";a.BL2(a.root);coutvvendl;coutvv"非递归中序遍历:";a.inOrder2(a.root);coutvvendl;coutvv"递归后序遍历:";a.BL3(a.root);coutvvendl;coutvv"非递归后序遍历:";a.postOrder3(a.root);coutvvendl;coutvv"树高为:"vva.Height(a.root)vvendl;coutvv"叶子总数为:"vva.CountLeaf(a.root)vvendl; return 0; }。
实验二 二叉树的基本操作
实验三二叉树的基本操作一、实验目的1、进一步掌握树的结构及非线性特点,递归特点和动态性。
2、掌握二叉树的建立算法。
3、掌握二叉树的三种遍历方法以及基于遍历的几种基本操作。
二、实验内容1、二叉树的链式存储结构的建立;2、二叉树的三种遍历算法以及基于遍历的几种操作的实现。
三、实验要求1、学生用C++/C完成算法设计和程序设计并上机调试通过;2、撰写实验报告,提供实验测试数据和实验结果;3、分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。
四、实验准备1、了解树的结构特点及概念、二叉树的概念及结构特点。
2、了解树和二叉树的基本概念和术语。
3、二叉树的三种遍历方法(先序、中序、后序遍历)先序遍历:若二叉树为空,则空操作,否则①访问根结点;②先序遍历左子树;③先序遍历右子树。
中序遍历:若二叉树为空,则空操作,否则①中序遍历左子树;②访问根结点;③中序遍历右子树。
后序遍历:若二叉树为空,则空操作,否则①后序遍历左子树;②后序遍历右子树;③访问根结点。
4、二叉树的各种存储结构及其适用范围,特别是链式存储结构。
五、实验步骤1、编程实现二叉树的建立、遍历以及基于遍历的几种基本操作。
(1)采用二叉链表存储结构创建一个二叉树;(2)用递归方法实现二叉树的三种遍历算法(3)求二叉树中叶子结点的个数,度为1 的结点个数和度为2 的结点个数;(4)求二叉树的深度。
六、实验参考代码#include "iostream.h"#include "stdio.h"#include "stdlib.h"#define OK 1#define ERROR 0#define OVERFLOW -2#define NULL 0typedef char TElemType; //限定元素的数据类型typedef int Status;typedef struct BiTNode // 定义二叉树结点结构{TElemType data;BiTNode *lchild, *rchild; // 左右孩子指针} BiTNode, *BiTree;//按扩展的前序序列建立二叉树存储结构的算法Status CreateBiTree(BiTree &T){char ch;scanf("%c",&ch);if (ch=='#') T = NULL;else{if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);T->data = ch; // 生成根结点CreateBiTree(T->lchild); // 构造左子树CreateBiTree(T->rchild); // 构造右子树}return OK;} // CreateBiTree// 先序遍历二叉树void PreOrder (BiTree T){if (T) {printf("%4c",T->data); // 访问结点PreOrder(T->lchild); // 遍历左子树PreOrder(T->rchild) ; // 遍历右子树}}// 中序遍历二叉树void InOrder (BiTree T){if (T){InOrder(T->lchild); // 遍历左子树printf("%4c",T->data); // 访问结点InOrder(T->rchild);// 遍历右子树}}// 后序遍历二叉树void PostOrder (BiTree T){if (T) {PostOrder (T->lchild); // 遍历左子树PostOrder (T->rchild);// 遍历右子树printf("%4c",T->data); // 访问结点}}//求二叉树的叶子结点数void CountLeaf (BiTree T, int& count){if(T){if((!T->lchild)&&(!T->rchild)) count++;CountLeaf(T->lchild,count);CountLeaf(T->rchild,count);}}//求二叉树中度为1的结点和度为2 的结点的数void CountBT(BiTree T,int &m,int &n){if(T){if((T->lchild!=0)&&(T->rchild!=0))n++; //度为2的结点else if(((T->lchild!=0)&&(T->rchild==0))||((T->lchild==0)&&(T->rchild!=0)))m++; //度为1 的结点CountBT (T->lchild,m,n);CountBT (T->rchild,m,n);}}//以下是求二叉树的深度int Depth (BiTree T ){int m,n;if(!T) return 0;else{m = Depth(T->lchild);n = Depth(T->rchild);return (m>n?m:n)+1;}}//主函数void main(){BiTree T;int s=0,m=0,n=0,d=0;T=NULL;int select;while(1) {printf("\n 请选择要执行的操作:\n");printf("1.创建二叉树\n");printf("2.二叉树的递归遍历算法(前、中、后)\n");printf("3.求二叉树的叶子结点数\n");printf("4.求二叉树的深度\n");printf("0.退出\n");scanf("%d",&select);getchar();switch(select) {case 0:return;case 1:printf("\n 请按先序次序输入各结点的值,以#表示空树:\n");CreateBiTree(T);printf("二叉树已建立完毕!\n");break;case 2:if(!T) printf("\n 未建立树,请先建树!\n");else {printf("\n 先序遍历:");PreOrder(T);printf("\n 中序遍历:");InOrder(T);printf("\n 后序遍历:");PostOrder(T);printf("\n");}break;case 3:if(!T) printf("\n 未建立树,请先建树!\n");else{CountLeaf(T,s);printf("\n 叶子结点数为:%d\n",s);CountBT(T,m,n);printf("度为1的结点数为:%d\n",m);printf("度为2 的结点数为:%d\n",n);}break;case 4:if(!T) printf("\n 未建立树,请先建树!\n");else{d=Depth(T);printf("\n 二叉树的深度为:%d\n",d);}break;default:printf("请确认选择项:\n");}//end switch}//end while}七、测试数据教材138 页,图7-10所示的二叉树按展的前序序列输入序列为:A B D # G # # # C E # # F H # # #。
数据结构实验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.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法;5.掌握构造哈夫曼树以及哈夫曼编码的方法。
实验内容编制一个演示二叉树创建、遍历、计算等操作的程序。
问题描述用数据结构相关知识,实现二叉树的定义和操作。
该程序包括二叉树结构类型以及对二叉树操作的具体的函数定义(包括:初始化二叉树、清空二叉树、检查二叉树是否为空、遍历二叉树(先序、后序、中序、层次)、求二叉树的深度、求二叉树所有节点数)。
问题分析该实验是基于C语言和数据结构知识基础的对二叉树的基本操作的检验,无需设计复杂的算法,程序语句也相对简单。
因此,我直接按要求定义了对二叉树操作的具体函数,并于主函数中实现对应的功能调用,其中,功能选择靠switch语句实现。
实验步骤1.需求分析本演示程序用VC++编写,完成二叉树的生成、遍历、计算等基本操作。
①输入的形式和输入值的范围:以字符(其中‘#’表示虚节点)的形式输入,以创建二叉树;在输入二叉树节点前,必须先确定该序列能正确创建二叉树。
②输出的形式:在所有三种操作中都显示操作是否正确以及操作后二叉树的内容。
③程序所能达到的功能:完成二叉树的生成、遍历(包括先序、后序、中序、层次四种方式)、计算等基本操作。
④测试数据:创建操作中依次输入a,b,d,#,g,#,#,#,c,e,#,#,f,#,#生成一个二叉树。
2.概要设计1)为了实现上述程序功能,需要定义二叉树的抽象数据类型:ADT BitTree {数据对象:由一个根节点和两个互不相交的左右子树构成数据关系:结点具有相同的数据类型及层次结构基本操作:Void BinTreeInit(BitTree *T)初始条件:无操作结果:初始化一棵二叉树Void BinTreeCreat(BitTree *T)初始条件:二叉树T已存在操作结果:按先序次序创建一棵二叉树2)本程序包含7个函数:①主函数main() ②初始化二叉树函数BinTreeInit() ③建立一棵二叉树函数BinTreeCreat() ④先序遍历函数PreOrderTraverse() ⑤中序遍历函数InOrderTraverse()⑥后序遍历函数PostOrderTraverse()⑦层次遍历函数LevelOrderTraverse()⑧求二叉树深度函数Countlevel()⑨检验空树函数BinTreeEmpty()⑩求节点数函数 Countnode()函数说明#include<stdio.h>#include<stdlib.h>typedef char Datatype;typedef struct NodeType{Datatype data;struct NodeType *lchild;struct NodeType *rchild;}BiTNode;typedef BiTNode * BinTree;//初始化二叉树。
二叉树实验报告
二叉树实验报告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.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。
通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。
通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。
同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。
二叉树的基本操作实验报告
二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中,我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。
在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可。
如果要删除的节点只有一个子节点,将其子节点连接到父节点上。
如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果:通过实验,我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。
通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。
数据结构实验报告(二叉树的基本操作)
else LeafNum=LeafCount(root->LChild)+LeafCount(root->RChild);
//叶子数为左右子树数目之和
return LeafNum;
printf("\n菜单选择\n\n");
printf(" 1.树状输出二叉树2.先序遍历二叉树\n");
printf(" 3.中序遍历二叉树4.后序遍历二叉树\n");
printf(" 5.输出叶子结点6.输出叶子结点的个数\n");
printf(" 7.输出二叉树的深度8.退出\n");
printf("\n----------------------------------------------------------------------\n");
{
printf("\n\n");
j=j+1; k=0;
while(k<nlocate)
{
printf(" ");
k++;
}
}
while(k<(nlocate-1))
{
printf(" ");
k++;
}
printf("%c",bt->data );
q.front=q.front+1;
if(bt->LChild !=NULL)//存在左子树,将左子树根节点入队列
二叉树基本操作--实验报告
宁波工程学院电信学院计算机教研室实验报告一、实验目的1、熟悉二叉树树的基本操作。
2、掌握二叉树的实现以及实际应用。
3、加深二叉树的理解,逐步培养解决实际问题的编程能力。
二、实验环境1台WINDOWS环境的PC机,装有Visual C++ 6.0。
三、实验内容【问题描述】现需要编写一套二叉树的操作函数,以便用户能够方便的利用这些函数来实现自己的应用。
其中操作函数包括:1>创建二叉树CreateBTNode(*b,*str):根据二叉树括号表示法的字符串*str生成对应的链式存储结构。
2>输出二叉树DispBTNode(*b):以括号表示法输出一棵二叉树。
3>查找结点FindNode(*b,x):在二叉树b中寻找data域值为x的结点,并返回指向该结点的指针。
4>求高度BTNodeDepth(*b):求二叉树b的高度。
若二叉树为空,则其高度为0;否则,其高度等于左子树与右子树中的最大高度加l。
5>求二叉树的结点个数NodesCount(BTNode *b)6>先序遍历的递归算法:void PreOrder(BTNode *b)7>中序遍历的递归算法:void InOrder(BTNode *b)8>后序遍历递归算法:void PostOrder(BTNode *b)9>层次遍历算法void LevelOrder(BTNode *b)【基本要求】实现以上9个函数。
主函数中实现以下功能:创建下图中的树b输出二叉树b找到’H’节点,输出其左右孩子值输出b的高度输出b的节点个数输出b的四种遍历顺序上图转化为二叉树括号表示法为A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str);//创建BTNode *FindNode(BTNode *b,ElemType x);//查找节点int BTNodeHeight(BTNode *b);//求高度void DispBTNode(BTNode *b);//输出int NodesCount(BTNode *b);//二叉树的结点个数void PreOrder(BTNode *b);//先序遍历递归void InOrder(BTNode *b);//中序遍历递归void PostOrder(BTNode *b);//后序遍历递归void LevelOrder(BTNode *b);//层次遍历//创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':top++;St[top]=p;k=1;break;case ')':top--;break;case ',':k=2;break;default:p=(BTNode *)malloc(sizeof(BTNode));p->data=ch;p->lchild=p->rchild=NULL;if(b==NULL)b=p;else{switch(k){case 1:St[top]->lchild=p;break;case 2:St[top]->rchild=p;break;}}}j++;ch=str[j];}}//输出void DispBTNode(BTNode *b){if(b!=NULL){printf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){printf("(");DispBTNode(b->lchild);if(b->rchild!=NULL)printf(",");DispBTNode(b->rchild);printf(")");}}}//查找节点BTNode *FindNode(BTNode *b,ElemType x){BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=FindNode(b->lchild,x);if(p!=NULL)return p;elsereturn FindNode(b->rchild,x);}}//求高度int BTNodeHeight(BTNode *b){int lchildh,rchildh;if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild);rchildh=BTNodeHeight(b->rchild);return(lchildh>rchildh)?(lchildh+1):(rchildh+1);}}//二叉树的结点个数int NodesCount(BTNode *b){if(b==NULL)return 0;elsereturn NodesCount(b->lchild)+NodesCount(b->rchild)+1;}//先序遍历递归void PreOrder(BTNode *b){if(b!=NULL){printf("%c",b->data);PreOrder(b->lchild);PreOrder(b->rchild);}}//中序遍历递归void InOrder(BTNode *b){if(b!=NULL){InOrder(b->lchild);printf("%c",b->data);InOrder(b->rchild);}}//后序遍历递归void PostOrder(BTNode *b){if(b!=NULL){PostOrder(b->lchild);PostOrder(b->rchild);printf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){BTNode *p;BTNode *qu[MaxSize];int front,rear;front=rear=-1;rear++;qu[rear]=b;while(front!=rear){front=(front+1)%MaxSize;p=qu[front];printf("%c",p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->lchild;}if(p->rchild!=NULL){rear=(rear+1)%MaxSize;qu[rear]=p->rchild;}}}void main(){BTNode *b,*p,*lp,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";//根据树形图改写成的//二叉树括号表示法的字符串*str//char str[100];scanf("%s",&str);//自行输入括号表示的二叉树CreateBTNode(b,str); //创建树bprintf("\n");printf("输出二叉树:");//输出二叉树bDispBTNode(b);printf("\n");printf("'H'结点:");//找到'H'节点,输出其左右孩子值p=FindNode(b,'H');printf("\n");if (p!=NULL){printf("左孩子节点的值");printf("%c",p->lchild->data);printf("\n");printf("右孩子节点的值");printf("%c",p->rchild->data);printf("\n");//此处输出p的左右孩子节点的值}printf("\n");printf("二叉树b的深度:%d\n",BTNodeHeight(b));//输出b的高度printf("二叉树b的结点个数:%d\n",NodesCount(b));//输出b的节点个数printf("\n");printf(" 先序遍历序列:\n");//输出b的四种遍历顺序printf(" 算法:");PreOrder(b);printf("\n");printf(" 中序遍历序列:\n");printf(" 算法:");InOrder(b);printf("\n");printf(" 后序遍历序列:\n");printf(" 算法:");PostOrder(b);printf("\n");printf(" 层次遍历序列:\n");printf(" 算法:");LevelOrder(b); printf("\n");}四、实验心得与小结通过实验,我熟悉二叉树树的基本操作,掌握二叉树的实现以及实际应用。
二叉树的基本操作实验
图(1)
图表1
else if(a==4)
{
printf("层序遍历:");
howmuch(T,2);
}
else if(a==5)
{
printf("总节点数:");
howmuch(T,0);
}
else if(a==6)
{
printf("总叶子数:");
howmuch(T,1);
}
else if(a==7)
{
printf("树的深度:");
二 概要设计
功能实现
1.int CreatBiTree(BiTree &T)用递归的方法先序建立二叉树, 并用链表储存该二叉树
2.int PreTravel(BiTree &T)前序遍历
3.intMidTravel(BiTree &T)中序遍历
4.intPostTravel(BiTree &T)后序遍历
实验三 二叉树的基本运算
一、实验目的
1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容
[问题描述]
建立一棵二叉树,试编程实现二叉树的如下基本操作:
1. 按先序序列构造一棵二叉链表表示的二叉树T;
2. 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;
5.int Depth(BiTree &T) //计算树的深度
6.inthowmuch(BiTree T,int h)采用树节点指针数组,用于存放遍历到的元素地址,如果有左孩子,存入地址,j加一 ,否则没操作,通过访问数组输出层次遍历的结果。k计算叶子数,j为总节点。
二叉树实验报告总结(共10篇)
二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。
二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,并简要给出算法设计小结和心得。
四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。
用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。
3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。
五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。
二叉树基本操作
二叉树基本操作二叉树基本操作一、实验目的1.熟悉二叉树结点的结构和对二叉树的基本操作。
2.掌握对二叉树每一种操作的具体实现。
3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
4.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法。
5.掌握构造哈夫曼树以及哈夫曼编码的方法。
二、实验内容(必做1)程序 1该程序的功能是实现二叉树结点的类型定义和对二叉树的基本操作。
该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。
/* 定义 DataType 为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{DataType data;struct BitNode *lchild,*rchild;}BitNode,*BitTree;/* 初始化二叉树,即把树根指针置空 */void BinTreeInit(BitTree *BT)/* 按先序次序建立一个二叉树*/void BinTreeCreat(BitTree *BT)/* 检查二叉树是否为空 */int BinTreeEmpty(BitTree *BT)/* 按任一种遍历次序(包括按先序、中序、后序、按层次)输出二叉树中的所有结点 */void BinTraverse(BitTree *BT)/* 求二叉树的深度 */int BinTreeDepth(BitTree BT)/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT)/* 清除二叉树,使之变为空树 */void BinTreeClear(BitTree *BT)程序2 二叉树采用二叉链表存储,设计按层次遍历二叉树的算法。
设计要求:在程序中构造两个子程序分别为void BinTreeCreat(BitTree *BT) /* 按前序次序建立一个二叉树*/ void layorder(BitTree T) /*按层次遍历二叉树 */程序 3哈夫曼树和哈夫曼编码:从终端输入若干个字符,统计字符出现的频率,将字符出现的频率作为结点的权值,建立哈夫曼树,然后对各字符进行哈夫曼编码。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。
问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。
由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。
处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。
算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。
输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。
对二叉树的一些运算结果以整型输出。
程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。
计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。
对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。
测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。
二叉树实验
二叉树实验1 实验目的1、熟悉二叉树的二叉链表存储结构;2、掌握构造二叉树的方法;3、加深对二叉树前序、中序、后序遍历的理解。
2 需求分析2.1 任务1功能:void PreOrder(BTNode *bt) 先序遍历约束条件:沿用源代码中链表结构体。
输入要求:输入一个二叉树链表。
输出要求:若是二叉树链表不为空则对二叉树链表进行先序遍历。
2.2 任务2功能:void InOrder(BTNode *bt) 中序遍历。
约束条件:沿用源代码中链表结构体。
输入要求:输入一个二叉树链表。
输出要求:若是二叉树链表不为空则对二叉树链表进行中序遍历。
2.3 任务3功能:void PostOrder(BTNode *bt) 后序遍历。
约束条件:沿用源代码中链表结构体。
输入要求:输入一个二叉树链表。
输出要求:若是二叉树链表不为空则对二叉树链表进行后序遍历。
2.4 任务4功能:int HeightBTree(BTNode *bt) 求二叉树的深度。
约束条件:沿用源代码中链表结构体。
输入要求:输入一个二叉树链表。
输出要求:若是二叉树链表为空则返回0,若二叉树链表不为空则统计出该二叉树的深度,然后返回该值。
2.5 任务5功能:void DisplayBTree(BTNode * bt,int i) 输出二叉树第i层的所有节点。
约束条件:沿用源代码中链表结构体。
输入要求:输入一个二叉树链表。
输出要求:若输入的i小于1,或者二叉树链表为空则直接返回,若二叉树链表不为空且i值符合要求,则打印i层所有的节点。
3概要设计3.1任务1void PreOrder(BTNode *bt)该函数首先进行条件判断if (bt != NULL)。
如果节点不为空,则执行后续的遍历操作。
如果节点为空,则不执行任何操作。
之后执行线序遍历:先打印当前节点的数据printf("%c", bt->data),然后递归调用先序遍历函数来处理左子树PreOrder(bt->lchild),然后递归调用先序遍历函数来处理右子树PreOrder(bt->rchild)。
实验七:二叉树的基本操作
实验七二叉树的基本操作一、【实验目的】1、掌握二叉树的链式存储结构2、掌握二叉树的基本操作(如左结点插入、右结点插入、左子树删除、右子树删除操作)3、掌握二叉树的三种遍历算法。
二、【实验内容】实现二叉树的插入操作,利用先序遍历实现叔的结点打印,并求出二叉树结点个数。
打印的结果为:ABCDFGE以下是部分代码:BiTree.htypedef struct Node{DataType data; /*数据域*/struct Node *leftChild; /*左子树指针*/struct Node *rightChild; /*右子树指针*/}BiTreeNode; /*结点的结构体定义*//*初始化创建二叉树的头结点*/void Initiate(BiTreeNode **root){*root = (BiTreeNode *)malloc(sizeof(BiTreeNode));(*root)->leftChild = NULL;(*root)->rightChild = NULL;}void Destroy(BiTreeNode **root){if((*root) != NULL && (*root)->leftChild != NULL)Destroy(&(*root)->leftChild);if((*root) != NULL && (*root)->rightChild != NULL)Destroy(&(*root)->rightChild);free(*root);}/*若当前结点curr非空,在curr的左子树插入元素值为x的新结点*/ /*原curr所指结点的左子树成为新插入结点的左子树*//*若插入成功返回新插入结点的指针,否则返回空指针*/ BiTreeNode *InsertLeftNode(BiTreeNode *curr, DataType x){独立完成}/*若当前结点curr非空,在curr的右子树插入元素值为x的新结点*/ /*原curr所指结点的右子树成为新插入结点的右子树*//*若插入成功返回新插入结点的指针,否则返回空指针*/BiTreeNode *InsertRightNode(BiTreeNode *curr, DataType x) {}/*若curr非空,删除curr所指结点的左子树*//*若删除成功返回删除结点的双亲结点指针,否则返回空指针*/ BiTreeNode *DeleteLeftTree(BiTreeNode *curr){if(curr == NULL || curr->leftChild == NULL) return NULL;Destroy(&curr->leftChild);curr->leftChild = NULL;return curr;}/*若curr非空,删除curr所指结点的右子树*//*若删除成功返回删除结点的双亲结点指针,否则返回空指针*/ BiTreeNode *DeleteRightTree(BiTreeNode *curr){if(curr == NULL || curr->rightChild == NULL) return NULL;Destroy(&curr->rightChild);curr->rightChild = NULL;return curr;}void PreOrder(BiTreeNode *t, void visit(DataType item)) /*使用visit()函数前序遍历二叉树t*/{}void visit(DataType item){printf("%c ", item);}主程序:#include <stdlib.h>#include <stdio.h>typedef char DataType;#include "BiTree.h"void main(void){ //插入操作,独立完成printf("前序遍历:");//遍历Destroy(&root); }三、【实验源代码】四、【实验结果】五、【实验心得】。
实验2 二叉树的基本操作
实验二二叉树的基本操作
一、实验目的与基本要求
掌握二叉树的结构特性,以及存储结构的特点。
掌握在链式存储结构上实现二叉树的基本操作的编程技术。
掌握用指针类型描述,访问和处理二叉树的运算。
二、实验准备
硬件:一台微机
软件:操作系统和Microsoft VC++ 6.0
三、实验内容
1、编写算法实现完全二叉树的性质5
设对一完全二叉树(含有15个结点个数)有如下说明:
int bt[16],i;/* 结点编号从1开始*/
任意给定结点i,验证关于完全二叉树的性质,即i的两个子结点为2*i和2*i+1,i的双亲结点为i/2。
2、编写算法实现二叉树三种遍历
(1)功能
建立二叉树,并进行遍历。
(2)输入要求
使用按数组标号法输入的方法构造二叉链表即构造二叉树。
二叉树结点中的数据为字符型,输入元素序号与值顺序为1A,2B,3C,4D,6F, 7G , 输入的两个数据都为0时,结束输入。
(3)测试数据
用三种递归方法输出遍历结果。
概要设计:
模块划分为5个,即(1)用数组表示输入法构造二叉链表,即编写建立二叉树的函数create (2)递归先序、中序、后序遍历3个模块;
(3)主函数。
调用create函数,建立一颗二叉树;然后分别调用先序、中序、后序遍历函数,将二叉树的先序、中序和后序遍历序列输出到屏幕上。
四、实验要求
1.用C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
五、程序实现
写出每个操作的算法(操作过程)
六、程序运行情况
写出输入数据及运行结果
1。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三二叉树的基本运算一、实验目的1、使学生熟练掌握二叉树的逻辑结构和存储结构。
2、熟练掌握二叉树的各种遍历算法。
二、实验内容[问题描述]建立一棵二叉树,试编程实现二叉树的如下基本操作:1. 按先序序列构造一棵二叉链表表示的二叉树T;2. 对这棵二叉树进行遍历:先序、中序、后序以及层次遍历,分别输出结点的遍历序列;3. 求二叉树的深度/结点数目/叶结点数目;(选做)4. 将二叉树每个结点的左右子树交换位置。
(选做)[基本要求]从键盘接受输入(先序),以二叉链表作为存储结构,建立二叉树(以先序来建立),[测试数据]如输入:ABCффDEфGффFффф(其中ф表示空格字符)则输出结果为先序:ABCDEGF中序:CBEGDFA后序:CGEFDBA层序:ABCDEFG[选作内容]采用非递归算法实现二叉树遍历。
三、实验前的准备工作1、掌握树的逻辑结构。
2、掌握二叉树的逻辑结构和存储结构。
3、掌握二叉树的各种遍历算法的实现。
一实验分析本次试验是关于二叉树的常见操作,主要是二叉树的建立和遍历。
二叉树的遍历有多种方法,本次试验我采用递归法,递归法比较简单。
二概要设计功能实现1.int CreatBiTree(BiTree &T) 用递归的方法先序建立二叉树, 并用链表储存该二叉树2.int PreTravel(BiTree &T) 前序遍历3. int MidTravel(BiTree &T) 中序遍历4.int PostTravel(BiTree &T) 后序遍历5.int Depth(BiTree &T) //计算树的深度6.int howmuch(BiTree T,int h) 采用树节点指针数组,用于存放遍历到的元素地址,如果有左孩子,存入地址,j加一,否则没操作,通过访问数组输出层次遍历的结果。
k计算叶子数,j为总节点。
7. int exchang(BiTree &T) 交换左右子树,利用递归,当有左右孩子时才交换三详细设计#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;int CreatBiTree(BiTree &T){//先序法创建二叉树char ch;if((ch=getchar())==' ')T=NULL;else{T=(BiTNode*)malloc(sizeof(BiTNode));if(!T)exit(1);T->data=ch;CreatBiTree(T->lchild);CreatBiTree(T->rchild);}return 0;}int PreTravel(BiTree &T){//前序遍历if(T){printf("%c",T->data);PreTravel(T->lchild);PreTravel(T->rchild);}return 0;}int MidTravel(BiTree &T){//中序遍历if(T){MidTravel(T->lchild);printf("%c",T->data);MidTravel(T->rchild);}return 0;}int PostTravel(BiTree &T){//后序遍历if(T){PostTravel(T->lchild);PostTravel(T->rchild);printf("%c",T->data);}return 0;}int howmuch(BiTree T,int h){BiTNode *Q[100];//树节点指针数组,用于存放遍历到的元素地址if(T==NULL)printf("空的二叉树\n");Q[0]=T; //存入树根int i,k=0;int j=1; //j为总节点for(i=0;i<j;i++){if(Q[i]->lchild!=NULL) //如果有左孩子,存入地址,j加一,否则没操作{Q[j]=Q[i]->lchild ;j++;}if(Q[i]->rchild!=NULL) //如果有右孩子,存入地址,j加一,否则没操作{Q[j]=Q[i]->rchild ;j++;}if(Q[i]->lchild==NULL&&Q[i]->rchild==NULL)k++; //计算叶子数}if(h==0)printf("%d", j);else if(h==1)printf("%d",k);else if(h==2){for(i=0;i<j;i++)printf("%c",Q[i]->data);}else{printf("参数错误");}return 0;}int Depth(BiTree &T) //计算树的深度{int lh , rh ;if( NULL == T )return 0 ;}else{lh = Depth( T->lchild ) ;rh = Depth( T->rchild ) ;return ( lh > rh ? lh : rh ) + 1 ;}}int exchang(BiTree &T)//交换左右子树{if(T != NULL){if(T->lchild!=NULL&&T->rchild!=NULL)//当有左右孩子时才交换{char t;t=T->lchild->data;T->lchild->data=T->rchild->data;T->rchild->data=t; //交换数据}exchang(T->lchild);// 递归调用exchang(T->rchild);}return 0;}int choose(BiTree T) //功能选{int a;scanf("%d",&a);if(a==1){printf("先序遍历:");PreTravel(T);}else if(a==2){printf("中序遍历:");MidTravel(T);}else if(a==3){printf("后序遍历:");PostTravel(T);else if(a==4){printf("层序遍历:");howmuch(T,2);}else if(a==5){printf("总节点数:");howmuch(T,0);}else if(a==6){printf("总叶子数:");howmuch(T,1);}else if(a==7){printf("树的深度:");printf("%d",Depth(T));}else if(a==8){printf("交换前\n");howmuch(T,2);exchang(T);printf("交换后\n");howmuch(T,2);}else if(a==9)exit(1);else printf("没有这个操作\n");printf(" 操作完成,请输入下一个操作\n");choose(T);return 0;}int main() //主函数{printf("----------------二叉树的基本操作----------------\n");printf("请先建立二叉树,按先序的方式输入如果数据为空输入空格\n");BiTree T; //定义二叉树,初始化CreatBiTree(T);choose(T);return 0;}四用户手册根据程序的提示按先序输入二叉树,如果数据为空输入空格,然后回车,输入你要进行的操作的序号。
1.先序遍历、2中序遍历、3 后序遍历、4层次遍历、5总节点数、6总叶子数、7树的深度、8交换左右子树、9结束操作五实验总结通过实验,我熟悉二叉树树的基本操作,掌握二叉树的实现以及实际应用。
加深了对二叉树的理解,逐步培养解决实际问题的编程能力以及进一步了解了二叉树。
递归的使用,要注意,初始时的状态以及如何使用递归,注意普遍性,思考时从普通的开始。
通过这次上机操作,让我明白书本上的程序一定要自己去调试,这样才能将书本程序与老师讲的内容融会贯通,达到温故而知新。
六运行结果图(1)图表1。