二叉树的树形输出
数据结构c语言课设-二叉树排序
题目:二叉排序树的实现1 内容和要求1）编程实现二叉排序树，包括生成、插入，删除；2）对二叉排序树进展先根、中根、和后根非递归遍历；3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
4）分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率，并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案：先实现二叉排序树的生成、插入、删除，编写DisplayBST函数把遍历结果用树的形状表示出来。
前中后根遍历需要用到栈的数据构造，分模块编写栈与遍历代码。
要求比照二叉排序树和数组的查找效率，首先建立一个数组存储一个班的成员信息，分别用二叉树和数组查找，利用clock〔〕函数记录查找时间来比照查找效率。
2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入，删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复！\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;if (!p->rchild) //右子树为空{q = p;p = p->lchild;free(q);}else if (!p->lchild) //左子树为空{q = p;p = p->rchild;free(q);}else{q = p;s = p->lchild;while (s->rchild){q = s;s = s->rchild;}p->data = s->data;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S) //构造空栈{S.base = (SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{if (S.top - S.base >= S.stacksize){S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号：" << a[i].key << " 姓名：" << a[i].name << " 成绩：" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。
数据结构二叉树实验报告
一 、实验目的和要求(1)掌握树的相关概念，包括树、节点的度、树的度、分支节点、叶子节点、孩子节点、双亲节 点、树的深度、森林等定义。
(2)掌握树的表示，包括树形表示法、文氏图表示法、凹入表示法和括号表示法等。
(3)掌握二叉树的概念，包括二叉树、满二叉树和完全二叉树的定义。
(4)掌握二叉树的性质。
(5)重点掌握二叉树的存储结构，包括二叉树顺序存储结构和链式存储结构。
(6)重点掌握二叉树的基本运算和各种遍历算法的实现。
(7)掌握线索二叉树的概念和相关算法的实现。
(8)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码的产生方法。
(9)掌握并查集的相关概念和算法。
(10)灵活运用二叉树这种数据结构解决一些综合应用问题。
二、实验内容注：二叉树b 为如图7-123所示的一棵二叉树图7-123+实验7.1 编写一个程序algo7-1.cpp,实现二叉树的各种运算，并在此基础上设计一个程序exp7-1.cpp 完成如下功能：(1)输出二叉树b ;(2)输出H 节点的左、右孩子节点值； (3)输出二叉树b 的深度； (4)输出二叉树b 的宽度； (5)输出二叉树b 的节点个数；(6)输出二叉树b 的叶子节点个数。
实验7.2设计一个程序exp7-2.cpp,实现二叉树的先序遍历、中序遍历和后序遍历和非递归算法， 以及层次变量里的算法。
并对图7-123所示的二叉树b 给出求解结果。
b+ACF GIKL+NM+E+HdJD₄B臣1607-1.CPPif(b?-HULL)re3P4+;Qu[rear]-p-b;Qu[rear].1no=1;while(reart=front){Front++;b=Qu[front]-P;lnum-Qu[front].1no;if(b->Ichildt=NULL)rpar+t;Qu[rear]-p=b->1child;Qu[rear].Ino-lnun+1;if(D->rch11d?=NULL)1/根结点指针入队//根结点的层次编号为1 1/队列不为空1/队头出队1/左孩子入队1/右孩子入队redr+t;qu[rear]-p=b->rchild;Qu[rear].1no-lnun*1;}}nax-0;lnun-1;i-1;uhile(i<=rear){n=0;whdle(i<=rear ge Qu[1].1no==1num)n+t;it+;Inun-Qu[i].1n0;if(n>max)nax=n;}return max;田1607-1.CPPreturn max;}elsereturn o;口×int Modes(BTNode *D) //求二叉树D的结点个数int nun1,nun2;if(b==NULL)returng,else if(b->ichild==NULL&D->rchild==NULL)return 1;else{num1-Hodes(b->Ichild);num2=Nodes(b->rchild);return(num1+nun2+1);LeafNodes(BINode *D) //求二叉树p的叶子结点个数int num1,num2;1f(D==NULL)return 0;else if(b->1chi1d==NULLc& b->rch11d==NULL)return 1;else{num1-LeafModes(b->lchild);num2=LeafNodes(b->rchild);return(nun1+nun2);int程序执行结果如下：xCProrn FlslirosfViu l SudiollyPrjecslro7 LJebuglFoj7 ex<1)输出二叉树：A<B<D,E<H<J,K<L,M<,N>>>>),C<F,G<,I>>)<2)'H’结点：左孩子为J石孩子为K(3)二叉树b的深度：7<4)二叉树b的宽度：4(5)二叉树b的结点个数：14(6)二叉树b的叶子结点个数：6<?>释放二叉树bPress any key to continue实验7 . 2程序exp7-2.cpp设计如下：坠eTPT-2.EPP#include<stdio.h》winclude<malloc.h>deFn Masie 00typde chr ElemTyetypede sruct nde{ElemType data;stuc node *lclldstruct node rchild;》BTHode;extern vod reaeBNodeBTNode extrn void DispBTHode(BTNodeuoid ProrderBTNode *b)if(b?-NULL)- 回1 / 数据元素1 / 指向左孩子1 / 指向右孩子*eb car *str)xb1 / 先序遍历的递归算法1 / 访问根结点/ / 递归访问左子树1 7 递归访问右子树/ / 根结点入栈//栈不为空时循环/ / 退栈并访问该结点/ / 右孩子入栈{》v oidprintf(*c“,b->data); Preorder(b->lchild); Pre0rder(b->rchild);Preorder1(BTNode *b)BTNode xSt[Maxsize],*p;int top=-1;if(b!-HULL)top++;St[top]-b;uhle (op>-)p-St[top];top--;printf("%c“,p->data);if(p->rchild?-HULL)A约e程p7-2.CPPprintF(”后序逅历序列：\n");printf(" 递归算法=");Postorder(b);printf("\n");printf(“非递归算法：“);Postorder1(b);printf("\n");序执行结果如下：xCAPrograFleicsoftVisal SudlyrjecsProj 2Debuzlroj72ex"二叉树b:A(B(D,ECH<J,K(L,M<,N)>))),C(F,GC.I>))层次遍历序列：A B C D E F G H I J K L M N先序遍历序列：递归算法：A B D E H J K L M N C F G I非归算法：A B D E H J K L M N C F G I中序遍历序列：递归算法： D B J H L K M N E A F C G I非递归算法：D B J H L K M N E A F C G I后序遍历序列：递归算法： D J L N M K H E B F I G C A非递归算法：D J L N H K H E B F I G C APress any key to continue臼p7-3.CPP15Pp a t h[p a t h l e n]-b->d a t a;//将当前结点放入路径中p a t h l e n t+;/7路任长度培1Al1Path1(b->ichild,patn,pathlen);1/递归扫描左子树Al1Path1(b->rchild,path,pathlen); //递归扫描右子树pathlen-- ; //恢复环境uoid Longpath(BTNode *b,Elemtype path[1,int pathlen,Elemtype longpath[],int elongpatnien) int i;1f(b==NULL){if(pathlen>longpatnlen) //若当前路径更长，将路径保存在1ongpatn中for(i-pathlen-1;i>-8;i--)longpath[i]=path[1];longpathlen-pathlen;elsepath[pathlen]=b->data; pathlen4; //将当前结点放入路径中//路径长度增1iongPath(b->lchild,path₇pathlen,langpath,longpathien);//递归扫描左子树LongPath(b->rchiid,path,pathien,longpath,longpathien);//递归扫描石子树pathlen--; /7饮其环境oid DispLeaf(BTNode xb)- 口凶uoid DispLeaf(BTNode xb)iE(D!=NULL){ if(b->1child--HULL B& b->rchild--HULL)printf("3c“,b->data);elsepispLeaf(b->ichild);DispLeaf(b->rchild);oid nain()8TNodexb;ElenType patn[Maxsize],longpath[Maxsize];int i.longpathien-U;CreateBTNode(b,"A(B(D,E(H(J,K(L,H(,N))))),C(F,G(,I)))");printf("\n二灾树b:");DispBTNode(b);printf("\n\n*);printf(”b的叶子结点：");DispLeaf(b);printf("\n\n");printf("A11Path:");A11Path(b);printf("m");printf("AiiPath1:n");AliPath1(b.path.);printf("");LongPath(b,path,8,longpath,longpathlen);printf(”第一条量长路径长度=d\n”,longpathlen);printf(”"第一茶最长路径：");for(i=longpathlen;i>=0;i--)printf("c",longpatn[1]);printf("\n\n");。
树-二叉树
信息学奥赛培训之『树——二叉树』树——二叉树为何要重点研究二叉树？ 引 ： 为何要重点研究二叉树 ？ （1）二叉树的结构最简单，规律性最强； （2）可以证明，所有树都能转为唯一对应的二叉树，不失一般性。
一、二叉树基础1. 二叉树的定义 二叉树是一类非常重要的树形结构，它可以递归地定义如下： 二叉树 T 是有限个结点的集合，它或者是空集，或者由一个根结点以及分别称为左 子树和右子树的两棵互不相交的二叉树。
因此，二叉树的根可以有空的左子树或空的右子树，或者左、右子树均为空。
二叉树有 5 种基本形态，如图 1 所示。
图1 二叉树的 5 种基本形态在二叉树中，每个结点至多有两个儿子，并且有左、右之分。
因此任一结点的儿子 不外 4 种情况：没有儿子；只有一个左儿子；只有一个右儿子；有一个左儿子并且有一 个右儿子。
注意：二叉树与树和有序树 的区别 二叉树与度数不超过 2 的树不同，与度数不超过 2 的有序树也不同。
在有序树中，11如果将树中结点的各子树看成从左至右是有次序的，则称该树为有序树，否则称为无序树。
-1-信息学奥赛培训之『树——二叉树』虽然一个结点的儿子之间是有左右次序的，但若该结点只有一个儿子时，就无须区分其 左右次序。
而在二叉树中，即使是一个儿子也有左右之分。
例如图 2-1 中(a)和(b)是两棵 不同的二叉树。
虽然它们与图 2-2 中的普通树(作为无序树或有序树)很相似，但它们却 不能等同于这棵普通的树。
若将这 3 棵树均看作是有序树，则它们就是相同的了。
图2-1 两棵不同的二叉树图2-2 一棵普通的树由此可见，尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。
不是 ．．2. 二叉树的性质图3 二叉树性质１： 在二叉树的第 i 层上至多有 2 i −1 结点(i>=1)。
性质２： 深度为 k 的二叉树至多有 2 k − 1 个结点(k>=1)。
性质３： 对任何一棵二叉树 T，如果其终端结点数为 n0,度为 2 的结点数为 n2,则 n0=n2+1。
二叉树
我们也可以把递归过程改成用栈实现的非递归过程，下面给出先序 遍历的非递归过程： procedure inorder(bt:tree); var stack:array[1..n] of tree; {栈} top:integer; {栈顶指针} p:tree; begin top:=0; while not ((bt=nil)and(top=0)) do begin
• ⑴如果i=1，则结点i为根，无父结点；如果i>1,则其 父结点编号为trunc(i/2)。 • ⑵如果2*i>n，则结点i为叶结点；否则左孩子编号为 2*i。 • ⑶如果2*i+1>n，则结点i无右孩子；否则右孩子编号 为2*i+1。
存储结构
• 二叉树的存储结构和普通树的存储结构基本相同，有链 式和顺序存储两种方法。 • ⑴链式存储结构：有单链表结构或双链表结构，基本数 据结构定义如下： type tree=^node;{单链表结构} node=record data:char;{数据域} lchild,rchild:tree;{指针域：分别指向左、右孩子} end; var bt:tree;
• 输入： • 其中第一行一个整数n，表示树的结点数。接下来的n行 每行描述了一个结点的状况，包含了三个整数，整数之 间用空格分隔，其中：第一个数为居民人口数；第二个 数为左链接，为0表示无链接；第三个数为右链接。 • 输出： • 只有一个整数，表示最小距离和。
• • • • • • • •
样例 输入： 5 13 2 3 4 0 0 12 4 5 20 0 0 40 0 0
2、删除二叉树 procedure dis(var bt:tree); begin if bt<>nil then begin dis(bt^.lchild); dis(bt^.rchild); dispose(bt); end； end；
树和二叉树——精选推荐
第6章 树和二叉树内容概要：本章主要介绍树，二叉树，最优二叉树的相关概念和操作，存储结构和相应的操作，并在综合应用设计中，给出了对应算法的C 语言实现。
教学目标1．理解各种树和森林与二叉树的相应操作。
2．熟练掌握二叉树的各种遍历算法，并能灵活运用遍历算法实现二叉树的其他操作。
3．熟练掌握二叉树和树的各种存储结构及其建立的算法。
4．掌握哈夫曼编码的方法。
5．通过综合应用设计，掌握各种算法的C 语言实现过程。
基本知识点：树和二叉树的定义、二叉树的存储表示、二叉树的遍历以及其它操作的实现、树和森林的存储表示、树和森林的遍历以及其它操作的实现、最优树和赫夫曼编码重点：二叉树的性质、二叉树的遍历及其应用，构造哈夫曼树。
难点：编写实现二叉树和树的各种操作的递归算法。
本章知识体系结构：课时安排：6个课时树的定义 树树的性质 树的逻辑表示法 树形表示法 树的存储结构 双亲存储结构 文氏表示法凹入表示法 括号表示法 孩子存储结构 孩子双亲存储结构二叉树二叉树的定义 二叉树的性质二叉树的逻辑表示法（采用树的逻辑表示法）二叉树的存储结构二叉树的顺序存储结构先序遍历 中序遍历 后序遍历二叉树的遍历 二叉树的链式存储结构（二叉链） 由先序序列和中序序列构造二叉树 由中序序列和后序序列构造二叉树二叉树的构造 二叉树的线索化 哈夫曼树二叉树和树之间的差别 二叉树与树、森林之间的转换二叉树和树课程数据结构教学教具多媒体课件学时2班级06网络教学日期/课时 /2课时教学单元第6章树和二叉树教学方法讲授（PPT）教学目标掌握树、二叉树的基本概念和术语，二叉树的性质教学重点二叉树的定义、二叉树的性质、链式存储结构教学难点二叉树的性质、链式存储二叉树的基本操作组织教学一、树的定义二、树的基本概念三、二叉树的定义、性质四、二叉树的顺序存储结构和链式存储结构五、小结作业复习本讲内容并预习下一讲内容课堂情况及课后分析课程数据结构教学教具多媒体课件学时2班级06网络教学日期/课时 /2课时教学单元第6章树和二叉树教学方法讲授（PPT）教学目标掌握二叉树遍历的三种方法及二叉树的基本操作教学重点二叉树的遍历算法教学难点中序与后序遍历的非递归算法组织教学一、复习二叉树的定义二、遍历二叉树的三种方法三、递归法遍历二叉树四、二叉树的基本操作五、总结作业复习本讲内容并预习下一讲内容课堂情况及课后分析课程数据结构教学教具多媒体课件学时2班级06网络教学日期/课时 /2课时教学单元第6章树和二叉树教学方法讲授（PPT）教学目标理解树与森林的转换，掌握哈夫曼树教学重点哈夫曼树教学难点树与森林的转换组织教学一、导入二、树与森林三、哈夫曼树四、小结作业习题6课堂情况及课后分析前面几章讨论的数据结构都属于线性结构，线性结构的特点是逻辑结构简单，易于进行查找、插入和删除等操作，可用于描述客观世界中具有单一前驱和后继的数据关系。
算术表达式(例题)-二叉树
最早提出遍历问题的是对存储在计算机中的表达式求值。
例如：(a+b ×(c-d))-e/f 。
表达式用树形来表示，如图8-11-1所示。
运算符在树中放在非终端结点的位置上，操作数放在叶子结点处。
当我们对此二叉树进行先序、中序和后序遍历后，便可得到表达式的前缀、中缀和后缀书写形式：前缀：-+a*b-cd/ef中缀：a+b*c-d-e/f 后缀：abcd-*+ef/-其中，中缀形式是算术表达式的通常形式，只是没有括号。
在计算机内，使用后缀表达式易于求值。
例1 输入一个算术表达式，判断该表达式是否合法，若不合法，给出错误信息；若合法，则输出合法表达式的表达式树。
【算法分析】表达式不合法有三种情况：①左右括号不匹配；②变量名不合法；③运算符两旁无参与运算的变量或数。
分析表达式树可以看到：表达式的根结点及其子树的根结点为运算符，其在树中的顺序是按运算的先后顺序从后到前，表达树的叶子为参与运算的变量或数。
表达式树如图8-11-2处理时，首先找到运算级别最低的运算符“+”作为根结点，继而确定该根结点的左、右子树结点在表达式串中的范围为a 和(b-c)/d ，再在对应的范围内寻找运算级别最低的运算符作为子树的根结点，直到范围内无运算符，则剩余的变量或数为表达式树的叶子。
【算法步骤】① 设数组ex 存放表达式串的各字符，lt 、rt 作为结点的左右指针，变量left 、right 用于存放每次取字符范围的左、右界。
② 设置左界初值为1；右界初值为串长度。
③ 判断左右括号是否匹配，不匹配则认为输入有错误。
④ 在表达式的左右界范围内寻找运算级别最低的运算符，同时判断运算符两旁有否参与运算的变量或数。
若无，则输入表达式不合法；若有，作为当前子树的根结点，设置左子树指针及其左右界值，设置右子树指针及其左右界值。
⑤ 若表达式在左右界范围内无运算符，则为叶子结点，判断变量名或数是否合法。
⑥ 转④，直到表达式字符取完为止。
【数据结构】二叉树
【数据结构】⼆叉树【⼆叉树】 ⼆叉树是最为简单的⼀种树形结构。
所谓树形结构，其特征（部分名词的定义就不明确给出了，毕竟不是学术⽂章。
）在于： 1. 如果是⾮空的树形结构，那么拥有⼀个唯⼀的起始节点称之为root（根节点） 2. 除了根节点外，其他节点都有且仅有⼀个“⽗节点”；除此外这些节点还都可以有0到若⼲个“⼦节点” 3. 树中的所有节点都必须可以通过根节点经过若⼲次后继操作到达 4. 节点之间不会形成循环关系，即任意⼀个节点都不可能从⾃⾝出发，经过不重复的径路再回到⾃⾝。
说明了树形结构内部蕴含着⼀种“序”，但是不是线性表那样的“全序” 5. 从树中的任意两个节点出发获取到的两个任意⼦树，要不两者⽆交集，要不其中⼀者是另⼀者的⼦集 限定到⼆叉树，⼆叉树就是任意⼀个节点⾄多只能有两个⼦节点的树形结构。
也就是说，某个节点的⼦节点数可以是0,1或2。
由于可以有两个⼦节点，所以区别两个⼦节点可以将其分别定义为左⼦节点和右⼦节点。
但是需要注意的是，若⼀个节点只有⼀个⼦节点，那么也必须明确这个⼦节点是左⼦节点还是右⼦节点。
不存在“中⼦节点”或者“单⼦节点”这种表述。
由于上述规则对所有节点都⽣效，所以⼆叉树也是⼀个递归的结构。
事实上，递归就是⼆叉树⼀个⾮常重要的特点，后⾯还会提到很多通过递归的思想来建⽴的例⼦。
对于左⼦节点作为根节点的那颗⼆叉树被称为相对本节点的左⼦树，右⼦树是同理。
■ 基本概念 空树 不包含任何节点的⼆叉树，连根节点也没有 单点树 只包含⼀个根节点的⼆叉树是单点树 ⾄于兄弟关系，⽗⼦关系，长辈后辈关系是⼀⾔既明的就不说了。
树中没有⼦节点的节点被称为树叶（节点），其余的则是分⽀节点。
⼀个节点的⼦节点个数被称为“度数”。
正如上所说，⼆叉树任意节点的度数取值可能是0，1或2。
节点与节点之间存在关联关系，这种关联关系的基本长度是1。
通过⼀个节点经过若⼲个关联关系到达另⼀个节点，经过的这些关联关系合起来被称为⼀个路径。
第六章-树和二叉树
之
树 和 二 叉 树 13
1 2 3 A B C
4 5 6 7 0 D E F
8 0
9 10 0 G
¾ 二叉树顺序存储的算法描述
数 据 结 构
¾ 初始化二叉树
之
树 和 二 叉 树 14
#define Max_Size 100 typedef int TElemType; typedef TElemType SqBT[Max_Size+1]; void InitBT(SqBT bt){//设置空树 int i; for(i=1;i<=Max_Size;i++) bt[i]=0; }
数 据 结 构
之
树 和 二 叉 树 19
¾ 后序遍历顺序二叉树算法 void PostBT(SqBT bt,int i){ if(i>Max_Size||!bt[i]) return; PostBT(bt,2*i); PostBT(bt,2*i+1); printf("%3d ",bt[i]); }
数 据 结 构
之
树 和 二 叉 树 4
5. 孩子结点、双亲结点、兄弟结点、堂兄弟 结点、祖先结点、子孙结点…… 6. 结点的层次从根开始，根为第一层，根的 孩子为第二层；若某结点在第L层，则其 子树的根就在第L+1层。 7. 树的深度或高度：树中结点的最大层次。 8. 有序树：如果将树中结点的各子树看成是 从左至右有次序的；反之，则是无序树。 9. 森林：是m棵互不相交的树的集合。
数 据 结 构
之
树 和 二 叉 树 25
¾ 打印一维数组 void printSq(SqBT bt){ int i; printf("\nSeqArray:"); for(i=1;i<=Max_Size;i++) printf("%3d ",bt[i]); }
数据结构第三版第七章作业参考答案
//栈指针置初值
do { while (t)
//将 t 的所有左结点进栈
{ top++;
St[top]=t;
t=t->lchild;
} p=NULL; flag=1; while (top!=-1 && flag)
//p 指e当前结点的前一个已fg
的
结
点
//h置 t 的fgij为已fg过
{ t=St[top]; if (t->rchild==p) { if (t==s)
7.1 设二叉树 bt 的一种存储结构如下：
1 2 3 4 5 6 7 8 9 10 lchild 0 0 2 3 7 5 8 0 10 1 data j h f d b a c e g i rchild 0 0 0 9 4 0 0 0 0 0
其中，bt 为树根结点指针，lchild、rchild 分别为结点的左、右孩子指针域，
Ctree(t->lchild,A,2*i);
//递归构造*t 的左子树
Ctree(t->rchild,A,2*i+1); //递归构造*t 的右子树
}
}
7.5 设计一个算法，将一棵以二叉链方式存储的二叉树 t 按顺序方式存储到数组 A 中。
解：由二叉树的顺序存储方式可知本题的递归模型f()如下：
f(t,A,i)：A[i]=' ';
//顺序队首尾指针 //cm=1 表示二叉树为完全二叉树 //bj=1 表示到目前为止所有结点均有左右孩子
if (b!=NULL)
{ rear++;
Qu[rear]=b;
while (first!=rear) { first++;
特殊形态的二叉树
.6.2.3 满二叉树与完全二叉树满二叉树和完全二叉树是两种特殊形态的二叉树。
（1）满二叉树满二叉树是指除最后一层外，每一层上的所有结点都有两个子结点。
即在满二叉树的第k 层上有2k-1个结点。
从上面满二叉树定义可知，必须是二叉树每一层上的结点数都达到最大，否则就不是满二叉树。
深度为m的满二叉树有2m-1个结点。
图1-23是两棵满二叉树。
图1-23(a)是深度为3的满二叉树，图1-23(b)是深度为4的满二叉树。
图1-23 满二叉树在满二叉树中，只有度为2和度为0的结点，没有度为1的结点。
所有度为0的结点即叶子结点都在同一层，即最后一层。
（2）完全二叉树完全二叉树是指除最后一层外，每一层上的结点数均达到最大值；在最后一层上只缺少右边的若干结点。
完全二叉树也可以这样来描述：如果对满二叉树的结点进行连续编号，从根结点开始，对二叉树的结点自上而下，自左至右用自然数进行连续编号，则深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1到n的结点一一对应时，称之完全二叉树。
由完全二叉树可知，满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。
图1-28(a)是深度为3的3棵完全二叉树，图1-28(b)是深度为4的一棵完全二叉树。
完全二叉树还具有以下两个性质：性质1：具有n个结点的完全二叉树深度为［log2n］+1。
性质2：如果对一棵有n个结点的完全二叉树的结点按层序编号（从第1层到第［log2n］+1层，每层从左到右）,则对任一结点k（1≤k≤n），有：①如果k＝1，则结点k父结点，是二叉树的根；如果k>1，则该结点的父结点编号为INT（k/2）；②如果2k≤n，则结点k的左子结点编号为2k；否则该结点没有左子结点（显然也没有右子结点）；③如果2k+1≤n，则结点k的右子结点编号为2k+1；否则该结点没有右子结点。
3.2.4.1 数据流图数据流图（Data Flow Diagram，DFD），它以图形的方式描绘数据在系统中流动和处理的过程，它只反映系统必须完成的逻辑功能，所以是一种功能模型。
二叉树基本操作--实验报告
宁波工程学院电信学院计算机教研室实验报告一、实验目的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");}四、实验心得与小结通过实验，我熟悉二叉树树的基本操作，掌握二叉树的实现以及实际应用。
2023年高考信息技术专题13 树与二叉树 知识点梳理(选修)(浙教版2019)
第十三章树与二叉树一、线性结构和非线性结构线性结构的所有元素都是线性排列的，结构中必然存在唯一的“起点”和“终点”元素。
且除首尾元素外，都有且只有一个“前驱”和“后继”节点。
例：链表、队列、栈非线性结构则完全相反，结构中可能存在多个“起点”和“终点”元素。
所有节点都可能存在0个或多个“前驱”和“后继”节点。
例：树、图二、树形结构树可以描述为由n（n>=0）个节点和n-1条边构成的一个有限集合，以及在该集合上定义的一种节点关系。
树形结构是一种特殊的非线性结构，其特点是：只有一个没有“前驱”，只有“后继”的根节点。
有多个只有“前驱”没有“后继”的叶子节点，其余节点均只有一个“前驱”和多个“后继”。
树的示例1.描述树形结构的词1.1节点名称（Node）：根节点：树中唯一没有前驱的节点，也称开始节点(A)叶子节点：树中没有后继的节点，也称终端节点(G,H,C,D,K,L,M,J,F)分支节点：除叶子节点之外的所有节点(A,B,E,I)内部节点：除根节点之外的分支节点(B,E,I)1.2节点关系：父子关系：节点间的前驱后继关系又称父子关系。
例：B是G的父节点；G是B的子节点兄弟关系：同一父节点下的所有节点关系称兄弟关系。
例：G和H是兄弟节点1.3度（Degree）：节点的度：一个节点拥有的子树（后继节点）的个数称之为该节点的度。
树的度：一棵树中最大的度称之为树的度。
例：图中A点的度为5，是该树中度最大的点，故该树的度为5。
1.4层/深（Level）:节点的层：节点的层数从根节点开始计算，根节点的层数为1。
每经过一条边，层数加1。
树的高度/深度（Depth）：树中节点最大层数称为树的高度或深度。
例：图中K点的深度为4，是该树中深度最大的点，故该树深度为4。
三、二叉树二叉树是树形结构的一种特殊情况，二叉树的度<=2。
1.完全二叉树和满二叉树满二叉树：所有节点度为2或0；所有叶子节点在同一层完全二叉树：最多只有最深两层节点的度小于2；最深一层的叶子节点依次排列在最左边。
二叉树
7.1.2
二叉树的五种基本形态
Ф
左子树
(a) (b) (c)
右子树
(d)
左子树
(e)
右子树
7.1.3
两种特殊形态的二叉树
结点拥有的子树数称为该结点的度(degree)。度为零的结点称 为叶子(leaf)，其余结点称为分支结点(branch)。树中结点的最大的 度称为树的度。显然，二叉树结点的度可能为0、1或2。 根结点的层次(level)为1，其余结点的层次等于该结点的双亲结 点的层次加1。树中结点的最大层次称为该树的高度或深度。 1．满二叉树 2．完全二叉树
7.6
本章小结
本章讨论了二叉树数据类型的定义以及实现方法。二叉树是 以两个分支关系定义的层次结构，结构中的数据元素之间存在着一 对多的关系，因此它为计算机应用中出现的具有层次关系或分支关 系的数据，提供了一种自然的表示方法。 二叉树是有明确的左子树和右子树的树形结构，因此当用二 叉树来描述层次关系时，其左孩子表示下属关系，而右孩子表示的 是同一层次的关系。 二叉树的遍历算法是实现各种操作的基础。遍历的实质是按 某种规则将二叉树中的数据元素排列成一个线性序列，二叉树的线 索链表便可看成是二叉树的一种线性存储结构，在线索链表上可对 二叉树进行线性化的遍历，即不需要递归，而是从第一个元素起， 逐个访问后继元素直至后继为空止。因此，线索链表是通过遍历生 成的，即在遍历过程中保存结点之间的前驱和后继的关系。
7.1.4
二叉树的几个特性
由二叉树的定义、形态，我们很容易的得出下面二叉树的 一些特性。 性质1 在二叉树的第i 层上至多有 2i-1 个结点(i≥1)。 性质2 深度为k的二叉树中至多含有2k-1 个结点(k≥1)。 性质3 对任何一棵二叉树 T，如果其终端结点数为，度为 2的结点数为，则。 性质4 具有n个结点的完全二叉树的深度为 log2n+1。 性质5 如果对一棵有 n 个结点的完全二叉树（其深度为 log2n+1）的结点按层序（从第1层到第 log2n+1 层，每层从左到 右）从1起开始编号。
数据结构课程设计_二叉树操作
数据结构课程设计_⼆叉树操作数据结构课程设计题⽬：⼆叉树的操作学⽣姓名：学号：系部名称：计算机科学与技术系专业班级：指导教师：课程设计任务书第⼀章程序要求1）完成⼆叉树的基本操作。
2）建⽴以⼆叉链表为存储结构的⼆叉树；3）实现⼆叉树的先序、中序和后序遍历；4）求⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。
第⼆章算法分析建⽴以⼆叉链表为存储结构的⼆叉树，在次⼆叉树上进⾏操作；1先序遍历⼆叉树的操作定义为：若⼆叉树唯恐则为空操作；否则（1）访问根节点；（2）先序遍历做字数和；（3）先序遍历有⼦树；2中序遍历⼆叉树的操作定义为：若⼆叉树为空，则空操作;否则（1）中序遍历做⼦树；（2）访问根节点；（3）中序遍历有⼦树；3后续遍历⼆叉树的操作定义为：若⼆叉树为空则为空操作；否则（1)后序遍历左⼦树;（2)后序遍历右⼦树;（3）访问根节点；⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。
第三章⼆叉树的基本操作和算法实现⼆叉树是⼀种重要的⾮线性数据结构，是另⼀种树形结构，它的特点是每个节点之多有两棵⼦树(即⼆叉树中不存在度⼤于2的结点)，并且⼆叉树的结点有左右之分，其次序不能随便颠倒。
1.1⼆叉树创建⼆叉树的很多操作都是基于遍历实现的。
⼆叉树的遍历是采⽤某种策略使得采⽤树形结构组织的若⼲年借点对应于⼀个线性序列。
⼆叉树的遍历策略有四种：先序遍历中续遍历后续遍历和层次遍历。
基本要求1 从键盘接受输⼊数据（先序），以⼆叉链表作为存储结构，建⽴⼆叉树。
2 输出⼆叉树。
3 对⼆叉树进⾏遍历（先序，中序，后序和层次遍历）4 将⼆叉树的遍历打印出来。
⼀．问题描述⼆叉树的很多操作都是基于遍历实现的。
⼆叉树的遍历是采⽤某种策略使得采⽤树型结构组织的若⼲结点对应于⼀个线性序列。
⼆叉树的遍历策略有四种：先序遍历、中序遍历、后序遍历和层次遍历。
⼆．基本要求1．从键盘接受输⼊数据（先序），以⼆叉链表作为存储结构，建⽴⼆叉树。
2．输出⼆叉树。
二叉树的建立、输出、结点、高度、叶结点的输出
7 二叉树的操作【实验简介】二叉树是树形结构的一种重要类型。
通过本次实验，熟悉二叉树结点的结构，掌握二叉树的基本操作以及具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
【实验内容】编写程序，实现对二叉树的以下操作：1．建立二叉树。
2．按任一种遍历次序输出二叉树中的所有结点。
3．求二叉树的深度。
4．求二叉树中的所有节点数。
5．求二叉树中的所有叶子节点数。
6．清除二叉树，使之编程一只空树。
【主要代码】#include<iostream>using namespace std;template <class T>struct BinTreeNode //二叉树结点类定义{ T data; //数据域BinTreeNode<T> *leftChild, *rightChild; //左子女、右子女链域BinTreeNode () //构造函数{ leftChild=NULL;rightChild=NULL; }BinTreeNode (T x,BinTreeNode<T> *left=NULL,BinTreeNode<T>*right=NULL){ data=x; leftChild=left;rightChild=right; }};template <class T>class BinaryTree{ //二叉树类定义public:BinaryTree() {root=NULL;} //构造函数BinaryTree (T value) //构造函数{RefValue=value;root=NULL;}~BinaryTree(){destroy(root);} //析构函数bool IsEmpty(){ return root==NULL;} //判二叉树空否int Height(){ return Height(root);} //求树高度int Size() { return Size(root); } //求结点数BinTreeNode<T> *getRoot() { return root; }BinTreeNode<T> *LeftChild (BinTreeNode<T> *cur) //返回左子女{ return (cur!=NULL)?cur->leftChild:NULL; }BinTreeNode<T> *RightChild (BinTreeNode<T> *cur) //返回右子女{ return (cur!=NULL)?cur->rightChild:NULL; }void Output (BinTreeNode<T> * subtree); //输出结点void BinaryTreeCount(BinTreeNode<T>* BT,int& m1,int& m2); //输出结点数和叶结点数void SetRefValue(T& M){RefValue=M;} //设置数据输入停止标志void Setroot(BinTreeNode<T>* N){root=N;} //设置根节点void CreateBinTree (BinTreeNode<T> *& subTree);protected:BinTreeNode<T> *root; //二叉树的根指针T RefValue; //数据输入停止标志//void CreateBinTree (istream& in, BinTreeNode<T> *& subTree); //从文件读入建树void destroy (BinTreeNode<T> *& subTree); //删除int Height (BinTreeNode<T> *subTree)const; //返回树高度int Size(BinTreeNode<T> *subTree)const; //返回结点数BinTreeNode<T> *Parent (BinTreeNode<T> * subTree, BinTreeNode<T> *cur); //返回父结点friend ostream& operator<<(ostream& out,BinaryTree<T>& Tree);};template<class T>void BinaryTree<T>::destroy (BinTreeNode<T> *& subTree)//私有函数: 删除根为subTree的子树{ if (subTree!=NULL){ destroy (subTree->leftChild); //删除左子树destroy (subTree->rightChild); //删除右子树delete subTree; //删除根结点}};template <class T>void BinaryTree<T>::CreateBinTree(BinTreeNode<T> *& subTree){ T item;cin>>item; //读入根结点的值if(item!=RefValue){ subTree=new BinTreeNode<T>(item); //建立根结点if (subTree==NULL){cerr << "存储分配错!" << endl; exit (1);}CreateBinTree (subTree->leftChild); //递归建立左子CreateBinTree (subTree->rightChild);//递归建立右子树}else {subTree=NULL;} //封闭指向空子树的指针};template <class T>int BinaryTree<T>::Height(BinTreeNode<T> *subTree)const{ //私有函数：利用二叉树后序遍历算法计算二叉树的高度或深度；if (subTree==NULL) return 0; //空树高度为0；else{int i=Height(subTree->leftChild);int j=Height(subTree->rightChild);return (i<j)?j+1:i+1;}};template <class T>void BinaryTree<T>::BinaryTreeCount(BinTreeNode<T>* BT,int& m1,int& m2)//分别统计出二叉树中所有结点数和叶子结点数{if(BT!=NULL){ m1++; //统计所有结点if(BT->leftChild==NULL&&BT->rightChild==NULL)m2++; //统计叶子结点数BinaryTreeCount(BT->leftChild,m1,m2);BinaryTreeCount(BT->rightChild,m1,m2);}else return;return;};template <class T>void BinaryTree<T>::Output (BinTreeNode<T> *subtree){//私有函数：利用二叉树后序遍历算法输出二叉树的结点if (subtree!=NULL){cout<<subtree->data<<'\t'; //输出根节点Output(subtree->leftChild); //遍历Output(subtree->rightChild);}return;};void main(){BinaryTree<int> a;int m=0,n=0,p=0;BinTreeNode<int> *b;b=a.getRoot();a.SetRefValue(p); //设置结束标志cout<<"请输入要建立的二叉树的整型数,输入0结束，0应比数字多1：";a.CreateBinTree(b); //创建二叉树cout<<"二叉树的所有结点为：";a.Output(b);cout<<'\n'; //输出所有结点a.Setroot(b);cout<<"二叉树的高度为：";cout<<a.Height()<<'\n'; //输出二叉树高度a.BinaryTreeCount(b,m,n); //输出结点数和叶子结点数cout<<"二叉树结点数为："<<m<<'\n'; //结点和叶结点个数输出cout<<"二叉树叶结点数为："<<n<<'\n';a.~BinaryTree(); //删除二叉树exit(1); //退出}总黄酮生物总黄酮是指黄酮类化合物，是一大类天然产物，广泛存在于植物界，是许多中草药的有效成分。
2. 输出二叉树中的叶子结点
ADT Tree 数据对象D：一个集合，该集合中的所有元素具有相同的特性。 数据关系R： 若D为空集，则为空树。 若D中仅含有一个数据元 素，则R为空集，否则R={H}，H是如下的二元关系： (1) 在D中存在唯一的称为根的数据元素root， 它在关系H下没 有前驱。
故（2）和（3）得证。
由（2）和（3）我们可很容易证明（1）。
当i=1时， 显然该结点为根结点，无双亲结点。当i>1时，设序号为i 的结点的双亲结点的序号为m，如果序号为i的结点是其双亲结点的左孩子， 根据（2）有i=2×m， m=i/2; 如果序号为i的结点是其双亲结点的右孩 子，根据（3）有i=2×m+1， 即m=（i-1）/2=i/2-1/2，综合这两种情况， 可以得到，当i>1时， 其双亲结点的序号等于［i/2］。证毕。
(5) Root（Tree）： 返回树Tree的根。
(6) Parent（Tree， x）： 树Tree存在， x是Tree中的某个结点。 若x为非根结点，则返回它的双亲， 否则返回“空”。
(7) FirstChild（Tree，x）： 树Tree存在， x是Tree中的某个结 点。若x为非叶子结点，则返回它的第一个孩子结点， 否则返回 “空”。
(7) LeftChild（bt， x）：求左孩子。 若结点x为叶子结点或x不 在bt中， 则返回“空”。
(8) RightChild（bt， x）：求右孩子。 若结点x为叶子结点或x 不在bt中， 则返回“空”。
(9) Traverse（bt）: 遍历操作。按某个次序依次访问二叉树中 每个结点一次且仅一次。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int Degree2Node(BiTree bt) //输出度为二的节点
{
if(!bt || !bt->LChild && !bt->RChild)
{
return 0;
}
if(bt->LChild && bt->RChild)
{
return Degree2Node(bt->LChild)+Degree2Node(bt->RChild)+1;
{
if(bt==NULL)
{
return ;
}
PrintTree( bt->RChild,nlayer+1);
for(int i=0;i<nlayer;i++)
{
printf(" ");
}
printf("%c \n",bt->data);
PrintTree(bt->LChild,nlayer+1);
printf("\n");
printf("树形输出是：\n");
PrintTree(bt,nlayer);
}
int depth = 0;
void CreateBiTree(BiTree *bt)
{
char ch;
ch=getchar();
if(ch=='.')
*bt=NULL;
else
{
*bt=(BiTree)malloc(sizeof(BinTNode));
(*bt)->data=ch;
CreateBiTree(&((*bt)->LChild));
CreateBiTree(&((*bt)->RChild));
}
}
void PreOrder(BiTree root)//先序遍历
{
if(root!=NULL)
{
printf("%c ",root->data);
PreOrder(root->LChild);
PreOrder(root->RChild);
CreateBiTree(&bt);
printf("先序遍历: ");
PreOrder(bt);
printf("\n");
PreTreeDepth(bt,h);
printf("输的深度是:%d",depth);
printf("\n");
degree2=Degree2Node(bt);
printf("度为二的节点是:%d",degree2);
#include "stdio.h"
#include "stdlib.h"
typedef char DataType;
typedef struct Node
{
DataType data;
struct Node *LChild;
struct Node *RChild;
}BinTNode,*BiTree;
}else {
return Degree2Node(bt->LChild)+Degree2Node(bt->RChild);
}
}
void main()
{
BiTree bt;
int degree2, h=1 , nlayer=1 ;
printf("给予的样本\n\n");
printf("-----AB.DF..G..C.E.H..------ \n\n");
}
}
int PostTreeDepth(BiTree bt) //二叉树的深度方法1
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->LChild);
hr=PostTreeDepth(bt->RChild);
max=hl>hr ? hl:hr;
return max+1;
}else {
return 0;
}
}
void PreTreeDepth(BiTree bt,int h)
{
if(bt!=NULL)
{
if(h>depth) depth=h;
PreTreeDepth(bt->LChild,h+1);#43;1);
}
}
void PrintTree(BiTree bt,int nlayer) //按树状打印二叉树