二叉树的随机生成及其遍历
二叉树的遍历及常用算法
⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设:L为遍历左⼦树,D为访问根结点,R为遍历右⼦树,且L必须位于R的前⾯可以得出以下三种不同的遍历次序:先序遍历操作次序为DLR,⾸先访问根结点，其次遍历根的左⼦树，最后遍历根右⼦树，对每棵⼦树同样按这三步(先根、后左、再右)进⾏中序遍历操作次序为LDR,⾸先遍历根的左⼦树，其次访问根结点，最后遍历根右⼦树，对每棵⼦树同样按这三步(先左、后根、再右)进⾏后序遍历操作次序为LRD,⾸先遍历根的左⼦树，其次遍历根的右⼦树，最后访问根结点，对每棵⼦树同样按这三步(先左、后右、最后根)进⾏层次遍历层次遍历即按照从上到下从左到右的顺序依次遍历所有节点,实现层次遍历通常需要借助⼀个队列,将接下来要遍历的结点依次加⼊队列中;遍历的应⽤“遍历”是⼆叉树各种操作的基础，可以在遍历过程中对结点进⾏各种操作，如:对于⼀棵已知⼆叉树求⼆叉树中结点的个数求⼆叉树中叶⼦结点的个数;求⼆叉树中度为1的结点个数求⼆叉树中度为2的结点个数5求⼆叉树中⾮终端结点个数交换结点左右孩⼦判定结点所在层次等等...C语⾔实现:#include <stdio.h>//⼆叉链表数据结构定义typedef struct TNode {char data;struct TNode *lchild;struct TNode *rchild;} *BinTree, BinNode;//初始化//传⼊⼀个指针令指针指向NULLvoid initiate(BinTree *tree) {*tree = NULL;}//创建树void create(BinTree *BT) {printf("输⼊当前结点值: (0则创建空节点)\n");char data;scanf(" %c", &data);//连续输⼊整形和字符时.字符变量会接受到换⾏,所以加空格if (data == 48) {*BT = NULL;return;} else {//创建根结点//注意开辟的空间⼤⼩是结构体的⼤⼩⽽不是结构体指针⼤⼩,写错了不会⽴马产⽣问题,但是后续在其中存储数据时极有可能出现内存访问异常(飙泪....) *BT = malloc(sizeof(struct TNode));//数据域赋值(*BT)->data = data;printf("输⼊节点 %c 的左孩⼦ \n", data);create(&((*BT)->lchild));//递归创建左⼦树printf("输⼊节点 %c 的右孩⼦ \n", data);create(&((*BT)->rchild));//递归创建右⼦树}}//求双亲结点(⽗结点)BinNode *Parent(BinTree tree, char x) {if (tree == NULL)return NULL;else if ((tree->lchild != NULL && tree->lchild->data == x) || (tree->rchild != NULL && tree->rchild->data == x))return tree;else{BinNode *node1 = Parent(tree->lchild, x);BinNode *node2 = Parent(tree->rchild, x);return node1 != NULL ? node1 : node2;}}//先序遍历void PreOrder(BinTree tree) {if (tree) {//输出数据printf("%c ", tree->data);//不为空则按顺序继续递归判断该节点的两个⼦节点PreOrder(tree->lchild);PreOrder(tree->rchild);}}//中序void InOrder(BinTree tree) {if (tree) {InOrder(tree->lchild);printf("%c ", tree->data);InOrder(tree->rchild);}}//后序void PostOrder(BinTree tree) {if (tree) {PostOrder(tree->lchild);PostOrder(tree->rchild);printf("%c ", tree->data);}}//销毁结点递归free所有节点void DestroyTree(BinTree *tree) {if (*tree != NULL) {printf("free %c \n", (*tree)->data);if ((*tree)->lchild) {DestroyTree(&((*tree)->lchild));}if ((*tree)->rchild) {DestroyTree(&((*tree)->rchild));}free(*tree);*tree = NULL;}}// 查找元素为X的结点使⽤的是层次遍历BinNode *FindNode(BinTree tree, char x) {if (tree == NULL) {return NULL;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];if (current->data == x) {return current;}front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}return NULL;}//层次遍历// 查找元素为X的结点使⽤的是层次遍历void LevelOrder(BinTree tree) {if (tree == NULL) {return;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];printf("%2c", current->data);front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}}//查找x的左孩⼦BinNode *Lchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->lchild;}return NULL;}//查找x的右孩⼦BinNode *Rchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->rchild;}return NULL;}//求叶⼦结点数量int leafCount(BinTree *tree) {if (*tree == NULL)return 0;//若左右⼦树都为空则该节点为叶⼦,且后续不⽤接续递归了else if (!(*tree)->lchild && !(*tree)->rchild)return 1;else//若当前结点存在⼦树,则递归左右⼦树, 结果相加return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));}//求⾮叶⼦结点数量int NotLeafCount(BinTree *tree) {if (*tree == NULL)return 0;//若该结点左右⼦树均为空,则是叶⼦,且不⽤继续递归else if (!(*tree)->lchild && !(*tree)->rchild)return 0;else//若当前结点存在左右⼦树,则是⾮叶⼦结点(数量+1),在递归获取左右⼦树中的⾮叶⼦结点,结果相加 return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;}//求树的⾼度(深度)int DepthCount(BinTree *tree) {if (*tree == NULL)return 0;else{//当前节点不为空则深度+1 在加上⼦树的⾼度,int lc = DepthCount(&((*tree)->lchild)) + 1;int rc = DepthCount(&((*tree)->rchild)) + 1;return lc > rc?lc:rc;// 取两⼦树深度的最⼤值 }}//删除左⼦树void RemoveLeft(BinNode *node){if (!node)return;if (node->lchild)DestroyTree(&(node->lchild));node->lchild = NULL;}//删除右⼦树void RemoveRight(BinNode *node){if (!node)return;if (node->rchild)DestroyTree(&(node->rchild));node->rchild = NULL;}int main() {BinTree tree;create(&tree);BinNode *node = Parent(tree, 'G');printf("G的⽗结点为%c\n",node->data);BinNode *node2 = Lchild(tree, 'D');printf("D的左孩⼦结点为%c\n",node2->data);BinNode *node3 = Rchild(tree, 'D');printf("D的右孩⼦结点为%c\n",node3->data);printf("先序遍历为:");PreOrder(tree);printf("\n");printf("中序遍历为:");InOrder(tree);printf("\n");printf("后序遍历为:");PostOrder(tree);printf("\n");printf("层次遍历为:");LevelOrder(tree);printf("\n");int a = leafCount(&tree);printf("叶⼦结点数为%d\n",a);int b = NotLeafCount(&tree);printf("⾮叶⼦结点数为%d\n",b);int c = DepthCount(&tree);printf("深度为%d\n",c);//查找F节点BinNode *node4 = FindNode(tree,'C');RemoveLeft(node4);printf("删除C的左孩⼦后遍历:");LevelOrder(tree);printf("\n");RemoveRight(node4);printf("删除C的右孩⼦后遍历:");LevelOrder(tree);printf("\n");//销毁树printf("销毁树 \n");DestroyTree(&tree);printf("销毁后后遍历:");LevelOrder(tree);printf("\n");printf("Hello, World!\n");return 0;}测试:测试数据为下列⼆叉树:运⾏程序复制粘贴下列内容:ABDGHECKFIJ特别感谢:iammomo。
数据结构实验五(二叉树的建立及遍历)题目和源程序
实验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 << "请按先序输入一个二叉树序列（可另输入，但要为先序），""无左右孩子则分别输入空格。
数据结构入门-树的遍历以及二叉树的创建
数据结构⼊门-树的遍历以及⼆叉树的创建树定义：1. 有且只有⼀个称为根的节点2. 有若⼲个互不相交的⼦树，这些⼦树本⾝也是⼀个树通俗的讲：1. 树是有结点和边组成，2. 每个结点只有⼀个⽗结点，但可以有多个⼦节点3. 但有⼀个节点例外，该节点没有⽗结点，称为根节点⼀、专业术语结点、⽗结点、⼦结点、根结点深度：从根节点到最底层结点的层数称为深度，根节点第⼀层叶⼦结点：没有⼦结点的结点⾮终端节点：实际上是⾮叶⼦结点度：⼦结点的个数成为度⼆、树的分类⼀般树：任意⼀个结点的⼦结点的个数都不受限制⼆叉树：任意⼀个结点的⼦结点个数最多是两个，且⼦结点的位置不可更改⼆叉数分类：1. ⼀般⼆叉数2. 满⼆叉树：在不增加树层数的前提下，⽆法再多添加⼀个结点的⼆叉树3. 完全⼆叉树：如果只是删除了满⼆叉树最底层最右边的连续若⼲个结点，这样形成的⼆叉树就是完全⼆叉树森林：n个互不相交的树的集合三、树的存储⼆叉树存储连续存储(完全⼆叉树)优点：查找某个结点的⽗结点和⼦结点(也包括判断有没有⼦结点)速度很快缺点：耗⽤内存空间过⼤链式存储⼀般树存储1. 双亲表⽰法：求⽗结点⽅便2. 孩⼦表⽰法：求⼦结点⽅便3. 双亲孩⼦表⽰法：求⽗结点和⼦结点都很⽅便4. ⼆叉树表⽰法：把⼀个⼀般树转化成⼀个⼆叉树来存储，具体转换⽅法：设法保证任意⼀个结点的左指针域指向它的第⼀个孩⼦，右指针域指向它的兄弟，只要能满⾜此条件，就可以把⼀个⼀般树转化为⼆叉树⼀个普通树转换成的⼆叉树⼀定没有右⼦树森林的存储先把森林转化为⼆叉树，再存储⼆叉树四、树的遍历先序遍历：根左右先访问根结点，再先序访问左⼦树，再先序访问右⼦树中序遍历：左根右中序遍历左⼦树，再访问根结点，再中序遍历右⼦树后续遍历：左右根后续遍历左⼦树，后续遍历右⼦树，再访问根节点五、已知两种遍历求原始⼆叉树给定了⼆叉树的任何⼀种遍历序列，都⽆法唯⼀确定相应的⼆叉树，但是如果知道了⼆叉树的中序遍历序列和任意的另⼀种遍历序列，就可以唯⼀地确定⼆叉树已知先序和中序求后序先序：ABCDEFGH中序：BDCEAFHG求后序：这个⾃⼰画个图体会⼀下就可以了，⾮常简单，这⾥简单记录⼀下1. ⾸先根据先序确定根，上⾯的A就是根2. 中序确定左右，A左边就是左树(BDCE)，A右边就是右树(FHG)3. 再根据先序，A左下⾯就是B，然后根据中序，B左边没有，右边是DCE4. 再根据先序，B右下是C，根据中序，c左下边是D，右下边是E，所以整个左树就确定了5. 右树，根据先序，A右下是F，然后根据中序，F的左下没有，右下是HG，6. 根据先序，F右下为G，然后根据中序，H在G的左边，所以G的左下边是H再来⼀个例⼦，和上⾯的思路是⼀样的，这⾥就不详细的写了先序：ABDGHCEFI中序：GDHBAECIF已知中序和后序求先序中序：BDCEAFHG后序：DECBHGFA这个和上⾯的思路是⼀样的，只不过是反过来找，后序找根，中序找左右树简单应⽤树是数据库中数据组织⼀种重要形式操作系统⼦⽗进程的关系本⾝就是⼀棵树⾯向对象语⾔中类的继承关系哈夫曼树六、⼆叉树的创建#include <stdio.h>#include <stdlib.h>typedef struct Node{char data;struct Node * lchild;struct Node * rchild;}BTNode;/*⼆叉树建⽴*/void BuildBT(BTNode ** tree){char ch;scanf("%c" , &ch); // 输⼊数据if(ch == '#') // 如果这个节点的数据是#说明这个结点为空*tree = NULL;else{*tree = (BTNode*)malloc(sizeof(BTNode));//申请⼀个结点的内存 (*tree)->data = ch; // 将数据写⼊到结点⾥⾯BuildBT(&(*tree)->lchild); // 递归建⽴左⼦树BuildBT(&(*tree)->rchild); // 递归建⽴右⼦树}}/*⼆叉树销毁*/void DestroyBT(BTNode *tree) // 传⼊根结点{if(tree != NULL){DestroyBT(tree->lchild);DestroyBT(tree->rchild);free(tree); // 释放内存空间}}/*⼆叉树的先序遍历*/void Preorder(BTNode * node){if(node == NULL)return;else{printf("%c ",node->data );Preorder(node->lchild);Preorder(node->rchild);}}/*⼆叉树的中序遍历*/void Inorder(BTNode * node){if(node == NULL)return;else{Inorder(node->lchild);printf("%c ",node->data );Inorder(node->rchild);}}/*⼆叉树的后序遍历*/void Postorder(BTNode * node){if(node == NULL)return;else{Postorder(node->lchild);Postorder(node->rchild);printf("%c ",node->data );}}/*⼆叉树的⾼度树的⾼度 = max(左⼦树⾼度，右⼦树⾼度) +1*/int getHeight(BTNode *node){int Height = 0;if (node == NULL)return 0;else{int L_height = getHeight(node->lchild);int R_height = getHeight(node->rchild);Height = L_height >= R_height ? L_height +1 : R_height +1; }return Height;}int main(int argc, char const *argv[]){BTNode * BTree; // 定义⼀个⼆叉树printf("请输⼊⼀颗⼆叉树先序序列以#表⽰空结点:");BuildBT(&BTree);printf("先序序列：");Preorder(BTree);printf("\n中序序列：");Inorder(BTree);printf("\n后序序列：");Postorder(BTree);printf("\n树的⾼度为：%d" , getHeight(BTree));return 0;}// ABC##DE##F##G##。
数据结构实验报告—二叉树
数据结构实验报告—二叉树数据结构实验报告—二叉树引言二叉树是一种常用的数据结构，它由节点和边构成，每个节点最多有两个子节点。
在本次实验中，我们将对二叉树的基本结构和基本操作进行实现和测试，并深入了解它的特性和应用。
实验目的1. 掌握二叉树的基本概念和特性2. 熟练掌握二叉树的基本操作，包括创建、遍历和查找等3. 了解二叉树在实际应用中的使用场景实验内容1. 二叉树的定义和存储结构：我们将首先学习二叉树的定义，并实现二叉树的存储结构，包括节点的定义和节点指针的表示方法。
2. 二叉树的创建和初始化：我们将实现二叉树的创建和初始化操作，以便后续操作和测试使用。
3. 二叉树的遍历：我们将实现二叉树的前序、中序和后序遍历算法，并测试其正确性和效率。
4. 二叉树的查找：我们将实现二叉树的查找操作，包括查找节点和查找最大值、最小值等。
5. 二叉树的应用：我们将探讨二叉树在实际应用中的使用场景，如哈夫曼编码、二叉搜索树等。
二叉树的定义和存储结构二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。
节点被表示为一个由数据和指向其左右子节点的指针组成的结构。
二叉树可以分为三类：满二叉树、完全二叉树和非完全二叉树。
二叉树可以用链式存储结构或顺序存储结构表示。
- 链式存储结构：采用节点定义和指针表示法，通过将节点起来形成一个树状结构来表示二叉树。
- 顺序存储结构：采用数组存储节点信息，通过计算节点在数组中的位置来进行访问和操作。
二叉树的创建和初始化二叉树的创建和初始化是二叉树操作中的基础部分。
我们可以通过手动输入或读取外部文件中的数据来创建二叉树。
对于链式存储结构，我们需要自定义节点和指针，并通过节点的方式来构建二叉树。
对于顺序存储结构，我们需要定义数组和索引，通过索引计算来定位节点的位置。
一般来说，初始化一个二叉树可以使用以下步骤：1. 创建树根节点，并赋初值。
2. 创建子节点，并到父节点。
3. 重复步骤2，直到创建完整个二叉树。
二叉树的各种遍历算法及其深度算法
二叉树的各种遍历算法及其深度算法一、二叉树的遍历算法二叉树是一种常见的数据结构，遍历二叉树可以按照根节点的访问顺序将二叉树的结点访问一次且仅访问一次。
根据遍历的顺序不同，二叉树的遍历算法可以分为三种：前序遍历、中序遍历和后序遍历。
1. 前序遍历（Pre-order Traversal）：首先访问根节点，然后遍历左子树，最后遍历右子树。
可以用递归或者栈来实现。
2. 中序遍历（In-order Traversal）：首先遍历左子树，然后访问根节点，最后遍历右子树。
可以用递归或者栈来实现。
3. 后序遍历（Post-order Traversal）：首先遍历左子树，然后遍历右子树，最后访问根节点。
可以用递归或者栈来实现。
二、二叉树的深度算法二叉树的深度，也叫做高度，指的是从根节点到叶子节点的最长路径上的节点数目。
可以使用递归或者层次遍历的方式来计算二叉树的深度。
1.递归算法：二叉树的深度等于左子树的深度和右子树的深度的较大值加一、递归的终止条件是当节点为空时，深度为0。
递归的过程中通过不断递归左子树和右子树，可以求出二叉树的深度。
2.层次遍历算法：层次遍历二叉树时，每遍历完一层节点，深度加一、使用一个队列来辅助层次遍历，先将根节点加入队列，然后依次取出队列中的节点，将其左右子节点加入队列，直到队列为空，完成层次遍历。
三、示例为了更好地理解二叉树的遍历和求深度的算法，我们以一个简单的二叉树为例进行说明。
假设该二叉树的结构如下：A/\BC/\/\DEFG其中，A、B、C、D、E、F、G分别代表二叉树的结点。
1.前序遍历：A->B->D->E->C->F->G2.中序遍历：D->B->E->A->F->C->G3.后序遍历：D->E->B->F->G->C->A4.深度：2以上是针对这个二叉树的遍历和深度的计算示例。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述：实现二叉树（包括二叉排序树）的建立，并实现先序、中序、后序和按层次遍历，计算叶子结点数、树的深度、树的宽度，求树的非空子孙结点个数、度为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，失败。
二叉树的生成与遍历
#include <alloc.h>#include "btree.h"#include "sstack.h"typedef struct stack_tag{elemtype *elem;int top;int size;}SQSTACK;int InitSqstack(SQSTACK *S,int n);void DestroySqstack(SQSTACK *S);int IsSqstackEmpty(SQSTACK S);int IsSqstackFull(SQSTACK S);int Push(SQSTACK *S,elemtype e);int Pop(SQSTACK *S,elemtype *e);int InitSqstack(SQSTACK *S, int n){S->elem=(elemtype *)malloc(n*sizeof(elemtype)); if(S->elem==NULL)return 0;S->size=n;S->top=-1;return 1;}void DestroySqstack(SQSTACK *S){free(S->elem);S->elem=NULL;S->top=-1;S->size=0;}int IsSqstackEmpty(SQSTACK S){return S.top==-1;}int IsSqstackFull(SQSTACK S){return S.top==S.size-1;}int Push(SQSTACK *S,elemtype e){if(IsSqstackFull(*S))return 0;S->top++;S->elem[S->top]=e;return 1;}int Pop(SQSTACK *S,elemtype *e){if(IsSqstackEmpty(*S)) return 0;*e=S->elem[S->top];S->top--;return 1;}typedef struct thrbtreenode{char data;int ltag,rtag;struct thrbtreenode *lchild,*rchild;} THRBTREENODE, *THRBTREENODEPTR,*THRBTREE; typedef THRBTREENODEPTR elemtype;typedef struct{int x,y;}BTREENODEPOS;#define MAXCOUNT 32void InitBtreeNodePos();THRBTREE CreateBtree2(char *str);void DestroyBtree(THRBTREE root);void ShowBtree(THRBTREE root,int index);void PreOrderThr(THRBTREE p);THRBTREE InOrderThread(THRBTREE root);void InOrderThr(THRBTREE p);THRBTREE PreOrderThread(THRBTREE root);#include <stdio.h>#include <conio.h>#include <graphics.h>#include <alloc.h>#include <string.h>#include "btree.h"#include "sstack.h"THRBTREENODEPTR pre;BTREENODEPOS btnpos[MAXCOUNT];void InitBtreeNodePos(void){int i;for(i=0;i<16;i++){btnpos[16+i].x=20+i*40;btnpos[16+i].y=480-30;}for(i=15;i>=1;i--){btnpos[i].x=(btnpos[2*i].x+btnpos[2*i+1].x)/2;btnpos[i].y=btnpos[2*i].y-80;}}THRBTREE CreateBtree1(char *str){THRBTREE root=NULL;THRBTREENODEPTR p;int tag,i,len;int mark;/* 1--characters,2--(,3--,4--) */SQSTACK s;if(str[0]==0)return root;root=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(root==NULL)return root;root->data=str[0];root->lchild=root->rchild=NULL;root->ltag=root->rtag=0;len=strlen(str);InitSqstack(&s,len);p=root;mark=1;for(i=1;str[i]!=0;i++)switch(str[i]){case '(':if(mark==2){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=2;Push(&s,p);tag=0;break;case ')':mark=4;if(!Pop(&s,&p)){DestroyBtree(root);printf("illegal global list!");return NULL;}break;case ',':if(mark==3){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=3;tag=1;break;default:if(mark==1){DestroyBtree(root);printf("illegal global list!");return NULL;}mark=1;if(IsSqstackEmpty(s)){DestroyBtree(root);printf("illegal global list!");return NULL;}p=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(p==NULL){DestroyBtree(root);return NULL;}p->data=str[i];p->lchild=p->rchild=NULL;p->ltag=p->rtag=0;if(tag==0)s.elem[s.top]->lchild=p;elses.elem[s.top]->rchild=p;break;}return root;}void DestroyBtree(THRBTREE root){if(root==NULL)return;if(root->ltag==0)DestroyBtree(root->lchild);if(root->rtag==0)DestroyBtree(root->rchild);root->lchild=NULL;root->rchild=NULL;free(root);}void ShowBtree(THRBTREE root,int index){int i,j,len;char str[10];if(root==NULL)return;i=index*2;j=index*2+1;setcolor(YELLOW);if(i<MAXCOUNT&&root->ltag==0&&root->lchild!=NULL) line(btnpos[index].x,btnpos[index].y,btnpos[i].x,btnpos[i].y); if(j<MAXCOUNT&&root->rtag==0&&root->rchild!=NULL) line(btnpos[index].x,btnpos[index].y,btnpos[j].x,btnpos[j].y); setfillstyle(SOLID_FILL,BLACK);setcolor(WHITE);fillellipse(btnpos[index].x,btnpos[index].y,15,15);sprintf(str,"%c",root->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2,btnpos[index].y-4,str); setcolor(YELLOW);if(root->ltag==1&&root->lchild!=NULL){sprintf(str,"%c",root->lchild->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2-8,btnpos[index].y,str);}if(root->rtag==1&&root->rchild!=NULL){sprintf(str,"%c",root->rchild->data);len=strlen(str);outtextxy(btnpos[index].x-len*8/2+8,btnpos[index].y,str);}if(i<MAXCOUNT&&root->ltag==0) ShowBtree(root->lchild,i);if(j<MAXCOUNT&&root->rtag==0) ShowBtree(root->rchild,j);}void InOrder(THRBTREE root,char *str){char tmpstr[10];if(root==NULL)return;InOrder(root->lchild,str);sprintf(tmpstr,"%c ",root->data);strcat(str,tmpstr);InOrder(root->rchild,str);}void InOrderThr(THRBTREE p){}THRBTREE InOrderThread(THRBTREE root){THRBTREE head;head=(THRBTREENODEPTR)malloc(sizeof(THRBTREENODE)); if(head==NULL)return NULL;head->lchild=NULL;return head;}void TraverseInOrderThr(THRBTREE root,char *str){return;}void main(){char *gstr="A(B(C,),E(F(G,H),))"; char trastr[80];THRBTREE root,thrt;int gdriver=DETECT,gmode;int i;InitBtreeNodePos();root=CreateBtree1(gstr);registerbgidriver(EGA VGA_driver); initgraph(&gdriver,&gmode,"");trastr[0]=0;InOrder(root,trastr);setcolor(WHITE);outtextxy(10,10,trastr);thrt=InOrderThread(root);trastr[0]=0; TraverseInOrderThr(root,trastr); setcolor(YELLOW);outtextxy(10,20,trastr); ShowBtree(thrt->lchild,1);getch();closegraph();DestroyBtree(root);}。
二叉树遍历实验报告
二叉树遍历实验报告二叉树遍历实验报告一、引言二叉树是计算机科学中常用的数据结构之一，它由节点组成，每个节点最多有两个子节点。
二叉树的遍历是指按照一定的规则访问二叉树中的所有节点。
本实验旨在通过实际操作，探索二叉树的三种遍历方式：前序遍历、中序遍历和后序遍历，并分析它们的应用场景和性能特点。
二、实验方法1. 实验环境本实验使用Python编程语言进行实现，并在Jupyter Notebook中运行代码。
2. 实验步骤（1）定义二叉树节点类首先，我们定义一个二叉树节点类，该类包含节点值、左子节点和右子节点三个属性。
（2）构建二叉树在主函数中，我们手动构建一个二叉树，包含多个节点，并将其保存为根节点。
（3）实现三种遍历方式通过递归的方式，实现二叉树的前序遍历、中序遍历和后序遍历。
具体实现过程如下：- 前序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
- 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
- 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
（4）测试遍历结果在主函数中，我们调用实现的三种遍历方式，对构建的二叉树进行遍历，并输出结果。
三、实验结果与分析经过实验，我们得到了二叉树的前序遍历、中序遍历和后序遍历的结果。
以下是我们的实验结果及分析：1. 前序遍历结果前序遍历结果为：A - B - D - E - C - F - G前序遍历的应用场景包括：复制整个二叉树、计算二叉树的深度和宽度等。
前序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
2. 中序遍历结果中序遍历结果为：D - B - E - A - F - C - G中序遍历的应用场景包括：二叉搜索树的中序遍历可以得到有序的节点序列。
中序遍历的时间复杂度为O(n)，其中n为二叉树的节点数。
3. 后序遍历结果后序遍历结果为：D - E - B - F - G - C - A后序遍历的应用场景包括：计算二叉树的高度、判断二叉树是否对称等。
二叉树的建立和遍历的实验报告
竭诚为您提供优质文档/双击可除二叉树的建立和遍历的实验报告篇一：二叉树遍历实验报告数据结构实验报告报告题目：二叉树的基本操作学生班级：学生姓名：学号：一．实验目的1、基本要求：深刻理解二叉树性质和各种存储结构的特点及适用范围；掌握用指针类型描述、访问和处理二叉树的运算；熟练掌握二叉树的遍历算法；。
2、较高要求:在遍历算法的基础上设计二叉树更复杂操作算法；认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。
二.实验学时：课内实验学时：3学时课外实验学时：6学时三．实验题目1．以二叉链表为存储结构，实现二叉树的创建、遍历（实验类型：验证型）1）问题描述：在主程序中设计一个简单的菜单，分别调用相应的函数功能：1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2）实验要求：在程序中定义下述函数，并实现要求的函数功能：createbinTree(binTreestructnode*lchild,*rchild;}binTnode;元素类型：intcreatebinTree(binTreevoidpreorder(binTreevoidInorder(binTreevoidpostorder(binTreevoidInordern(binTreeintleaf(bi nTreeintpostTreeDepth(binTree2、编写算法实现二叉树的非递归中序遍历和求二叉树高度。
1）问题描述：实现二叉树的非递归中序遍历和求二叉树高度2）实验要求：以二叉链表作为存储结构3)实现过程：1、实现非递归中序遍历代码：voidcbiTree::Inordern(binTreeinttop=0;p=T;do{while(p!=nuLL){stack[top]=p;;top=top+1;p=p->lchild;};if(top>0){top=top-1;p=stack[top];printf("%3c",p->data);p=p->rchild;}}while(p!=nuLL||top!=0);}2、求二叉树高度：intcbiTree::postTreeDepth(binTreeif(T!=nuLL){l=postTreeDepth(T->lchild);r=postTreeDepth(T->rchil d);max=l>r?l:r;return(max+1);}elsereturn(0);}实验步骤：1）新建一个基于consoleApplication的工程，工程名称biTreeTest；2）新建一个类cbiTree二叉树类。
二叉树的遍历有三种方式
二叉树的遍历有三种方式，如下：（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。
简记根-左-右。
（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。
简记左-根-右。
（3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。
简记左-右-根。
例1：如上图所示的二叉树，若按前序遍历，则其输出序列为。
若按中序遍历，则其输出序列为。
若按后序遍历，则其输出序列为。
前序：根A，A的左子树B，B的左子树没有，看右子树，为D，所以A-B-D。
再来看A的右子树，根C，左子树E，E的左子树F，E的右子树G，G的左子树为H，没有了结束。
连起来为C-E-F-G-H,最后结果为ABDCEFGH中序：先访问根的左子树,B没有左子树，其有右子树D，D无左子树，下面访问树的根A，连起来是BDA。
再访问根的右子树，C的左子树的左子树是F，F的根E，E的右子树有左子树是H，再从H出发找到G，到此C的左子树结束，找到根C，无右子树，结束。
连起来是FEHGC, 中序结果连起来是BDAFEHGC 后序：B无左子树，有右子树D，再到根B。
再看右子树，最下面的左子树是F，其根的右子树的左子树是H，再到H的根G，再到G的根E，E的根C无右子树了，直接到C，这时再和B找它们其有的根A，所以连起来是DBFHGECA例2:有下列二叉树，对此二叉树前序遍历的结果为（）。
A）ACBEDGFH B）ABDGCEHFC）HGFEDCBA D）ABCDEFGH解析：先根A，左子树先根B，B无左子树，其右子树，先根D，在左子树G，连起来是ABDG。
A的右子树，先根C，C左子树E，E无左子树，有右子树为H，C的右子树只有F，连起来是CEHF。
整个连起来是B答案ABDGCEHF。
例3：已知二叉树后序遍历是DABEC，中序遍历序列是DEBAC，它的前序遍历序列是( ) 。
A）CEDBA B）ACBED C）DECAB D）DEABC解析：由后序遍历可知，C为根结点，由中序遍历可知，C左边的是左子树含DEBA，C右边无结点，知根结点无右子树。
二叉树的建立和遍历实验报告
二叉树的建立和遍历实验报告一、引言（100字）二叉树是一种常见的数据结构，它由根节点、左子树和右子树组成，具有递归性质。
本次实验的目的是了解二叉树的建立过程和遍历算法，以及熟悉二叉树的相关操作。
本实验采用C语言进行编写。
二、实验内容（200字）1.二叉树的建立：通过输入节点的值，逐个建立二叉树的节点，并通过指针连接起来。
2.二叉树的遍历：实现二叉树的三种常用遍历算法，即前序遍历、中序遍历和后序遍历。
三、实验过程（400字）1.二叉树的建立：首先，定义二叉树的节点结构，包含节点值和指向左右子树的指针；然后，通过递归的方式，依次输入节点的值，创建二叉树节点，建立好节点之间的连接。
2.二叉树的前序遍历：定义一个函数，实现前序遍历的递归算法，先输出当前节点的值，再递归遍历左子树和右子树。
3.二叉树的中序遍历：同样，定义一个函数，实现中序遍历的递归算法，先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树。
4.二叉树的后序遍历：同样，定义一个函数，实现后序遍历的递归算法，先递归遍历左子树和右子树，再输出当前节点的值。
四、实验结果（300字）通过实验，我成功建立了一个二叉树，并实现了三种遍历算法。
对于建立二叉树来说，只要按照递归的思路，先输入根节点的值，再分别输入左子树和右子树的值，即可依次建立好节点之间的连接。
建立好二叉树后，即可进行遍历操作。
在进行遍历算法的实现时，我首先定义了一个函数来进行递归遍历操作。
在每一次递归调用中，我首先判断当前节点是否为空，若为空则直接返回；若不为空，则按照特定的顺序进行遍历操作。
在前序遍历中，我先输出当前节点的值，再递归遍历左子树和右子树；在中序遍历中，我先递归遍历左子树，再输出当前节点的值，最后递归遍历右子树；在后序遍历中，我先递归遍历左子树和右子树，再输出当前节点的值。
通过运行程序，我成功进行了二叉树的建立和遍历，并得到了正确的结果。
可以看到，通过不同的遍历顺序，可以获得不同的遍历结果，这也是二叉树遍历算法的特性所在。
创建二叉树的三种算法
创建二叉树的三种算法1.递归算法递归算法是最直观也是最常用的创建二叉树的方法之一、递归算法通过递归地创建左子树和右子树来构建完整的二叉树。
具体步骤如下：-创建一个二叉树结构的定义，包含一个存储数据的变量和左右子节点。
-如果当前节点为空，直接将新节点插入当前位置。
-如果新节点的值小于当前节点的值，递归地将新节点插入当前节点的左子树。
-如果新节点的值大于等于当前节点的值，递归地将新节点插入当前节点的右子树。
递归算法的示例代码如下所示：```pythonclass TreeNode:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef insert(root, val):if root is None:return TreeNode(val)if val < root.val:root.left = insert(root.left, val)elif val >= root.val:root.right = insert(root.right, val)return root```2.先序遍历算法先序遍历算法通过遍历给定的节点集合，按照先序的顺序将节点逐个插入到二叉树中。
这种算法可以使用栈来实现。
具体步骤如下：-创建一个空栈，同时创建一个新节点的拷贝作为当前节点。
-依次遍历给定的节点集合，如果新节点的值小于当前节点的值，将当前节点的左子节点指向新节点，并将新节点入栈，并将新节点移动到当前节点的左子节点。
-如果新节点的值大于等于当前节点的值，重复上述过程，直到找到一个合适的位置并插入新节点。
-当遍历完所有节点后，返回二叉树的根节点。
先序遍历算法的示例代码如下所示：```pythonclass TreeNode:def __init__(self, val): self.val = valself.left = Noneself.right = Nonedef insert(root, val): if root is None:return TreeNode(val) stack = []cur = rootwhile True:if val < cur.val:if not cur.left:cur.left = TreeNode(val) breakelse:cur = cur.leftelse:if not cur.right:cur.right = TreeNode(val)breakelse:cur = cur.rightreturn root```3.层次遍历算法层次遍历算法通过逐层遍历给定的节点集合，按照从上到下、从左到右的顺序将节点逐个插入到二叉树中。
二叉树的创建与遍历的实验总结
二叉树的创建与遍历的实验总结引言二叉树是一种重要的数据结构，在计算机科学中有着广泛的应用。
了解二叉树的创建和遍历方法对于数据结构的学习和算法的理解至关重要。
本文将对二叉树的创建和遍历进行实验，并总结相应的经验和思考。
二叉树的定义在开始实验之前，我们首先需要了解二叉树的定义和基本概念。
二叉树是一种每个节点最多拥有两个子节点的树形结构。
每个节点包含一个值和指向其左右子节点的指针。
根据节点的位置，可以将二叉树分为左子树和右子树。
创建二叉树二叉树的创建可以采用多种方法，包括手动创建和通过编程实现。
在实验中，我们主要关注通过编程方式实现二叉树的创建。
1. 递归方法递归是一种常用的创建二叉树的方法。
通过递归，我们可以从根节点开始，逐层创建左子树和右子树。
具体步骤如下：1.创建一个空节点作为根节点。
2.递归地创建左子树。
3.递归地创建右子树。
递归方法的代码实现如下所示：class TreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = Nonedef create_binary_tree(values):if not values:return None# 使用队列辅助创建二叉树queue = []root = TreeNode(values[0])queue.append(root)for i in range(1, len(values)):node = TreeNode(values[i])# 当前节点的左子节点为空，则将新节点作为左子节点if not queue[0].left:queue[0].left = node# 当前节点的右子节点为空，则将新节点作为右子节点elif not queue[0].right:queue[0].right = node# 当前节点的左右子节点已经齐全，可以从队列中删除该节点queue.pop(0)# 将新节点添加到队列中，下一次循环时可以使用该节点queue.append(node)return root2. 非递归方法除了递归方法，我们还可以使用非递归方法创建二叉树。
二叉树的四种遍历算法
⼆叉树的四种遍历算法⼆叉树作为⼀种重要的数据结构，它的很多算法的思想在很多地⽅都⽤到了，⽐如STL算法模板，⾥⾯的优先队列、集合等等都⽤到了⼆叉树⾥⾯的思想，先从⼆叉树的遍历开始：看⼆叉树长什么样⼦：我们可以看到这颗⼆叉树⼀共有七个节点0号节点是根节点1号节点和2号节点是0号节点的⼦节点，1号节点为0号节点的左⼦节点，2号节点为0号节点的右⼦节点同时1号节点和2号节点⼜是3号节点、四号节点和五号节点、6号节点的双亲节点五号节点和6号节点没有⼦节点（⼦树），那么他们被称为‘叶⼦节点’这就是⼀些基本的概念⼆叉树的遍历⼆叉树常⽤的遍历⽅式有：前序遍历、中序遍历、后序遍历、层序遍历四种遍历⽅式，不同的遍历算法，其思想略有不同，我们来看⼀下这四种遍历⽅法主要的算法思想：1、先序遍历⼆叉树顺序：根节点 –> 左⼦树 –> 右⼦树，即先访问根节点，然后是左⼦树，最后是右⼦树。
上图中⼆叉树的前序遍历结果为：0 -> 1 -> 3 -> 4 -> 2 -> 5 -> 62、中序遍历⼆叉树顺序：左⼦树 –> 根节点 –> 右⼦树，即先访问左⼦树，然后是根节点，最后是右⼦树。
上图中⼆叉树的中序遍历结果为：3 -> 1 -> 4 -> 0 -> 5 -> 2 -> 63、后续遍历⼆叉树顺序：左⼦树 –> 右⼦树 –> 根节点，即先访问左⼦树，然后是右⼦树，最后是根节点。
上图中⼆叉树的后序遍历结果为：3 -> 4 -> 1 -> 5 -> 6 -> 2 -> 04、层序遍历⼆叉树顺序：从最顶层的节点开始，从左往右依次遍历，之后转到第⼆层，继续从左往右遍历，持续循环，直到所有节点都遍历完成上图中⼆叉树的层序遍历结果为：0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6下⾯是四种算法的伪代码：前序遍历：preOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束cout << tree[n].w ; // 输出当前节点内容preOrderParse(tree[n].leftChild); // 递归输出左⼦树preOrderParse(tree[n].rightChild); // 递归输出右⼦树}中序遍历inOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束inOrderParse(tree[n].leftChild); // 递归输出左⼦树cout << tree[n].w ; // 输出当前节点内容inOrderParse(tree[n].rightChild); // 递归输出右⼦树}pastOrderParse(int n) {if(tree[n] == NULL)return ; // 如果这个节点不存在，那么结束pastOrderParse(tree[n].leftChild); // 递归输出左⼦树pastOrderParse(tree[n].rightChild); // 递归输出右⼦树cout << tree[n].w ; // 输出当前节点内容}可以看到前三种遍历都是直接通过递归来完成，⽤递归遍历⼆叉树简答⽅便⽽且好理解，接下来层序遍历就需要动点脑筋了，我们如何将⼆叉树⼀层⼀层的遍历输出？其实在这⾥我们要借助⼀种数据结构来完成：队列。
二叉树的先序,中序,后序遍历代码
二叉树的先序,中序,后序遍历代码一、二叉树的先序、中序和后序遍历1、先序遍历先序遍历是根节点、左子树、右子树的顺序访问二叉树的一种遍历方法。
在先序遍历中，先访问根节点，然后递归访问左子树，最后递归访问右子树。
具体的代码如下：（1）//先序遍历法PreOrder(Tree T){if(T!=NULL){Visit(T);//访问根节点PreOrder(T->Left);//遍历左子树PreOrder(T->Right);//遍历右子树}}2、中序遍历中序遍历是左子树、根节点、右子树的顺序访问二叉树的一种遍历方法。
在中序遍历中，先递归访问左子树，然后访问根节点，最后递归访问右子树。
具体的代码如下：（2）//中序遍历法InOrder(Tree T){if(T!=NULL){InOrder(T->Left);//遍历左子树Visit(T);//访问根节点InOrder(T->Right);//遍历右子树}}3、后序遍历后序遍历是左子树、右子树、根节点的顺序访问二叉树的一种遍历方法。
在后序遍历中，先递归访问左子树，然后递归访问右子树，最后访问根节点。
具体的代码如下：（3）//后序遍历法PostOrder(Tree T){if(T!=NULL){PostOrder(T->Left);//遍历左子树PostOrder(T->Right);//遍历右子树Visit(T);//访问根节点}}二、先序、中序和后序遍历的应用（1）构造二叉树先序序列和中序序列是完全可以解决构造出一颗二叉树的，必要的条件是中序和先序的元素的个数必须相同。
后序序列无法实现这一点，只能确定根节点的位置。
（2）深度优先搜索深度优先搜索是一种图遍历算法，它使用栈来帮助用户访问一棵树，也就是深度优先算法。
先序遍历是先从根节点访问，中序遍历是在访问左子树后再访问根节点，而后序遍历是在访问右子树后再访问根节点。
（3）计算二叉树深度根据先序遍历和后序遍历可以知道二叉树的深度。
二叉树的遍历
T->rchild= CreatBiTree(); /*构造右子树*/ 扩展先序遍历序列
}
2021/2/21
return (T) ;}
A B Φ D Φ Φ C Φ 17Φ
T
T
T
ch=B
ch=Φ
Λ
T
T= Λ, Creat(T)
ch=A T
A
B creat(T L)
ΛB 返回
creat(T L)
creat(T R)
A
p=p->RChild;
}
2021/2/21
}
top
A
B
C
D
top
B
top
A
A
top
D
A
top
A
top
C
13
top
中序遍历二叉树的非递归算法：
A
void InOrder(BiTree T)
{ InitStack(&S); 相当于top=-1;
p=T;
B
C
while(p!=NULL | | !IsEmpty(S)) 相当于top==-1;
}
后序遍历二叉树的递归算法：
void PostOrder (BiTree T)
{ if(T!=NULL)
{ PostOrder (T->lchild);
PostOrder (T->rchild);
printf(T->data); }
2021/2/21
15
}
先序遍历二叉树的递归算法： void PreOder (BiTree T) { if(T! =NULL){ printf (T->data); PreOrder (T->lchild); PreOrder (T->rchild); } }
数据结构中二叉树的生成及遍历非递归算法浅析
及运算 都较为简练 ， 因此 ， 二叉树 在数据结构课 程 中显得 特别 ｃ ａ ｄｔ； ｈｒ ａａ ｓ ｕｔ ｔｏ ｅｃｉ ， ｈｄ ｔ ｃ ｂｎｄ ｈ ｄｒ ｉ ； ｒ ｌ ｌ ｃｌ 二叉树是 由结点的有 限集合构成 ，这个有限集合或者为空 ｝ｔ ｅ Ｂｒ ； ｅ 集 ，或者是 由一个根节点及两棵互不相交的分别称之为这个根 Ｂｒｅ ［ ａｓ ｅ ｔ Ｑ ｍ ｘｉ ］ ｅ ｚ；
一
、
引言
＃ ｃ ｄ “ａｏｈ ｉｌ ｅ ｍ１ ・ ｎｕ ］ ” ｃ
ｔ ｅｅ。 ｃ ｂ ｏｅ ｙ ｄ ｔ ｔ ｔ ｄ｛ ｐ ｎ
、
二叉树是一种重要 的树形结构 ， 其结构规整。许多实际问 ＃ ｅｎ Ｕ Ｌ０ ｄｆ ｅ Ｌ ｉ Ｎ
题抽象 出来 的数据结构往往是二叉树 的形式 ， 而且其存储结构 重要 ， 这里 我们先 了解一下二叉树 。
，
立二 叉链表。 一般的二 对于 叉树， 必须添加一些 虚结点， 使其成 ‘ ～’ ： 一 、
队列是一个指针类型 的数组 ， 保存已输入 的结点 ＿… 、
… ～ … 一 ’
，
＃ ｅ ｎ ｘ ｉ ０ ｄ ｆ ｅｍａ ｓｚ １ ０ ｉ ｅ 衔ｎ ｌ ｄ ｓｄｏｈ” ｃｕ ｅ“ ｔ ｉ．
ｓ＞ 一
ｌ＝ Ｌ ； ｄ Ｕ Ｌ
ｒ ａ＋ ； ｅ ｒ ＋
Ｑｒａ１ｓ ｒ ； ｅ ＝
。
３ 办公 自动化杂志 ｏ。
ｉ ｒａ－ １Ｔ ｓ ｆ ｅｒ＝ ）＝ ： （ ＝
ｅｓ ｌｅ
ｆ＝ｔ ｋｔ ］ Ｔ ｓ ｃ ［ｐ； ａ ｏ
近 ＞ｉ ＝ ｐ 卜 ｒ ＝） 曲ｔ
ｆｒ ｆ“ ＂ － ｄｔ ； ｐｉ （％ｃ ， ＞ ａａ ｎ Ｔ ）
递归算法 ， 故有关二叉树的试题通 常要求采用非递归算 法， 这就 Ｂｒ ， ； ｔｅ ｅ ｓ 使得掌握二叉树的生成及遍历的非递归算法成为必要 。 ｔＮ Ｉ ； ＝ ｕＪ Ｌ
用C语言编写二叉树的建立与遍历
用C语言编写二叉树的建立与遍历1．对题目要有需求分析在需求分析中，将题目中要求的功能进行叙述分析，并且设计解决此问题的数据存储结构，设计或叙述解决此问题的算法。
给出实现功能的一组或多组测试数据，程序调试后，将按照此测试数据进行测试的结果列出来。
如果程序不能正常运行，写出实现此算法中遇到的问题和改进方法；2．对题目要有相应的源程序源程序要按照写程序的规则来编写。
要结构清晰，重点函数的重点变量，重点功能部分要加上清晰的程序注释。
(注释量占总代码的四分之一)程序能够运行，要有基本的容错功能。
尽量避免出现操作错误时出现死循环；3．最后提供的主程序可以象一个应用系统一样有主窗口，通过主菜单和分级菜单调用课程设计中要求完成的各个功能模块，调用后可以返回到主菜单，继续选择其他功能进行其他功能的选择。
二叉树的建立与遍历[问题描述]建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。
[基本要求]从键盘接受输入，以二叉链表作为存储结构，建立二叉树，并对其进行遍历（先序、中序、后序），将遍历结果打印输出。
以下是我的数据结构实验的作业：肯定好用，里面还包括了统计树的深度和叶子数！记住每次做完一个遍历还要重新输入你的树哦！#include "stdio.h"#include "string.h"#define NULL 0typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree Create(BiTree T){char ch;ch=getchar();if(ch=='#')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))printf("Error!");T->data=ch;T->lchild=Create(T->lchild);T->rchild=Create(T->rchild); }return T;}void Preorder(BiTree T){if(T){printf("%c",T->data); Preorder(T->lchild); Preorder(T->rchild);}}int Sumleaf(BiTree T){int sum=0,m,n;if(T){if((!T->lchild)&&(!T->rchild)) sum++;m=Sumleaf(T->lchild);sum+=m;n=Sumleaf(T->rchild);sum+=n;}return sum;}void zhongxu(BiTree T){if(T){zhongxu(T->lchild);printf("%c",T->data); zhongxu(T->rchild);}}void houxu(BiTree T){if(T){houxu(T->lchild);houxu(T->rchild);printf("%c",T->data);}}int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}main(){BiTree T;int sum,dep;T=Create(T);Preorder(T);printf("\n");zhongxu(T);printf("\n");houxu(T);printf("\n");sum=Sumleaf(T);printf("%d",sum);dep=Depth(T);printf("\n%d",dep);}在Turbo C的环境下，先按Ctrl+F9运行程序，此时就是建立二叉树的过程，例如输入序列ABC##DE#G##F###（其中的“#”表示空，并且输入过程中不要加回车，因为回车也有对应的ASCII码，是要算字符的，但是输入完之后可以按回车退出），然后再按ALT+F5显示用户界面，这时候就能够看到结果了。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
叉树的随机生成及其遍历张 zhaohan 10804XXXXX2010/6/12问题重述利用随机函数产生50个(不大于1 00且各不相同的)随机整数，用这些整数来生成一棵二叉树，分别对二叉树进行先根遍历，中根遍历和后根遍历并输出树中结点元素序列。
程序设计(一) 需求分析：•问题的定义与要求： 1 、产生50个不大于100且各不相同的随机整数 (由系统的随机函数生成并对100取模)；2、先根遍历并输出结果；3、中根遍历并输出结果；4、后根遍历并输出结果；按层次浏览二叉树结5、点；6、退出程序。
•俞入：所需功能，选项为1〜6。
•输出：按照用户功能选择输出结果。
•限制：输入的功能选择在1〜6之间，否则无回应。
•模块功能及要求：RandDif(): 生成50个随机不大于100的整数，每次生成不同随机整数。
CreateBitree(): 给数据结点生成二叉树，使每个结点的左右儿子指针指向左右儿子。
NRPreOrder(): 非递归算法的先根遍历。
inOrderTraverse(): 递归算法的中根遍历。
P ostOrderTraverseO：递归算法的后根遍历。
Welcome(): 欢迎窗口。
Menu()：菜单。
Goodbye()：再见窗口。
(二) 概要设计：首先要生成二叉树，由于是对随机生成的50个数生成二叉树，故可以采取顺序存储的方式，对结点的左右儿子进行赋值。
生成的二叉树是完全二叉树。
先根遍历的非递归算法：1、根结点进栈2、结点出栈，被访问3、结点的右、左儿子（非空）进栈4、反复执行2、3 ，至栈空为止。
先根遍历的算法流程图：根结点进栈( a[0]=T->boot,p=a[0] ) 访问结点printf(*p)右儿子存在则进栈a[i]=(*p).rchild; i++;左儿子存在则进栈a[i]=(*p).rchild; i++;栈顶降低top--：i--;p=a[i];栈非空while(i>-1)返回中根遍历的递归算法流程图：T为空Return;inOrderTraverse(T->lchild)Printf(T->data) inOrderTraverse(T->rchild)返回后根遍历的递归算法流程图：T为空Return;inOrderTraverse(T->lchild) inOrderTraverse(T->rchild)Printf(T->data)返回遍历输出均按链式存储。
链式存储的特点是借助指示元素存储地址的指针（数组元素之间的逻辑poin ter)表示关系。
按层次查看二叉树元素则按下标顺序直接输出。
同时，生成随机数、生成二叉树均是按顺序存储。
顺序存储的特点是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系。
（三）详细设计程序源代码设计：1）定义结点：struct dataint n;struct data *lchild;struct data *rchild;}data[N];2）产生随机数RandDif(struct data data[]) int i,j;srand((int)time(0));for(i=0;i<N;i++)data[i].n=rand()%100;for(j=i-1;j>1;j--)if(data[i].n==data[j].n||data[i].n==0){i--;j=0;}3）生成二叉树CreateBitree(struct data data[]) int i;for(i=0;i<25;i++)data[i].lchild=&data[2*i+1];data[i].rchild=&data[2*i+2];printf("\nSuccessfully create a Binary Tree.\n");printf("The Binary Tree has 50 different element.");4）先根遍历的非递归算法NRPreOrder(struct data data[]) int i=0;struct data *a[N],*p=&data[0];while(i>-1)printf("%-4d",(*p).n);if((*(*p).rchild).n)a[i]=(*p).rchild;i++;if((*(*p).lchild).n)a[i]=(*p).lchild;i++;i--;p=a[i];/ }}5)先根遍历的递归算法PreOrderTraverse(struct data data) if(data.n)printf("%-4d",data.n);PreOrderTraverse(*(data.lchild));PreOrderTraverse(*(data.rchild));6)中根遍历的递归算法inOrderTraverse(struct data data) if(data.n)inOrderTraverse(*(data.lchild));printf("%-4d",data.n);inOrderTraverse(*(data.rchild));7）后根遍历的递归算法PostOrderTraverse(struct data data)if(data.n)PostOrderTraverse(*(data.lchild)); PostOrderTraverse(*(data.rchild)); printf("%-4d",data.n);（四 ） 测试结果：由于先、中、后根遍历递归算法类似，故此处,选择中根遍历递归算法进行测试：如某次生成的 50个数为： 28 96 97 60 43 65 90 70 11 91 6 4 37 44 94 81 56 63 14 28 73 67 64 1345 75 88 57 77 86 55 69 23 98 31 85 8 12 87 9 51 93 3 40 18 17 72 21 10 58而生成的二叉树为：289669 23 98 31 85 8 12 87 9 51 93 3 40 18 17 72 21图：二叉树中根遍历结果为： 69 81 23 70 98 56 31 60 85 63 8 11 12 14 87 96 9 28 51 91 93 73 3 43 40 67 186 17 64 72 28 21 13 10 4 58 45 65 75 37 88 97 57 44 77 90 86 94 55而程序中根遍历结果为： 69 81 23 70 98 56 31 60 85 63 8 11 12 14 87 96 9 28 51 91 93 73 3 43 4067 18 6 17 64 72 28 21 13 10 4 58 45 65 75 37 88 97 57 44 77 90 86 94 55完全符合，递归算法测试完毕。
验证先根遍历的非归算法：9760 43 65 9070 11 91 37 44 9481 56 63 1428 73 67 64 13 45 75 88 57 77 86 5510 58在main()中加入先根递归算法和非递归算法作结果比较。
由于递归算法已经验证，故此处 只须非递归算法和递归算法结果符合即可。
生成 50个数：1 12 38 79 72 86 13 4 11 7 58 75 88 6 3 82 50 57 61 91 92 14 28 68 46 99 30 25 2024 85 63 5 39 9 49 60 31 90 96 76 36 98 83 27 84 22 56 21 87递归算法的先根遍历结果： 1 12 79 4 82 63 5 50 39 9 11 57 49 60 64 31 90 72 7 91 96 76 92 3698 58 14 83 27 28 84 22 38 86 75 68 56 21 46 87 88 99 30 13 6 25 20 3 24 85非递归算法的先根遍历结果： 1 12 79 4 82 63 5 50 39 9 11 57 49 60 64 31 90 72 7 91 96 76 9236 98 58 14 83 27 28 84 22 38 86 75 68 56 21 46 87 88 99 30 13 6 25 20 3 24 85在生成 50个随机不同整数的过程中遇到了几次问题，如循环条件差一个数，就会导致生成 数中有几个数是相同的，此时就需要修改循环条件；数据要排除 0。
函数的参数传递存在一定误区，有几次传递参数不当，格式不符，导致不能得到结果，在 认清了函数参数传递的要求后问题得以解决。
调试的时候为发现各个细节问题，会在各个模块的容易出问题的过程加输出函数，就便于 发现问题所在。
易知生成随机数的时间复杂度为，生成二叉树的时间复杂度为0(n)，递归遍历的时间复杂度均为0(n),而非递归先根遍历的时间复杂度也为附： 完整程序代码：/* 利用随机函数产生 50个(不大于 100且各不相同的 )随机整数，用这些整数来生成一棵二树，分 别对二叉树进行先根遍历，中根遍历和后根列遍历输出树中结点元素序列。
先根遍历输出要求 采用非递归来实现。
struct data{int n;struct data *lchild; struct data *rchild; }data[N]; /* 定义数组元素 */O(n)。
#include <stdio.h> #include <stdlib.h> #include <time.h> #include <conio.h> #define N 50 #define NULL 0i++;void RandDif( struct data data[]) {/* 生成个互不相同的随机整数 */ int i,j;srand(( int )time(0)); /* 每次生成不同的随机数 */ for (i=0;i<N;i++) data[i].n=rand()%100; if (data[i].n==data[j].n||data[i].n==0){i--;j=0;}void CreateBitree( struct data data[]) 生成二树 */int i ; for (i=0;i<25;i++) /* 将结点的左右儿子指针指向相应的左右儿子 */data[i].lchild=&data[2*i+1];data[i].rchild=&data[2*i+2]; printf( "\nSuccessfully create a Binary Tree.\n");printf( "The Binary Tree has 50 different element." });void NRPreOrder( struct data data[]) {/* 先根遍历输出，非递归算法 */ int i=0; struct data *a[N],*p=&data[0]; while (i>-1) printf( "%-4d" ,(*p).n);if ((*(*p).rchild).n) { /* 存在右儿子，则右儿子进栈 */ a[i]=(*p).rchild; i++; if ((*(*p).lchild).n) { /* 存在右儿子，则左儿子进栈 */ a[i]=(*p).lchild;for (j=i-1;j>-1;j--){/*void PreOrderTraverse( struct {/* 先根遍历输出，递归算法*/ data data)if(data.n)printf( "%-4d" ,data.n);PreOrderTraverse(*(data.lchild)) ; /* 先根遍历右子树*/PreOrderTraverse(*(data.rchild)) ; /* 先根遍历左子树*/void inOrderTraverse( struct {/* 中跟遍历输出，递归算法*/ data data)if (data.n)inOrderTraverse(*(data.lchild) ); /* 中跟遍历左子树*/printf( "%-4d" ,data.n);inOrderTraverse(*(data.rchild) ); /* 中跟遍历右子树*/void PostOrderTraverse( struct {/* 后根遍历输出，递归算法*/ data data)if (data.n)PostOrderTraverse(*(data.lchild)) ; /* 后根遍历左子树*/PostOrderTraverse(*(data.rchild)) ; /* 后根遍历右子树*/printf( "%-4d" ,data.n);void Welcome(){/* 欢迎窗口*/ printf( "\n\n Welcome use Traverse Binary Tree\n\n" );printf ( "\n\n\n\n" );printf ( "\n" );printf ( Specialty:Information and Computational Science Program\n" );printf ( Class:2 Grade:2 No.:200530760214 Name:Lin Weiyang\n" );printf ( Press any key tocontinue...\n");getch(); void Menu() {/* 菜单 */printf( ***************************************************************\n" ); printf ( ** Please select the function you need: **\n" ); printf ( ** 1.Create another tree. **\n" ); printf ( ** 2.Preorder traverse the Binary Tree. **\n" ); printf ( ** 3.Inorder traverse the Binary Tree. **\n" ); printf ( ** 4.Postorder traverse the Binary Tree. **\n" ); printf ( ** 5.Display the Binary Tree. **\n" ); printf ( ** 6.Exit . **\n " ); printf ( ***************************************************************\n" );void Goodbye(){/* 再见窗口*/printf( "\n" ); printf( "\n" );printf( II TTT TTT TT TT TT TT TT TT TT TTT T \n" printf( II TT TT TT TTTT TT TT TT TT TT TT \n" printf( II TT TT TT TT TT TTT TT TT TT TT \n" printf( II TT TT TT TT TT TTTT TT TT TT TT \n"printf( II TT TTTTTT TT TT TT TTTT TTTT TT \n printf( II TT TT TT TTTTTT TT TTT TT TT TT \n" printf( II TT TT TT TT TT TT TT TT TT TT \n" printf( II TT TT TT TT TT TT TT TT TT TT TT \n" printf( II TT TT TT TT TT TT TT TT TT TTTT \n"printf( "\n" );printf( "\n" );printf( II Copyright 2010 ZhangZhaohan\n"printf( IIPress any key to exit...\n"getch();} } );void main() int i; Welcome(); Loop: ); ); ); ); );); );); ); );clrscr();Menu();switch (getchO)getch(); goto Loop; break ;case '6' :; break;default : goto Loop;} clrscr();Goodbye();可执行文件: 程序运行截图: s« l#c ( 1_屛 f unc< 111 It ytkii next :1 .CrRntn nnntlmp tnta . ** Z.Frconlci' trauerse the Sin^rv Time. ** 3. Inoirdep tp-avei*se thnBinary Trsa “4.Pbctdhriai* tlw Binary 1 .** the Ri'Trrn , P PASE dou key ta cont iniie...运行窗口: 先根遍历case '1' :RandDif(data);CreateBitree(data); printf( "\n\nP ress any key to continue...'"' ); getch(); goto Loop; break;case '2' :p rintf( "The Preorder traverse of the Binary Tree is:\n" );NRP reOrder(data); printf( "\n\ nP ress any key to continue...\n" );getch(); goto Loop; break ;case 3 :printf( "The Inorder traverse of the Binary Tree is:\n" );inOrderTraverse(data[0]) ;p rintf( "\n\nP ress any key to continue...\n" );getch(); goto Loop; break ;case '4' :printf( "The Postorder traverse of the Binary Tree is:\n" );PostOrderTraverse(data[0]) ;p rintf( "\n\nP ress any key to continue...\n" ); getch(); goto Loop; break ;case '5' :printf( "The element of the Binary Tree are:\n" );for (i=0;iv50;i++)printf( "%-4d" ,data[i].n);printf( "\n\nP ress any key to continue...\n" ); h4 9 1 IhpLS FmoMie> ti'dive^t 39 24 37? 41 G1 44 马韶 9U 3 SH Hi 5b $V ira C9 u 1 tv? F Binaryin： 2a 32 ~~G9 53 75 51 79 ZG 艸 归 5S日3 砧 a4. 9 t。