数据结构课程设计-二叉树
数据结构c语言课设-二叉树排序
题目:二叉排序树的实现1 内容和要求1)编程实现二叉排序树,包括生成、插入,删除;2)对二叉排序树进展先根、中根、和后根非递归遍历;3)每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
4)分别用二叉排序树和数组去存储一个班(50 人以上)的成员信息(至少包括学号、姓名、成绩3 项),比照查找效率,并说明在什么情况下二叉排序树效率高,为什么?2 解决方案和关键代码2.1 解决方案:先实现二叉排序树的生成、插入、删除,编写DisplayBST函数把遍历结果用树的形状表示出来。
前中后根遍历需要用到栈的数据构造,分模块编写栈与遍历代码。
要求比照二叉排序树和数组的查找效率,首先建立一个数组存储一个班的成员信息,分别用二叉树和数组查找,利用clock〔〕函数记录查找时间来比照查找效率。
2.2关键代码树的根本构造定义及根本函数typedef struct{KeyType key;} ElemType;typedef struct BiTNode//定义链表{ElemType data;struct BiTNode *lchild, *rchild;}BiTNode, *BiTree, *SElemType;//销毁树int DestroyBiTree(BiTree &T){if (T != NULL)free(T);return 0;}//清空树int ClearBiTree(BiTree &T){if (T != NULL){T->lchild = NULL;T->rchild = NULL;T = NULL;}return 0;}//查找关键字,指针p返回int SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p) {if (!T){p = f;return FALSE;}else if EQ(key, T->data.key){p = T;return TRUE;}else if LT(key, T->data.key)return SearchBST(T->lchild, key, T, p);elsereturn SearchBST(T->rchild, key, T, p);}二叉树的生成、插入,删除生成void CreateBST(BiTree &BT, BiTree p){int i;ElemType k;printf("请输入元素值以创立排序二叉树:\n");scanf_s("%d", &k.key);for (i = 0; k.key != NULL; i++){//判断是否重复if (!SearchBST(BT, k.key, NULL, p)){InsertBST(BT, k);scanf_s("%d", &k.key);}else{printf("输入数据重复!\n");return;}}}插入int InsertBST(BiTree &T, ElemType e){BiTree s, p;if (!SearchBST(T, e.key, NULL, p)){s = (BiTree)malloc(sizeof(BiTNode));s->data = e;s->lchild = s->rchild = NULL;if (!p)T = s;else if LT(e.key, p->data.key)p->lchild = s;elsep->rchild = s;return TRUE;}else return FALSE;}删除//某个节点元素的删除int DeleteEle(BiTree &p){BiTree q, s;if (!p->rchild) //右子树为空{q = p;p = p->lchild;free(q);}else if (!p->lchild) //左子树为空{q = p;p = p->rchild;free(q);}else{q = p;s = p->lchild;while (s->rchild){q = s;s = s->rchild;}p->data = s->data;if (q != p)q->rchild = s->lchild;elseq->lchild = s->lchild;delete s;}return TRUE;}//整棵树的删除int DeleteBST(BiTree &T, KeyType key) //实现二叉排序树的删除操作{if (!T){return FALSE;}else{if (EQ(key, T->data.key)) //是否相等return DeleteEle(T);else if (LT(key, T->data.key)) //是否小于return DeleteBST(T->lchild, key);elsereturn DeleteBST(T->rchild, key);}return 0;}二叉树的前中后根遍历栈的定义typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int InitStack(SqStack &S) //构造空栈{S.base = (SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackint Push(SqStack &S, SElemType e) //插入元素e为新栈顶{if (S.top - S.base >= S.stacksize){S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}//Pushint Pop(SqStack &S, SElemType &e) //删除栈顶,应用e返回其值{if (S.top == S.base) return ERROR;e = *--S.top;return OK;}//Popint StackEmpty(SqStack S) //判断是否为空栈{if (S.base == S.top) return TRUE;return FALSE;}先根遍历int PreOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);if (!Visit(p->data)) return ERROR;p = p->lchild;}else{Pop(S, p);p = p->rchild;}}return OK;}中根遍历int InOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S;BiTree p;InitStack(S);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);p = p->lchild;}else{Pop(S, p);if (!Visit(p->data)) return ERROR;p = p->rchild;}}return OK;}后根遍历int PostOrderTraverse(BiTree T, int(*Visit)(ElemType e)) {SqStack S, SS;BiTree p;InitStack(S);InitStack(SS);p = T;while (p || !StackEmpty(S)){if (p){Push(S, p);Push(SS, p);p = p->rchild;}else{if (!StackEmpty(S)){Pop(S, p);p = p->lchild;}}}while (!StackEmpty(SS)){Pop(SS, p);if (!Visit(p->data)) return ERROR;}return OK;}利用数组存储一个班学生信息ElemType a[] = { 51, "陈继真", 88,82, "黄景元", 89,53, "贾成", 88,44, "呼颜", 90,25, "鲁修德", 88,56, "须成", 88,47, "孙祥", 87, 38, "柏有患", 89, 9, " 革高", 89, 10, "考鬲", 87, 31, "李燧", 86, 12, "夏祥", 89, 53, "余惠", 84, 4, "鲁芝", 90, 75, "黄丙庆", 88, 16, "李应", 89, 87, "杨志", 86, 18, "李逵", 89, 9, "阮小五", 85, 20, "史进", 88, 21, "秦明", 88, 82, "杨雄", 89, 23, "刘唐", 85, 64, "武松", 88, 25, "李俊", 88, 86, "卢俊义", 88, 27, "华荣", 87, 28, "杨胜", 88, 29, "林冲", 89, 70, "李跃", 85, 31, "蓝虎", 90, 32, "宋禄", 84, 73, "鲁智深", 89, 34, "关斌", 90, 55, "龚成", 87, 36, "黄乌", 87, 57, "孔道灵", 87, 38, "张焕", 84, 59, "李信", 88, 30, "徐山", 83, 41, "秦祥", 85, 42, "葛公", 85, 23, "武衍公", 87, 94, "范斌", 83, 45, "黄乌", 60, 67, "叶景昌", 99, 7, "焦龙", 89, 78, "星姚烨", 85, 49, "孙吉", 90, 60, "陈梦庚", 95,};数组查询函数void ArraySearch(ElemType a[], int key, int length){int i;for (i = 0; i <= length; i++){if (key == a[i].key){cout << "学号:" << a[i].key << " 姓名:" << a[i].name << " 成绩:" << a[i].grade << endl;break;}}}二叉树查询函数上文二叉树根本函数中的SearchBST()即为二叉树查询函数。
数据结构二叉树学习教案
[1]
A
[2]
B
[3]
C
[4]
D
[5]
E
般不用
[6] [7] [8] [9]
F G H I
A
一 、顺序 存储结 构 按 二 叉 树 的 结点“ 自上而 下、从 左至右 ”编号 ,用一 组连续 (liánxù)的 存储 单元存 储。
B
C
D EF G
H
I
问:顺序存储后能否复原成唯一对应(duìyìng)的二叉树形状? 答:若是完全/满二叉树则可以做到唯一复原。
right_child
data
left_child
right_child
第6页/共17页
第七页,共16页。
二 叉 树 结 点 (jié diǎn)数 据 类 型 定 义 : typedef stru ct B iTNod e {
TElemT ype d ata; struct BiTN ode *lef t_chi ld, *righ t_ch ild; } BiTNo de, * BiTr ee;
f
d
b
e
ac
g i
h
j
第14页/共17页
第十五页,共16页。
习题2:若一棵二叉树,左右子树均有三个结点,其左子树的前 (先)序序列与中序序列相同,右子树的中序序列与后序 序列相同,试构造该树。
习题3:一棵非空的二叉树其先序序列和后序序列正好相反,画出 这棵二叉树的形状。
习题4:已知一棵完全二叉树共有892个结点,试求:⑴ 树的高度; ⑵ 叶结点数;⑶ 单支(度为1)结点数;⑷ 最后(zuìhòu)一 个非终端结点的序号。
第9页/共17页
第十页,共16页。
数据结构课程设计报告-二叉树根节点到指定节点的路径
数据结构课程设计报告-二叉树根节点到指定节点的路径数据结构课程设计报告二叉树根节点到指定节点的路径——递归调用思想班级:__ 软件092________ 姓名:_ __________ 指导教师:__ 成绩:___________________ 信息工程学院2011 年 6 月17 日- 2 - 摘要(题目): 二叉树根节点到指定节点的路径 1.引言二叉树是n 个结点的有穷个集合,它或者是空集(n=0),或者同时满足以下两个条件;(1)有且仅有一个称为根的结点;(2)其余结点分为两个互不相交的集合T1,T2,并且T1,T2,都是二叉树,分别称为根的左子树和右子树。
二叉树形结构在客观世界中大量存在,如行政组织机构和人类社会的家谱关系等都可用二叉树结构形象地表示。
在计算机应用领域,二叉树也被广泛地应用。
例如在编译程序中,可用二叉树来表示源程序的语法结构;在数据库系统中,可用二叉树来表示组织信息;在计算机图形学中,可用二叉树来表示图像关系等。
因此对二叉树的研究具有重要意义。
2.需求分析利用一个简单的菜单,通过菜单项进行选择,实现和完成如下功能:用先序输入,建立二叉树存储结构、求指定结点的路径。
对于建立二叉树存储结构,考虑到栈和队列的存储结构比较繁琐,从而定义一指针数组来一一存储该二叉树先序遍历过的结点,并对该结点进行判断是否为指定的目标结点,并进行输出等操作。
3.概要设计对二叉树采用链式存储结构,其结构定义如下:typedef structnode{ DataType data; struct node*lchild,*rchild; }BinTNode,*BinTree; 每个结点中设置三个域,即值域data,左指针域*lchild 和右指针域*rchild。
本程序分为6 大模块:全局变量定义、创建结构体、创建二叉链表存储表示、查找目标结点、求结点路径、主函数。
(1)全局变量定义(2)创建结构体(3)创建二叉链表存储表示:定义二叉树的链式存储结构,输入数据生成二叉树。
数据结构-二叉排序树
二叉排序树操作一、设计步骤1)分析课程设计题目的要求2)写出详细设计说明3)编写程序代码,调试程序使其能正确运行4)设计完成的软件要便于操作和使用5)设计完成后提交课程设计报告(一)程序功能:1)创建二叉排序树2)输出二叉排序树3)在二叉排序树中插入新结点4)在二叉排序树中删除给定的值5)在二叉排序树中查找所给定的值(二)函数功能:1) struct BiTnode 定义二叉链表结点类型包含结点的信息2) class BT 二叉排序树类,以实现二叉排序树的相关操作3) InitBitree() 构造函数,使根节点指向空4) ~BT () 析构函数,释放结点空间5) void InsertBST(&t,key) 实现二叉排序树的插入功能6) int SearchBST(t,key) 实现二叉排序树的查找功能7) int DelBST(&t,key) 实现二叉排序树的删除功能8) void InorderBiTree (t) 实现二叉排序树的排序(输出功能)9) int main() 主函数,用来完成对二叉排序树类中各个函数的测试二、设计理论分析方法(一)二叉排序树定义首先,我们应该明确所谓二叉排序树是指满足下列条件的二叉树:(1)左子树上的所有结点值均小于根结点值;(2)右子数上的所有结点值均不小于根结点值;(3)左、右子数也满足上述两个条件。
根据对上述的理解和分析,我们就可以先创建出一个二叉链表结点的结构体类型(struct BiTNode)和一个二叉排序树类(class BT),以及类中的构造函数、析构函数和其他实现相关功能的函数。
(二)插入函数(void InsertBST(&t,key))首先定义一个与BiTNode<k> *BT同一类型的结点p,并为其申请空间,使p->data=key,p->lchild和p->rchild=NULL。
数据结构——- 二叉树
证明: 5.1 二叉树的概念
(1)总结点数为 ●二叉树的主要性质 n=n0+n1+n2 (2)除根结点外,每个 ●性质3: 结点都有一个边e进入 任何一棵二叉树,若其终端结点数为n0, n=e+1 度为2的结点数为n2,则n0=n2+1 (3)边e又是由度为1或2 A 的点射出,因此 e=n1+2n2 G B (4)由(2)(3) F C D n=n1+2n2+1 (5)由(4)-(1)可得 G n0=n2+1
《数据结构与算法》
★★★★★
第五章 二叉树
廊坊师范学院 数学与信息科学学院
树型结构--实例:五子棋
A
B
D
E
F
C
…...........
…...........
第五章 二叉树
本章重点难点
重点: 二叉树的定义,性质,存储结 构以及相关的应用——遍历,二叉搜 索树,堆优先 队列,Huffman树等 难点: 二叉树的遍历算法及相关应用
证明: 5.1 二叉树的概念
(1)总结点数为 ●二叉树的主要性质 n=n0+n1+n2 (2)除根结点外,每个 ●性质3: 结点都有一个边e进入 任何一棵二叉树,若其终端结点数为n0, n=e+1 度为2的结点数为n2,则n0=n2+1 (3)边e又是由度为1或2 A 的点射出,因此 e=n1+2n2 G B (4)由(2)(3) F C D n=n1+2n2+1 (5)由(4)-(1)可得 G n0=n2+1
A B C E D F G
证明: 由性质4可推出
由性质2(深度为k的 二叉树,至多有2k+1-1 个结点)可知,高度 为h(k+1)的二叉树,其 有n (n>0)个结点的完全二叉树的高度为 结点个数n满足: 「log2(n+1) ,深度为「log2(n+1) -1 2h-1-1<n<=2h-1 高度:二叉树中最大叶结点的层数+1 2h-1<n+1<=2h 取对数得到: 0层 1 h-1<log2(n+1)<=h 3 1层 2 因为h是整数,所以 h= log2(n+1) 5 2层 4
数据结构_二叉树的遍历_课程设计
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;
数据结构详细教案——树与二叉树
数据结构详细教案——树与二叉树一、教学目标1.了解树和二叉树的基本概念和特点;2.掌握树和二叉树的基本操作;3.能够通过递归遍历树和二叉树。
二、教学重难点1.树和二叉树的基本概念和特点;2.递归遍历树和二叉树。
三、教学内容1.树的概念和特点1.1树的定义树是n(n>=0)个节点的有限集。
当n=0时,称为空树;如果不为空树,则1. 树有且仅有一个特殊节点被称为根(Root);2.其余节点可分为m(m>0)个互不相交的有限集T1,T2,...,Tm,其中每个集合又是一棵树。
1.2节点间的关系- 父节点(parent)是当前节点的直接上级节点;- 子节点(child)是当前节点的直接下级节点;- 兄弟节点(sibling)是具有同一父节点的节点;- 祖先节点(ancestor)是通过从当前节点到根的任意路径可以到达的节点;- 子孙节点(descendant)是通过从该节点到子树的任意节点可以到达的节点。
1.3树的特点-树是一个有层次的结构,可以看作是一个鱼骨图;-树中的每个节点都可以有多个子节点,但只有一个父节点;-树中的节点之间是唯一的,不存在重复节点;-树中的任意两个节点之间都有且仅有一条路径连接。
2.二叉树的概念和特点2.1二叉树的定义二叉树是一种特殊的树结构,它的每个节点最多只能有两个子节点,分别称为左子节点和右子节点。
2.2二叉树的特点-二叉树的度最大为2,即每个节点最多有两个子节点;-二叉树的第i层最多有2^(i-1)个节点;-对于任意一颗二叉树,如果其叶子节点数为n0,度为2的节点数为n2,则有n0=n2+1;-完全二叉树是一种特殊的二叉树,除了最后一层的叶子节点外,每一层的节点都是满的。
四、教学过程1.讲解树和二叉树的基本概念和特点,引导学生理解树和二叉树的定义和节点间的关系。
2.分析树和二叉树的基本操作,并通过实例演示操作过程,让学生掌握操作的步骤和方法。
3.运用递归算法遍历树和二叉树的过程,详细讲解前序遍历、中序遍历和后序遍历的定义和实现方法。
数据结构实验报告-树(二叉树)
实验5:树(二叉树)(采用二叉链表存储)一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。
三、实验基本原理之前我们都是学习的线性结构,这次我们就开始学习非线性结构——树。
线性结构中结点间具有唯一前驱、唯一后继关系,而非线性结构中结点的前驱、后继的关系并不具有唯一性。
在树结构中,节点间关系是前驱唯一而后继不唯一,即结点之间是一对多的关系。
直观地看,树结构是具有分支关系的结构(其分叉、分层的特征类似于自然界中的树)。
四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值,空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为:" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为:" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为:" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1:创建二叉树--------------" << endl;cout << "--------------2:前序遍历----------------" << endl;cout << "--------------3:中序遍历----------------" << endl;cout << "--------------4:后序遍历----------------" << endl;cout << "--------------5:总结点数----------------" << endl;cout << "--------------6:叶子节点数--------------" << endl;cout << "--------------7:树的深度----------------" << endl;cout << "--------------8:树根到叶子的最长路径----" << endl;cout << "--------------9:交换所有节点左右子女----" << endl;cout << "--------------10:顺序存储---------------" << endl;cout << "--------------11:显示顺序存储-----------" << endl;cout << "--------------12:退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例:1.创建二叉树(二叉链表形式)2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验,我掌握了二叉树的顺序存储和链式存储,体会了二叉树的存储结构的特性,掌握了二叉树的树上相关操作。
数据结构课程设计报告-最短路径算法-二叉树的三种遍历
数据结构课程设计报告班级:计算机科学与技术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) 程序要添加适当的注释,程序的书写要采用缩进格式。
数据结构二叉树知识点总结
数据结构二叉树知识点总结二叉树是指每个节点最多有两个子节点的树结构。
它是一种重要的数据结构,在算法和程序设计中被广泛应用。
下面是对二叉树的主要知识点进行详细总结。
1.二叉树的基本概念:-树节点:树的基本单元,包含数据项(节点值)和指向其他节点的指针。
-根节点:树的第一个节点。
-叶节点(又称为终端节点):没有子节点的节点。
-子节点:一些节点的下一级节点。
-父节点:一些节点的上一级节点。
-兄弟节点:拥有同一父节点的节点。
-深度:从根节点到当前节点的路径长度。
-高度:从当前节点到最远叶节点的路径长度。
2.二叉树的分类:-严格二叉树:每个节点要么没有子节点,要么有两个子节点。
-完全二叉树:除了最后一层外,其他层的节点数都达到最大,并且最后一层的节点依次从左到右排列。
-满二叉树:每个节点要么没有子节点,要么有两个子节点,并且所有叶节点都在同一层上。
-平衡二叉树:任意节点的两棵子树的高度差不超过13.二叉树的遍历:-前序遍历:根节点->左子树->右子树。
递归实现时,先访问当前节点,然后递归遍历左子树和右子树。
-中序遍历:左子树->根节点->右子树。
递归实现时,先递归遍历左子树,然后访问当前节点,最后递归遍历右子树。
-后序遍历:左子树->右子树->根节点。
递归实现时,先递归遍历左子树,然后递归遍历右子树,最后访问当前节点。
-层序遍历:从上到下,从左到右依次访问每个节点。
使用队列实现。
4.二叉查找树(BST):-二叉查找树是一种有序的二叉树,对于树中的每个节点,其左子树的节点的值都小于当前节点的值,右子树的节点的值都大于当前节点的值。
-插入操作:从根节点开始,递归地比较要插入的值和当前节点的值,根据比较结果向左或向右移动,直到找到插入位置为止。
-查找操作:从根节点开始,递归地比较要查找的值和当前节点的值,根据比较结果向左或向右移动,直到找到目标节点或到叶节点。
-删除操作:有三种情况:-被删除节点是叶节点:直接将其删除。
数据结构课程设计 哈夫曼树
数据结构课程设计哈夫曼树数据结构课程设计 - 哈夫曼树一、引言哈夫曼树(Huffman Tree)是一种经典的数据结构,常被用于数据压缩和编码中。
它是一种特殊的二叉树,具有最优的前缀编码性质。
本文将详细介绍哈夫曼树的定义、构建方法以及应用场景。
二、哈夫曼树的定义哈夫曼树是一种满足以下条件的二叉树:1. 所有的叶子节点都带有权值;2. 没有度为1的节点;3. 任意两个叶子节点的路径长度不相同。
三、哈夫曼树的构建方法1. 构建哈夫曼树的基本思想是将权值较小的节点放在较低的层次,权值较大的节点放在较高的层次;2. 首先,根据给定的权值集合,将每一个权值看做一个独立的节点;3. 然后,选择两个权值最小的节点,将它们合并为一个新节点,并将新节点的权值设置为这两个节点的权值之和;4. 重复上述步骤,直到只剩下一个节点,即为哈夫曼树的根节点。
四、哈夫曼编码哈夫曼编码是一种变长编码方式,用于将字符转换为二进制编码。
它的特点是没有编码冗余,即每一个字符的编码都不是其他字符编码的前缀。
这种编码方式可以大幅度减小数据的存储空间和传输带宽。
五、哈夫曼树的应用场景1. 数据压缩:哈夫曼树可以根据字符浮现的频率构建最优的编码方式,从而实现数据的高效压缩;2. 文件压缩:将文件中的字符转换为哈夫曼编码,可以大幅度减小文件的大小;3. 图象压缩:将图象中的像素值转换为哈夫曼编码,可以实现图象的无损压缩;4. 视频压缩:将视频中的帧数据转换为哈夫曼编码,可以减小视频文件的大小。
六、哈夫曼树的时间复杂度和空间复杂度1. 构建哈夫曼树的时间复杂度为O(nlogn),其中n为权值的个数;2. 哈夫曼编码的时间复杂度为O(n),其中n为字符的个数;3. 哈夫曼树的空间复杂度为O(n),其中n为权值的个数。
七、总结哈夫曼树是一种重要的数据结构,具有广泛的应用场景。
通过构建最优的编码方式,可以实现高效的数据压缩和编码。
掌握哈夫曼树的定义、构建方法以及应用场景,对于数据结构课程的学习和实践具有重要意义。
二叉树遍历及应用课程设计
内蒙古科技大学本科生课程设计论文题目:数据结构课程设计——二叉树遍历及应用学生姓名:学号:专业:计算机科学与技术班级:指导教师:兰孝文2020年 1 月 3 日内蒙古科技大学课程设计任务书课程名称数据结构课程设计设计题目二叉树的遍历和应用指导教师兰孝文时间2019.12.30——2020.1.3一、教学要求1. 掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力2. 初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能3. 提高综合运用所学的理论知识和方法独立分析和解决问题的能力4. 训练用系统的观点和软件开发一般规范进行软件开发,培养软件工作者所应具备的科学的工作方法和作风二、设计资料及参数每个学生在教师提供的课程设计题目中任意选择一题,独立完成,题目选定后不可更换。
二叉树的遍历和应用以二叉链表表示二叉树,在此基础上实现对二叉树的遍历和应用。
要求设计类(或类模板)来描述二叉树,包含必要的构造函数和析构函数,以及其他能够完成如下功能的成员函数:❖创建二叉树❖输出二叉树❖二叉树的先序、中序、后序遍历❖二叉树的按层遍历❖统计二叉树的叶子结点、计算二叉树的深度并设计主函数测试该类(或类模板)。
三、设计要求及成果1. 分析课程设计题目的要求2. 写出详细设计说明3. 编写程序代码,调试程序使其能正确运行4. 设计完成的软件要便于操作和使用5. 设计完成后提交课程设计报告四、进度安排资料查阅与讨论(1天)系统分析(1天)系统的开发与测试(2天)编写课程设计说明书和验收(1天)五、评分标准1. 根据平时上机考勤、表现和进度,教师将每天点名和检查2. 根据课程设计完成情况,必须有可运行的软件。
3. 根据课程设计报告的质量,如有雷同,则所有雷同的所有人均判为不及格。
4. 根据答辩的情况,应能够以清晰的思路和准确、简练的语言叙述自己的设计和回答教师的提问六、建议参考资料1.《数据结构(C语言版)》严蔚敏、吴伟民主编清华大学出版社20132.《数据结构课程设计案例精编(用C/C++描述)》,李建学等编著,清华大学出版社 2010 3.《数据结构:用面向对象方法与C++语言描述》,殷人昆主编,清华大学出版社 2012目录1. 功能设计 (1)(1)创建二叉树 (1)(2)先序递归遍历 (1)(3)中序递归遍历 (1)(4)后序递归遍历 (1)2. 算法流程图 (2)(1)创建二叉树 (2)(2)先序递归遍历 (3)(3)中序递归遍历 (4)(4)后序递归遍历 (5)3.问题描述 (6)4. 详细设计 (7)(1)设计思想 (7)(2)设计表示 (7)(3)函数接口说明: (8)(4)函数调用关系如图所示: (8)(5)实现注释 (9)5. 运行结果截图 (10)6. 总结 (12)附录 (13)1.功能设计(1)创建二叉树利用二叉树模板类,创建二叉树时产生类模板,调用类的构造函数来创建,修改二叉树的结构时,可以调用赋值语句直接把广义表转换成二叉树。
数据结构课程设计_二叉树操作
数据结构课程设计_⼆叉树操作数据结构课程设计题⽬:⼆叉树的操作学⽣姓名:学号:系部名称:计算机科学与技术系专业班级:指导教师:课程设计任务书第⼀章程序要求1)完成⼆叉树的基本操作。
2)建⽴以⼆叉链表为存储结构的⼆叉树;3)实现⼆叉树的先序、中序和后序遍历;4)求⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。
第⼆章算法分析建⽴以⼆叉链表为存储结构的⼆叉树,在次⼆叉树上进⾏操作;1先序遍历⼆叉树的操作定义为:若⼆叉树唯恐则为空操作;否则(1)访问根节点;(2)先序遍历做字数和;(3)先序遍历有⼦树;2中序遍历⼆叉树的操作定义为:若⼆叉树为空,则空操作;否则(1)中序遍历做⼦树;(2)访问根节点;(3)中序遍历有⼦树;3后续遍历⼆叉树的操作定义为:若⼆叉树为空则为空操作;否则(1)后序遍历左⼦树;(2)后序遍历右⼦树;(3)访问根节点;⼆叉树的结点总数、叶⼦结点个数及⼆叉树的深度。
第三章⼆叉树的基本操作和算法实现⼆叉树是⼀种重要的⾮线性数据结构,是另⼀种树形结构,它的特点是每个节点之多有两棵⼦树(即⼆叉树中不存在度⼤于2的结点),并且⼆叉树的结点有左右之分,其次序不能随便颠倒。
1.1⼆叉树创建⼆叉树的很多操作都是基于遍历实现的。
⼆叉树的遍历是采⽤某种策略使得采⽤树形结构组织的若⼲年借点对应于⼀个线性序列。
⼆叉树的遍历策略有四种:先序遍历中续遍历后续遍历和层次遍历。
基本要求1 从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。
2 输出⼆叉树。
3 对⼆叉树进⾏遍历(先序,中序,后序和层次遍历)4 将⼆叉树的遍历打印出来。
⼀.问题描述⼆叉树的很多操作都是基于遍历实现的。
⼆叉树的遍历是采⽤某种策略使得采⽤树型结构组织的若⼲结点对应于⼀个线性序列。
⼆叉树的遍历策略有四种:先序遍历、中序遍历、后序遍历和层次遍历。
⼆.基本要求1.从键盘接受输⼊数据(先序),以⼆叉链表作为存储结构,建⽴⼆叉树。
2.输出⼆叉树。
数据结构二叉树遍历说课
5 教学方法分析
教法
1、讲授法 2、讲解演示法 3、讨论法
学法
1、边学边练 2、举一反三,自主学习法
6 教学过程分析1 导入Fra bibliotek2 讲授
3 练习
4 拓展
方案: • 旧知识回顾 • 提出如何遍历
二叉树的问题
意义: 采用任务驱动 法,激发学生 的学习兴趣, 为新课的学习 埋下伏笔。
方案:
方案:
• 分散重难点,分 层次教学,逐步
授课对象:大一下学期的学生。 学生特点:具备独立思考能力,对新事物接受
能力较强。
能力状态:处于数据结构的起步学习阶段,无
明显的层次及优劣的区别。
授课 策略
适当调整课堂节奏 保证整体学生的学习效果
3 教学目标
知识目标
理解并掌握二叉 树的三种遍历方 法,能够准确的 对二叉树进行三 种遍历,并能够 根据给出的两种 遍历序列还原一 棵二叉树。
1. 教材分析 2. 学情分析 3. 教学目标 4. 教学重难点 5. 教学方法分析 6. 教学过程分析
1 教材分析
数据结构(C语言版)
清华大学出版社出版,严蔚敏和吴伟民主编。 第六章第三节内容“遍历二叉树”。 重点介绍了二叉树的遍历算法,
是基础的数据结构课程。
本节课起着承上启下的作用。
2 学情分析
递进。
• 进行典型例题 的操作
• 学会一种遍历后, 找学生讲解,教
师配合演示,导 出后两种方法。 意义:
意义:
强化对遍历二
使学生充分体验
研究性学习过程, 培养学生研究思 维与能力。
叉树遍历的三
种方法的运用 和操作。
方案:
• 分组讨论: 给出先序、中 序序列,还原 一棵二叉树。
数据结构详细教案——树与二叉树
数据结构教案第六章树与二叉树目录6.1树的定义和基本术语 (1)6.2二叉树 (2)6.2.1 二叉树的定义 (2)6.2.2 二叉树的性质 (4)6.2.3 二叉树的存储结构 (5)6.3树和森林 (6)6.4二叉树的先|中|后序遍历算法 (7)6.5先|后|中序遍历的应用扩展 (9)6.5.1 基于先序遍历的二叉树(二叉链)的创建 (9)6.5.2 统计二叉树中叶子结点的数目 (9)6.5.3 求二叉树的高度 (10)6.5.4 释放二叉树的所有结点空间 (11)6.5.5 删除并释放二叉树中以元素值为x的结点作为根的各子树 (12)6.5.6 求位于二叉树先序序列中第k个位置的结点的值 (12)6.5.7 线索二叉树 (13)6.5.8 树和森林的遍历 (14)6.6二叉树的层次遍历 (16)6.7判断一棵二叉树是否为完全二叉树 (16)6.8哈夫曼树及其应用 (18)6.8.1 最优二叉树(哈夫曼树) (18)6.8.2 哈夫曼编码 (19)6.9遍历二叉树的非递归算法 (19)6.9.1 先序非递归算法 (19)6.9.2 中序非递归算法 (20)6.9.3 后序非递归算法 (21)第6章二叉树和树6.1 树的定义和基本术语1、树的递归定义1)结点数n=0时,是空树2)结点数n>0时有且仅有一个根结点、m个互不相交的有限结点集——m棵子树2、基本术语结点:叶子(终端结点)、根、内部结点(非终端结点、分支结点);树的规模:结点的度、树的度、结点的层次、树的高度(深度)结点间的关系:双亲(1)—孩子(m),祖先—子孙,兄弟,堂兄弟兄弟间是否存在次序:无序树、有序树去掉根结点非空树森林引入一个根结点3、树的抽象数据类型定义树特有的操作:查找:双亲、最左的孩子、右兄弟结点的度不定,给出这两种操作可以查找到一个结点的全部孩子插入、删除:孩子遍历:存在一对多的关系,给出一种有规律的方法遍历(有且仅访问一次)树中的结点ADT Tree{数据对象:D={a i | a i∈ElemSet, i=1,2,…,n, n≥0}数据关系:若D为空集,则称为空树;若D仅含一个数据元素,则R为空集,否则R={H},H是如下二元关系:(1) 在D中存在唯一的称为根的数据元素root,它在关系H下无前驱;(2) 若D-{root}≠Ф,则存在D-{root}的一个划分D1, D2, …, D m (m>0)(D i 表示构成第i棵子树的结点集),对任意j≠k (1≤j, k≤m) 有D j∩D k=Ф,且对任意的i (1≤i≤m),唯一存在数据元素x i∈D i, 有<root,x i>∈H(H表示结点之间的父子关系);(3) 对应于D-{root}的划分,H-{<root, x1>,…, <root, x m>}有唯一的一个划分H1, H2, …, H m(m>0)(H i表示第i棵子树中的父子关系),对任意j≠k(1≤j,k≤m)有H j∩H k=Ф,且对任意i(1≤i≤m),H i是D i上的二元关系,(D i, {H i})是一棵符合本定义的树,称为根root的子树。
数据结构-二叉树(2)链表法和广义表法表示二叉树
数据结构-⼆叉树(2)链表法和⼴义表法表⽰⼆叉树数组表⽰法⽤于完全⼆叉树的存储表⽰⾮常有效,但表⽰⼀般⼆叉树,尤其是形态剧烈变化的⼆叉树,存储空间的利⽤很不理想使⽤⼆叉链表表⽰⼆叉树:#include <iostream>using namespace std;template <class T>struct BinTreeNode{T data;BinTreeNode<T> *leftChild,*rightChild;BinTreeNode():leftChild(NULL),rightChild(NULL){}BinTreeNode(T x,BinTreeNode<T> *l=NULL,BinTreeNode<T> *r=NULL):data(x),leftChild(l),rightChild(r){};};template <class T>class BinaryTree{public:BinaryTree():root(NULL){}BinaryTree(T value):RefValue(value),root(NULL){}BinaryTree(const BinaryTree<T>& s){root=Copy(s.root);} //复制构造函数~BinaryTree(){destroy(root);}bool IsEmpty(){return(root==NULL);}BinTreeNode<T> *Parent(BinTreeNode<T> *current){ //返回⽗结点return(root==NULL||root==current)?NULL:Parent(root,current);}BinTreeNode<T> *LeftChild(BinTreeNode<T> *current){ //返回左⼦⼥return(current!=NULL)?current->leftChild:NULL;}BinTreeNode<T> *RightChild(BinTreeNode<T> *current){ //返回右⼦⼥return(current!=NULL)?current->rightChild:NULL;}int Height(){return Height(root);} //返回树⾼度int Size(){return Size(root);} //返回结点数BinTreeNode<T> *getRoot()const{return root;} //取根void preOrder(void (*visit)(BinTreeNode<T> *p)){preOrder(root,visit);} //对根结点前序遍历void InOrder(void (*visit)(BinTreeNode<T> *p)){InOrder(root,visit);} //对根结点中序遍历void postOrder(void (*visit)(BinTreeNode<T> *p)){postOrder(root,visit);} //对根结点后序遍历void levelOrder(void (*visit)(BinTreeNode<T> *p)); //层次序遍历int Insert(const T& item); //插⼊新元素BinTreeNode<T> *Find(T& item)const; //搜索protected:BinTreeNode<T> *root; //⼆叉树根指针T RefValue; //数据输⼊停⽌标志,⽤⼴义表表⽰⼆叉树的时候⽤void CreateBinTree(istream& in,BinTreeNode<T> *subTree); //从⽂件读⼊建树bool Insert(BinTreeNode<T> *subTree,const T&x); //插⼊void destroy(BinTreeNode<T> *subTree); //删除BinTreeNode<T> *Copy(BinTreeNode<T> *orignode); //复制int Height(BinTreeNode<T> *subTree)const; //返回树⾼度int Size(BinTreeNode<T> *subTree)const; //返回结点数BinTreeNode<T> *Parent(BinTreeNode<T> *subTree,BinTreeNode<T> *current); //从结点subTree开始搜索结点current的⽗结点 BinTreeNode<T> *Find(BinTreeNode<T> *subTree,const T& x)const; //搜寻值为x的结点void Traverse(BinTreeNode<T> *subTree,ostream& out); //前序遍历输出void preOrder(BinTreeNode<T>* subTree,void (*visit)(BinTreeNode<T> *p)); //对p结点前序遍历void InOrder(BinTreeNode<T>* subTree,void (*visit)(BinTreeNode<T> *p)); //中序遍历void postOrder(BinTreeNode<T>* subTree,void (*visit)(BinTreeNode<T> *p)); //后序遍历friend istream& operator>>(istream& in,BinaryTree<T>& Tree);friend ostream& operator<<(ostream& out,BinaryTree<T>& Tree);friend bool operator==(const BinaryTree<T>& s,const BinaryTree<T>& t);bool equal(BinTreeNode<T> *a,BinTreeNode<T> *b)const;};template <class T>void BinaryTree<T>::destroy(BinTreeNode<T> *subTree){//私有函数,若指针subTree不为空,则删除根为subTree的⼦树if(subTree!=NULL){destroy(subTree->leftChild);destroy(subTree->rightChild);delete subTree;}}template <class T>BinTreeNode<T> *BinaryTree<T>::Parent(BinTreeNode<T> *subTree,BinTreeNode<T> *current){//私有函数,从结点subTree开始搜索结点current的⽗结点,返回⽗结点地址或者NULLif(subTree==NULL) return NULL;if(subTree->leftChild==current || subTree->rightChild==current) return subTree;BinTreeNode<T> *p;if((p=Parent(subTree->leftChild,current))!=NULL) return p; //使⽤p=Parent(subTree->leftChild,current)递归在左⼦树中搜索,p==NULL则说明搜索失败else return Parent(subTree->rightChild,current);}template <class T>void BinaryTree<T>::Traverse(BinTreeNode<T> *subTree,ostream& out){//私有函数,搜索并前序输出根为subTree的⼆叉树if(subTree!=NULL){out<<subTree->data<<'';Traverse(subTree->leftChild,out); //递归搜索并输出subTree的左⼦树Traverse(subTree->rightChild,out); //递归搜索并输出subTree的右⼦树}}template <class T>istream& operator>>(istream& in,BinaryTree<T>& Tree){//重载操作,输⼊并建⽴⼀颗⼆叉树Tree,in是输⼊流对象Tree.CreateBinTree(in,Tree.root); //此处友元函数不能直接访问类的成员函数return in;}template <class T>ostream& operator<<(ostream& out,BinaryTree<T>& Tree){//重载操作,输出⼀颗⼆叉树Tree,out是输出流对象out<<"⼆叉树的前序遍历\n";Tree.Traverse(Tree.root,out); //从根开始输出out<<endl;return out;}template <class T>bool operator==(const BinaryTree<T>& s,const BinaryTree<T>& t){//判断两棵⼆叉树的等价性,它需要是BinaryTree类的友元函数return s.equal(s.root,t.root); //此处s是const对象,equal应该是const⽅法}template <class T>void BinaryTree<T>::preOrder(BinTreeNode<T> *subTree, void (*visit)(BinTreeNode<T> *)) {if(subTree!=NULL){visit(subTree);preOrder(subTree->leftChild,visit);preOrder(subTree->rightChild,visit);}}template <class T>void BinaryTree<T>::InOrder(BinTreeNode<T> *subTree, void (*visit)(BinTreeNode<T> *)) {//递归函数,此算法按照中序次序遍历以subTree为根的⼦树if(subTree!=NULL){InOrder(subTree->leftChild,visit);visit(subTree);InOrder(subTree->rightChild,visit);}}template <class T>void BinaryTree<T>::postOrder(BinTreeNode<T> *subTree, void (*visit)(BinTreeNode<T> *)) {if(subTree!=NULL){postOrder(subTree->leftChild,visit);postOrder(subTree->rightChild,visit);visit(subTree);}}template <class T>int BinaryTree<T>::Size(BinTreeNode<T> *subTree)const{//私有函数,介绍以subTree为根的⼆叉树的结点个数if(subTree==NULL) return0;else return1+Size(subTree->leftChild)+Size(subTree->rightChild);}template <class T>int BinaryTree<T>::Height(BinTreeNode<T> *subTree)const{//私有函数,计算以subTree为根的⼆叉树的深度if(subTree==NULL) return0;else{int i=Height(subTree->leftChild);int j=Height(subTree->rightChild);return(i<j)?j+1:i+1;}}template <class T>BinTreeNode<T> *BinaryTree<T>::Copy(BinTreeNode<T> *orignode){//私有函数,这个函数返回⼀个指针,给出⼀个以orignode为根的⼆叉树的副本if(orignode==NULL) return NULL;BinTreeNode<T> *temp=new BinTreeNode<T>;temp->data=orignode->data;temp->leftChild=Copy(orignode->leftChild); //此处注意不能直接=,因为需要建⽴新结点再赋值temp->rightChild=Copy(orignode->rightChild);return temp;}template <class T>bool BinaryTree<T>::equal(BinTreeNode<T> *a,BinTreeNode<T> *b)const{//如果a和b的⼦树不同,则函数返回false,否则函数返回true,它需要是BinTreeNode类的友元函数if(a==NULL && b==NULL) return true;if(a!=NULL && b!=NULL && a->data==b->data && equal(a->leftChild,b->leftChild) && equal(a->rightChild,b->rightChild)) return true;else return false;}template <class T>void BinaryTree<T>::CreateBinTree(istream& in,BinTreeNode<T> *subTree){//私有函数,以前序遍历⽅式递归建⽴⼆叉树T item;if(!in.eof()){ //读不到输⼊流时in.eof()为真in>>item;subTree=new BinTreeNode<T>(item);if(subTree==NULL){cerr<<"分配存储错误!"<<endl;exit(1);}CreateBinTree(in,subTree->leftChild);CreateBinTree(in,subTree->rightChild);}else subTree=NULL;}⼆叉链表找到⽗结点很困难,可以使⽤三叉链表输⼊输出⼆叉树时,可以输⼊⼀个⼴义表形式的⼆叉树,此时需要⽤栈保存字符。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二叉树的创建、遍历、深度、结点及叶子结点的个数
一、实验目的
1、理解数据结构中二叉树的定义和建立。
2、掌握二叉树的C语言描述。
3、熟练掌握单链表的创建、先序、中序及后序遍历和求深度、结点数、叶子结点数算法
的设计与C语言实现。
4、将理论与实际相结合,切实提高自己的逻辑能力和动手能力。
二、设计内容
在C语言的环境下,创建一个二叉树,由二叉树的递归定义可知,二叉树是由3个基本单元组成:根结点,左子树,右子树。
若能遍历这三部分,便是遍历了整个二叉树。
首先,定义一个结构体,左,右孩子指针,同时分为先序遍历,中序遍历,后序遍历,程序的基本算法思想:
先序遍历二叉树,若二叉树为空,则空操作;否则
(1)访问根结点;
(2)先序遍历左子树;
(3)先序遍历右子树。
中序遍历二叉树,若二叉树为空,则空操作;否则
(1)中序遍历左子树;
(2)访问根结点;
(3)中序遍历右子树。
后序遍历二叉树,若二叉树为空,则空操作;否则
(1)后序遍历左子树;
(2)后序遍历右子树;
(3)访问根结点。
叶子数的求法则是需要根据用层次遍历的算法,来算出每一层的叶子数,从而统计出整棵树的叶子数。
三、概要设计
抽象数据类型二叉树的定义如下:
ADT BinaryTree{
数据对象D:D是具有相同特性的数据元素的集合。
数据关系R:
若D=Φ,则R=Φ,称BinaryTree为空二叉树;
若D≠Φ,则R={H},H是如下二元关系;
(1)在D中存在惟一的称为根的数据元素root,它在关系H下无前驱;
(2)若D-{root}≠Φ,则存在D-{root}={D1,Dr},且D1∩Dr =Φ;
(3)若D1≠Φ,则D1中存在惟一的元素x1,<root,x1>∈H,且存在D1上的关系H1 ⊆H;若Dr≠Φ,则Dr中存在惟一的元素xr,<root,xr>∈H,且存在
上的关系Hr ⊆H;H={<root,x1>,<root,xr>,H1,Hr};
(4)(D1,{H1})是一棵符合本定义的二叉树,称为根的左子树;(Dr,{Hr})是一棵符合本定义的二叉树,称为根的右子树。
基本操作P:
InitBiTree(&T);
操作结果:构造空二叉树T。
Preorder(T) ;
初始条件:二叉树T存在。
操作结果:先序遍历T。
Inorder (T) ;
初始条件:二叉树T存在。
操作结果:中序遍历T。
Postorder (T) ;
初始条件:二叉树T存在。
操作结果:后序遍历T。
TreeDepth(T);
初始条件:二叉树T存在。
操作结果:返回T的深度。
}ADT BinaryTree
四、算法流程图
五、算法源代码
#include"stdio.h"
#include"string.h"
#include"malloc.h"
#define Max 20 //结点的最大个数
typedef struct node{
char data;
struct node *lchild,*rchild;
}BinTNode; //自定义二叉树的结点类型
typedef BinTNode *BinTree; //定义二叉树的指针
int NodeNum,leaf; //NodeNum为结点数,leaf为叶子数
//基于先序遍历算法创建二叉树
//要求输入先序序列,其中加入虚结点“#”以示空指针的位置BinTree CreatBinTree(void)
{
BinTree T;
char ch;
if((ch=getchar())=='#')
return(NULL); //读入#,返回空指针
else{
T=(BinTNode *)malloc(sizeof(BinTNode));//生成结点
T->data=ch;
T->lchild=CreatBinTree(); //构造左子树
T->rchild=CreatBinTree(); //构造右子树
return(T);
}
}
//DLR 先序遍历
void Preorder(BinTree T)
{
if(T) {
printf("%c",T->data); //访问结点
Preorder(T->lchild); //先序遍历左子树
Preorder(T->rchild); //先序遍历右子树
}
}
//LDR 中序遍历
void Inorder(BinTree T)
{
if(T) {
Inorder(T->lchild); //中序遍历左子树
printf("%c",T->data); //访问结点
Inorder(T->rchild); //中序遍历右子树
}
}
//LRD 后序遍历
void Postorder(BinTree T)
{
if(T) {
Postorder(T->lchild); //后序遍历左子树
Postorder(T->rchild); //后序遍历右子树
printf("%c",T->data); //访问结点
}
}
//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法int TreeDepth(BinTree T)
{
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr? hl:hr; //取左右深度的最大值
NodeNum=NodeNum+1; //求结点
if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0,即为叶子。
return(max+1);
}
else return(0);
}
//主函数
main()
{
BinTree root;
int i,depth;
printf("\n");
printf("请输入一个二叉树(用#代表虚结点):"); //输入完全二叉树的先序序列,// 用#代表虚结点,如ABD###CE##F##
root=CreatBinTree(); //创建二叉树,返回根结点
do { //从菜单中选择遍历方式,输入序号。
printf("\t********** 请选择************\n");
printf("\t1: 先序遍历\n");
printf("\t2: 中序遍历\n");
printf("\t3: 后序遍历\n");
printf("\t4: 深度、结点数、叶子结点数\n");
printf("\t0: Exit\n");
printf("\t*******************************\n");
scanf("%d",&i); //输入菜单序号(0-4)
switch (i){
case 1: printf("先序遍历为: ");
Preorder(root); //先序遍历
break;
case 2: printf("中序遍历为: ");
Inorder(root); //中序遍历
break;
case 3: printf("后序遍历为: ");
Postorder(root); //后序遍历
break;
case 4: depth=TreeDepth(root); //求树的深度及叶子数
printf("二叉树深度=%d\n",depth);
printf("结点个数=%d\n",NodeNum);
printf("叶子结点个数=%d\n",leaf);
break;
default: exit (1);
}
printf("\n");
} while(i!=0);
}
六、实验运行结果
七、心得体会
通过编写这个比较基础的二叉树的建立和遍历的实现的程序,基本掌握了以前学习的一些C语言的知识。
很多知识点都是通过二次看书才理解了,现在可以编写一些简单的C语言程序。
借这个设计时间又掌握了一些C语言编程的用法,对以后编写大一点的程序有很大的帮助。
编写的时候虽然刚开始有些困难,但通过看书.询问同学和借由网络,都一点一点的解决了。
虽然编程有点枯燥,但是通过不断努力编写出来后心里还是非常兴奋的。
就像学习英语,一步一步的积累。
在以后的学习中,希望通过不断的编
写争取写出一些功能较为庞大的程序。