二叉树叶子结点个数计算
实验报告二叉树求叶子结点数目
实验报告二叉树求叶子结点数目实验目的：1.理解二叉树的概念和基本操作。
2.学会使用递归算法实现对二叉树的遍历和操作。
实验内容：给定一个二叉树，求其叶子结点的数目。
实验原理：二叉树是一种常用的数据结构，其所有节点的度不超过2、对于二叉树的遍历，有三种常见的方式：前序遍历、中序遍历和后序遍历。
其中，前序遍历是先访问根节点，然后依次访问左子树和右子树；中序遍历是先访问左子树，然后访问根节点，最后访问右子树；后序遍历是先访问左子树，然后访问右子树，最后访问根节点。
根据二叉树的定义，叶子结点即没有子节点的节点，可以通过递归的方式遍历二叉树来求解叶子结点的数目。
具体操作如下：1. 创建一个变量count，用于记录叶子结点的数目，初始值为0。
2.若当前节点为空，则返回0。
3. 若当前节点没有左子树和右子树，则说明当前节点是叶子结点，count加14. 若当前节点有左子树，则递归调用函数求解左子树的叶子结点数目，并将结果加到count上。
5. 若当前节点有右子树，则递归调用函数求解右子树的叶子结点数目，并将结果加到count上。
6. 返回count作为结果。
实验步骤：1.创建一个二叉树的类，包括节点类和二叉树类，定义根节点和相关操作方法。
2. 在二叉树类中定义一个递归函数countLeafNodes，用于求解叶子结点的数目。
3. 在countLeafNodes函数中实现上述的递归算法。
4.在主函数中创建一个二叉树对象，并插入一些节点。
5. 调用countLeafNodes函数，输出叶子结点的数目。
实验结果：经过测试，结果正确。
实验总结：通过本次实验，我进一步理解了二叉树的概念和基本操作，并学会了使用递归算法实现对二叉树的遍历和操作。
特别是通过实现统计叶子结点数目的功能，我对递归算法有了更深入的理解。
在实验过程中，我也遇到了一些问题，例如如何正确地进行前序遍历，并正确判断叶子结点。
通过查阅资料和与同学的讨论，我逐渐解决了这些问题。
叶子结点 偶数
叶子结点偶数
叶子结点与偶数的关联主要体现在完全二叉树中叶子结点数量的计算上。
完全二叉树是一种特殊的二叉树，其中每一层（除最后一层外）都完全填充，而最后一层从左到右尽可能填充。
对于完全二叉树，如果总节点数为偶数，那么叶子节点的数量可以通过以下公式计算：叶子节点数 = 总节点数 / 2。
这个规律是由完全二叉树的性质决定的，因为在完全二叉树中，除了叶子节点外，每个节点都有一个或两个子节点，而叶子节点没有子节点。
例如，如果一个完全二叉树有200个节点（偶数），那么它的叶子节点数就是200 / 2 = 100个。
这个规律在计算机科学和数据结构中非常有用，因为它允许我们快速确定完全二叉树中叶子节点的数量，而无需逐个检查每个节点。
C++如何实现二叉树叶子节点个数计算
C++如何实现二叉树叶子节点个数计算C++如何实现二叉树叶子节点个数计算很多人都不知道C++如何实现二叉树叶子节点个数计算，下面店铺为大家解答一下，希望能帮到大家！/*求二叉树叶子节点个数 -- 采用递归和非递归方法经调试可运行源码及分析如下：***/#include#include#includeusing std::cout;using std::cin;using std::endl;using std::stack;/*二叉树结点定义*/typedef struct BTreeNode{char elem;struct BTreeNode *pleft;struct BTreeNode *pright;}BTreeNode;/*求二叉树叶子节点数叶子节点：即没有左右子树的结点递归方式步骤：如果给定节点proot为NULL，则是空树，叶子节点为0，返回0；如果给定节点proot左右子树均为NULL，则是叶子节点，且叶子节点数为1，返回1；如果给定节点proot左右子树不都为NULL，则不是叶子节点，以proot为根节点的'子树叶子节点数=proot左子树叶子节点数+proot 右子树叶子节点数。
/*递归实现求叶子节点个数*/int get_leaf_number(BTreeNode *proot){if(proot == NULL)return 0;if(proot->pleft == NULL && proot->pright == NULL)return 1;return (get_leaf_number(proot->pleft) + get_leaf_number(proot->pright));}/*非递归：本例采用先序遍历计算判断当前访问的节点是不是叶子节点，然后对叶子节点求和即可。
**/int preorder_get_leaf_number(BTreeNode* proot){if(proot == NULL)return 0;int num = 0;stackst;while (proot != NULL || !st.empty()){while (proot != NULL){cout << "节点：" << proot->elem << endl;st.push(proot);proot = proot->pleft;}if (!st.empty()){proot = st.top();st.pop();if(proot->pleft == NULL && proot->pright == NULL) num++;proot = proot -> pright;}}return num;}/*初始化二叉树根节点*/BTreeNode* btree_init(BTreeNode* &bt){bt = NULL;return bt;}/*先序创建二叉树*/void pre_crt_tree(BTreeNode* &bt){char ch;cin >> ch;if (ch == '#'){bt = NULL;}else{bt = new BTreeNode;bt->elem = ch;pre_crt_tree(bt->pleft);pre_crt_tree(bt->pright);}}int main(){int tree_leaf_number = 0;BTreeNode *bt;btree_init(bt);//初始化根节点pre_crt_tree(bt);//创建二叉树tree_leaf_number = get_leaf_number(bt);//递归cout << "二叉树叶子节点个数为:" << tree_leaf_number << endl;cout << "非递归先序遍历过程如下：" << endl;tree_leaf_number = preorder_get_leaf_number(bt);//非递归cout << "二叉树叶子节点个数为:" << tree_leaf_number << endl;system("pause");return 0;}/*运行结果：a b c # # # d e # # f # #---以上为输入------以下为输出---二叉树叶子节点个数为:3非递归遍历过程如下：节点：a节点：b节点：c节点：d节点：e节点：f二叉树叶子节点个数为:3 请按任意键继续. . .本例创建的二叉树形状：ab dc e f*/下载全文。
叶子结点数的计算公式
叶子结点数的计算公式叶子节点数的计算公式叶子节点是指在一棵树中没有子节点的节点。
在计算机科学中，树是一种常见的数据结构，用于组织和存储数据。
树的节点之间存在父子关系，每个节点可以有多个子节点。
叶子节点是树中最底层的节点，它们没有子节点。
叶子节点数的计算公式可以根据树的特性和节点的关系来推导和计算。
下面我们将详细介绍叶子节点数的计算方法。
我们需要了解树的基本概念。
树包含一个根节点和若干子树，每个子树也是一棵树。
树的节点可以分为内部节点和叶子节点。
内部节点是除了根节点和叶子节点之外的节点。
叶子节点是没有子节点的节点。
叶子节点数的计算公式如下：1. 如果树为空，则叶子节点数为0。
2. 如果树只包含一个节点，且该节点为根节点，则叶子节点数为1。
3. 如果树不为空且有多个节点，则叶子节点数等于所有子树的叶子节点数之和。
根据上述公式，我们可以通过递归的方式来计算叶子节点数。
递归是一种解决问题的方法，它将问题分解为更小的子问题，并通过不断地调用自身来解决子问题。
下面我们以一棵二叉树为例来说明叶子节点数的计算过程。
假设我们有以下一棵二叉树：```A/ \B C/ \ / \D E F G```根据计算公式，我们可以分析如下：1. 树不为空且有多个节点，所以叶子节点数等于所有子树的叶子节点数之和。
2. 根节点A有两个子节点B和C。
3. B有两个子节点D和E，它们都是叶子节点。
4. C有两个子节点F和G，它们也都是叶子节点。
因此，叶子节点数等于B的叶子节点数加上C的叶子节点数，即2 + 2 = 4。
通过上述例子，我们可以看出，叶子节点数的计算公式是适用于任意类型的树的。
无论是二叉树、多叉树还是其他类型的树，只要满足树的定义，都可以使用相同的计算方法来求解叶子节点数。
叶子节点数的计算公式是树结构中的一个重要概念，它可以帮助我们更好地理解和分析树的特性。
在实际的编程和算法设计中，我们经常需要对树进行操作和处理，而叶子节点数的计算公式就是其中一个重要的工具。
二叉树结点计算公式
二叉树结点计算公式二叉树是一种常见的数据结构，由结点和连接这些结点的边组成。
每个结点都有一个值，并且可以有最多两个子结点。
根据二叉树结点的计算公式，我们可以更好地理解和运用二叉树。
二叉树的结点计算公式可以帮助我们计算二叉树的深度。
二叉树的深度是指从根结点到最远叶子结点的路径长度。
通过遍历二叉树的每个结点，并计算结点所在的层数，我们可以得到二叉树的深度。
这可以通过递归算法实现，即从根结点开始，递归地计算左右子树的深度，并取较大值加1作为树的深度。
二叉树的结点计算公式还可以帮助我们计算二叉树的节点数。
节点数是指二叉树中所有结点的总数。
通过递归地遍历每个结点，并计数每个结点，我们可以得到二叉树的节点数。
递归算法的思路是，树的节点数等于左子树的节点数加右子树的节点数再加1。
二叉树的结点计算公式还可以用于计算二叉树的叶子结点数。
叶子结点是指没有子结点的结点。
通过遍历每个结点，并判断其是否为叶子结点，我们可以得到二叉树的叶子结点数。
递归算法的思路是，如果当前结点没有左子树和右子树，则它是叶子结点，否则递归地计算左右子树的叶子结点数并相加。
二叉树的结点计算公式还可以帮助我们判断二叉树是否为平衡二叉树。
平衡二叉树是指任意节点的左右子树的高度差不超过1的二叉树。
通过计算每个结点的左子树和右子树的深度差，并判断是否满足平衡二叉树的定义，我们可以确定二叉树是否为平衡二叉树。
递归算法的思路是，判断当前结点的左子树和右子树的深度差是否满足平衡二叉树的定义，并递归地判断左右子树是否为平衡二叉树。
除了上述常见的二叉树计算公式，还有一些其他的应用。
例如，我们可以通过二叉树的结点计算公式来计算二叉树的直径。
二叉树的直径是指二叉树中任意两个结点之间的最长路径长度。
通过遍历每个结点，并计算以该结点为根结点的子树的直径，我们可以得到二叉树的直径。
递归算法的思路是，二叉树的直径等于左子树的直径、右子树的直径和经过根结点的最长路径长度中的最大值。
二叉树节点计算法方法
1．6 树与二叉树树是一种简单的非线性结构，所有元素之间具有明显的层次特性。
在树结构中，每一个结点只有一个前件，称为父结点，没有前件的结点只有一个，称为树的根结点，简称树的根。
每一个结点可以有多个后件，称为该结点的子结点。
没有后件的结点称为叶子结点。
在树结构中，一个结点所拥有的后件的个数称为该结点的度，所有结点中最大的度称为树的度。
树的最大层次称为树的深度。
二叉树的特点：（1）非空二叉树只有一个根结点；（2）每一个结点最多有两棵子树，且分别称为该结点的左子树与右子树。
二叉树的基本性质：（1）在二叉树的第k层上，最多有2k-1(k≥1)个结点；（2）深度为m的二叉树最多有2m-1个结点；（3）度为0的结点（即叶子结点）总是比度为2的结点多一个；（4）具有n个结点的二叉树，其深度至少为[log2n]+1,其中[log2n]表示取log2n的整数部分；（5）具有n个结点的完全二叉树的深度为[log2n]+1；（6）设完全二叉树共有n个结点。
如果从根结点开始，按层序（每一层从左到右）用自然数1，2，….n给结点进行编号（k=1,2….n），有以下结论：①若k=1，则该结点为根结点，它没有父结点；若k>1，则该结点的父结点编号为INT(k/2)；②若2k≤n，则编号为k的结点的左子结点编号为2k；否则该结点无左子结点（也无右子结点）；③若2k+1≤n，则编号为k的结点的右子结点编号为2k+1；否则该结点无右子结点。
满二叉树是指除最后一层外，每一层上的所有结点有两个子结点，则k层上有2k-1个结点深度为m的满二叉树有2m-1个结点。
完全二叉树是指除最后一层外，每一层上的结点数均达到最大值，在最后一层上只缺少右边的若干结点。
二叉树存储结构采用链式存储结构，对于满二叉树与完全二叉树可以按层序进行顺序存储。
二叉树的遍历：（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树；（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树；（3）后序遍历（LRD）首先遍历左子树，然后访问遍历右子树，最后访问根结点。
求二叉树的深度、总结点数和叶子结点数
求⼆叉树的深度、总结点数和叶⼦结点数⼆叉树的⼆叉链表的存储结构：typedef char TElemType;typedef struct BiTNode{TElemType data;//数据元素BiTNode * lchild;//指向左孩⼦BiTNode * rchild;//指向右孩⼦}BiTNode,* BiTree;⼀、⼆叉树的深度如果⼆叉树为空，结点的深度为0；如果⼆叉树只有⼀个结点G为例，其中，它的左右⼦树的深度为0；⽽这种情况⼆叉树的深度为1。
如果⼆叉树有两个结点D，G为例，其中，以D为根结点的⼆叉树的左⼦树的深度为0，右⼦树的深度为（0+1）；⽽这种情况⼆叉树的深度为2。
…………如果⼆叉树有n个结点,⼆叉树的深度为⼆叉树左右⼦树深度的最⼤值+1。
代码：int Depth(BiTree T){int m,n;if(!T) return 0;if(!T->lchild && !T->rchild) return 1;else{m = Depth(T->lchild);n = Depth(T->rchild);return 1+(m>n?m:n);}⼆、⼆叉树的叶⼦结点数如果⼆叉树为空，⼆叉树的叶⼦结点数为0；如果⼆叉树只有⼀个结点G（左右⼦树为空）为例，⽽这种情况⼆叉树的叶⼦结点数为1。
如果⼆叉树有两个结点D（右⼦树为⾮空），G（左右⼦树为空）为例，其中，以D为根结点的⼆叉树的左⼦树的叶⼦结点数为0，右⼦树的叶⼦结点数为1；⽽这种情况⼆叉树的叶⼦结点数为1。
…………如果⼆叉树有n个结点,⼆叉树的叶⼦结点数为⼆叉树左右⼦树叶⼦结点数的和。
代码：int CountLeaf(BiTree T){int m,n;if(!T) return 0;if(!T->lchild && !T->rchild) return 1;else{m = CountLeaf(T->lchild);n = CountLeaf(T->rchild);return m+n;}}三、⼆叉树的结点数如果⼆叉树为空，⼆叉树的结点数为0；如果⼆叉树只有⼀个结点G（左右⼦树为空）为例，⽽这种情况⼆叉树的结点数为1。
编写递归算法计算二叉树中叶子结点的数目
编写递归算法计算二叉树中叶子结点的数目递归算法是一种自己调用自己的算法，常用于解决具有重复性质问题的计算过程。
计算二叉树中叶子结点的数目是其中一个经典的应用。
下面将详细介绍如何编写递归算法计算二叉树中叶子结点的数目。
首先，我们需要定义二叉树的数据结构。
一个二叉树由根结点和左右子树组成，每个结点包含一个数据元素和指向左右子树的指针。
```pythonclass Node:def __init__(self, data):self.data = dataself.left = Noneself.right = None```接下来，我们定义一个递归函数来计算二叉树中叶子结点的数目。
递归函数基本思路是：如果当前结点为空，则返回0；如果当前结点没有左右子树，则返回1；否则，递归计算左右子树的叶子结点数目，并返回左右子树叶子结点数目之和。
```pythondef count_leaves(root):if root is None:return 0if root.left is None and root.right is None:return 1return count_leaves(root.left) + count_leaves(root.right) ```用法示例：```python#创建一个二叉树root = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5)root.right.left = Node(6)root.right.right = Node(7)num_leaves = count_leaves(root)print("The number of leaves is:", num_leaves)```输出结果：```The number of leaves is: 4```在上述示例中，我们创建了一个二叉树，并计算了其中叶子结点的数目，结果为4递归算法的基本思想是将大问题拆解为小问题，并在每一层递归中处理子问题。
编写递归算法计算二叉树中叶子结点的数目
学院名称专业班级实验成绩学生姓名学号实验日期课程名称数据结构实验题目 2 树一、实验目的与要求熟悉树的各种表示方法和各种遍历方式，掌握有关算法的实现，了解树在计算机科学及其它工程技术中的应用。
二、主要仪器设备Cfree三、实验内容和原理[问题描述]编写递归算法，计算二叉树中叶子结点的数目。
[输入]一棵二叉树的结点若无子树，则可将其子树看作“.”，输入时，按照前序序列的顺序输入该结点的内容。
对例题中的树，其输入序列ABD..EH...CF.I..G..。
○A○B○C○D○E○F○G○H○I[输出]若为空二叉树，则输出：THIS IS A EMPTY BINARY TREE。
若二叉树不空，输出叶子结点的个数。
[存储结构]采用二叉链表存储[算法的基本思想]采用递归方法建立和遍历二叉树。
首先建立二叉树的根结点，然后建立其左右子树，直到空子树为止。
遍历二叉树，若某一结点的左右孩子均为NULL，则该结点为叶子结点。
[参考源程序]#include <stdio.h>#include<malloc.h>struct node{char info;struct node *llink, *rlink;};typedef struct node NODE;NODE *create(){ //构造二叉树char x;NODE *p;scanf("%c", &x);printf("%c", x); //打印出已输入的二叉树if(x!='.'){p=(NODE *)malloc(sizeof(NODE));p->info=x;p->llink=create();p->rlink=create();}else p=NULL;return p;}int run(NODE *t){static int count=0;if(t){run(t->llink); //递归遍历左子树，直到叶子处run(t->rlink); //递归遍历右子树，直到叶子处if(t->llink ==NULL && t->rlink == NULL) {count++;}}return count;}main(){ NODE *T;int left_number;printf("请输入一棵树:\n" );T=create();printf("\n");if(!T) printf("This is a empty binary tree.");else{left_number=run(T);printf("\n这棵树共有%d 个子叶. \n", left_number);}printf("\n");}四、实验结果与分析（2）习题1：注意叶子结点是指该结点既没有左孩子又没有右孩子，采用递归算法就很容易计算出其数目。
编写递归算法,计算二叉树中叶子结点的数目。
}
}
return count;
}
main()
{ NODE *T;
int left_number;
printf("请输入一棵树:\n" );
T=create();
printf("\n");
if(!T) printf("This is a empty binary tree.");
else{
left_number=run(T);
printf("\n这棵树共有%d 个子叶. \n", left_number);
}
printf("\n");}
四、实验结果与分析
（2）习题1：注意叶子结点是指该结点既没有左孩子又没有右孩子，采用递归算法就很容易计算出其数目。
实验结果如图：
五、实验心得及体会
本次实验加深了我对树的各种遍历方法。
尤其是先序遍历。
在建立树的过程中更是采取了递归的方法。
有的算法用递归表示要比用循环表示简洁精练[如二叉树的遍历]，代码更简洁清晰，可读性更好有的算法递归能实现循环不一定能实现，递归的内部实现要消耗额外的空间和时间。
所以说循环的效率更高。
编写递归算法计算二叉树中叶子结点的数目
编写递归算法计算二叉树中叶子结点的数目递归算法是一种重要且常用的算法思想，可以帮助解决许多复杂的问题。
在计算二叉树中叶子节点的数目时，我们可以通过递归的方式来实现。
首先，我们需要定义二叉树的数据结构。
二叉树由节点（Node）组成，每个节点包含一个值（value），以及左子树（left）和右子树（right）。
如果一个节点没有左子树和右子树，则该节点为叶子节点。
```pythonclass Node:def __init__(self, value):self.value = valueself.left = Noneself.right = None```接下来，我们可以使用递归算法来计算二叉树中叶子节点的数目。
递归算法的思想是将一个复杂的问题分解成一个或多个相似的子问题。
对于计算二叉树中叶子节点的数目，我们可以将其分解为计算左子树中叶子节点的数目和计算右子树中叶子节点的数目两个子问题。
```pythondef count_leaves(root):if root is None:return 0if root.left is None and root.right is None:return 1left_leaves = count_leaves(root.left)right_leaves = count_leaves(root.right)return left_leaves + right_leaves```在递归函数`count_leaves`中，我们首先进行递归终止条件的判断。
如果当前节点为None，说明已经遍历到了树的底部，此时的叶子节点数为0。
如果当前节点没有左子树和右子树，说明当前节点为叶子节点，此时的叶子节点数为1对于非叶子节点，我们需要继续递归计算左子树和右子树中叶子节点的数目。
递归调用`count_leaves`函数，传入左子树和右子树，分别得到左子树和右子树中叶子节点的数目。
已知完全二叉树的结点数，求叶子节点数
已知完全二叉树的结点数，求叶子节点数
定达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是 完全二叉树 例题：假如一个完全二叉树中有743个节点, 则该二叉树中的叶子节点个数为？ 假设完全二叉树中，度为0的叶子结点为n0，度为1的结点为n1，度为2的结点为n2，总结点数为n。 则n=n0+n1+n2; 并且有n-1=2n2+n1; 如果总结点数为奇数，则n1为0，为偶数，则n1为1； 带入式子求得n0： 371
在深度为5的满二叉树中,叶子结点的个数为
在深度为5的满二叉树中,叶子结点的个数为
满二叉树是一种树形结构，它是每一个结点都有两个子节点的树结构，可以表示为节点及其关联的子节点，它的特点是所有的叶子节点都在最底层，并且除了叶子节点外其他的节点都有两个子节点，满二叉树是一种节省空间的数据结构，它有应用于二叉搜索树，树形集合，Fibonacci的堆，多路查找树等诸多操作。
在深度为5的满二叉树中，叶子结点的个数为，等于2的5次方减1，其值为31。
满二叉树只有叶子结点在最低层，而其他非叶子节点都有两个子节点，因此只需要计算最底层节点个数即可得出叶子结点的个数。
那么在深度为5的满二叉树中，最底层叶子结点的个数是2的5次方，等于31个叶子结点。
满二叉树有着一系列的优点，它的空间复杂度低，存储空间占用少，搜索的效率更高，在处理大量数据的时候性能会更加优越，而且在处理复杂程序的时候，它几乎就是必须使用的数据结构，比如搜索引擎就使用了满二叉树。
满二叉树是一种重要的数据结构，它在现代计算机中得到了广泛的运用，由于其具有空间优势、搜索效率等优点，除此之外，还具有比较便利的处理节点索引和字节寻址的能力，它可以被应用在许多领域，如数据库管理，图形图像处理等等。
总的来说，深度为5的满二叉树中叶子结点的个数是31个，满二叉树有多种优势，它在许多行业有着广泛的应用，是一种具有很高性价比的数据结构，受到世界各地程序员和编程爱好者的欢迎。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算二叉树叶子结点
1.程序设计简介
已知一棵二叉树，求该二叉树中叶子结点的个数。
2.基本要求
（1）设计二叉树的二叉链表为存储结构
（2）设计求叶子结点个数的递归算法
（3）输入：一颗二叉树
（4）输出：二叉树中叶子结点的个数
3.实现提示
（1）存储设计
二叉树采用二叉链表为存储结构
(2)算法设计
求二叉树中叶子结点个数，即求二叉树的所有结点中左、右子树均为空的结点个数之和。
可以将此问题转化为遍历问题，在遍历中“访问一个结点”时判断该结点是不是叶子，若是则将计数器累加。
4.源程序
#include<iostream>
#include<string>
using namespace std;
struct BiNode 行与测试
6.调试感想
非递归算法求叶子结点的个数
#include<stack>
#include<iostream>
using namespace std;
struct node
{
int data;
node *lchild;
node *rchild;
};
node *root=NULL;
void mid(node*root,int key=500)
{
int sum=0;
stack<node*>s;
while(NULL!=root || !())
{
if(NULL!=root)
{
(root);
root=root->lchild;
}
else
{
root=();
// cout<<root->data<<" ";
if(NULL==root->lchild && NULL==root->rchild)
++sum;
();
root=root->rchild;
}
}
cout<<sum<<endl;
}
int main()
{
root=new node;
root->data=100;
node *a=new node;
node *b=new node;
node *a1=new node;
node *a2=new node;
node *b1=new node;
node *b2=new node;
a->data=200;
b->data=300;
a1->data=400;
a2->data=500;
b1->data=600;
b2->data=700;
root->lchild=a;
root->rchild=b;
a->lchild=a1;
a->rchild=a2;
b->lchild=b1;
b->rchild=b2;
a1->lchild=NULL;
a1->rchild=NULL;
a2->lchild=NULL;
a2->rchild=NULL;
b1->lchild=NULL;
b1->rchild=NULL;
b2->lchild=NULL;
b2->rchild=NULL;
mid(root);
return 0;
}。