二叉排序树与平衡二叉排序树基本操作的实现

合集下载

数据结构中平衡二叉树的教学探讨与研究

数据结构中平衡二叉树的教学探讨与研究

数据结构中平衡二叉树的教学探讨与研究作者:朱洪浩来源:《赤峰学院学报·自然科学版》 2012年第5期朱洪浩(蚌埠学院计算机科学与技术系,安徽蚌埠 233000)摘要:平衡二叉树是对二叉排序树的一种改进,又被称为AVL树,平衡二叉树的结构较好,可以提高查找运算的速度.本文分析了权威教材和相关论文中平衡二叉树的调整方法,这些方法学生普遍反映理解和掌握较困难.据此,本文依据平衡因子和二叉排序树的特性,设计出一种基于平衡因子和二叉排序树的平衡二叉树的调整方法,该方法易于理解和掌握.关键词:二叉排序树;平衡因子;平衡二叉树中图分类号:TP311.12 文献标识码:A 文章编号:1673-260X(2012)03-0019-031 引言数据结构课程是计算机及相关专业的核心课程,是程序设计的重要理论技术基础[1].在动态查找表中,平衡二叉树被广泛的应用,平衡二叉树又称AVL树,它是由Adel,son-Vel,skii和Landis两位数学家于1962年提出并用他们的名字来命名的.平衡二叉树或者是一棵空树,或者是满足下列条件的二叉排序树:二叉排序树的所有结点的平衡因子为-1、0和1.所谓平衡因子BF(Balance Factor)可定义为某结点左子树的深度减去右子树的深度[2].若二叉树中任一个结点的平衡因子的绝对值大于1,则该二叉树就不是平衡二叉树.平衡二叉树在插入结点和删除结点时候,会使其变得不平衡.为此,需要对二叉排序树进行调整,使之重新变为平衡二叉树.相关教材和论文中关于平衡二叉树的调整方法较难理解,学生难以接受.笔者通过阅读大量的相关资料,并且总结教学经验,提出了一种易于理解和实用的二叉排序树转换成平衡二叉树方法.2 平衡二叉树调整方法的文献综述由于平衡二叉树的重要性,以及学生在学习平衡二叉树调整的过程中,普遍反映对用于平衡二叉树调整的四种方法较难理解,算法复杂.为此,许多学者对平衡二叉树的调整进行了大量的研究.严蔚敏、吴伟民[1]在《数据结构》(C语言版)一书中二叉排序树调整为平衡二叉树采用左旋转(LL)、右旋转(LR)、先左旋转后右旋转(LR)、先右旋转后左旋转(RL)四种旋转方法.李春葆[2]在《数据结构教程》(第2版)一书中也是采用了LL、LR、RR、RL四种旋转方法.朱宇、张红彬[3]在《平衡二叉树的选择调整算法》一文中,提出利用“中为根、小为左、大为右”的调整策略,但本质上仍然是利用旋转的思想.胡云[4]在《快速构建AVL树》一文中采用“将二叉排序树中的数据进行排序,将中点数据作为根,大于中点的数据构成右子树,小于中点的数据构成左子树,然后采用同样的方法分别对左子树和右子树进行调整.”但从作者举出的实例可以看出,该方法与传统方法得到的平衡二叉树并不一致.杜薇薇[5]等在《基于平衡因子的AVL树设计实现》一文中则从平衡因子出发,并用数学公式进行了验证了插入和删除操作.刘绍翰[6]等在《一种简化的AVL树的实现方法》一文提出了高度平衡树(HAVL)它是一种新的AVL树的数学描述.以上文献中虽然提出了较好的调整方法,但在平衡二叉树的调整基本上仍然是采用旋转的方法进行调整,并没有从根本上解决学生的困惑.笔者在教学中发现学生对二叉排序树的建立普遍能熟练掌握,并且平衡二叉树的前提必须是一棵二叉排序树,为此,本文提出了一种利用平衡因子和构建二叉排序树的方法来实现平衡二叉树的调整,从而解决了学生的困惑.3 平衡二叉树的调整方法根据平衡二叉树的定义可知,插入和删除结点造成平衡二叉树不平衡的原因是产生2或者-2的平衡因子,其实,调整的方法只需将以平衡因子为2或者-2为根结点的子二叉排序树重新找一个根结点建立新的子二叉排序树.从而使二叉排序树中的平衡因子都为-1、0或者1,即调整成为平衡二叉树.问题的关键是如何找根结点,即序列中的第一个结点,具体方法如下文所示规则.3.1 插入结点的调整插入结点时,可以利用规则一、规则二进行:规则一某结点的平衡因子为2时,把以该结点为根的树采用中序遍历的方法进行遍历,即得到一个递增的子序列,同时看该结点的左孩子的平衡因子.(1)若左孩子的平衡因子为-1时,则取该左孩子的右孩子结点,并将其移动到序列的最前面,得到一个新的序列,对该序列构造二叉排序树.(2)若左孩子的平衡因子为1时,则取该左孩子结点,并将其移动到序列的最前面,得到一个新序列,对该序列构造二叉排序树.规则二某结点的平衡因子为-2时,把以该结点为根的树采用中序遍历的方法进行遍历,即得到一个递增的子序列,同时看该结点的右孩子的平衡因子.(1)若右孩子的平衡因子为-1时,则取该右孩子结点,并将其移动到序列的最前面,得到一个新的序列,对该序列构造二叉排序树.(2)若右孩子的平衡因子为1时,则取该右孩子的左孩子结点,并将其移动到序列的最前面,得到一个新序列,对该序列构造二叉排序树.3.2 删除结点的调整删除结点时,要确定删除的结点是否是叶子结点,具体方法见规则三.规则三(1)若删除的是叶子结点,直接删除,并且自底向下查看树中的平衡因子,若发现存在平衡因子为2时,采用规则一进行调整,若平衡因子为-2时,则采用规则二进行调整.(2)若不是叶子结点,首先按照二叉排序树非叶子结点的删除方法即用该结点左子树的最大值(或者右子树的最小值)代替该结点,然后在从二叉排序树中删去它的最大值(或者最小值),同样,自底向下查看树中的平衡因子,若发现存在平衡因子为2时,采用规则一进行调整,若平衡因子为-2时,则采用规则二进行调整.4 算法描述4.1 插入结点的算法平衡二叉树的插入实现算法步骤:(1)插入结点L(L总是作为新的叶子结点插入的),插入的方法同一般的二叉排序树插入结点一样.(2)沿着插入结点L的路线返回,逐层回溯.必要时修改L的祖先的平衡因子,发现平衡因子为2或-2时,则利用规则一、规则二找到结点R.(3)把该二叉排序树进行中序遍历,得到一递增序列,并把结点R移动到该序列的最前面,然后对新形成的序列构造二叉排序树.同时检查树中其它结点,若发现平衡因子为2或-2的结点,进行调整.重复(2)(3)直到所有的结点都保持平衡为止.(4)回到(1),继续插入新的结点,直到所有的结点都插入完为止.实例1:输入关键字序列{16,3,7,11,9,26,18, 14,15},构造一棵平衡二叉树[2].4.2 删除结点的算法平衡二叉树的删除实现算法步骤:(1)用二叉排序树的删除算法找到并删除结点L.(2)从被删除结点到根结点逐层向上回溯,必要时修改L的祖先结点的平衡因子,发现平衡因子为2或-2时,则利用规则一、规则二找到结点R.(3)把该二叉排序树进行中序遍历,得到一递增序列,并把结点R移动到该序列的最前面,然后对新形成的序列构造二叉排序树.(4)如果调整之后,子树的总高度比调整前降低了,仍然要继续回溯,直到所有结点平衡因子都为-1、0、1时,即都保持平衡为止.实例2:对实例1生成的AVL树,给出删除结点11,9,14的步骤[2].5 结束语平衡二叉树的调整是数据结构教学中的重点和难点,学生在学习的过程中对该部分内容难以理解和接受,为了打破这种局面,作者通过阅读大量的资料,总结了此方法,该方法“只需找到新的根结点,重新构造成二叉排序树”即可,通过教学实践发现,本文采用的方法容易被学生理解和掌握,在教学中得到了良好的效果,得到学生的认可.参考文献:〔1〕严蔚敏,吴伟民.数据结构(C语言版)[M].北京:清华大学出版社,2007.〔2〕李春葆.数据结构教程(第2版).北京:清华大学出版社,2007.〔3〕朱宇,张红彬.平衡二叉树的选择调整算法[J].中国科学院研究生院学报,2006,23(4):527-533.〔4〕胡云.快速构建AVL树[J].安阳师范学院学报,2007(6):61-63.〔5〕杜薇薇,张翼燕,瞿春柳.基于平衡因子的AVL树设计实现[J].计算机技术与发展,2010,20(3):24-27.〔6〕刘绍翰,高天行,黄志球.一种简化的AVL树的实现方法[J].三峡大学学报(自然科学版),2011,33(1):85-87.。

数据结构平衡二叉树的操作演示

数据结构平衡二叉树的操作演示

平衡二叉树操作的演示1.需求分析本程序是利用平衡二叉树,实现动态查找表的基本功能:创建表,查找、插入、删除。

具体功能:(1)初始,平衡二叉树为空树,操作界面给出创建、查找、插入、删除、合并、分裂六种操作供选择。

每种操作均提示输入关键字。

每次插入或删除一个结点后,更新平衡二叉树的显示。

(2)平衡二叉树的显示采用凹入表现形式。

(3)合并两棵平衡二叉树。

(4)把一棵二叉树分裂为两棵平衡二叉树,使得在一棵树中的所有关键字都小于或等于x,另一棵树中的任一关键字都大于x。

如下图:2.概要设计平衡二叉树是在构造二叉排序树的过程中,每当插入一个新结点时,首先检查是否因插入新结点而破坏了二叉排序树的平衡性,若是则找出其中的最小不平衡子树,在保持二叉排序树特性的前提下,调整最小不平衡子树中各结点之间的链接关系,进行相应的旋转,使之成为新的平衡子树。

具体步骤:(1)每当插入一个新结点,从该结点开始向上计算各结点的平衡因子,即计算该结点的祖先结点的平衡因子,若该结点的祖先结点的平衡因子的绝对值不超过1,则平衡二叉树没有失去平衡,继续插入结点;(2)若插入结点的某祖先结点的平衡因子的绝对值大于1,则找出其中最小不平衡子树的根结点;(3)判断新插入的结点与最小不平衡子树的根结点个关系,确定是那种类型的调整;(4)如果是LL型或RR型,只需应用扁担原理旋转一次,在旋转过程中,如果出现冲突,应用旋转优先原则调整冲突;如果是LR型或RL型,则需应用扁担原理旋转两次,第一次最小不平衡子树的根结点先不动,调整插入结点所在子树,第二次再调整最小不平衡子树,在旋转过程中,如果出现冲突,应用旋转优先原则调整冲突;(5)计算调整后的平衡二叉树中各结点的平衡因子,检验是否因为旋转而破坏其他结点的平衡因子,以及调整后平衡二叉树中是否存在平衡因子大于1的结点。

流程图3.详细设计二叉树类型定义:typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;struct BSTNode *lchild ,*rchild;} BSTNode,* BSTree;Status SearchBST(BSTree T,ElemType e)//查找void R_Rotate(BSTree &p)//右旋void L_Rotate(BSTree &p)//左旋void LeftBalance(BSTree &T)//插入平衡调整void RightBalance(BSTree &T)//插入平衡调整Status InsertAVL(BSTree &T,ElemType e,int &taller)//插入void DELeftBalance(BSTree &T)//删除平衡调整void DERightBalance(BSTree &T)//删除平衡调整Status Delete(BSTree &T,int &shorter)//删除操作Status DeleteAVL(BSTree &T,ElemType e,int &shorter)//删除操作void merge(BSTree &T1,BSTree &T2)//合并操作void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2)//分裂操作void PrintBSTree(BSTree &T,int lev)//凹入表显示附录源代码:#include<stdio.h>#include<stdlib.h>//#define TRUE 1//#define FALSE 0//#define OK 1//#define ERROR 0#define LH +1#define EH 0#define RH -1//二叉类型树的类型定义typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;//结点的平衡因子struct BSTNode *lchild ,*rchild;//左、右孩子指针} BSTNode,* BSTree;/*查找算法*/Status SearchBST(BSTree T,ElemType e){if(!T){return 0; //查找失败}else if(e == T->data ){return 1; //查找成功}else if (e < T->data){return SearchBST(T->lchild,e);}else{return SearchBST(T->rchild,e);}}//右旋void R_Rotate(BSTree &p){BSTree lc; //处理之前的左子树根结点lc = p->lchild; //lc指向的*p的左子树根结点p->lchild = lc->rchild; //lc的右子树挂接为*P的左子树lc->rchild = p;p = lc; //p指向新的根结点}//左旋void L_Rotate(BSTree &p){BSTree rc;rc = p->rchild; //rc指向的*p的右子树根结点p->rchild = rc->lchild; //rc的左子树挂接为*p的右子树rc->lchild = p;p = rc; //p指向新的根结点}//对以指针T所指结点为根结点的二叉树作左平衡旋转处理,//本算法结束时指针T指向新的根结点void LeftBalance(BSTree &T){BSTree lc,rd;lc=T->lchild;//lc指向*T的左子树根结点switch(lc->bf){ //检查*T的左子树的平衡度,并做相应的平衡处理case LH: //新结点插入在*T的左孩子的左子树,要做单右旋处理T->bf = lc->bf=EH;R_Rotate(T);break;case RH: //新结点插入在*T的左孩子的右子树上,做双旋处理rd=lc->rchild; //rd指向*T的左孩子的右子树根switch(rd->bf){ //修改*T及其左孩子的平衡因子case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild); //对*T的左子树作左旋平衡处理R_Rotate(T); //对*T作右旋平衡处理}}//右平衡旋转处理void RightBalance(BSTree &T){BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= rc->bf=EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}//插入结点Status InsertAVL(BSTree &T,ElemType e,int &taller){//taller反应T长高与否if(!T){//插入新结点,树长高,置taller为trueT= (BSTree) malloc (sizeof(BSTNode));T->data = e;T->lchild = T->rchild = NULL;T->bf = EH;taller = 1;}else{if(e == T->data){taller = 0;return 0;}if(e < T->data){if(!InsertAVL(T->lchild,e,taller))//未插入return 0;if(taller)//已插入到*T的左子树中且左子树长高switch(T->bf){//检查*T的平衡度,作相应的平衡处理case LH:LeftBalance(T);taller = 0;break;case EH:T->bf = LH;taller = 1;break;case RH:T->bf = EH;taller = 0;break;}}else{if (!InsertAVL(T->rchild,e,taller)){return 0;}if(taller)//插入到*T的右子树且右子树增高switch(T->bf){//检查*T的平衡度case LH:T->bf = EH;taller = 0;break;case EH:T->bf = RH;taller = 1;break;case RH:RightBalance(T);taller = 0;break;}}}return 1;}void DELeftBalance(BSTree &T){//删除平衡调整BSTree lc,rd;lc=T->lchild;switch(lc->bf){case LH:T->bf = EH;//lc->bf= EH;R_Rotate(T);break;case EH:T->bf = EH;lc->bf= EH;R_Rotate(T);break;case RH:rd=lc->rchild;switch(rd->bf){case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild);R_Rotate(T);}}void DERightBalance(BSTree &T) //删除平衡调整{BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case EH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}void SDelete(BSTree &T,BSTree &q,BSTree &s,int &shorter){if(s->rchild){SDelete(T,s,s->rchild,shorter);if(shorter)switch(s->bf){case EH:s->bf = LH;shorter = 0;break;case RH:s->bf = EH;shorter = 1;break;case LH:DELeftBalance(s);shorter = 0;break;}return;}T->data = s->data;if(q != T)q->rchild = s->lchild;elseq->lchild = s->lchild;shorter = 1;}//删除结点Status Delete(BSTree &T,int &shorter){ BSTree q;if(!T->rchild){q = T;T = T->lchild;free(q);shorter = 1;}else if(!T->lchild){q = T;T= T->rchild;free(q);shorter = 1;}else{SDelete(T,T,T->lchild,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}}return 1;}Status DeleteAVL(BSTree &T,ElemType e,int &shorter){ int sign = 0;if (!T){return sign;}else{if(e == T->data){sign = Delete(T,shorter);return sign;}else if(e < T->data){sign = DeleteAVL(T->lchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}return sign;}else{sign = DeleteAVL(T->rchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = LH;shorter = 0;break;case RH:T->bf = EH;break;case LH:DELeftBalance(T);shorter = 0;break;}return sign;}}}//合并void merge(BSTree &T1,BSTree &T2){int taller = 0;if(!T2)return;merge(T1,T2->lchild);InsertAVL(T1,T2->data,taller);merge(T1,T2->rchild);}//分裂void split(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ int taller = 0;if(!T)return;split(T->lchild,e,T1,T2);if(T->data > e)InsertAVL(T2,T->data,taller);elseInsertAVL(T1,T->data,taller);split(T->rchild,e,T1,T2);}//分裂void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ BSTree t1 = NULL,t2 = NULL;split(T,e,t1,t2);T1 = t1;T2 = t2;return;}//构建void CreatBSTree(BSTree &T){int num,i,e,taller = 0;printf("输入结点个数:");scanf("%d",&num);printf("请顺序输入结点值\n");for(i = 0 ;i < num;i++){printf("第%d个结点的值",i+1);scanf("%d",&e);InsertAVL(T,e,taller) ;}printf("构建成功,输入任意字符返回\n");getchar();getchar();}//凹入表形式显示方法void PrintBSTree(BSTree &T,int lev){int i;if(T->rchild)PrintBSTree(T->rchild,lev+1);for(i = 0;i < lev;i++)printf(" ");printf("%d\n",T->data);if(T->lchild)PrintBSTree(T->lchild,lev+1);void Start(BSTree &T1,BSTree &T2){int cho,taller,e,k;taller = 0;k = 0;while(1){system("cls");printf(" 平衡二叉树操作的演示 \n\n");printf("********************************\n");printf(" 平衡二叉树显示区 \n");printf("T1树\n");if(!T1 )printf("\n 当前为空树\n");else{PrintBSTree(T1,1);}printf("T2树\n");if(!T2 )printf("\n 当前为空树\n");elsePrintBSTree(T2,1);printf("\n********************************************************************* *********\n");printf("T1操作:1.创建 2.插入 3.查找 4.删除 10.分裂\n");printf("T2操作:5.创建 6.插入 7.查找 8.删除 11.分裂\n");printf(" 9.合并 T1,T2 0.退出\n");printf("*********************************************************************** *******\n");printf("输入你要进行的操作:");scanf("%d",&cho);switch(cho){case 1:CreatBSTree(T1);break;case 2:printf("请输入要插入关键字的值");scanf("%d",&e);InsertAVL(T1,e,taller) ;break;case 3:printf("请输入要查找关键字的值");scanf("%d",&e);if(SearchBST(T1,e))printf("查找成功!\n");elseprintf("查找失败!\n");printf("按任意键返回87"); getchar();getchar();break;case 4:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T1,e,k))printf("删除成功!\n");elseprintf("删除失败!\n");printf("按任意键返回");getchar();getchar();break;case 5:CreatBSTree(T2);break;case 6:printf("请输入要插入关键字的值"); scanf("%d",&e);InsertAVL(T2,e,taller) ;break;case 7:printf("请输入要查找关键字的值"); scanf("%d",&e);if(SearchBST(T2,e))printf("查找成功!\n");elseprintf("查找失败!\n");printf("按任意键返回");getchar();getchar();break;case 8:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T2,e,k))printf("删除成功!\n");elseprintf("删除失败!\n");printf("按任意键返回");getchar();getchar();break;case 9:merge(T1,T2);T2 = NULL;printf("合并成功,按任意键返回"); getchar();getchar();break;case 10:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T1,e,T1,T2) ;printf("分裂成功,按任意键返回"); getchar();getchar();break;case 11:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T2,e,T1,T2) ;printf("分裂成功,按任意键返回"); getchar();getchar();break;case 0:system("cls");exit(0);}}}main(){BSTree T1 = NULL;BSTree T2 = NULL;Start(T1,T2);}。

平衡二叉树和二叉排序树(二叉搜索树)区别

平衡二叉树和二叉排序树(二叉搜索树)区别

平衡⼆叉树和⼆叉排序树(⼆叉搜索树)区别
平衡⼆叉树是⼀种⼆叉搜索树。

其可以保证在log2(n)的时间内找到节点,⽽普通的⼆叉搜索树在最坏情况下性能近似与链
表,所⽤时间为log(n)。

常⽤的平衡⼆叉树有AVL树和红⿊树其算法的难点在于插⼊删除节点后树的旋转
平衡⼆叉树 ----> O(log2(n))
普通⼆叉搜索树 ----> O(n)
在⼆叉搜索树的插⼊和删除运算中,采⽤平衡树的优点是:使树的结构较好,从⽽提⾼查找运算的速度。

缺点是:是插⼊和删除运算变得复杂化,从⽽降低了他们的运算速度。

对⼆叉搜索树删除节点⽽引起的不平衡性进⾏的操作⽐插⼊节点的情况要复杂,在此就不再论述了。

操作系统的设计也有⽤到哦
很多数据库的实现是基于更复杂的平衡⼆叉树
可以⾃⼰实现⼀个集合或者map,统计单词出现的次数
stl的map/set都在⽤
普通⼆叉搜索树最坏情况是只有左边⼀个分⽀,如1-2-3-4-5(5在最上⾯,1在左下⾓),但是平衡⼆叉树可以调整。

为1-2-3-4-5(3在最上⾯,1在左下⾓,5在右下⾓)。

平衡⼆叉树 ----> O(log2(n))
普通⼆叉搜索树 ----> O(n)
所以平衡⼆叉树的搜索性能⽐⼆叉搜索树(⼆叉排序树)好。

二叉排序树

二叉排序树

②若*p结点只有左子树,或只有右子树,则可将*p的左子 树或右子树直接改为其双亲结点*f的左子树,即: f->1child=p->1child(或f->1child=p->rchild); free(p); *f
F *p P P1
*f
F
*f
F *p P
*f
F
Pr
P1
Pr
③若*p既有左子树,又有右子树。则:
-1 0
47
-1
47
47
0
31 69
69
25
0
47
0
25
0
47
-1 0
31
0
69
0
40
69
40
69
0
25 76
40
76
(a)
AL、BL、BR 都是空树
(b) AL、BL、BR 都是非空树
LR型调整操作示意图
2
A
-1
0
C
AR C BL CL CR AR
0 0
B BL CL S
B
A
CR
(a) 插入结点*s后失去平衡
31
0 0 -1
31
0 1
28
0
25
0 0
47
0
25
-1
47
0
25
0
31
0
16 0
28
16
28
0
16 30
30
47
(c) LR(R)型调整
RL型调整操作示意图
A B C A BR CR B BR
AL
C
AL
CL CR

平衡二叉树10.3.2

平衡二叉树10.3.2

11
28
96 98
25
(1) LL型调整 型调整 p A 1 2
调整方法: 调整方法: 单向右旋平衡,即将 的左孩子 单向右旋平衡,即将A的左孩子 B 向右上旋转代替 成为根结点, 向右上旋转代替A成为根结点 成为根结点, 结点向右下旋转成为B的右 将A结点向右下旋转成为 的右 结点向右下旋转成为 子树的根结点, 子树的根结点,而B的原右子树 的原右子树 则作为A结点的左子树 结点的左子树. 则作为 结点的左子树. h d e B
1 38 -1 24 88
0 -1 -2
0
11
28 1
96
0
-1 0
25
0
98
1,平衡二叉树插入结点的调整方法
若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性, 若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性, 首先从根结点到该新插入结点的路径之逆向根结点方向找第一个失去平 衡的结点, 衡的结点,然后以该失衡结点和它相邻的刚查找过的两个结点构成调整 子树(最小不平衡子树 即调整子树是指以离插入结点最近,且平衡因子 最小不平衡子树), 子树 最小不平衡子树 ,即调整子树是指以离插入结点最近 且平衡因子 绝对值大于1的结点为根结点的子树 使之成为新的平衡子树. 的结点为根结点的子树,使之成为新的平衡子树 绝对值大于 的结点为根结点的子树 使之成为新的平衡子树. 38 24 88 -2
(2)RR型调整 型调整 p A -1 -2
调整方法: 调整方法: 单向左旋平衡:即将 的右孩子 的右孩子B向 单向左旋平衡:即将A的右孩子 向 左上旋转代替A成为根结点 成为根结点, 左上旋转代替 成为根结点,将A结 结 点向左下旋转成为B的左子树的根 点向左下旋转成为 的左子树的根 结点, 的原左子树则作为A结点 结点,而B的原左子树则作为 结点 的原左子树则作为 的右子树. 的右子树. B

详解平衡二叉树

详解平衡二叉树

一、平衡二叉树的概念平衡二叉树(Balanced binary tree)是由阿德尔森-维尔斯和兰迪斯(Adelson-Velskii and Landis)于1962年首先提出的,所以又称为AVL树。

定义:平衡二叉树或为空树,或为如下性质的二叉排序树:(1)左右子树深度之差的绝对值不超过1;(2)左右子树仍然为平衡二叉树.平衡因子BF=左子树深度-右子树深度.平衡二叉树每个结点的平衡因子只能是1,0,-1。

若其绝对值超过1,则该二叉排序树就是不平衡的。

如图所示为平衡树和非平衡树示意图:二、平衡二叉树算法思想若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。

首先要找出插入新结点后失去平衡的最小子树根结点的指针。

然后再调整这个子树中有关结点之间的链接关系,使之成为新的平衡子树。

当失去平衡的最小子树被调整为平衡子树后,原有其他所有不平衡子树无需调整,整个二叉排序树就又成为一棵平衡二叉树。

失去平衡的最小子树是指以离插入结点最近,且平衡因子绝对值大于1的结点作为根的子树。

假设用A表示失去平衡的最小子树的根结点,则调整该子树的操作可归纳为下列四种情况。

1)LL型平衡旋转法由于在A的左孩子B的左子树上插入结点F,使A的平衡因子由1增至2而失去平衡。

故需进行一次顺时针旋转操作。

即将A的左孩子B向右上旋转代替A作为根结点,A向右下旋转成为B的右子树的根结点。

而原来B的右子树则变成A的左子树。

(2)RR型平衡旋转法由于在A的右孩子C 的右子树上插入结点F,使A的平衡因子由-1减至-2而失去平衡。

故需进行一次逆时针旋转操作。

即将A的右孩子C向左上旋转代替A作为根结点,A向左下旋转成为C的左子树的根结点。

而原来C的左子树则变成A的右子树。

(3)LR型平衡旋转法由于在A的左孩子B的右子数上插入结点F,使A的平衡因子由1增至2而失去平衡。

故需进行两次旋转操作(先逆时针,后顺时针)。

即先将A结点的左孩子B的右子树的根结点D向左上旋转提升到B结点的位置,然后再把该D结点向右上旋转提升到A结点的位置。

平衡二叉树

平衡二叉树
1 1 0 0 0 1 0 0 (a) 平衡二叉树 -1 -1 1
2 -1 0 0 0
-1
-2 0 0 1
0 0
1
(b) 不平衡二叉树 图9.6 平衡与不平衡二叉树及结点的平衡因子
平衡二叉树是二叉排序树的另一种形式. 平衡二叉树 我们希望由任何初始序列构成的二叉排序 树都是平衡二叉树 平衡二叉树.因为平衡二叉树 平衡二叉树上任 平衡二叉树 平衡二叉树 1 何结点的左右子树的深度之差都不超过1, 则可以证明它的深度和logN是同数量级的 (其中N是结点的个数).由此,它的平 均查找长度也和logN同数量级.
typedef structBSTNode { ElemType data; int bf; //结点的平衡因子 结点的平衡因子 struct BSTNode *lchild, *rchild; //左,右孩子指针 左 } BSTNode, * BSTree;
算法9.7如下: 算法 如下: 如下 void R_Rotate (BSTree &p) { //对以 为根的二叉排序树作右旋处理,处理之后p指向新的树根结点, 对以*p为根的二叉排序树作右旋处理,处理之后 指向新的树根结点, 对以 为根的二叉排序树作右旋处理 指向新的树根结点 //即旋转处理之前的左子树的根结点 即旋转处理之前的左子树的根结点 lc = p->lchild; //lc指向的 的左子树根结点 指向的*p的左子树根结点 - 指向的 p->lchild = lc->rchild; //lc的右子树挂接为 的左子树 的右子树挂接为*p的左子树 - - 的右子树挂接为 lc->rchild = p; - p = lc; //p指向新的根结点 指向新的根结点 } // R_Rotate

数据结构:第9章 查找2-二叉树和平衡二叉树

数据结构:第9章 查找2-二叉树和平衡二叉树
NODE *t; char x; {if(t==NULL)
return(NULL); else
{if(t->data==x) return(t);
if(x<(t->data) return(search(t->lchild,x));
else return(search(t->lchild,x)); } }
——这种既查找又插入的过程称为动态查找。 二叉排序树既有类似于折半查找的特性,又采用了链表存储, 它是动态查找表的一种适宜表示。
注:若数据元素的输入顺序不同,则得到的二叉排序树形态 也不同!
讨论1:二叉排序树的插入和查找操作 例:输入待查找的关键字序列=(45,24,53,45,12,24,90)
二叉排序树的建立 对于已给定一待排序的数据序列,通常采用逐步插入结点的方 法来构造二叉排序树,即只要反复调用二叉排序树的插入算法 即可,算法描述为: BiTree *Creat (int n) //建立含有n个结点的二叉排序树 { BiTree *BST= NULL;
for ( int i=1; i<=n; i++) { scanf(“%d”,&x); //输入关键字序列
– 法2:令*s代替*p
将S的左子树成为S的双亲Q的右子树,用S取代p 。 若C无右子树,用C取代p。
例:请从下面的二叉排序树中删除结点P。
F P
法1:
F
P
C
PR
C
PR
CL Q
CL QL
Q SL
S PR
QL S
SL
法2:
F
PS
C
PR
CL Q
QL SL S SL

数据结构 -第12周查找第3讲-二叉排序树.pdf

数据结构 -第12周查找第3讲-二叉排序树.pdf

以二叉树或树作为表的组织形式,称为树表,它是一类动态查找表,不仅适合于数据查找,也适合于表插入和删除操作。

常见的树表:二叉排序树平衡二叉树B-树B+树9.3.1 二叉排序树二叉排序树(简称BST)又称二叉查找(搜索)树,其定义为:二叉排序树或者是空树,或者是满足如下性质(BST性质)的二叉树:❶若它的左子树非空,则左子树上所有节点值(指关键字值)均小于根节点值;❷若它的右子树非空,则右子树上所有节点值均大于根节点值;❸左、右子树本身又各是一棵二叉排序树。

注意:二叉排序树中没有相同关键字的节点。

二叉树结构满足BST性质:节点值约束二叉排序树503080209010854035252388例如:是二叉排序树。

66不试一试二叉排序树的中序遍历序列有什么特点?二叉排序树的节点类型如下:typedef struct node{KeyType key;//关键字项InfoType data;//其他数据域struct node*lchild,*rchild;//左右孩子指针}BSTNode;二叉排序树可看做是一个有序表,所以在二叉排序树上进行查找,和二分查找类似,也是一个逐步缩小查找范围的过程。

1、二叉排序树上的查找Nk< bt->keybtk> bt->key 每一层只和一个节点进行关键字比较!∧∧p查找到p所指节点若k<p->data,并且p->lchild=NULL,查找失败。

若k>p->data,并且p->rchild=NULL,查找失败。

查找失败的情况加上外部节点一个外部节点对应某内部节点的一个NULL指针递归查找算法SearchBST()如下(在二叉排序树bt上查找关键字为k的记录,成功时返回该节点指针,否则返回NULL):BSTNode*SearchBST(BSTNode*bt,KeyType k){if(bt==NULL||bt->key==k)//递归出口return bt;if(k<bt->key)return SearchBST(bt->lchild,k);//在左子树中递归查找elsereturn SearchBST(bt->rchild,k);//在右子树中递归查找}在二叉排序树中插入一个关键字为k的新节点,要保证插入后仍满足BST性质。

平衡二叉树的生成过程

平衡二叉树的生成过程
(3)LR型
LR型:插入位置为左子树的右孩子,要进行两次旋转,先左旋转,再右旋转;第一次最小不平衡子树的根结点先不动,调整插入结点所在的子树,调整后的树变成LL型树,第二次再调整最小不平衡子树(根据LL型的调整规则,调整为平衡二叉树)。
由于在A的左子树B的右子树上插入了结点F,A的平衡因子由1变为了2,成为不平衡的最小二叉树根结点。第一次旋转A结点不动,先将B的右子树的根结点D向左上旋转提升到B结点的位置,然后再把该D结点向右上旋转提升到A结点的位置。
(4)RL型
RL型:插入位置为右子树的左孩子,进行两次调整,先右旋转调整为RR型,再左旋转,从RR型调整到平衡二叉树;处理情况与LR类似。
总结:RR型和LL型插入导致的树失去平衡,只需要做一次旋转调整即可。而RL型和LR型插入导致的结点失去平衡,要调整两次。对于RL/LR的调整策略是:
第一次调整,最小不平衡子树的根结点先不动,调整插入结点所在的子树(这个子树是指最小不平衡结点的一颗子树,且这棵子树是插入结点的子树)为RR型或者LL型,第二次再调整最小不平衡子树(调整策略要么是RR型要么是LL型)。
bf=GetHeight(root->lchild)-GetHeight(root->rchild);ﻫreturnbf;ﻫ}ﻫvoid AVLTree::CreateTree(TreeNode*&root,intdata)ﻫ{
if(root==NULL)ﻫ{
root=(TreeNode*)malloc(sizeof(TreeNode));ﻫ root->m_nValue=data;
#include<iostream>
#include<fstream>ﻫ#include<malloc.h>ﻫusing namespacestd;ﻫ#defineLH 1//左高ﻫ#defineEH 0//等高

高度平衡的二叉树

高度平衡的二叉树
高度平衡的二叉搜索树
AVL( Addison-Velski and Landis )树 伸展树 红黑树

二叉搜索树性能分析

对于有 n 个关键码的集合,其关键码有 n! 种 不同排列,可构成不同二叉搜索树有 1 n C 2 n (棵)
n 1
{2, 1, 3} {1, 2, 3} {1, 3, 2} {2, 3, 1} {3, 1, 2} {3, 2, 1}
B
BRAຫໍສະໝຸດ AR中序序列:BL
B
BR
A
AR
注意:改组后
B
A
平衡度为 0
2)RR平衡旋转: 若在A的右子树的右子树上插入结点,使A的平衡
因子从-1增加至-2,需要进行一次逆时针旋转。
(以B为旋转轴)
A B A C
左单旋转 (RotateLeft )
+1
A
0
+2
A
+1
C C A
0
0
B h D h
(a)
C E
Double Rotations
Fig. 28-5 (a) Adding 70 to the tree in Fig. 28-2c destroys its balance; to restore the balance, perform both (b) a right rotation and (c) a left rotation.
h
B
E
h D h
(b)
E
h + 1
B
h
D h + h 1
(c)
如果在子树E中插入一个新结点,该子树高度增1导致 结点A的平衡因子变成+2,出现不平衡。 沿插入路径检查三个结点A、C和E。它们处于一条方 向为“\”的直线上,需要做左单旋转。 以结点C为旋转轴,让结点A反时针旋转。

二叉树与平衡二叉树实现

二叉树与平衡二叉树实现

数据结构课程设计(1)作业A一、大型作业(课程设计)题目和内容1.1二叉排序树与平衡二叉排序树基本操作的实现1.用二叉链表作储存结构(1)以回车(‘\n’)为输入结束标志,输入数列L,生成二叉排序树T;(2)对二叉排序树T作中序遍历,输出结果;(3)计算二叉排序树T的平均查找长度,输出结果;(4)输入元素x,查找二叉排序树T,如果存在含x的结点,则删除该结点,并作中序遍历(执行操作2);否则输出信息“无结点x”;(5)判断二叉排序树T是否为平衡二叉树,输出信息“OK!”/“NO!”;*(6)再用数列L,生成平衡二叉排序树BT:当插入新元素后,发现当前二叉排序树BT 不是平衡二叉排序树,则立即将它转换成新的平衡二叉排序树BT;*(7)计算平衡二叉排序树BT的平均查找长度,输出结果。

2、用顺序表(一维数组)作存储结构(1)以回车(‘\n’)为输入结束标志,输入数列L,生成二叉排序树T;(2)对二叉排序树T作中序遍历,输出结果;(3)计算二叉排序树T的平均查找长度,输出结果;(4)输入元素x,查找二叉排序树T,如果存在含x的结点,则删除该结点,并作中序遍历(执行操作2);否则输出信息“无结点x”;(5)判断二叉排序树T是否为平衡二叉树,输出信息“OK!”/“NO!”。

二. 程序中所采用的数据结构及存储结构的说明程序中的数据采用“树形结构”作为其数据结构。

具体的,我采用的是“二叉排序树”。

二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:(1)若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;(2)若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;(3)它的左右子树也分别为二叉排序树。

程序中分别采用了“二插链表”和“一维数组”作为其存储结构。

二插链表存储结构中二插树的结点由一个数据元素和分别指向其左、右子树的两个分支构成。

如:我的程序中采用的结构是:typedef struct Tnode{int data;struct Tnode *lchild,*rchild;}*node,BSTnode;一维数组顺序表存储结构是用一组地址连续的存储单元依次自上而下、自左而右存储完全二插树上的结点元素,即将完全二叉树上编号为i的结点元素存储在如上定义的一维数组中下标为i-1的分量中。

算法(平衡二叉树)

算法(平衡二叉树)

算法(平衡⼆叉树)科普⼆叉树⼆叉树⼆叉数是每个节点最多有两个⼦树,或者是空树(n=0),或者是由⼀个根节点及两个互不相交的,分别称为左⼦树和右⼦树的⼆叉树组成满⼆叉树有两个⾮空⼦树(⼆叉树中的每个结点恰好有两个孩⼦结点切所有叶⼦结点都在同⼀层)也就是⼀个结点要么是叶结点,要么是有两个⼦结点的中间结点。

深度为k且含有2^k-1个结点的⼆叉树完全⼆叉树从左到右依次填充从根结点开始,依次从左到右填充树结点。

除最后⼀层外,每⼀层上的所有节点都有两个⼦节点,最后⼀层都是叶⼦节点。

平衡⼆叉树AVL树[3,1,2,5,9,7]⾸先科普下⼆叉排序树⼜称⼆叉查找树,议程⼆叉搜索树⼆叉排序树的规则⽐本⾝⼤放右边,⽐本⾝⼩放左边平衡⼆叉数⾸先是⼀个⼆叉排序树左右两个⼦树的⾼度差不⼤于1下⾯图中是平衡的情况下⾯是不平衡的情况引⼊公式(LL)右旋function toateRight(AvlNode){let node=AvlNode.left;//保存左节点 AvlNode.left=node.right;node.right=AvlNode;}(RR)左旋function roateLeft(AvlNode){let node=AvlNode.right;//保存右⼦节点AvlNode.right=node.left;node.left=AvlNode;return node;}左右旋⼤图判断⼆叉树是不是平衡树⼆叉树任意结点的左右⼦树的深度不超过1深度计算定义⼀个初始化的⼆叉树var nodes = {node: 6,left: {node: 5,left: {node: 4},right: {node: 3}},right: {node: 2,right: {node: 1}}}//计算⾼度const treeDepth = (root) => {if (root == null) {return 0;}let left = treeDepth(root.left)let right = treeDepth(root.right)return 1+(left>right?left:right)}//判断深度const isTree=(root)=>{if (root == null) {return true;}let left=treeDepth(root.left)let right=treeDepth(root.right)let diff=left-right;if (diff > 1 || diff < -1) {return false}return isTree(root.left)&&isTree(root.right) }console.log(isTree(nodes))判断⼆叉数是不是搜索⼆叉树//第⼀种 //中序遍历let last=-Infinity;const isValidBST=(root)=>{if (root == null) {return true;}//先从左节点开始if (isValidBST(root.left)) {if (last < root.node) {last=root.node;return isValidBST(root.right)}}return false}console.log(isValidBST(nodes))//第⼆种const isValidBST = root => {if (root == null) {return true}return dfs(root, -Infinity, Infinity)}const dfs = (root, min, max) => {if (root == null) {return true}if (root.node <= min || root.node >= max) {return false}return dfs(root.left, min, root.node) && dfs(root.right, root.node, max)}console.log(isValidBST(nodes))实现⼀个⼆叉树实现了⼆叉树的添加,删除,查找,排序//⼆叉树结点class TreeNode {constructor(n, left, right){this.n = n;this.left = left;this.right = right;}}//⼆叉树class BinaryTree {constructor(){this.length = 0;this.root = null;this.arr = [];}//添加对外⼊⼝,⾸个参数是数组,要求数组⾥都是数字,如果有不是数字则试图转成数字,如果有任何⼀个⽆法强制转成数字,则本操作⽆效 addNode(){let arr = arguments[0];if(arr.length == 0) return false;return this.judgeData('_addNode', arr)}//删除结点deleteNode(){let arr = arguments[0];if(arr.length == 0) return false;return this.judgeData('_deleteNode', arr)}//传值判断,如果全部正确,则全部加⼊叉树judgeData(func, arr){let flag = false;//任何⼀个⽆法转成数字,都会失败if(arr.every(n => !Number.isNaN(n))){let _this = this;arr.map(n => _this[func](n));flag = true;}return flag;}//添加的真实实现_addNode(n){n = Number(n);let current = this.root;let treeNode = new TreeNode(n, null, null);if(this.root === null){this.root = treeNode;}else {current = this.root;while(current){let parent = current;if(n < current.n){current = current.left;if(current === null){parent.left = treeNode;}}else {current = current.right;if(current === null){parent.right = treeNode;}}}}this.length++;return treeNode;}//删除节点的真实实现_deleteNode(n){n = Number(n);if(this.root === null){return;}//查找该节点,删除节点操作⽐较复杂,为排除找不到被删除的节点的情况,简化代码,先保证该节点是存在的,虽然这样做其实重复了⼀次查询了,但⼆叉树的查找效率很⾼,这是可接受的let deleteNode = this.findNode(n);if(!deleteNode){return;}//如果删除的是根节点if(deleteNode === this.root){if(this.root.left === null && this.root.right === null){this.root = null;}else if(this.root.left === null){this.root = this.root.right;}else if(this.root.right === null){this.root = this.root.left;}else {let [replaceNode, replacePNode, rp] = this.findLeftTreeMax(deleteNode);replacePNode[rp] = null;replaceNode.left = this.root.left;replaceNode.right = this.root.right;this.root = replaceNode;}}else {//被删除的⽗节点,⼦节点在⽗节点的位置p,有left,right两种可能let [deleteParent, p] = this.findParentNode(deleteNode);if(deleteNode.left === null && deleteNode.right === null){deleteParent[p] = null;}else if(deleteNode.left === null){deleteParent[p] = deleteNode.right;}else if(deleteNode.right === null){deleteParent[p] = deleteNode.left;}else {//⽤来替换被删除的节点,⽗节点,节点在⽗节点的位置let [replaceNode, replacePNode, rp] = this.findLeftTreeMax(deleteNode);if(replacePNode === deleteNode){deleteParent[p] = replaceNode;}else {deleteParent[p] = replaceNode;replacePNode.right = null;}replacePNode[rp] = null;replaceNode.left = deleteNode.left;replaceNode.right = deleteNode.right;}}this.length--;}//查找findNode(n){let result = null;let current = this.root;while(current){if(n === current.n){result = current;break;}else if(n < current.n){current = current.left;}else {current = current.right;}}return result;}//查找⽗节点findParentNode(node){let [parent, child, p] = [null, null, null];if(this.root !== node){parent = this.root;if(node.n < parent.n){child = parent.left;p = 'left';}else {child = parent.right;p = 'right';}while(child){if(node.n === child.n){break;}else if(node.n < child.n){parent = child;child = parent.left;p = 'left';}else {parent = child;child = parent.right;p = 'right';}}}return [parent, p];}//查找当前有左⼦树的节点的最⼤值的节点M,如有A个节点被删除,M是最接近A点之⼀(还有⼀个是右⼦树节点的最⼩值) findLeftTreeMax(topNode){let [node, parent, p] = [null, null, null];if(this.root === null || topNode.left === null){return [node, parent, p];}parent = topNode;node = topNode.left;p = 'left';while(node.right){parent = node;node = node.right;p = 'right';}return [node, parent, p];}//查找最⼤值maxValue(){if(this.root !== null){return this._findLimit('right');}}//查找最⼩值minValue(){if(this.root !== null){return this._findLimit('left');}}//实现查找特殊值_findLimit(pro){let n = this.root.n;let current = this.root;while(current[pro]){current = current[pro];n = current.n;}return n;}//中序排序,并⽤数组的形式显⽰sortMiddleToArr(){this._sortMiddleToArr(this.root);return this.arr;}//中序⽅法_sortMiddleToArr(node){if(node !== null){this._sortMiddleToArr(node.left);this.arr.push(node.n);this._sortMiddleToArr(node.right);}}//打印⼆叉树对象printNode(){console.log(JSON.parse(JSON.stringify(this.root)));}}//测试var binaryTree = new BinaryTree();binaryTree.addNode([50, 24, 18, 65, 4, 80, 75, 20, 37, 40, 60]);binaryTree.printNode();//{n: 50, left: {…}, right: {…}}console.log(binaryTree.maxValue());//80console.log(binaryTree.minValue());//4console.log(binaryTree.sortMiddleToArr());// [4, 18, 20, 24, 37, 40, 50, 60, 65, 75, 80] binaryTree.deleteNode([50]);binaryTree.printNode();//{n: 40, left: {…}, right: {…}}排序复习function ArrayList() {this.array = [];}ArrayList.prototype = {constructor: ArrayList,insert: function(item) {this.array.push(item);},toString: function() {return this.array.join();},swap: function(index1, index2) {var aux = this.array[index2];this.array[index2] = this.array[index1];this.array[index1] = aux;},//冒泡排序bubbleSort: function() {var length = this.array.length;for (var i = 0; i < length; i++) {for (var j = 0; j < length - 1 - i; j++) {if (this.array[j] > this.array[j + 1]) {this.swap(j, j + 1);}}}},//选择排序selectionSort: function() {var length = this.array.length;var indexMin;for (var i = 0; i < length - 1; i++) {indexMin = i;for (var j = i; j < length; j++) {if (this.array[indexMin] > this.array[j]) {indexMin = j;}}if (indexMin !== i) {this.swap(indexMin, i);}}},//插⼊排序insertionSort: function() {var length = this.array.length;var j;var temp;for (var i = 1; i < length; i++) {temp = this.array[i];j = i;while (j > 0 && this.array[j - 1] > temp) {this.array[j] = this.array[j - 1];j--;}this.array[j] = temp;}},//归并排序mergeSort: function() {function mergeSortRec(array) {var length = array.length;if (length === 1) {return array;}var mid = Math.floor(length / 2);var left = array.slice(0, mid);var right = array.slice(mid, length);return merge(mergeSortRec(left), mergeSortRec(right)); }function merge(left, right) {var result = [];var il = 0;var ir = 0;while (il < left.length && ir < right.length) {if (left[il] < right[ir]) {result.push(left[il++]);} else {result.push(right[ir++]);}}while (il < left.length) {result.push(left[il++]);}while (ir < right.length) {result.push(right[ir++]);}return result;}this.array = mergeSortRec(this.array);},//快速排序quickSort:function(){function sort(array){if (array.length <= 1) {return array;}var pivotIndex = Math.floor(array.length/2);var pivot = array.splice(pivotIndex,1)[0];var left = [];var right = [];for(var i = 0; i < array.length; i++){if (array[i] < pivot) {left.push(array[i]);}else{right.push(array[i]);}}return sort(left).concat([pivot],sort(right));}this.array = sort(this.array);}};...................................................................................................................############################################################################ ###################################################################################。

头歌二叉排序表的基本操作

头歌二叉排序表的基本操作

头歌二叉排序表的基本操作一、概述二叉排序树,也称为二叉搜索树(Binary Search Tree, BST),是一种特殊的二叉树,其中每个节点都满足以下性质:对于任意节点,其左子树中所有节点的值都小于该节点的值,而其右子树中所有节点的值都大于该节点的值。

这种特性使得二叉排序树成为一种非常有效的数据结构,用于在各种算法中实现快速查找、插入和删除操作。

二、基本操作1. 插入操作插入操作是二叉排序树中最常用的操作之一。

其基本步骤如下:(1)创建一个新节点,并将要插入的值赋给该节点。

(2)如果二叉排序树为空,则将新节点作为根节点。

(3)否则,从根节点开始比较新节点的值与当前节点的值。

如果新节点的值小于当前节点的值,则将新节点插入到当前节点的左子树中;否则,将新节点插入到当前节点的右子树中。

(4)重复步骤3,直到找到一个空位置来插入新节点。

2. 删除操作删除操作是二叉排序树中比较复杂的操作之一。

其基本步骤如下:(1)找到要删除的节点。

如果找不到要删除的节点,则无法进行删除操作。

(2)如果找到要删除的节点,则将其从树中删除。

如果该节点只有一个子节点,则直接删除该节点;如果该节点有两个子节点,则可以选择将其中的一个子节点“提升”到该节点的位置,然后删除该子节点。

在提升子节点时,需要考虑子节点的值与要删除的节点的值之间的关系,以确保二叉排序树的性质不变。

(3)如果被提升的子节点仍然包含要删除的节点,则需要重复步骤2,直到找到要删除的节点并将其删除。

3. 查找操作查找操作用于在二叉排序树中查找指定的值。

其基本步骤如下:(1)从根节点开始,比较当前节点的值与要查找的值。

如果它们相等,则查找成功,返回当前节点的位置。

(2)如果当前节点的值大于要查找的值,则进入当前节点的左子树中进行查找;否则进入当前节点的右子树中进行查找。

(3)重复步骤2,直到找到要查找的值或者搜索路径上的所有节点都已访问过。

如果最终没有找到要查找的值,则返回空指针。

数据结构_第9章_查找2-二叉树和平衡二叉树

数据结构_第9章_查找2-二叉树和平衡二叉树

F
PS
C
PR
CL Q
QL SL S SL
10
3
18
2
6 12
6 删除10
3
18
2
4 12
4
15
15
三、二叉排序树的查找分析
1) 二叉排序树上查找某关键字等于给定值的结点过程,其实 就是走了一条从根到该结点的路径。 比较的关键字次数=此结点的层次数; 最多的比较次数=树的深度(或高度),即 log2 n+1
-0 1 24
0 37
0 37
-0 1
需要RL平衡旋转 (绕C先顺后逆)
24
0
-012
13
3573
0
01
37
90
0 53 0 53
0 90
作业
已知如下所示长度为12的表:
(Jan, Feb, Mar, Apr, May, June, July, Aug, Sep, Oct, Nov, Dec)
(1) 试按表中元素的顺序依次插入一棵初始为空的二叉 排序树,画出插入完成之后的二叉排序树,并求其在 等概率的情况下查找成功的平均查找长度。
2) 一棵二叉排序树的平均查找长度为:
n i1
ASL 1
ni Ci
m
其中:
ni 是每层结点个数; Ci 是结点所在层次数; m 为树深。
最坏情况:即插入的n个元素从一开始就有序, ——变成单支树的形态!
此时树的深度为n ; ASL= (n+1)/2 此时查找效率与顺序查找情况相同。
最好情况:即:与折半查找中的判ห้องสมุดไป่ตู้树相同(形态比较均衡) 树的深度为:log 2n +1 ; ASL=log 2(n+1) –1 ;与折半查找相同。

平衡二叉树操作的演示

平衡二叉树操作的演示

#include<stdio.h>#include<malloc.h>typedef int KeyType; //定义关键字类型typedef struct node //记录类型{KeyType key; //关键字项int bf; //平衡因子struct node *lchild,*rchild; //左右孩子指针}BSTNode;void LeftProcess(BSTNode *&p,int &taller){//对以指针p所指结点为根的二叉树作左平衡旋转处理,本算法结束时,//指针p指向新的根结点BSTNode *p1,*p2;if(p->bf==0) //原本左右子树等高,现因左子树增高而使树增高{p->bf=1;taller=1;}else if(p->bf==-1) //原本右子树比左子树高,现左右子树等高{p->bf=0;taller=0;}else //原本左子树比右子树高,须作左子树的平衡处理{p1=p->lchild; //p指向*p的左子树根节点if(p1->bf==1) //新结点插入在*p的左孩子的左子树上,要做LL 调整{p->lchild=p1->rchild;p1->rchild=p;p->bf=p1->bf=0;p=p1;}else if(p1->bf==-1) //新结点插入在*p的左孩子的右子树上,要做LR调整{p2=p1->rchild;p1->rchild=p2->lchild;p2->lchild=p1;p->lchild=p2->rchild;p2->rchild=p;if(p2->bf==0) //新结点插入在*p2处作为叶子结点的情况p->bf=p1->bf=0;else if(p2->bf==1) //新结点插在*p2的左子树上的情况{p1->bf=0;p->bf=-1;}else //新结点插在*p2的右子树上的情况{p1->bf=1;p->bf=0;}p=p2;p->bf=0; //仍将p指向新的根结点,并置其bf值为0}taller=0;}}void RightProcess(BSTNode *&p,int &taller){//对以指针p所指结点为根的二叉树作右平衡旋转处理,本算法结束时,//指针p指向新的根结点BSTNode *p1,*p2;if(p->bf==0) //原本左右子树等高,现因右子树增高而使树增高{p->bf=-1;taller=1;}else if(p->bf==1) //原本左子树比右子树高,现左右子树等高{p->bf=0;taller=0;}else //原本右子树比左子树高,须作右子树的平衡处理{p1=p->rchild; //p指向*p的右子树根结点if(p1->bf==-1) //新结点插入在*p的右孩子的左子树上,要做RR 调整{p->rchild=p1->lchild;p1->lchild=p;p->bf=p1->bf=0;p=p1;}else if(p1->bf==1) //新结点插入在*p的右孩子的左子树上,要做RL 调整{p2=p1->lchild;p1->lchild=p2->rchild;p2->rchild=p1;p->rchild=p2->lchild;p2->lchild=p;if(p2->bf==0) //新结点插在*p2处作为叶子结点的情况p->bf=p1->bf=0;else if(p2->bf==-1) //新结点插在*p2的右子树上的情况{p1->bf=0;p->bf=1;}else //新结点插在*p2的左子树上的情况{p1->bf=-1;p->bf=0;}p=p2;p->bf=0; //仍将p指向新的结点,并置其bf值为0}taller=0;}}int InsertA VL(BSTNode*&b,KeyType e,int &taller){//若在平衡二叉排序树b中不存在和e有相同关键字的结点,则插入一个数据元素为e的新结点,//并返回1,否则返回0。

二叉查找树(BST)、平衡二叉树(AVL树)

二叉查找树(BST)、平衡二叉树(AVL树)

⼆叉查找树(BST)、平衡⼆叉树(AVL树)⼆叉查找树(BST) 特殊的⼆叉树,⼜称为排序⼆叉树、⼆叉搜索树、⼆叉排序树。

⼆叉查找树实际上是数据域有序的⼆叉树,即对树上的每个结点,都满⾜其左⼦树上所有结点的数据域均⼩于或等于根结点的数据域,右⼦树上所有结点的数据域均⼤于根结点的数据域。

如下图所⽰:⼆叉查找树通常包含查找、插⼊、建树和删除操作。

⼆叉查找树的创建对于⼀棵⼆叉查找树,其创建与⼆叉树的创建很类似,略有不同的是,⼆叉查找树,为了保证整棵树都关于根结点的⼤⼩呈左⼩右⼤的特征,在创建时,需要根据当前结点的⼤⼩来判断插⼊位置,给出如下代码:template<typename T>void BSTree<T>::createBSTreeByFile(ifstream &f){T e;queue<BSNode<T>*> q;while(!f.eof()){InputFromFile(f, e);Insert(root, e);}}template<typename T>void BSTree<T>::Insert(BSNode<T>* &t, T x){//得⽤指针的引⽤,不然传参时由于形参实例化,并不能成功创建⼆叉树if(t==NULL){t = new BSNode<T>;t->data = x;t->lchild = t->rchild = NULL;return;}if(x<=t->data){Insert(t->lchild, x);}else{Insert(t->rchild, x);}}⼆叉查找树的查找⼆叉查找树的查找有递归和⾮递归两种,对于递归⽅式,其递归边界为树的终⽌结点,⾮递归⽅式则采取对树中所有结点采取BFS或者DFS进⾏遍历的⽅式。

二叉排序树与平衡二叉排序树基本操作的实现 文本文档

二叉排序树与平衡二叉排序树基本操作的实现 文本文档

10 设计说明书(论文)质量 30 综述简练完整,有见解;立论正确,论述充分,结论严谨合理;实验正确,分析处理科学。
11 创新 10 对前人工作有改进或突破,或有独特见解。
成绩
指导教师评语
指导教师签名: 年 月 日
摘要及关键字
本程序中的数据采用“树形结构”作为其数据结构。具体采用的是“二叉排序树”。
1.2.5 平衡二叉树( AVL树 )
①平衡二叉树(Balanced Binary Tree)是指树中任一结点的左右子树的高度大致相同。 ②任一结点的左右子树的高度均相同(如满二叉树),则二叉树是完全平衡的。通常,只要二叉树的高度为O(1gn),就可看作是平衡的。 ③平衡的二叉排序树指满足BST性质的平衡二叉树。 ④AVL树中任一结点的左、右子树的高度之差的绝对值不超过1。在最坏情况下,n个结点的AVL树的高度约为1.44lgn。而完全平衡的二叉树高度约为lgn,AVL树是最接近最优的。
1.2.4平均查找长度…………………………………………………………… 6
1.2.5平均二叉树(AVL树)…………………………………………………… 6
1.2.6平衡因子………………………………………………………………… 7
1.2.7平衡二叉树的调整方法…………………………………………………… 7
攀枝花学院本科学生课程设计任务书
题 目 二叉排序树与平衡二叉树的实现
1、课程设计的目的
使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法。
使学生掌握软件设计的基本内容和设计方法,并培养学生进行规范化软件设计的能力。
3) 使学生掌握使用各种计算机资料和有关参考资料,提高学生进行程序设计的基本能力。

数据结构实验三——二叉树基本操作及运算实验报告

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为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,失败。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

编号:B04900083学号:8 Array课程设计教学院计算机学院课程名称数据结构与算法题目二叉排序树与平衡二叉排序树基本操作的实现专业计算机科学与技术班级二班姓名同组人员指导教师成俊2015 年12 月27 日课程设计任务书2015 ~2016 学年第 1 学期学生:专业班级:计科二指导教师:成俊工作部门:计算机学院一、课程设计题目:二叉排序树与平衡二叉排序树基本操作二、课程设计容用二叉链表作存储结构,编写程序实现二叉排序树上的基本操作:以回车('\n')为输入结束标志,输入数列L,生成二叉排序树T;对二叉排序树T作中序遍历;计算二叉排序树T的平均,输出结果;输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历;否则输出信息“无结点x”;判断二叉排序树T是否为平衡二叉树;再用数列L,生成平衡二叉排序树BT:当插入新元素之后,发现当前的二叉排序树BT不是平衡二叉排序树,则立即将它转换成新的平衡二叉排序树BT;计算平衡的二叉排序树BT的平均查找长度,输出结果。

三、进度安排1.分析问题,给出数学模型,选择数据结构.2.设计算法,给出算法描述3.给出源程序清单4. 编辑、编译、调试源程序5. 撰写课程设计报告四、基本要求编写AVL树判别程序,并判别一个二叉排序树是否为AVL树。

二叉排序树用其先序遍历结果表示,如:5,2,1,3,7,8。

实现AVL树的ADT,包括其上的基本操作:结点的加入和删除;另外包括将一般二叉排序树转变为AVL树的操作。

实现提示主要考虑树的旋转操作。

目录一、课程设计题目: 二叉排序树与平衡二叉排序树基本操作 (1)二、课程设计容 (1)三、进度安排 (1)四、基本要求 (1)一、概述 (3)1.课程设计的目的 (3)2.课程设计的要求 (3)二、总体方案设计 (4)三、详细设计 (6)1.课程设计总体思想 (6)2.模块划分 (7)3.流程图 (8)四、程序的调试与运行结果说明 (9)五、课程设计总结 (14)参考文献 (14)一、概述1.课程设计的目的1.充分理解和掌握二叉树、平衡二叉树的相关概念和知识。

2.掌握排序二叉树的生成、结点删除、插入等操作过程。

3.并实现从键盘上输入一系列数据(整型),建立一棵平衡二叉树。

4.任意插入或删除一个结点后判断是否为平衡二叉树。

5.将非平衡二叉树转换成平衡二叉树。

6.按中序遍历输出这棵平衡二叉树。

2.课程设计的要求用二叉链表作存储结构,编写程序实现二叉排序树上的基本操作:以回车('\n')为输入结束标志,输入数列L,生成二叉排序树T;对二叉排序树T作中序遍历;计算二叉排序树T的平均查找长度,输出结果;输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历;否则输出信息“无结点x”;判断二叉排序树T是否为平衡二叉树;再用数列L,生成平衡二叉排序树BT:当插入新元素之后,发现当前的二叉排序树BT不是平衡二叉排序树,则立即将它转换成新的平衡二叉排序树BT;计算平衡的二叉排序树BT的平均查找长度,输出结果。

编写A VL树判别程序,并判别一个二叉排序树是否为A VL树。

二叉排序树用其先序遍历结果表示,如:5,2,1,3,7,8。

实现A VL树的ADT,包括其上的基本操作:结点的加入和删除;另外包括将一般二叉排序树转变为A VL树的操作。

实现提示主要考虑树的旋转操作。

二、总体方案设计1)建立二叉排序树,编写二叉排序树T作中序遍历。

2)查找删除二叉排序树函数。

3)编写判断二叉排序树T是否为平衡二叉树函数,把非平衡二叉排序树转换成平衡二叉排序树。

4)编写计算二叉树BT的平均查找长度函数。

我负责的是第一部分,二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:1.若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;2.若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;3.它的左、右子树也分别为二叉排序树。

以链表存储结构创建二叉排序树,以回车('\n')为输入结束标志,输入数列L,生成二叉排序树T;对二叉排序树T作中序遍历。

中序遍历二叉树算法的框架是:若二叉树为空,则空操作;否则(1)中序遍历左子树(L);(2)访问根结点(V);(3)中序遍历右子树(R)。

函数1:中序遍历二叉树中序遍历二叉树也采用递归函数的方式,先访问左子树2i,然后访问根结点i,最后访问右子树2i+1.先向左走到底再层层返回,直至所有的结点都被访问完毕。

(石林)函数2:平均查找长度计算二叉排序树的平均查询长度时,可采用类似中序遍历的递归方式,用s记录总查询长度,j记录每个结点的查询长度,s值初值为0,采用累加的方式最总得到总查询长度s,平均查询长度等于s/i(i为树中结点个数)。

(吴进)函数3:查找删除二叉排序树函数输入元素x,查找二叉排序树T,若存在含x的结点,则删该结点,并作中序遍历(执行函数1);否则输出信息“无x”。

(常勋)函数4:判断二叉排序树T是否为平衡二叉树,若不是则用数列L,生成平衡排序二叉树BT;最后调用函数6 ,接着调用函数5.判断二叉排序树是否为平衡二叉树的函数也是采用递归函数的方式,分别判定以树中每个节点为根节点的子树是否为平衡二叉树。

只要有一个子树不为平衡二叉树,则该树便不是平衡二叉树。

函数5:在平衡二叉树BT上插入新元素,若发现当前的二叉排序树BT不是平衡二叉排序树,则立即将它转换成新的平衡二叉排序树BT。

三、详细设计1.课程设计总体思想1.生成二叉排序树:建立二叉排序树采用的是边查找边插入的方式。

查找函数采用递归的方式进行查找。

查找是按照二叉排序树的性质进行的,通过比较要插入元素的关键字与当前结点关键字的大小来决定我们是遍历当前结点的哪个子树。

如果小于当前结点关键字,则遍历它的左子树;大于当前结点关键字,则遍历它的右子树;等于当前关键字,则此元素不插入原树。

我们按照这样的规律,一直向下遍历,知道它的子树为空,则返回当前结点的上一个结点。

然后利用插入函数将该元素插入原树。

2.中序遍历:对二叉排序树进行中序遍历采用递归函数的方式。

在根节点不为空的情况下,先访问左子树,在访问根结点,最后访问右子树。

3.平均查找长度:计算二叉排序树的平均查找长度,仍采用类似中序遍历的递归方式,用s 记录总查找长度,j记录每个结点的查找长度,s置初值为0,采用累加的方式最终得到总查找长度s,平均查找长度就等于s/j(i为树中结点的总个数)。

4.删除结点:删除结点函数,采用边查找变删除的方式。

如果没有查找到,则不对树做任何的修改:如果查找到结点,则分四种情况分别进行讨论:(1)该结点左右子树均为空;(2)该结点仅左子树为空;(3)该结点仅右子树为空;(4)该结点左右子树都不为空;5.用数列L,生成平衡的二叉排序树BT;当插入新元素之后,发现当前的二叉排序树BT不是平衡二叉排序树,则立即将它转换成新的平衡的二叉排序树BT。

我所负责的模块函数定义如下void TraverseOrderDSTable(BSTree DT, void(*Visit)(ElemType)) //按中序遍历详细的程序代码如下:typedef struct BSTNode //二叉排序树类型{ ElemType data;struct BSTNode *lchild, *rchild;}BSTNode, *BSTree;Status InitDSTable(BSTree &DT){ //构造一个空的动态BST查找表DTDT = NULL;return 1;}void TraverseOrderDSTable(BSTree DT, void(*Visit)(ElemType)){ //按中序遍历对DT的每个结点调用函数Visit()一次且至多一次if(DT){ TraverseOrderDSTable (DT->lchild, Visit);Visit(DT->data);TraverseOrderDSTable (DT->rchild, Visit);}}2.模块划分Main:主函数模块,在主函数中调用其他函数:(1)Status InsertBST(BSTree &T, ElemType e) //创建二叉排序树(2)void TraverseOrderDSTable(BSTree DT, void(*Visit)(ElemType)) void TraverseOrderDSTable(AVLTree DT, void(*Visit)(ElemType)) //中序遍历二叉排序树和平衡二叉排序树(3)void asl() //计算平均长度(4)BSTree SearchBST(BSTree T, KeyType key)void SearchBST(BSTree &T, KeyType key, BSTree f, BSTree &p, Status &flag)void Delete(BSTree &p)Status DeleteBST(BSTree &T, KeyType key)//查找并删除结点(5)Status InsertAVL(AVLTree &T, ElemType e, Status &taller) //创建平衡二叉排序树void RightBalance(AVLTree &T)//对以*p为根的二叉排序树作右旋处理,处理之后p指向新的树根结点,即旋转处理之前的左子树的根结点 void LeftBalance(AVLTree &T)//对以*p为根的二叉排序树作左旋处理,处理之后p指向新的树根结点,即旋转处理之前的右子树的根结点AVLTree SearchAVL(AVLTree T, KeyType key)//衡二叉排序树中进行查找。

3.流程图四、程序的调试与运行结果说明主函数代码:void main(){int num, i, select, t, *depth, max, flag;KeyType j; Status k;ElemType *r, *tempr, tempbst, tempavl;BSTree bst, p;AVLTree avl, q;do{printf("请输入要输入的数据的总数,总数要大于0:");scanf("%d",&num); if(num <=0)printf("\n输入的总数要大于0,请重新输入:");}while(num <=0);gl_count = num;r = (ElemType*)malloc(gl_count*(sizeof(ElemType)));printf("请输入生成二叉树的整型数据,前后数据用空格隔开:\n"); for(i=0; i<gl_count; i++){scanf("%d", &r[i].key) ;r[i].order = i+1;}printf("\n用户输入的数据及序号如下:\n");for(i=0; i< gl_count; i++){print(r[i]);if((i+1)%6 == 0) printf("\n");}select = 0; flag = 0; InitDSTable(bst);for(i=0; i<gl_count; i++)InsertBST(bst, r[i]);printf("\n按中序遍历该二叉排序树的结果如下:\n");TraverseOrderDSTable(bst, print);cout<<endl<<endl<<"以下是对二叉排序树的基本操作:"<<endl <<"1.查找一个节点"<<endl<<"2.插入一个节点"<<endl<<"3.删除一个节点"<<endl<<"4.判别二元查找树是否为平衡二叉树"<<endl<<"5.二叉树转换为平衡二叉树"<<endl<<"6.退出系统"<<endl;do{if(flag == 6);printf("\n请输入二叉排序树基本操作的选项:");scanf("%d", &select);switch(select){case 1:printf("请输入待查找的数据:");scanf("%d", &j);p = SearchBST(bst, j);if(p){printf("\n二叉排序树中存在此值:");print(p->data);}else printf("\n二叉排序树中不存在此值。

相关文档
最新文档