叶老师版数据结构二叉树各种函数.doc
- 格式:doc
- 大小:287.93 KB
- 文档页数:15
二叉树叶子节点数计算公式在计算机科学领域,二叉树是一种非常常见的数据结构,它由节点组成,每个节点最多有两个子节点。
其中,叶子节点是指没有子节点的节点,它们位于二叉树的末端。
计算二叉树的叶子节点数是一个常见且重要的问题,本文将介绍如何通过简单的方法来计算二叉树的叶子节点数。
我们需要了解二叉树的结构。
二叉树可以分为左子树和右子树,每个节点都有一个左子节点和一个右子节点(如果存在的话)。
叶子节点是指没有左子节点和右子节点的节点。
因此,计算二叉树的叶子节点数可以通过遍历整个二叉树并统计叶子节点的数量来实现。
一种简单的方法是使用递归。
通过递归地遍历二叉树的每个节点,我们可以轻松地计算出叶子节点的数量。
具体来说,我们可以按照以下步骤来计算叶子节点数:1. 从根节点开始,如果当前节点为空,则返回0。
2. 如果当前节点是叶子节点(即没有左子节点和右子节点),则返回1。
3. 否则,递归地计算左子树和右子树的叶子节点数,并将它们相加。
通过以上步骤,我们可以得到整个二叉树的叶子节点数。
这种方法简单直观,适用于大多数二叉树的情况。
除了递归方法外,我们还可以使用迭代方法来计算二叉树的叶子节点数。
迭代方法通常需要借助数据结构(如栈或队列)来辅助计算。
具体步骤如下:1. 初始化一个栈,并将根节点入栈。
2. 循环遍历栈,直到栈为空。
3. 每次弹出栈顶节点,并检查其是否为叶子节点。
如果是,则将叶子节点计数加一。
4. 如果当前节点有左子节点,则将左子节点入栈;如果有右子节点,则将右子节点入栈。
通过迭代方法,我们也可以得到二叉树的叶子节点数,这种方法在某些情况下可能更有效。
在实际应用中,计算二叉树的叶子节点数是一个常见的问题,它可以帮助我们更好地理解和分析二叉树的结构。
通过掌握递归和迭代两种方法,我们可以灵活地解决这类问题,并深入理解二叉树的特性。
通过本文介绍的方法,我们可以轻松计算二叉树的叶子节点数,这对于深入学习数据结构和算法有着重要的意义。
以二叉树或树作为表的组织形式,称为树表,它是一类动态查找表,不仅适合于数据查找,也适合于表插入和删除操作。
常见的树表:二叉排序树平衡二叉树B-树B+树9.3.1 二叉排序树二叉排序树(简称BST)又称二叉查找(搜索)树,其定义为:二叉排序树或者是空树,或者是满足如下性质(BST性质)的二叉树:❶若它的左子树非空,则左子树上所有节点值(指关键字值)均小于根节点值;❷若它的右子树非空,则右子树上所有节点值均大于根节点值;❸左、右子树本身又各是一棵二叉排序树。
注意:二叉排序树中没有相同关键字的节点。
二叉树结构满足BST性质:节点值约束二叉排序树503080209010854035252388例如:是二叉排序树。
66不试一试二叉排序树的中序遍历序列有什么特点?二叉排序树的节点类型如下:typedef struct node{KeyType key;//关键字项InfoType data;//其他数据域struct node*lchild,*rchild;//左右孩子指针}BSTNode;二叉排序树可看做是一个有序表,所以在二叉排序树上进行查找,和二分查找类似,也是一个逐步缩小查找范围的过程。
1、二叉排序树上的查找Nk< bt->keybtk> bt->key 每一层只和一个节点进行关键字比较!∧∧p查找到p所指节点若k<p->data,并且p->lchild=NULL,查找失败。
若k>p->data,并且p->rchild=NULL,查找失败。
查找失败的情况加上外部节点一个外部节点对应某内部节点的一个NULL指针递归查找算法SearchBST()如下(在二叉排序树bt上查找关键字为k的记录,成功时返回该节点指针,否则返回NULL):BSTNode*SearchBST(BSTNode*bt,KeyType k){if(bt==NULL||bt->key==k)//递归出口return bt;if(k<bt->key)return SearchBST(bt->lchild,k);//在左子树中递归查找elsereturn SearchBST(bt->rchild,k);//在右子树中递归查找}在二叉排序树中插入一个关键字为k的新节点,要保证插入后仍满足BST性质。
数据结构⼆叉树知识点总结术语1. 节点的度:⼀个节点含有的⼦树的个数称为该节点的度;2. 叶节点或终端节点:度为零的节点;3. ⾮终端节点或分⽀节点:度不为零的节点;4. ⽗亲节点或⽗节点:若⼀个节点含有⼦节点,则这个节点称为其⼦节点的⽗节点;5. 兄弟节点:具有相同⽗节点的节点互称为兄弟节点;6. 节点的层次:从根开始定义起,根为第1层,根的⼦节点为第2层,以此类推;7. 树的⾼度或深度:树中节点的最⼤层次;8. 堂兄弟节点:⽗节点在同⼀层的节点互为堂兄弟;9. 节点的祖先:从根到该节点所经分⽀上的所有节点;10. 孙:以某节点为根的⼦树中任⼀节点都称为该节点的⼦孙。
11. 森林:由m(m>=0)棵互不相交的树的集合称为森林;12. 满⼆叉树:⼀棵深度为k,且有2^k-1 (2的k次⽅减⼀)个节点称之为满⼆叉树13. 完全⼆叉树:完全⼆叉树是由满⼆叉树⽽引出来的。
对于深度为K的,有n个结点的⼆叉树,当且仅当其每⼀个结点都与深度为K的满⼆叉树中编号从1⾄n的结点⼀⼀对应时称之为完全⼆叉树。
叶节点只能出现在最下层和次下层,并且最下⾯⼀层的结点都集中在该层最左边的若⼲位置的⼆叉树⼆叉树的性质1.在⾮空⼆叉树中,第i层的结点总数不超过2^(i-1),i>=1;2.深度为h的⼆叉树最多有2^h-1个结点(h>=1),最少有h个结点;3.对于任意⼀棵⼆叉树,如果其叶结点数为N0,⽽度数为2的结点总数为N2,则N0=N2+1;4.具有n个结点的完全⼆叉树的深度为K =[log2n」+1(取下整数)5.有N个结点的完全⼆叉树各结点如果⽤顺序⽅式存储,则结点之间有如下关系:若I为结点编号则如果I>1,则其⽗结点的编号为I/2;6.完全⼆叉树,如果2*I<=N,则其左⼉⼦(即左⼦树的根结点)的编号为2*I;若2*I>N,则⽆左⼉⼦;如果2*I+1<=N,则其右⼉⼦的结点编号为2*I+1;若2*I+1>N,则⽆右⼉⼦。
树和二叉树的计算公式
树和二叉树是计算机科学中重要的数据结构,它们可以用于各种算法和数据处理应用。
在计算树和二叉树的性质和操作时,需要使用一些计算公式。
一、树的计算公式
1. 节点总数公式:假设一棵树有n个节点,那么它的节点总数
为n=1+r1+r2+...+rk,其中r1、r2、...、rk分别表示每个节点的
子节点数。
2. 叶子节点数公式:一棵树的叶子节点数等于每个非叶节点子
节点数之和加1,即l=r1+r2+...+rk+1。
3. 深度公式:一棵树的深度为从根节点到最深叶子节点的路径
长度,可以用递归的方式计算:d(T)=max{d(T1),d(T2),...,d(Tk)}+1,其中T1、T2、...、Tk是根节点的子树,d(Ti)表示第i个子树的深度。
二、二叉树的计算公式
1. 节点总数公式:假设一棵二叉树有n个节点,那么它的节点
总数为n=2^h-1,其中h为树的高度。
2. 叶子节点数公式:一棵二叉树的叶子节点数等于度数为2的
节点数加1,即l=n/2+1。
3. 深度公式:一棵二叉树的深度为从根节点到最深叶子节点的
路径长度,可以用递归的方式计算:d(T)=max{d(T1),d(T2)}+1,其
中T1、T2是根节点的左右子树,d(Ti)表示第i个子树的深度。
以上是树和二叉树的一些常用计算公式,可以用于分析和设计算法,帮助开发人员更好地理解和应用这些数据结构。
计算机二级二叉树知识点1.二叉树的定义:二叉树是一种常见的树形结构,其中每个节点最多有两个子节点,分别称为左子节点和右子节点。
二叉树的节点结构通常包括一个数据元素和指向左右子节点的指针。
2.二叉树的性质:(1)二叉树的第i层最多有2^(i-1)个节点。
(2)高度为h的二叉树最多有2^h-1个节点。
(3)对于任意一棵二叉树,如果其叶子节点数为n0,度为2的节点数为n2,则n0=n2+1(4)一棵深度为k且节点总数为n的二叉树,当且仅当其满足2^(k-1)<=n<=2^k-1时,才称为完全二叉树。
3.二叉树的分类:(1)满二叉树:除了叶子节点之外,每个节点都有两个子节点,且所有叶子节点在同一层次上。
(2)完全二叉树:最后一层之前的层都是满的,并且最后一层的节点都靠左排列。
(3)平衡二叉树:左右子树的高度差不超过1的二叉树。
(4)线索二叉树:对于每个节点,除了指向其左右子节点的指针外,还包含指向其在其中一种序列下的前驱节点和后继节点的指针。
4.二叉树的遍历方法:(1)前序遍历:先访问根节点,然后递归地遍历左子树,最后递归地遍历右子树。
(2)中序遍历:先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。
(3)后序遍历:先递归地遍历左子树,然后递归地遍历右子树,最后访问根节点。
(4)层次遍历:按照从上到下、从左到右的顺序逐层访问每个节点。
5.二叉树:二叉树(Binary Search Tree,BST)是一种特殊的二叉树,它的每个节点的值都大于其左子树中的所有节点值,小于其右子树中的所有节点值。
因此,对于一个二叉树,可以采用中序遍历的方法得到一个有序序列。
二叉树的插入操作:按照二叉树的定义,从根节点开始,将要插入的值与当前节点的值比较,如果小于当前节点的值,则向左子树递归插入,如果大于当前节点的值,则向右子树递归插入,直至找到一个空节点,然后插入新节点。
二叉树的删除操作:删除一个节点需要考虑三种情况:删除节点没有子节点、只有一个子节点、有两个子节点。
【数据结构】⼆叉树【⼆叉树】 ⼆叉树是最为简单的⼀种树形结构。
所谓树形结构,其特征(部分名词的定义就不明确给出了,毕竟不是学术⽂章。
)在于: 1. 如果是⾮空的树形结构,那么拥有⼀个唯⼀的起始节点称之为root(根节点) 2. 除了根节点外,其他节点都有且仅有⼀个“⽗节点”;除此外这些节点还都可以有0到若⼲个“⼦节点” 3. 树中的所有节点都必须可以通过根节点经过若⼲次后继操作到达 4. 节点之间不会形成循环关系,即任意⼀个节点都不可能从⾃⾝出发,经过不重复的径路再回到⾃⾝。
说明了树形结构内部蕴含着⼀种“序”,但是不是线性表那样的“全序” 5. 从树中的任意两个节点出发获取到的两个任意⼦树,要不两者⽆交集,要不其中⼀者是另⼀者的⼦集 限定到⼆叉树,⼆叉树就是任意⼀个节点⾄多只能有两个⼦节点的树形结构。
也就是说,某个节点的⼦节点数可以是0,1或2。
由于可以有两个⼦节点,所以区别两个⼦节点可以将其分别定义为左⼦节点和右⼦节点。
但是需要注意的是,若⼀个节点只有⼀个⼦节点,那么也必须明确这个⼦节点是左⼦节点还是右⼦节点。
不存在“中⼦节点”或者“单⼦节点”这种表述。
由于上述规则对所有节点都⽣效,所以⼆叉树也是⼀个递归的结构。
事实上,递归就是⼆叉树⼀个⾮常重要的特点,后⾯还会提到很多通过递归的思想来建⽴的例⼦。
对于左⼦节点作为根节点的那颗⼆叉树被称为相对本节点的左⼦树,右⼦树是同理。
■ 基本概念 空树 不包含任何节点的⼆叉树,连根节点也没有 单点树 只包含⼀个根节点的⼆叉树是单点树 ⾄于兄弟关系,⽗⼦关系,长辈后辈关系是⼀⾔既明的就不说了。
树中没有⼦节点的节点被称为树叶(节点),其余的则是分⽀节点。
⼀个节点的⼦节点个数被称为“度数”。
正如上所说,⼆叉树任意节点的度数取值可能是0,1或2。
节点与节点之间存在关联关系,这种关联关系的基本长度是1。
通过⼀个节点经过若⼲个关联关系到达另⼀个节点,经过的这些关联关系合起来被称为⼀个路径。
数据结构树与⼆叉树常⽤计算公式在⼆叉树的理论推导以及⼀些⾼频类型题中,我们经常需要计算⼆叉树的总结点数,某⼀层的结点数以及已知结点数反推树的⾼度,本⽂围绕这⼏个⾼频知识点,归纳总结以下公式。
公式(1)⾮空⼆叉树叶⼦结点数 = 度为2的结点数 + 1 即,N0=N2+1(2)⾮空⼆叉树上第K层⾄多有2k−1个结点(K≥1)(3)⾼度为H的⼆叉树⾄多有2H−1 个结点(H≥1)(4)具有N个(N>0)结点的完全⼆叉树的⾼度为⌈log2(N+1)⌉或⌊log2N⌋+1(5)对完全⼆叉树按从上到下、从左到右的顺序依次编号1,2,...,N,则有以下关系:①当i>1 时,结点i的双亲结点编号为⌊i/2⌋,即当i为偶数时,其双亲结点的编号为i/2 ,它是双亲结点的左孩⼦;当i为奇数时,其双亲结点的编号为 (i−1)/2 ,它是双亲结点的右孩⼦。
②当 2i≤N时,结点i的左孩⼦编号为 2i,否则⽆左孩⼦。
③当 2i+1≤N时,结点i的右孩⼦编号为 2i+1 ,否则⽆右孩⼦。
④结点i所在层次(深度)为⌊log2i⌋+1 。
(设根结点为第1层)经典例题**408考研-2011-4** 若⼀棵完全⼆叉树有768个结点,则⼆叉树中叶结点的个数是_____。
A.257B.258C.384D.385解法1根据完全⼆叉树的性质,最后⼀个分⽀结点的序号为⌊n/2⌋=⌊768/2⌋=384 ,故叶⼦结点的个数为 768−384=384解法2由⼆叉树的性质N=N0+N1+N2和N0=N2+1 可知N=2N0−1+N1,2N0−1+N1=768显然,N1=1,2N0=768,则N0=384解法3完全⼆叉树的叶⼦结点只可能出现在最下两层,由题可计算完全⼆叉树的⾼度为10。
第10层的叶⼦结点数为 768−(29−1)=257第10层的叶⼦结点在第9层共有⌈257/2⌉=129 个⽗节点第9层的叶⼦结点数为 (29−1)−129=127则叶⼦结点总数为 257+127=384Processing math: 100%。
二叉树各种计算公式总结二叉树是一种常见的数据结构,它由一个根节点和最多两个子节点组成。
许多计算问题可以通过对二叉树进行各种操作和遍历来解决。
在本文中,将总结二叉树的各种计算公式。
1.二叉树节点个数:二叉树节点个数的计算公式是N=N1+N2+1,其中N表示二叉树的节点个数,N1表示左子树的节点个数,N2表示右子树的节点个数。
2. 二叉树的高度:二叉树的高度是指从根节点到最远叶子节点的最长路径上的节点数量。
计算二叉树的高度的公式是H = max(H1, H2) + 1,其中H表示二叉树的高度,H1表示左子树的高度,H2表示右子树的高度。
3.二叉树的深度:二叉树的深度是指从根节点到当前节点的路径的长度。
计算二叉树的深度的公式是D=D1+1,其中D表示二叉树的深度,D1表示父节点的深度。
4.二叉查找树:二叉查找树是一种有序二叉树,它要求对于树中的每个节点,左子树的值都小于节点的值,右子树的值都大于节点的值。
在二叉查找树中进行的公式是:-如果目标值等于当前节点的值,则返回当前节点;-如果目标值小于当前节点的值,则在左子树中继续;-如果目标值大于当前节点的值,则在右子树中继续。
5.二叉树的遍历:二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点。
常见的二叉树遍历方式有三种:- 前序遍历:先访问根节点,然后递归地访问左子树,最后递归地访问右子树。
可以表示为:root -> 左子树 -> 右子树。
- 中序遍历:先递归地访问左子树,然后访问根节点,最后递归地访问右子树。
可以表示为:左子树 -> root -> 右子树。
- 后序遍历:先递归地访问左子树,然后递归地访问右子树,最后访问根节点。
可以表示为:左子树 -> 右子树 -> root。
6.二叉树的最大路径和:二叉树的最大路径和是指二叉树中两个节点之间路径上的节点值的最大和。
可以通过递归地计算每个子树的最大路径和,然后选择最大的子树路径和来得出最终结果。
二叉树的叶子计算方法引言概述:二叉树是一种常见的数据结构,它具有根节点、左子树和右子树等基本组成部分。
在二叉树中,叶子节点是指没有子节点的节点。
计算二叉树的叶子节点数量是一项重要的任务,它可以帮助我们了解二叉树的结构和特性。
本文将介绍二叉树叶子计算的方法。
正文内容:1. 递归法1.1 定义递归函数:首先,我们需要定义一个递归函数来计算二叉树的叶子节点数量。
该函数的输入参数是二叉树的根节点,返回值是叶子节点的数量。
1.2 递归终止条件:在递归函数中,我们需要定义递归的终止条件。
当递归到叶子节点时,我们将返回1,表示找到了一个叶子节点。
1.3 递归调用:在递归函数中,我们将对左子树和右子树分别调用递归函数,将它们的返回值相加,即可得到整个二叉树的叶子节点数量。
2. 迭代法2.1 使用栈数据结构:我们可以使用栈数据结构来实现二叉树的迭代计算。
首先,将根节点入栈。
2.2 迭代遍历:在迭代过程中,我们使用一个计数器来记录叶子节点的数量。
每次从栈中弹出一个节点,如果该节点是叶子节点,则将计数器加1。
然后,将该节点的左子节点和右子节点依次入栈。
2.3 迭代终止条件:当栈为空时,迭代结束,我们可以得到二叉树的叶子节点数量。
3. 层次遍历法3.1 使用队列数据结构:层次遍历是一种广度优先搜索的方法,我们可以使用队列数据结构来实现。
首先,将根节点入队。
3.2 层次遍历:在遍历过程中,我们使用一个计数器来记录叶子节点的数量。
每次从队列中出队一个节点,如果该节点是叶子节点,则将计数器加1。
然后,将该节点的左子节点和右子节点依次入队。
3.3 层次遍历终止条件:当队列为空时,遍历结束,我们可以得到二叉树的叶子节点数量。
总结:通过递归法、迭代法和层次遍历法,我们可以计算二叉树的叶子节点数量。
递归法通过定义递归函数和终止条件来实现,迭代法通过使用栈数据结构来实现,层次遍历法通过使用队列数据结构来实现。
这些方法各有优劣,可以根据实际情况选择适合的方法来计算二叉树的叶子节点数量。
二叉树算结点的公式二叉树是一种最常用的数据结构之一,它由根节点、左子树、右子树构成。
在二叉树中,每个节点最多有两个子节点,一个是左子节点,一个是右子节点。
在计算二叉树的结点数时,我们需要运用以下公式:设该二叉树的结点数为n,叶子结点数为m,则有:n = m + 1 + 度为2的非叶子结点数由此可以看出,在二叉树中,结点的数量与叶子结点和度为2的非叶子结点数量有直接关系。
以下是二叉树结点计算公式的详细解释:1. 叶子结点的个数叶子结点是没有子节点的结点,因此当我们需要计算二叉树的结点数时,首先需要得到叶子结点的数量。
计算叶子结点数量的方法很简单,只要按照以下公式进行计算即可:m = $n_0$其中,m代表叶子结点数量,$n_0$代表度为0的结点数量。
在计算二叉树结点数时,度为0的结点数量即为叶子结点数量。
2. 度为2的非叶子结点数量度为2的非叶子结点是有两个子节点的结点,它们是连接二叉树的关键节点。
由于它们都有两个子节点,因此度为2的非叶子结点数量对整个二叉树的结构和大小都有很大的影响。
计算方法如下:设度为2的非叶子结点数量为k,则有:$k = n_2$其中,$n_2$代表度为2的结点数量。
3. 二叉树结点数量当我们得到了叶子结点和度为2的非叶子结点数量后,就可以按照公式计算整个二叉树的结点数量了。
如下所示:$n = m + 1 + k$其中,n代表二叉树的结点数量,m代表叶子结点数量,k代表度为2的非叶子结点数量。
最终得到的n就是整个二叉树的结点数量。
综上所述,二叉树的结点数量与叶子结点数量和度为2的非叶子结点数量有关。
要计算二叉树的结点数量,我们需要先计算叶子结点和度为2的非叶子结点数量,再按照公式进行计算。
二叉树的结点数量公式可以为我们快速、准确地计算二叉树中的结点数量提供帮助。
二叉树结点计算公式一、二叉树的结点计算公式1. 结点数计算公式二叉树的结点数可以通过递归计算的方式得到。
对于一个二叉树,其结点数等于左子树的结点数加上右子树的结点数再加1(根结点)。
2. 叶子结点数计算公式叶子结点是指没有子结点的结点。
二叉树的叶子结点数可以通过递归计算的方式得到。
对于一个二叉树,如果根结点为空,则叶子结点数为0;否则,叶子结点数等于左子树的叶子结点数加上右子树的叶子结点数。
3. 二叉树的深度计算公式二叉树的深度是指从根结点到叶子结点的最长路径长度。
可以通过递归计算的方式得到二叉树的深度。
对于一个二叉树,如果根结点为空,则深度为0;否则,深度等于左子树的深度和右子树的深度中的较大值加1。
4. 二叉树的高度计算公式二叉树的高度是指从叶子结点到根结点的最长路径长度。
可以通过递归计算的方式得到二叉树的高度。
对于一个二叉树,如果根结点为空,则高度为0;否则,高度等于左子树的高度和右子树的高度中的较大值加1。
5. 二叉树的平衡因子计算公式二叉树的平衡因子是指一个结点的左子树的高度减去右子树的高度。
可以通过递归计算的方式得到二叉树的平衡因子。
对于一个二叉树,如果根结点为空,则平衡因子为0;否则,平衡因子等于左子树的高度减去右子树的高度。
1. 计算二叉树的结点数假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,结点数等于左子树的结点数加上右子树的结点数再加1,即结点数=结点数(B) + 结点数(C) + 1。
2. 计算二叉树的深度假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,深度等于左子树的深度和右子树的深度中的较大值加1,即深度=MAX(深度(B), 深度(C)) + 1。
3. 计算二叉树的平衡因子假设有一棵二叉树,根结点是A,左子树是B,右子树是C。
根据结点计算公式,平衡因子等于左子树的高度减去右子树的高度,即平衡因子=高度(B) - 高度(C)。
〃二叉树类template <class T> class Binary Tree {public:BinaryNode<T> *root;〃构造空二叉树//以标明空子树的先根序列构造一棵二叉树〃以先根和中根序列构造二叉树 〃析构函数〃判断是否空二叉树 〃先根次序遍历二叉树 //中根次序遍历二叉树//后根次序遍历二叉树 〃返冋二叉树的结点个数int height();〃返回二叉BinaryNode<T>* search(T value);//查找首次BinaryNode<T>* getParent(BinaryNode<T>*node); 〃返回 node 结点的父母结点BinaryNode<T>* insert(BinaryNode<T> *p, T value, bool leftChild=true); 〃插入 value 作为 p结点的孩子void remove(BinaryNode<T> *p, bool leftChild=true); 〃删除 p 结点的左或右子树BinaryNode<T>* create(T prelist[], int n, int &i); 〃以标明空子树的先根遍历序列创建子#include "BinaryNode.h" #include "SeqStack.h” #include "LinkedStack.h u #include "SeqQueue.h" //#include "LinkedQueue.h"〃二叉树的二叉链表结点类 //顺序栈 〃链式栈 〃顺序循环队列 〃链式队列〃二叉树类〃指向根结点BinaryTree();BinaryTree(T prelist[], int n);BinaryTree(T prelist[], T inlistf], int n); 〜BinaryTree(); bool isEmptyO; void preOrder(); void inOrder(); void postOrder(); int count();void printGList(); void inOrderTraverse(); void levelOrder(); private:void preOrder(BinaryNode<T> *p); void inOrder(BinaryNode<T> *p); void postOrder(BinaryNode<T> *p); void destroy(BinaryNode<T> *p);〃以广义表表示输出二叉树〃中根次序遍历二叉树的非递归算法 〃按层次遍历二叉树〃先根次序遍历以P 结点为根的子树 〃屮根次序遍历以P 结点为根的子树 〃后根次序遍历以P 结点为根的子树 〃撤销二叉树BinaryNode<T>* create(T prelistf], T inlistf], int preStart, int inStart, int n); 〃以先根和屮 根序列创建一棵子树int count(BinaryNode<T> *p); 〃返冋以p 结点为根的子树结点个数 int height(BinaryNode<T> *p);//返冋以p 结点为根的子树高度BinaryNode<T>* search(BinaryNode<T> *p, T value); 〃在以 p 为根的子树屮查找首次出 现的值为value 的结点BinaryNode<T>* getParent(BinaryNode<T> BinaryNode<T> *node);void replaceAll(BinaryNode<T> *p, T old, T value); 〃在以 p 为根的子树中实现全部 替换 bool equals(BinaryNode<T> *p, BinaryNode<T> *q);〃判断以 p 和 q 结点为根的两棵子树是否相等BinaryNode<T>* copy(BinaryNode<T> *p);〃第8章习题bool isSorted(BinaryNode<T>* p);void printGList(BinaryNode<T> *p); 树〃第6章习题public: void leaf(); int countLeaf();bool replace(T old, T value); valuevoid replaceAll(T old, T value); int operator==(BinaryTree<T> &bitree); BinaryTree(BinaryTree<T> &bitree); void preOrderTraverse(); bool isSorted();〃以广义表表示输出以p 结点为根的子〃遍历输出叶子结点 〃返回二叉树的叶子结点数〃将首次岀现的值为old 结点值替换为〃将值为old 的结点全部替换为value //比较两棵二叉树是否相等,重载运算符 〃由已知的bitree 构造二叉树 〃先根次序遍历二叉树的非递归算法 〃判断一棵二叉树是否为二叉排序树 private:void leaf(BinaryNode<T> *p); 结点 int countLeaf(BinaryNode<T> *p);个数〃输出以p 结点为根的子树的所有叶子 〃返回以p 结点为根的子树的叶子结点〃复制以p 根的子二叉树template <class T>B in aryTree<T>::BinaryTree()〃构造空二叉树root = NULL;template <class T>bool BinaryTree<T>::isEmptyO { return root==NULL;}〃3・二叉树的先根、中根和后根次序遍历算法template <class T>void BinaryTree<T>::preOrder(){cout«,*先根次序遍历二叉树:”;preOrder(root); 数cout«endl;}template <class T>void BinaryTree<T>::preOrder(BinaryNode<T> *p) 归函数{if(p!=NULL){cout«p->data«H preOrder(p->Ieft);递归调用preOrder(p->right);递归调用}1template <class T>void BinaryTree<T>::inOrder(){cout«"中根次序遍历二叉树:”;inOrder(root); 数cout«endl;}template <class T>void BinaryTree<T>::inOrder(BinaryNode<T> *p)归函数if(p!=NULL){〃判断是否空二叉树〃先根次序遍历二叉树〃调用先根次序遍历二叉树的递归函〃先根次序遍历以p结点为根的子树,递〃若二叉树不空〃访问当前结点〃按先根次序遍历当前结点的左子树,〃按先根次序遍历当前结点的右子树,〃中根次序遍历二叉树〃调用中根次序遍历二叉树的递归函〃中根次序遍历以p结点为根的子树,递inOrder(p->left); cout«p->data«H inOrder(p->right);template <class T>void BinaryTree<T>::postOrder() //后根次序遍历二叉树{cout«,*后根次序遍历二叉树:”;postOrder(root); 〃调用后根次序遍历二叉树的递归函数cout«endl;}template <class T>void BinaryTree<T>::postOrder(BinaryNode<T> *p) 〃后根次序遍历以p 结点为根的子树,递归函数{if (p!二NULL){postOrder(p->left);postOrder(p->right);cout«p->data«"}}//4.基于遍历的操作template <class T>B inaiyTree<T> ~ B inaryTree() 〃析构函数{cout«n撤销二叉树:”;destroy(root);cout«endl;} template <class T>void BinaryTree<T>::destroy(BinaryNode<T> *p) 〃撤销以p 结点为根的子树,后根次序遍历讦(p!=NULL){destroy(p->left); destroy(p->right);cout«p->data«'r 〃显示撤销结点的次序 delete p; } }//【例6.1】构造并遍历二叉树。
template <class T> int BinaryTree<T>::count() 〃返回二叉树的结点个数{return count(root); }template <class T>int BinaryTree<T>::count(BinaryNode<T> *p) 〃返冋以p 结点为根的子树结点个数 {if (p==NULL) return 0; elsereturn I +count(p->left)+count(p->right);}template <class T> int BinaryTree<T>::height() {return height(root); }template <class T>int BinaryTree<T>::height(BinaryNode<T> *p) 序遍历{if(p!=NULL) {int lh = height(p->left); int rh = height(p ・>right); return (lh>=rh) ? lh+1 : rh+1; }return 0;〃返回二叉树的高度〃返回以p 结点为根的子树高度,后根次 〃求左子树的高度template <class T>BinaiyNode<T>* BinaiyTree<T>::search(T value)〃查找首次出现的值为 value 结点{return search(root, value);template <class T>BinaryNode<T>* BinaryTree<T>::search(BinaryNode<T> 水p, T value) 〃在以 p 为根的子树中 查找{〃先根次序遍历查找值为value 的结点,返回首次出现结点指针,若未找到返回NULLtemplate <class T>BinaryNode<T>* BinaryTree<T>::getParent(BinaryNode<T> *node) 〃返冋 node 结点的父母 结点指针 { 〃若空树、未找到或node 为根,返回 NULLif (root==NULL || node==NULL || node==root)return NULL; retum getParent(root, node);template <class T>BinaryNode<T>* BinaryTree<T>::getParent(BinaryNode<T>BinaryNode<T> *node){〃在以p 为根的子树中查找并返回node 结点的父母结点指针BinaryNode<T> *find=NULL; if(p!=NULL){if (p->left==node || p->right==node)return p;find = getParent(p->left, node); if (find 二二NULL)BinaryNode<T> *find 二NULL; if (p!二NULL){if (p->data==value)retum p; find = search(p->left, value);归调用if (find==NULL)find = search(p ・>right,value); }return find;〃记载找到结点〃查找成功,返回结点指针〃在左子树中查找,find 指向找到结点,递〃若在左子树中未找到〃则继续在右子树屮查找,递归调用〃返回查找结果find = getParent(p->right, node);}return find;}//5.构造二叉树template <class T>BinaryTree<T>::BinaryTree(T prelistf], T inlistf], int n) 〃以先根和中根序列构造二叉树//n指定序列长度root = create(prelist, inlist, 0, 0, n);}template <class T>BinaryNode<T>* BinaryTree<T>::create(T prelist[], T inlist[], int preStart,int inStart, int n) 〃以先根和中根序列创建一棵子树,子树根结点是prelist[i],返回根结点指针BinaryNode<T> *p=NULL;讦(n>0)return p;template <class T>BinaryTree<T>::BinaryTree(T prelist[], int n) 〃以标明空子树的先根序列构造二叉树{int i=();root=create(prelist, n, i);}template <class T>BinaryNode<T>* BinaryTree<T>::create(T prelistf], int n, int &i){ 〃以标明空子树的先根次序遍历序列创建一棵子树,子树根结点是prelist[i],返回根结点指针BinaryNode<T> *p=NULL;p = new BinaryNode<T>(elem); p->left = create(prelist, n, i); p->right = create(prelist, n, i); } } return p;//【例6.2] 输出二叉树中指定结点的所有祖先结点。