二叉树的遍历课程设计(C++)含源代码
C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历

C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历二叉树的遍历问题描述输入一棵二叉树的先序和中序遍历序列,输出其后序遍历序列。
输入输入文件为tree.in,共两行,第一行一个字符串,表示树的先序遍历,第二行一个字符串,表示树的中序遍历。
树的结点一律用小写字母表示。
输出输出文件为tree.out,仅一行,表示树的后序遍历序列。
样例输入abdecdbeac样例输出debca--------------------------------------------------------------------- --------------------------------------------------------------------- #includeusing namespace std;struct tree{char data;tree *l,*r;};tree * create(char pre[],char in[]){tree *root;if(strlen(pre)==0) {root=NULL;}else{root=new tree;root->data=pre[0];char pre1[20];pre1[0]='\0';char pre2[20];pre2[0]='\0';char in1[20];in1[0]='\0';char in2[20];in2[0]='\0';int n=1;for(int i=0;i<strlen(in);i++){< p=""> if(in[i]!=pre[0]&&n==1){in1[i]=in[i];in1[i+1]='\0';}if(in[i]==pre[0]) n=2;if(in[i]!=pre[0]&&n==2){in2[i-strlen(in1)-1]=in[i];in2[i-strlen(in1)+1]='\0';}}for(int i=1;i<strlen(pre);i++){< p=""> if(i<strlen(in1)+1){< p="">pre1[i-1]=pre[i];pre1[i]='\0';}else {pre2[i-1-strlen(pre1)]=pre[i];pre2[i-strlen(pre1)]='\0';}}root->l=create(pre1,in1);root->r=create(pre2,in2);}return root;}void post(tree * root){if(root==NULL) return; else {post(root->l);post(root->r);cout<data;}}int main(){char pre[100];char in[100];cin>>pre;cin>>in;tree * root=create(pre,in); post(root);return 0;}</strlen(in1)+1){<></strlen(pre);i++){<></strlen(in);i++){<>。
数据结构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()即为二叉树查询函数。
c++课程设计报告(二叉树运算)

课程设计报告设计题目:二叉树解决四则运算问题院系:自动化院班级:XXX学号:XXX姓名:XX指导老师:XX时间:XX一.程序功能简介利用二叉树的结构解决带括号的四则运算的问题。
程序利用二叉树的堆栈将二叉树的结点变成结点中的数据时运算符,左右子树是标准结点形式,或是另外的标准二叉树形式,通过后序遍历,经标准结点中的表达式求出。
二.课程设计要求(1)读懂程序,将程序的运算步骤完整的描述出来。
(2)四则运算的表达式可以接受空格输入(3)依照运算顺序依次输出四则运算每一步的算式及及结果,最后输出最终计算结果三.课程设计思想这个课题设计要求最关键的就是读懂程序,用类实现四则运算其实不是很难,只是利用二叉树实现带括号的四则运算有些难度。
初读源程序觉得摸不到头脑,几遍下来还是能够理解的。
在程序中先计算的式子放在栈顶,首先赋值右子树,再赋值左子树,保证优先级。
如图:二叉树类栈运算符栈)—* (+输入“+”,“(”,“*”三个运算符没有优先级冲突,按顺序压栈,然后输入“—”,优先级低于“*”,binary_tree temp_tree; //生成二叉树string thisstring="";thisstring = thisstring + OpStack.top();OpStack.pop() //将栈顶优先级高的运算符移除(即这边的乘号)etree.root = build_node(thisstring);//将优先级高的运算符作为二叉树的根结点copy(temp_tree.root,NodeStack.top().root);//将二叉树堆栈栈顶的二叉树复制到新生成的二叉树中(即把1复制到新的二叉树中)NodeStack.pop();//移除二叉树栈栈顶etree.root->right_child = temp_tree.root;//将二叉树作为新二叉树的右分支temp_tree.root = NULL;copy(temp_tree.root,NodeStack.top().root); //继续将下一个栈顶二叉树复制(即把5复制)etree.root->left_child = temp_tree.root;//成为新二叉树的左分支NodeStack.pop();//移除temp_tree.root = NULL;copy(temp_tree.root, etree.root);NodeStack.push(temp_tree);//新二叉树进栈etree.root = NULL;OpStack.push(c);//优先级低的运算符压栈过程如图:栈顶二叉树temp_tree二叉树Etree二叉树将temp_tree作为etree的右结点新的二叉树类栈最后进行一个遍历,判断运算符栈是否处理完,算出最后结果。
实现二叉树的各种遍历算法实验报告

if(a[i]>kmax) kmax = a[i]; return kmax; } /** 求二叉树的节点个数 **/ int Nodes(BTNode *b) { if(b==NULL)
2.2:( 1 )实现二叉树的先序遍历 ( 2)实现二叉树的中序遍历 ( 3)实现二叉树的后序遍历
三 实验内容 :
3.1 树的抽象数据类型 : ADT Tree{
.专业 .整理 .
下载可编辑
数据对象 D: D 是具有相同特性的数据元素的集合 。 数据关系 R: 若 D 为空集 , 则称为空树 ;
若 D 仅含有一个数据元素 ,则 R 为空集 , 否则 R={H} , H 是如 下二元关系 :
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(" )"); } } } /** 深度 **/ int BTNodeDepth(BTNode *b)
下载可编辑
实现二叉树的各种遍历算法实验报告
一 实验题目 : 实现二叉树的各种遍历算法 二 实验要求 :
2.1:(1 ) 输出二叉树 b ( 2)输出 H 节点的左右孩子节点值 ( 3)输出二叉树 b 的深度 ( 4)输出二叉树 b 的宽度 ( 5)输出二叉树 b 的节点个数 ( 6)输出二叉树 b 的叶子节点个数 ( 7)释放二叉树 b
二叉树的遍历(先序遍历、中序遍历、后序遍历全)实验报告

实验目的编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。
实验内容编程序并上机调试运行。
编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。
编写程序/***********二叉树的遍历**************/#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;/*************************************************///按先序次序构建的二叉树链表void CreatBiTree(BiTree *T){char ch;if((ch=getchar())==' ')*T=NULL;else{*T=(BiTNode*)malloc(sizeof(BiTNode));if(!(*T))exit(1);(*T)->data=ch;CreatBiTree(&(*T)->lchild);CreatBiTree(&(*T)->rchild);}}/*************************************************/ //先序遍历--递归算法void PreOrderTraverse(BiTree T){if(T){printf("%c",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}/*************************************************/ //中序遍历--递归算法void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);printf("%c",T->data);InOrderTraverse(T->rchild);}}/*************************************************/ //后序遍历--递归算法void PostOrderTraverse(BiTree T){if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c",T->data);}}/*************************************************/ //main函数void main(){BiTree T;printf("请按先序次序输入二叉树中结点的值,空格字符表示空树:\n" );CreatBiTree(&T);printf("\n");printf("先序遍历为:\n");PreOrderTraverse(T);printf("\n\n");printf("中序遍历为:\n");InOrderTraverse(T);printf("\n\n");printf("后序遍历为:\n");PostOrderTraverse(T);printf("\n\n");getchar();}运行程序:结果分析:按先序输入的二叉树为ABC^^DE^G^^F^^^(^为空格)该二叉树画成树形为:其先序遍历为:ABCDEGF其中序遍历为:CBEGDFA其后序遍历为:CGEFDBA可以看出运行结果是正确的。
C语言实现创建二叉树,先序遍历、中序遍历、后序遍历输出

C语⾔实现创建⼆叉树,先序遍历、中序遍历、后序遍历输出# include <stdio.h># include <stdlib.h># include <string.h># include <iostream># define OK 0;# define ERROR -1;typedef int TElemType;typedef char DataType;typedef int Status;typedef struct BiNode {DataType data;//存⾃定义类型的值struct BiNode *lchild, *rchild;//左右⼩孩指针}BiNode,*BiTree;void CreatBiNode(BiNode **Node)//此处应注意传递的参数(⼆重指针){char data;scanf_s("%c", &data);*Node = (BiTree)malloc(sizeof(BiNode));if (data == '#'){*Node = NULL;}else if ((data != '#') && (*Node)){(*Node)->data = data;(*Node)->lchild = NULL;(*Node)->rchild = NULL;CreatBiNode(&(*Node)->lchild);CreatBiNode(&(*Node)->rchild);}}Status PreOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {printf("%c", T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}Status InOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {InOrderTraverse(T->lchild);printf("%c", T->data);InOrderTraverse(T->rchild);}}Status PostOrderTraverse(BiTree T) {if (T == NULL) {return OK;}else {PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c", T->data);}}int main(){printf("先序输⼊⼆叉树(空结点⽤'#'表⽰):");BiTree T=NULL;CreatBiNode(&T);printf("先序遍历⼆叉树:");PreOrderTraverse(T);printf("\n中序遍历⼆叉树:");InOrderTraverse(T);printf("\n后序遍历⼆叉树:");PostOrderTraverse(T);system("pause");return 0;}解决思想:⼩⽣⽤的是递归创建⼆叉树,递归遍历⼆叉树,因为使⽤递归会⽐较简洁。
数据结构_二叉树的遍历_课程设计

8
if(bt!=NULL)/*二叉树 bt 非空*/ { inorder(bt->lchild);/*中序遍历 bt 的左子树*/ printf("%c",bt->data);/*访问结点 bt*/ inorder(bt->rchild);/*中序遍历 bt 的右子树*/ } } void postorder(bitree *bt)/*后序序遍历二叉树*/ { if(bt!=NULL) { postorder(bt->lchild); postorder(bt->rchild); printf("%c",bt->data); } }
3.2.2 二叉树的中序递归遍历算法
void inorder(bitree *bt)/*中序序遍历二叉树*/ { if(bt!=NULL)/*二叉树 bt 非空*/ { inorder(bt->lchild);/*中序遍历 bt 的左子树*/ printf("%c",bt->data);/*访问结点 bt*/ inorder(bt->rchild);/*中序遍历 bt 的右子树*/ } }
图 1 “菜单”界面
图2
创建二叉树
5
图 3 二叉树的先序遍历
图4
二叉树的中序输出
6
图 5 二叉树的后序输出
五:实验总结 虽然做的过程中出现很多错误。但是最后还是一一纠正了,并在其中发现了自 身的不足,补学补差。最后终于完成了。
六:源程序附录
#include<stdio.h> #include<stdlib.h> typedef char datatype; typedef struct node { datatype data;/*数据元素*/ struct node *lchild,*rchild;/*指向左,右孩子*/ }bitree; bitree *root;/*二叉树结点类型定义*/ bitree *creatbitree(bitree *root)/*创建二叉树*/ { char ch;
数据结构课程设计--按层次遍历二叉树

数据结构课程设计--按层次遍历二叉树学号:题目按层次遍历二叉树学院计算机科学与技术专业计算机科学与技术班级姓名指导教师2013 年 6 月 20 日11 问题描述及要求 (4)1.1问题描述 (4)1.2任务要求 ............................................................. 4 2 开发平台及所使用软件 ....................................................... 4 3 程序设计思路 (5)3.1 二叉树存储结构设计 (5)3.2 题目算法设计 (5)3.2.1 建立二叉树 (5)3.2.2 遍历二叉树 (5)3.3.3 按要求格式输出已建立的二叉树 (6)3.3 测试程序 ............................................................ 6 4 调试报告...................................................................6 5 经验和体会 ................................................................. 6 6源程序清单及运行结果 (7)6.1源程序清单 (7)6.2 运行结果 ............................................................. 9 7 参考文献..................................................................10 本科生课程设计成绩评定表 (11)2课程设计任务书学生姓名: 专业班级: 计科ZY1102班指导教师: 工作单位: 计算机科学系题目: 按层次遍历二叉树初始条件:编写按层次顺序(同一层自左至右)遍历二叉树的算法。
二叉树遍历讲课教案ppt课件

资金是运动的价值,资金的价值是随 时间变 化而变 化的, 是时间 的函数 ,随时 间的推 移而增 值,其 增值的 这部分 资金就 是原有 资金的 时间价 值
6.5 线索二叉树
§ 何谓线索二叉树? § 线索链表的遍历算法 § 如何建立线索链表?
一、问题的提出
顺着某一条搜索路径巡访二叉树 中的结点,使得每个结点均被访问一 次,而且仅被访问一次。
“访问”的含义可以很是随 时间变 化而变 化的, 是时间 的函数 ,随时 间的推 移而增 值,其 增值的 这部分 资金就 是原有 资金的 时间价 值
if (T) {
visit(T->data);
// 访问结点
Preorder(T->lchild, visit); // 遍历左子树
Preorder(T->rchild, visit);// 遍历右子树 }
}
资金是运动的价值,资金的价值是随 时间变 化而变 化的, 是时间 的函数 ,随时 间的推 移而增 值,其 增值的 这部分 资金就 是原有 资金的 时间价 值
资金是运动的价值,资金的价值是随 时间变 化而变 化的, 是时间 的函数 ,随时 间的推 移而增 值,其 增值的 这部分 资金就 是原有 资金的 时间价 值
二、先左后右的遍历算法
先(根)序的遍历算法 中(根)序的遍历算法 后(根)序的遍历算法
资金是运动的价值,资金的价值是随 时间变 化而变 化的, 是时间 的函数 ,随时 间的推 移而增 值,其 增值的 这部分 资金就 是原有 资金的 时间价 值
先(根)序的遍历算法:
若二叉树为空树,则空操作;否则, (1)访问根结点; (2)先序遍历左子树; (3)先序遍历右子树。
数据结构课程设计报告-最短路径算法-二叉树的三种遍历

数据结构课程设计报告班级:计算机科学与技术132班姓名:赖恒财指导教师:董跃华成绩:32信息工程学院2015 年7月8日目录图的最短路径算法实现1. 需求分析 (1)1.1 程序设计内容 (1)1.2 设计要求 (1)2.概要设计 (2)3.详细设计 (2)3.1 数据类型的定义 (2)3.2 功能模块的设计 (2)3.3 主程序流程 (9)4.调试分析 (10)4.1 问题回顾和分析 (10)4.2.经验和体会 (11)5.测试结果 (12)二叉树的遍历1.设计目的 (13)2.需求分析 (14)2.1课程设计的内容和要求 (14)2.2选题的意义及背景 (14)3.概要设计 (14)3.1设计思想 (14)3.2程序数据类型 (16)3.3程序模块分析 (16)3.3.1置空栈 (16)3.3.2入栈 (17)3.3.3出栈 (17)3.3.4取栈顶操作 (17)3.3.5判空栈 (17)3.4函数关系: (18)4.详细设计 (18)4.1二叉树算法程序截图和结果 (18)5.程序测试结果及问题分析 (19)6.总结 (20)参考文献 (21)附录1 (22)附录2 (26)图的最短路径算法实现----基于floyd最短路径算法1.需求分析设计校园平面图,所含景点不少于8个。
以图中顶点表示学校内各景点,存放景点的名称、景点介绍信息等;以边表示路径,存放路径长度信息。
要求将这些信息保存在文件graph.txt中,系统执行时所处理的数据要对此文件分别进行读写操作。
1.1程序设计内容1.从文件graph.txt中读取相应数据, 创建一个图,使用邻接矩阵表示图;2.景点信息查询:为来访客人提供校园任意景点相关信息的介绍;3.问路查询:为来访客人提供校园任意两个景点之间的一条最短路径。
1.2 设计要求(1) 程序要具在一定的健壮性,即当输入数据非法时,程序也能适当地做出反应。
(2) 程序要添加适当的注释,程序的书写要采用缩进格式。
数据结构课程设计二叉树遍历C++语言

淮阴工学院实践报告数据结构课程设计设计题目:二叉树遍历系别:计算机工程学院专业:软件工程班级:软件1111学生姓名: 周淼学号: 1111315217起止日期: 2012年12月24日~2012年12月30日指导教师:寇海洲摘要:现代社会生活中,计算机扮演着重要角色,而随着计算机运行速度的不断加快,对数据的处理能力也日益增强,因此,程序所涉及的数据成爆发式增长。
随之而来的问题就是如何科学有效的对数据进行操作,使得计算机的时间和空间利用率最高。
针对这样的问题,我选择了二叉树对数据的各种操作作为我的课程设计主题,希望通过课程设计来提高对数据的处理能力,促进对数据结构课程的理解,在日后面向对象的程序设计中科学的规划数据结构。
在本次课程设计中,二叉树的建立使用了递归算法,遍历则同时使用了递归与非递归的算法,同时,在遍历算法的实现中使用了栈结构与队列结构,这大大方便了二叉树的遍历。
在前序、中序、后续遍历算法中,分别实现了递归与非递归算法,从实际应用中体验了递归这一算法的优越性。
关键词:二叉树建立,递归与非递归,遍历,栈,队列编号:47淮阴工学院软件工程专业数据结构课程设计答辩记录课题名称:二叉树的算法班级软件1111 学号1111315217 姓名周淼记录人:寇海洲2012 年12 月28日目录1需求分析 (6)1.1二叉树与树结构 (6)1.2面向对象的程序设计 (6)1.3二叉树遍历的应用 (6)1.4软件运行环境:Visual C++ 6.0版本 (6)2概要设计 (7)2.1 总体功能结构 (7)2.2数据结构部分设计 (7)2.2.1结点结构 (7)2.2.2 二叉树结构 (8)3详细设计 (13)3.1建立二叉树 (13)3.1.1功能描述 (13)3.1.2算法原理 (13)3.1.3 具体程序 (13)3.2 前序遍历 (14)3.2.1 功能原理 (14)3.2.2 算法原理 (14)3.2.3 具体程序 (14)3.3 中序遍历 (15)3.3.1 功能原理 (15)3.3.2 算法原理 (15)3.3.3 具体程序 (15)3.4 后序遍历 (16)3.4.1功能原理 (16)3.4.2 算法原理 (16)3.4.3 具体程序 (17)3.5层次序非递归遍历 (18)3.5.1 功能原理 (18)3.5.2 算法原理 (18)3.5.3 具体程序 (18)3.6 栈结构 (19)3.6.1 功能原理 (19)3.6.2算法原理 (19)3.6.3 具体程序 (19)3.7 队列结构 (20)3.7.1 功能原理 (20)3.7.2 算法原理 (20)3.7.3 具体程序 (20)4调试与操作说明 (21)致谢 (24)参考文献 (25)附录: (26)1需求分析1.1二叉树与树结构树结构的是建立在数据逻辑结构基础上的数据结构类型,二叉树则是树结构中最常见和使用最多的类型。
二叉树的遍历代码

二叉树的遍历代码二叉树是一种非常常见的数据结构,它由根节点、左子树和右子树组成,可以用于实现各种算法和应用。
在使用二叉树时,我们常常需要进行遍历来获取树中的节点信息。
下面,我们将详细介绍二叉树的遍历方法及其代码实现。
二叉树的遍历方法分为三种:前序遍历、中序遍历和后序遍历。
它们的不同之处在于遍历节点的顺序不同。
我们分别来介绍一下这三种遍历方法。
1.前序遍历前序遍历的顺序是:先访问根节点,然后递归访问左子树和右子树。
实现前序遍历的代码如下:```pythondef preorder_traversal(node):if node:print(node.data)preorder_traversal(node.left)preorder_traversal(node.right)```在代码中,我们首先输出根节点的值,然后分别递归访问左子树和右子树,直到遍历完整个树。
2.中序遍历中序遍历的顺序是:先递归访问左子树,然后访问根节点,最后递归访问右子树。
实现中序遍历的代码如下:```pythondef inorder_traversal(node):if node:inorder_traversal(node.left)print(node.data)inorder_traversal(node.right)```在代码中,我们先递归访问左子树,然后输出根节点的值,最后递归访问右子树。
3.后序遍历后序遍历的顺序是:先递归访问左子树和右子树,然后访问根节点。
实现后序遍历的代码如下:```pythondef postorder_traversal(node):if node:postorder_traversal(node.left)postorder_traversal(node.right)print(node.data)```在代码中,我们先递归访问左子树和右子树,然后输出根节点的值。
通过前序遍历、中序遍历和后序遍历,我们可以获取二叉树中每个节点的值。
c++实现树(二叉树)的建立和遍历算法(一)(前序,中序,后序)

c++实现树(⼆叉树)的建⽴和遍历算法(⼀)(前序,中序,后序)最近学习树的概念,有关⼆叉树的实现算法记录下来。
不过学习之前要了解的预备知识:树的概念;⼆叉树的存储结构;⼆叉树的遍历⽅法。
⼆叉树的存储结构主要了解⼆叉链表结构,也就是⼀个数据域,两个指针域,(分别为指向左右孩⼦的指针),从下⾯程序1,⼆叉树的存储结构可以看出。
⼆叉树的遍历⽅法:主要有前序遍历,中序遍历,后序遍历,层序遍历。
(层序遍历下⼀篇再讲,本篇主要讲的递归法)下篇主要是,之后会有c++模板实现和。
如这样⼀个⼆叉树:它的前序遍历顺序为:ABDGHCEIF(规则是先是根结点,再前序遍历左⼦树,再前序遍历右⼦树)它的中序遍历顺序为:GDHBAEICF(规则是先中序遍历左⼦树,再是根结点,再是中序遍历右⼦树)它的后序遍历顺序为:GHDBIEFCA(规则是先后序遍历左⼦树,再是后序遍历右⼦树,再是根结点)如果不懂的话,可以参看有关数据结构的书籍。
1,⼆叉树的存储结构(⼆叉链表)//⼆叉树的⼆叉链表结构,也就是⼆叉树的存储结构,1个数据域,2个指针域(分别指向左右孩⼦)typedef struct BiTNode{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree;2,⾸先要建⽴⼀个⼆叉树,建⽴⼆叉树必须要了解⼆叉树的遍历⽅法。
//⼆叉树的建⽴,按前序遍历的⽅式建⽴⼆叉树,当然也可以以中序或后序的⽅式建⽴⼆叉树void CreateBiTree(BiTree *T){ElemType ch;cin >> ch;if (ch == '#')*T = NULL; //保证是叶结点else{*T = (BiTree)malloc(sizeof(BiTNode));//if (!*T)//exit(OVERFLOW); //内存分配失败则退出。
二叉树的遍历实验报告

二叉树的遍历实验报告一、实验目的1.了解二叉树的基本概念和性质;2.理解二叉树的遍历方式以及它们的实现方法;3.学会通过递归和非递归算法实现二叉树的遍历。
二、实验内容1.二叉树的定义在计算机科学中,二叉树是一种重要的数据结构,由节点及它们的左右儿子组成。
没有任何子节点的节点称为叶子节点,有一个子节点的节点称为一度点,有两个子节点的节点称为二度点。
二叉树的性质:1.每个节点最多有两个子节点;2.左右子节点的顺序不能颠倒,左边是父节点的左子节点,右边是父节点的右子节点;3.二叉树可以为空,也可以只有一个根节点;4.二叉树的高度是从根节点到最深叶子节点的层数;5.二叉树的深度是从最深叶子节点到根节点的层数;6.一个深度为d的二叉树最多有2^(d+1) -1个节点,其中d>=1;7.在二叉树的第i层上最多有2^(i-1)个节点,其中i>=1。
2.二叉树的遍历方式二叉树的遍历是指从根节点出发,按照一定的顺序遍历二叉树中的每个节点。
常用的二叉树遍历方式有三种:前序遍历、中序遍历和后序遍历。
前序遍历:先遍历根节点,再遍历左子树,最后遍历右子树;中序遍历:先遍历左子树,再遍历根节点,最后遍历右子树;后序遍历:先遍历左子树,再遍历右子树,最后遍历根节点。
递归算法:利用函数调用,递归实现二叉树的遍历;非递归算法:利用栈或队列,对二叉树进行遍历。
三、实验步骤1.创建二叉树数据结构并插入节点;2.实现二叉树的前序遍历、中序遍历、后序遍历递归算法;3.实现二叉树的前序遍历、中序遍历、后序遍历非递归算法;4.测试算法功能。
四、实验结果1.创建二叉树数据结构并插入节点为了测试三种遍历方式的算法实现,我们需要创建一个二叉树并插入节点,代码如下:```c++//定义二叉树节点struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};递归算法是实现二叉树遍历的最简单方法,代码如下:```c++//前序遍历非递归算法vector<int> preorderTraversal(TreeNode* root) {stack<TreeNode*> s;vector<int> res;if (!root) return res;s.push(root);while (!s.empty()) {TreeNode* tmp = s.top();s.pop();res.push_back(tmp->val);if (tmp->right) s.push(tmp->right);if (tmp->left) s.push(tmp->left);}return res;}4.测试算法功能return 0;}```测试结果如下:preorderTraversal: 4 2 1 3 6 5 7inorderTraversal: 1 2 3 4 5 6 7postorderTraversal: 1 3 2 5 7 6 4preorderTraversalNonRecursive: 4 2 1 3 6 5 7inorderTraversalNonRecursive: 1 2 3 4 5 6 7postorderTraversalNonRecursive: 1 3 2 5 7 6 4本次实验通过实现二叉树的递归和非递归遍历算法,加深了对二叉树的理解,并熟悉了遍历算法的实现方法。
二叉树的遍历教案教学设计

二叉树的遍历教案教学设计教案教学设计:二叉树的遍历一、教学目标:1. 了解二叉树的遍历方式:前序遍历、中序遍历和后序遍历。
2. 能够使用递归和非递归两种方法实现二叉树的遍历。
3. 能够分析和比较不同遍历方式的时间复杂度和空间复杂度。
二、教学内容:1. 二叉树的遍历概念及分类。
2. 递归遍历算法的原理及实现。
3. 非递归遍历算法的原理及实现。
4. 比较不同遍历方式的时间复杂度和空间复杂度。
三、教学重点:1. 能够理解二叉树的遍历分类及其特点。
2. 能够使用递归和非递归两种方法实现二叉树的遍历。
四、教学难点:1. 非递归遍历算法的实现。
2. 比较不同遍历方式的时间复杂度和空间复杂度。
五、教学过程:1. 导入新知识,激发学生兴趣(5分钟)教师通过展示一棵二叉树的图片引入二叉树的遍历概念,并让学生猜测遍历的意义。
2. 介绍二叉树的遍历分类及特点(10分钟)教师介绍二叉树的遍历分类:前序遍历(根-左-右)、中序遍历(左-根-右)和后序遍历(左-右-根),并讲解每种遍历方式的特点。
3. 介绍递归遍历算法的原理及实现(15分钟)教师通过演示前序遍历的递归算法实现,介绍递归遍历的原理和递归函数的编写,让学生理解递归遍历的思路。
4. 演示递归遍历算法的应用(15分钟)教师在白板上画一棵二叉树,演示如何使用递归算法实现不同的遍历方式,并让学生跟随演示进行练习。
5. 介绍非递归遍历算法的原理及实现(15分钟)教师介绍非递归遍历算法的思路,包括使用栈数据结构进行遍历的原理及实现。
6. 演示非递归遍历算法的应用(15分钟)教师在白板上画一棵二叉树,演示如何使用非递归算法实现不同的遍历方式,并让学生跟随演示进行练习。
7. 比较不同遍历方式的时间复杂度和空间复杂度(10分钟)教师比较不同遍历方式的时间复杂度和空间复杂度,让学生了解不同的遍历方式在不同场景下的优劣。
8. 小结与作业布置(5分钟)教师对本节课进行小结,并布置作业:编写一个程序,实现二叉树的遍历,并分析所用遍历方式的时间复杂度和空间复杂度。
中序遍历二叉树的递归算法c语言代码

中序遍历二叉树的递归算法c语言代码二叉树的中序遍历递归算法是左子树-> 根节点-> 右子树。
以下是C语言代码实现:```c#include <stdio.h>#include <stdlib.h>// 定义二叉树节点结构体struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};// 定义二叉树中序遍历函数void inorderTraversal(struct TreeNode *root) {if (root == NULL) { // 如果根节点为空,直接返回return;}inorderTraversal(root->left); // 先遍历左子树printf("%d ", root->val); // 输出根节点值inorderTraversal(root->right); // 最后遍历右子树}int main() {// 创建一棵二叉树struct TreeNode *root = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node1 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node2 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node3 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node4 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node5 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node6 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node7 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node8 = (struct TreeNode*)malloc(sizeof(struct TreeNode));struct TreeNode *node9 = (struct TreeNode*)malloc(sizeof(struct TreeNode));node1->val = 1;node1->left = node2;node1->right = node3;node2->val = 2;node2->left = NULL;node2->right = NULL;node3->val = 3;node3->left = node4;node3->right = node5;node4->val = 4;node4->left = NULL;node4->right = NULL;node5->val = 5;node5->left = NULL;node5->right = NULL;root->val = 0; // 设置根节点值为0,这样在遍历时会跳过根节点输出0,避免输出多个根节点值。
数据结构课程设计-二叉树的基本操作

二叉树的基本操作摘要:本次课程设计通过对二叉树的一系列操作主要练习了二叉树的建立、四种遍历方式:先序遍历、中序遍历、后序遍历和层序遍历以及节点数和深度的统计等算法。
增加了对二叉树这一数据结构的理解,掌握了使用c语言对二叉树进行一些基本的操作。
关键字:递归、二叉树、层序遍历、子树交换一、程序简介本程序名为“二叉树基本操作的实现”,其主要为练习二叉树的基本操作而开发,其中包含了建立、遍历、统计叶子结点和深度等一系列操作。
其中定义二叉链表来表示二叉树,用一个字符类型的数据来表示每一个节点中存储的数据。
由于没有进行图形界面的设计,用户可以通过程序中的遍历二叉树一功能来查看操作的二叉树。
二、功能模块2.1功能模块图2.2功能模块详解2.2.1建立二叉树输入要建立的二叉树的扩展二叉树的先序遍历序列,来建立二叉树,建立成功会给出提示。
2.2.2遍历二叉树执行操作之后会有四个选项可供选择:先序遍历、中序遍历、后序遍历、层序遍历。
输入对应的序号即可调动相关函数输出相应的遍历序列。
2.2.3统计叶子节点树执行之后输出叶子结点的个数。
2.2.4求二叉树深度执行之后输出二叉树的深度。
2.2.5子树交换交换成功则会给出提示,用户可通过遍历二叉树来观察子树交换之后的二叉树。
三、数据结构和算法设计3.1二叉链表的设计1.typedef struct BiNode {2.char data;3.struct BiNode* lchild; //左孩子4.struct BiNode* rchild; //右孩子5.}BiTree;用一个字符型保存节点数据,分别定义两个struct BiNode类型的指针来指向左孩子和右孩子。
在BiTree.h中实现相关的功能。
3.2队列的实现1.typedef struct {2. ElemType* data;3.int head;//队头指针4.int tail;//队尾指针5.} SqQueue;队列主要用于二叉树遍历过程中的层序遍历,从根节点开始分别将左右孩子放入队列,然后从对头开始输出。
二叉树先序遍历c语言

二叉树先序遍历c语言在计算机科学的领域中,二叉树是一种非常重要且常用的数据结构。
它由节点组成,每个节点可以存储一个值,并且最多有两个子节点,分别称为左子节点和右子节点。
二叉树可以用来解决许多实际问题,例如在编写搜索算法时,可以使用二叉树来快速定位目标值。
同时,二叉树还可以用于构建更复杂的数据结构,例如堆和红黑树。
在二叉树中,先序遍历是一种遍历方式。
它的步骤如下:1. 访问根节点。
2. 遍历左子树。
3. 遍历右子树。
下面我们将用C语言来实现二叉树的先序遍历。
首先,我们需要定义一个二叉树节点的结构体,如下所示:```ctypedef struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;} TreeNode;```然后,我们可以通过递归的方式来实现先序遍历函数,代码如下:```cvoid preorderTraversal(TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->val); // 访问根节点preorderTraversal(root->left); // 遍历左子树preorderTraversal(root->right); // 遍历右子树}```在这个递归函数中,我们首先判断根节点是否为空,如果为空则返回。
然后,我们访问根节点的值,并依次递归地遍历左子树和右子树。
接下来,我们可以创建一个二叉树并测试我们的先序遍历函数。
下面是一个简单的示例:```cint main() {TreeNode* root = malloc(sizeof(TreeNode));root->val = 1;TreeNode* node1 = malloc(sizeof(TreeNode));node1->val = 2;TreeNode* node2 = malloc(sizeof(TreeNode));node2->val = 3;root->left = node1;root->right = node2;printf("先序遍历结果:");preorderTraversal(root);printf("\n");return 0;}```在这个示例中,我们创建了一个具有三个节点的二叉树,并调用先序遍历函数进行遍历。
用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)。
《数据结构》课程设计报告设计题目:二叉树的遍历*名:**学号: *********专业:计算机科学与技术院系:计算机科学与技术班级: 1002指导教师:***2012年 3 月1日摘要:本文主要说明如何实现二叉树的遍历。
此次二叉树的遍历基于二叉树的二叉链表存储结构。
遍历方式包括:前序遍历,中序遍历,后续遍历,层序遍历。
其中前序遍历和后续遍历采用非递归算法实现。
编程环境为VC++,除了遍历操作外,还增加了求二叉树的深度,总结点数,每层结点数,以及最近共同祖先(LCA)问题的算法。
关键字:二叉树遍历非递归C++ LCAAbstract: This paper mainly describes how to implement binary tree traversal. The binary tree traversal is based on binary tree binary storage structure. Traversal method includes: preorder traversal,inorder traversal, postorder traversal, levelorder traversal. The former preorder traversal and postorder use of non - recursive algorithm. Programming environment is VC + +, in addition to traversal operation, also increased for solving the binary tree depth 、summary points and each layer of nodes, as well as the most recent common ancestor ( LCA ) algorithm.Keywords: binary tree traversal non-recursive C++ LCA目录一、问题描述 (4)问题描述:创建二叉树并遍历 (4)基本要求: (4)二、需求分析 (4)三、概要设计 (4)1.创建二叉树 (4)2.二叉树的非递归前序遍历示意图 (4)3.二叉树的后序非递归遍历示意图 (5)四、数据结构设计 (5)1.二叉树结点数据类型定义为: (5)2.二叉树数据类型定义为: (5)五、算法设计 (6)1、创建二叉树 (6)2、非递归前序遍历 (7)3、非递归后序遍历 (7)4、求二叉树的高度 (8)5、求二叉树每一层的结点数 (9)6、求两节点最近共同祖先 (9)6、算法流程图 (10)六、程序测试与实现 (11)1、函数之间的调用关系 (11)2、主程序 (11)3、测试数据 (13)4、测试结果 (13)七、调试分析 (14)八、遇到的问题及解决办法 (15)九、心得体会 (15)十、参考文献 (15)一、问题描述问题描述:创建二叉树并遍历基本要求:1、分别运用非递归的方式完成对二叉树的先序和后序遍历2、输出二叉树的高度3、输出每一层的结点数4、查找结点P 和结点Q的最近共同祖先二、需求分析1.本程序的功能包括二叉树的建立,二叉树的递归遍历,二叉树的非递归遍历,查询二叉树的深度,查询每层的结点数,查找两个结点的最近共同祖先,二叉树的打印。
2.程序运行后显现提示信息,等候用户输入0—6以进入相应的操作功能。
3.用户输入数据完毕,程序将输出运行结果。
4.测试数据应为字符型数据。
三、概要设计1.创建二叉树输入数据不低于15个,用递归方法建立二叉树。
2.二叉树的非递归前序遍历示意图图3.2二叉树前序遍历示意图3.二叉树的后序非递归遍历示意图图3.4二叉树后序遍历示意图四、数据结构设计1.二叉树结点数据类型定义为:template <typename T>struct BiNode{BiNode<T> *rchild,*lchild;//指向左右孩子的指针T data; //结点数据信息};2.二叉树数据类型定义为:template <typename T>class BiTree{template <typename T>friend ostream & operator <<(ostream &os ,BiTree<T> &bt); public:BiTree();//无参构造函数BiTree(int m){};//有参空构造函数BiTree(T ary[],int num,T none);//有参构造函数~BiTree();//析构函数void preorder();//递归前序遍历void inorder();//递归中序遍历void postorder();//递归后续遍历void levelorder();//层序遍历int count();//计算二叉树的结点数int depth();//计算二叉树的深度void display(ostream &os);//打印二叉树,有层次void LevelNum();//计算每一层结点数void PreOrder();//非递归前序遍历void PostOrder();//非递归后序遍历void creat();//创建二叉树T leastCommanAncestor(T va, T vb);//求树中任意两结点最近共同祖先protected://以下函数供上面函数调用//对应相同功能void creat(BiNode <T>* &root);//创建void release(BiNode<T>* &root);//删除BiNode<T> * Build(T ary[],int num,T none,int idx);//用数组创建二叉树void PreOrder(BiNode<T>* root);//前序遍历void PostOrder(BiNode<T>* root);//后续遍历void LevelNum(BiNode<T>* root);//层序遍历void preorder(BiNode<T>* root);//递归前序遍历void inorder(BiNode<T>* root);//递归中序遍历void postorder(BiNode<T>* root);//递归后续遍历void levelorder(BiNode<T>*root);//层序遍历int count(BiNode<T>* root);//计算结点数int depth(BiNode<T>* root);//计算深度void display(ostream& os,BiNode<T>* root,int dep);//打印static bool leastCommanAncestor(BiNode<T> *root, T va, T vb, BiNode<T>*&result, BiNode<T>* parrent);//求最近共同祖先private:BiNode<T> *rootptr;};五、算法设计1、创建二叉树//实现外部递归调用void BiTree<T>::creat(){creat(rootptr);}//类体内递归创建二叉树template <typename T>void BiTree<T>::creat(BiNode<T> * & root){T item;cin>>item;if(item=='#') root=NULL;else{root=new BiNode<T>;root->data=item;creat(root->lchild);creat(root->rchild);}}2、非递归前序遍历template <typename T>void BiTree<T>::PreOrder(){PreOrder(rootptr);}template <typename T>void BiTree<T>::PreOrder(BiNode<T>* root){stack <BiNode<T> *> s;while(root!=NULL||!s.empty()){while(root){cout<<root->data;s.push(root);root=root->lchild;}if(!s.empty()){root=s.top();s.pop();root=root->rchild;}}}3、非递归后序遍历template <typename T>void BiTree<T>::PostOrder(){PostOrder(rootptr);}template <typename T>void BiTree<T>::PostOrder(BiNode<T> *root){stack<BiNode<T>*> s;//定义栈,节点类型为TreeNode BiNode<T> *p = root;BiNode<T> *pre = NULL;//pre表示最近一次访问的结点while(p||!s.empty()){//沿着左孩子方向走到最左下。
while(p){s.push(p);p = p->lchild;}//get the top element of the stackp = s.top();//如果p没有右孩子或者其右孩子刚刚被访问过if(p->rchild== NULL|| p->rchild == pre) {//visit this element and then pop it cout <<p->data;s.pop();pre = p;p = NULL;}else{p = p->rchild;}}//end of while(p || st.size()!=0)}4、求二叉树的高度template <typename T>int BiTree<T>::depth(){return depth(rootptr);}template <typename T>int BiTree<T>::depth(BiNode<T> *root){int rdep,ldep;if(root==NULL)return 0;else{ldep=depth(root->lchild);rdep=depth(root->rchild);return (rdep>ldep?rdep:ldep)+1;}}5、求二叉树每一层的结点数template <typename T>void BiTree<T>::LevelNum(){LevelNum(rootptr);}template <typename T>void BiTree<T>::LevelNum(BiNode<T> * root){queue <BiNode<T> *> q;int front,rear,first,last,level;front=rear=first=0;last=level=1;if(root){q.push(root);rear++;while(front<rear){root=q.front();q.pop();front++;if(root->lchild){q.push(root->lchild);rear++;}if(root->rchild){q.push(root->rchild);rear++;}if(front==last){cout<<"第"<<level<<"层有"<<last-first<<"个结点"<<endl;level++;last=rear;first=front;}}}}6、求两节点最近共同祖先template <typename T>T BiTree<T>::leastCommanAncestor(T n1, T n2){return leastCommanAncestor(rootptr,n1,n2);}template <typename T>T BiTree<T>::leastCommanAncestor(BiNode<T> * root, T n1, T n2) {if(root == NULL || root->data == n1 || root->data == n2) return -1;if((root->rchild!= NULL) &&(root->rchild->data == n1 || root->rchild->data == n2))return root->data;if((root->lchild != NULL) &&(root->lchild->data == n1 || root->lchild->data == n2))return root->data;if(root->data > n1 && root->data < n2)return root->data;if(root->data > n1 && root->data > n2)return leastCommanAncestor(root->lchild, n1, n2);if(root->data < n1 && root->data < n2)return leastCommanAncestor(root->rchild, n1, n2);}6、算法流程图六、程序测试与实现1、函数之间的调用关系2、主程序void main(){BiTree<char> Tree(1);while(1){cout<<"\t\t 欢迎使用本系统!! "<<endl;cout<<"\t\t######################################## "<<endl;cout<<"\t\t# # "<<endl;cout<<"\t\t# 1--创建一颗二叉树并显示 # "<<endl;cout<<"\t\t# 2--遍历二叉树 # "<<endl;cout<<"\t\t# 3--查询二叉树的深度和结点数 # "<<endl;cout<<"\t\t# 4--查询每层结点数 # "<<endl;cout<<"\t\t# 5--查找两节点P和Q的最近共同祖先 # "<<endl;cout<<"\t\t# 6--退出 # "<<endl;cout<<"\t\t# # "<<endl;cout<<"\t\t######################################## "<<endl;cout<<"请输入你的选择:";int x;cin>>x;switch(x){case 1:{cout<<"请输入二叉树的前序遍历:"<<endl;cout<<"(以#作为分支结尾,例如:A B # # C # #)"<<endl;Tree.creat();cout<<Tree;cout<<endl;}break;case 2:{cout<<endl;cout<<"前序遍历为:";Tree.PreOrder();cout<<endl;cout<<"中序遍历为:";Tree.inorder();cout<<endl;cout<<"后序遍历为:";Tree.PostOrder();cout<<endl;cout<<"层序遍历为:";Tree.levelorder();cout<<endl;cout<<endl;}break;case 3: {cout<<"树的深度为:"<<Tree.depth()<<endl;cout<<"树的结点数:"<<Tree.count()<<endl;cout<<endl;}break;case 4:{Tree.LevelNum();}break;case 5:{char ch1,ch2;cout<<"请输入P数据信息:";cin>>ch1;cout<<"请输入Q数据信息:";cin>>ch2;cout<<ch1<<"和"<<ch2<<"的最近共同祖先是"<<Tree.leastCommanAncestor(ch1, ch2)<<endl;}break;case 6:return;break;default: cout<<"请输入正确的选择"<<endl;break;}}}3、测试数据AB#CD###E#FGH##K### 4、测试结果七、调试分析创建二叉树:依次输入二叉树前序遍历序列,构建相应的二叉树。