平衡二叉树的生成过程

合集下载

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

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

平衡二叉树操作的演示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);}。

平衡二叉树构造过程

平衡二叉树构造过程

平衡二叉树构造过程
平衡二叉树的构造过程主要分为以下几个步骤:
1.定义平衡二叉树的结构:平衡二叉树的结构类似于普通二叉树,每
个节点的左子树和右子树的深度差不超过1。

2.插入节点:当往平衡二叉树中插入一个节点时,需要先通过二叉搜
索树的方式找到新节点的插入位置。

然后,通过旋转操作将树重新平衡。

旋转分为左旋和右旋两种操作。

3.左旋:当一个节点的右子树深度大于左子树深度时,需要进行左旋
操作。

左旋操作是将该节点的右子树进行旋转,使其成为该节点的父节点,该节点成为该节点的右子树的左子树。

4.右旋:当一个节点的左子树深度大于右子树深度时,需要进行右旋
操作。

右旋操作是将该节点的左子树进行旋转,使其成为该节点的父节点,该节点成为该节点的左子树的右子树。

5.删除节点:当从平衡二叉树中删除一个节点时,需要通过旋转操作
将树重新平衡,避免树退化成非平衡二叉树,导致性能下降。

6.重新计算节点深度:平衡二叉树的关键是保证每个节点的左子树和
右子树深度差不超过1,因此在进行节点插入和删除操作后,需要重新计
算每个节点的深度,并检查是否满足平衡二叉树的结构。

通过以上步骤,可以构造一个平衡二叉树。

在应用中,平衡二叉树常
用于高效的查找和排序操作。

平衡二叉树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

数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL

数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL

数据结构与算法系列研究五——树、⼆叉树、三叉树、平衡排序⼆叉树AVL树、⼆叉树、三叉树、平衡排序⼆叉树AVL⼀、树的定义树是计算机算法最重要的⾮线性结构。

树中每个数据元素⾄多有⼀个直接前驱,但可以有多个直接后继。

树是⼀种以分⽀关系定义的层次结构。

a.树是n(≥0)结点组成的有限集合。

{N.沃恩}(树是n(n≥1)个结点组成的有限集合。

{D.E.Knuth})在任意⼀棵⾮空树中:⑴有且仅有⼀个没有前驱的结点----根(root)。

⑵当n>1时,其余结点有且仅有⼀个直接前驱。

⑶所有结点都可以有0个或多个后继。

b. 树是n(n≥0)个结点组成的有限集合。

在任意⼀棵⾮空树中:⑴有⼀个特定的称为根(root)的结点。

⑵当n>1时,其余结点分为m(m≥0)个互不相交的⼦集T1,T2,…,Tm。

每个集合本⾝⼜是⼀棵树,并且称为根的⼦树(subtree)树的固有特性---递归性。

即⾮空树是由若⼲棵⼦树组成,⽽⼦树⼜可以由若⼲棵更⼩的⼦树组成。

树的基本操作1、InitTree(&T) 初始化2、DestroyTree(&T) 撤消树3、CreatTree(&T,F) 按F的定义⽣成树4、ClearTree(&T) 清除5、TreeEmpty(T) 判树空6、TreeDepth(T) 求树的深度7、Root(T) 返回根结点8、Parent(T,x) 返回结点 x 的双亲9、Child(T,x,i) 返回结点 x 的第i 个孩⼦10、InsertChild(&T,&p,i,x) 把 x 插⼊到 P的第i棵⼦树处11、DeleteChild(&T,&p,i) 删除结点P的第i棵⼦树12、traverse(T) 遍历树的结点:包含⼀个数据元素及若⼲指向⼦树的分⽀。

●结点的度: 结点拥有⼦树的数⽬●叶结点: 度为零的结点●分枝结点: 度⾮零的结点●树的度: 树中各结点度的最⼤值●孩⼦: 树中某个结点的⼦树的根●双亲: 结点的直接前驱●兄弟: 同⼀双亲的孩⼦互称兄弟●祖先: 从根结点到某结点j 路径上的所有结点(不包括指定结点)。

平衡二叉树

平衡二叉树
#define EH 0 //等高
#define RH -1 //右高
//平衡二叉树的类型
struct AVLNode
{
int data;
int bf; //bf结点的平衡因子,只能够取0,-1,1,为左子树的深度减去右子树的深度
struct AVLNode *lchild,*rchild; //左、右孩子指针
{
AVLNode *rc,*rd;
rc=T->rchild;
switch(rc->bf)
{
case RH:
T->bf=rc->bf=EH;
L_Rotate(T);
break;
case LH:
rd=rc->lchild;
switch(rd->bf)
{
case RH:
T->bf=LH;
rc->bf=EH;
};
2.右旋操作:
void R_Rotate(AVLNode *&p)//LL型算法
{
AVLNode *lc=p->lchild; // lc指向p的左子树根结点
p->lchild=lc->rchild; // lc的右子树挂接为p(之前跟节点)的左子树
lc->rchild=p;
p=lc; // p指向新的根结点
插入和删除:
插入删除是互为镜像的操作。我们可以采用前面对二叉排序树的删除操作来进行。然后,在删除掉结点后,再对平衡树进行平衡化处理。删除之所以删除操作需要的平衡化可能比插入时次数多,就是因为平衡化不会增加子树的高度,但是可能会减少子树的高度,在有有可能使树增高的插入操作中,一次平衡化能抵消掉增高;在有可能使树减低的删除操作中,平衡化可能会带来祖先节点的不平衡。AVL树体现了一种平衡的美感,两种旋转是互为镜像的,插入删除是互为镜像的操作,没理由会有那么大的差别。实际上,平衡化可以统一的这样来操作:

二叉树的建立方法总结

二叉树的建立方法总结

⼆叉树的建⽴⽅法总结之前已经介绍了⼆叉树的四种遍历(如果不熟悉),下⾯介绍⼀些⼆叉树的建⽴⽅式。

⾸先需要明确的是,由于⼆叉树的定义是递归的,所以⽤递归的思想建⽴⼆叉树是很⾃然的想法。

1. 交互式问答⽅式这种⽅式是最直接的⽅式,就是先询问⽤户根节点是谁,然后每次都询问⽤户某个节点的左孩⼦是谁,右孩⼦是谁。

代码如下(其中字符'#'代表空节点):#include <cstdio>#include <cstdlib>using namespace std;typedef struct BTNode *Position;typedef Position BTree;struct BTNode{char data;Position lChild, rChild;};BTree CreateBTree(BTree bt, bool isRoot){char ch;if (isRoot)printf("Root: ");fflush(stdin); /* 清空缓存区 */scanf("%c", &ch);fflush(stdin);if (ch != '#'){isRoot = false;bt = new BTNode;bt->data = ch;bt->lChild = NULL;bt->rChild = NULL;printf("%c's left child is: ", bt->data);bt->lChild = CreateBTree(bt->lChild, isRoot);printf("%c's right child is: ", bt->data);bt->rChild = CreateBTree(bt->rChild, isRoot);}return bt;}int main(){BTree bt;bt = CreateBTree(bt, true);LevelOrderTraversal(bt); /* 层序遍历 */return0;}2. 根据先序序列例如输⼊序列ABDH##I##E##CF#J##G##(#表⽰空),则会建⽴如下图所⽰的⼆叉树思路和第⼀种⽅式很相似,只是代码实现细节有⼀点区别,这⾥给出创建函数BTree CreateBTree(){BTree bt = NULL;char ch;scanf("%c", &ch);if (ch != '#'){bt = new BTNode;bt->data = ch;bt->lChild = CreateBTree();bt->rChild = CreateBTree();}return bt;}3. 根据中序序列和后序序列和⽅式⼆不同的是,这⾥的序列不会给出空节点的表⽰,所以如果只给出先序序列,中序序列,后序序列中的⼀种,不能唯⼀确定⼀棵⼆叉树。

数据结构:第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

平衡二叉树详解

平衡二叉树详解

平衡⼆叉树详解平衡⼆叉树详解简介平衡⼆叉树(Balanced Binary Tree)具有以下性质:它是⼀棵空树或它的左右两个⼦树的⾼度差的绝对值不超过1,并且左右两个⼦树都是⼀棵平衡⼆叉树。

平衡⼆叉树的常⽤实现⽅法有红⿊树、AVL、替罪⽺树、Treap、伸展树等。

其中最为经典当属AVL树,我们总计⽽⾔就是:平衡⼆叉树是⼀种⼆叉排序树,其中每⼀个结点的左⼦树和右⼦树的⾼度差⾄多等于1。

性值AVL树具有下列性质的⼆叉树(注意,空树也属于⼀种平衡⼆叉树):l 它必须是⼀颗⼆叉查找树l 它的左⼦树和右⼦树都是平衡⼆叉树,且左⼦树和右⼦树的深度之差的绝对值不超过1。

l 若将⼆叉树节点的平衡因⼦BF定义为该节点的左⼦树的深度减去它的右⼦树的深度,则平衡⼆叉树上所有节点的平衡因⼦只可能为-1,0,1.l 只要⼆叉树上有⼀个节点的平衡因⼦的绝对值⼤于1,那么这颗平衡⼆叉树就失去了平衡。

实现平衡⼆叉树不平衡的情形:把需要重新平衡的结点叫做α,由于任意两个结点最多只有两个⼉⼦,因此⾼度不平衡时,α结点的两颗⼦树的⾼度相差2.容易看出,这种不平衡可能出现在下⾯4中情况中:1.对α的左⼉⼦的左⼦树进⾏⼀次插⼊2.对α的左⼉⼦的右⼦树进⾏⼀次插⼊3.对α的右⼉⼦的左⼦树进⾏⼀次插⼊4.对α的右⼉⼦的右⼦树进⾏⼀次插⼊(1)LR型(2)LL型(3)RR型(4)RL型完整代码#include<stdio.h>#include<stdlib.h>//结点设计typedef struct Node {int key;struct Node *left;struct Node *right;int height;} BTNode;int height(struct Node *N) {if (N == NULL)return0;return N->height;}int max(int a, int b) {return (a > b) ? a : b;}BTNode* newNode(int key) {struct Node* node = (BTNode*)malloc(sizeof(struct Node));node->key = key;node->left = NULL;node->right = NULL;node->height = 1;return(node);}//ll型调整BTNode* ll_rotate(BTNode* y) {BTNode *x = y->left;y->left = x->right;x->right = y;y->height = max(height(y->left), height(y->right)) + 1;x->height = max(height(x->left), height(x->right)) + 1;return x;}//rr型调整BTNode* rr_rotate(BTNode* y) {BTNode *x = y->right;y->right = x->left;x->left = y;y->height = max(height(y->left), height(y->right)) + 1;x->height = max(height(x->left), height(x->right)) + 1;return x;}//判断平衡int getBalance(BTNode* N) {if (N == NULL)return0;return height(N->left) - height(N->right);}//插⼊结点&数据BTNode* insert(BTNode* node, int key) {if (node == NULL)return newNode(key);if (key < node->key)node->left = insert(node->left, key);else if (key > node->key)node->right = insert(node->right, key);elsereturn node;node->height = 1 + max(height(node->left), height(node->right)); int balance = getBalance(node);if (balance > 1 && key < node->left->key) //LL型return ll_rotate(node);if (balance < -1 && key > node->right->key) //RR型return rr_rotate(node);if (balance > 1 && key > node->left->key) { //LR型node->left = rr_rotate(node->left);return ll_rotate(node);}if (balance < -1 && key < node->right->key) { //RL型node->right = ll_rotate(node->right);return rr_rotate(node);return node;}//遍历void preOrder(struct Node *root) { if (root != NULL) {printf("%d ", root->key);preOrder(root->left);preOrder(root->right);}}int main() {BTNode *root = NULL;root = insert(root, 2);root = insert(root, 1);root = insert(root, 0);root = insert(root, 3);root = insert(root, 4);root = insert(root, 4);root = insert(root, 5);root = insert(root, 6);root = insert(root, 9);root = insert(root, 8);root = insert(root, 7);printf("前序遍历:");preOrder(root);return0;}。

高度平衡的二叉树

高度平衡的二叉树
高度平衡的二叉搜索树
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反时针旋转。

算法(平衡二叉树)

算法(平衡二叉树)

算法(平衡⼆叉树)科普⼆叉树⼆叉树⼆叉数是每个节点最多有两个⼦树,或者是空树(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);}};...................................................................................................................############################################################################ ###################################################################################。

第四章二叉树_2

第四章二叉树_2

9
二叉搜索树插入操作
利用插入操作可以构造一棵二叉搜索树 首先给出结点序列: 首先给出结点序列 13、8、23、5、18、37 、 、 、 、 、
Φ13
8 5 5 18
83 18 5 2 37 23 37 37 18
10
template<class T> void BST<T>::insertNodeHelper(const T& el) { BSTNode<T> *p = root, *prev = 0; while (p != 0) { prev = p; if( p->data < el ) p = p->rchild; else p = p->lchild; } if( root == 0 ) root = new BSTNode<T>(el); else if( prev->data < el ) p = prev->rchild = new BSTNode<T>(el); else p = prev->lchild = new BSTNode<T>(el); } //find a place for inserting new node; //插入节点 插入节点
20
课堂练习
4.14 对于3个关键码值A、B、C,有多 少个不同的二叉搜索树?画出相应二叉 树。
21
平衡的二叉搜索树(AVL)
BST受输入顺序影响 受输入顺序影响
最好O(log n) 最好 最坏O(n) 最坏
怎样使得BST始终保持 始终保持O(log n)级的平衡状态? 级的平衡状态 怎样使得 始终保持 级的平衡状态? Adelson-Velskii和Landis发明了AVL树 发明了AVL Adelson-Velskii和Landis发明了AVL树

平衡二叉树构造过程

平衡二叉树构造过程

平衡二叉树构造过程1.插入操作:插入新节点是平衡二叉树构造过程中的基本操作之一、首先,将新节点插入到二叉树中的合适位置,然后检查树的平衡性。

在插入过程中,需要更新每个节点的高度,并验证是否需要进行旋转操作,以保持树的平衡。

具体插入操作的步骤如下:1.1在树中查找合适的位置插入新节点,按照二叉树的规则:-如果新节点值小于当前节点值,则继续在当前节点的左子树中查找合适位置插入新节点;-如果新节点值大于当前节点值,则继续在当前节点的右子树中查找合适位置插入新节点;-如果当前节点为空,则将新节点插入到此位置。

1.2更新每个节点的高度,从插入的节点开始,向上遍历到根节点。

计算每个节点的左子树高度和右子树高度,然后取其中较大值加1作为节点的新高度。

1.3验证平衡性。

对于每个节点,计算其左右子树高度差的绝对值,如果超过1,则需要进行旋转操作。

2.旋转操作:旋转是平衡二叉树构造过程中的关键步骤,用来调整树的结构,使其保持平衡。

2.1左旋:将当前节点的右子树变为新的根节点,当前节点成为新的根节点的左子树,新的根节点的左子树成为当前节点的右子树。

2.2右旋:将当前节点的左子树变为新的根节点,当前节点成为新的根节点的右子树,新的根节点的右子树成为当前节点的左子树。

2.3左右旋:先对当前节点的左子树进行左旋操作,然后再对当前节点进行右旋操作。

2.4右左旋:先对当前节点的右子树进行右旋操作,然后再对当前节点进行左旋操作。

旋转操作的目的是调整树的结构,使得左右子树的高度差不超过1,并保持二叉树的性质。

3.删除操作:删除节点是平衡二叉树构造过程中的另一个重要操作。

删除操作也需要更新树的高度和进行旋转操作。

删除操作的步骤如下:3.1在树中查找要删除的节点。

如果要删除的节点是叶子节点,则直接删除即可。

3.2如果要删除的节点只有一个子节点,则将子节点替换成当前节点的位置。

3.3如果要删除的节点有两个子节点,则找到当前节点的后继节点(即比当前节点大的最小节点)或前驱节点(即比当前节点小的最大节点),将后继节点或前驱节点的值复制到当前节点,并删除后继节点或前驱节点。

平衡二叉搜索树构建

平衡二叉搜索树构建

平衡二叉搜索树构建在计算机科学中,平衡二叉搜索树(Balanced Binary Search Tree)是一种重要的数据结构。

它以二叉搜索树为基础,通过对节点进行平衡操作,确保整棵树的高度保持在较小的范围内,从而提高了插入、删除和查找等操作的效率。

本文将介绍平衡二叉搜索树的构建过程,以及常用的构建算法。

一、平衡二叉搜索树的定义与特性平衡二叉搜索树是一种特殊的二叉搜索树,它满足以下两个条件:1. 左子树和右子树的高度差不超过1;2. 左子树和右子树也都是平衡二叉搜索树。

基于这两个条件,平衡二叉搜索树能够保持树的平衡,在进行插入、删除等操作时,不会导致树的高度过高,保证了搜索的效率。

二、平衡二叉搜索树的构建平衡二叉搜索树的构建过程包括节点的插入和平衡操作。

1. 节点插入节点的插入操作与普通二叉搜索树相同,即按照大小关系将新节点插入到合适的位置。

但在插入完成后,为了保持平衡,需要执行平衡操作。

2. 平衡操作平衡操作分为四种情况,分别是左左旋转、左右旋转、右右旋转和右左旋转。

下面分别介绍这四种情况的平衡操作。

- 左左旋转:当在某个节点的左孩子的左子树上插入节点时,会导致该节点左子树的高度大于右子树的高度,需要进行左旋转操作。

左旋转的具体步骤如下:1. 将节点的左孩子设为根节点;2. 将根节点的右孩子设为节点的左孩子;3. 将节点设为根节点的右孩子。

- 左右旋转:当在某个节点的左孩子的右子树上插入节点时,会导致该节点左子树的高度小于右子树的高度,需要进行左右旋转操作。

左右旋转的具体步骤如下:1. 将节点的左孩子的右子树设为根节点的左孩子;2. 将根节点设为节点的左孩子的右子树;3. 将节点的左孩子设为根节点的左孩子;4. 将根节点设为节点的左孩子的右子树。

- 右右旋转:当在某个节点的右孩子的右子树上插入节点时,会导致该节点右子树的高度大于左子树的高度,需要进行右旋转操作。

右旋转的具体步骤与左左旋转的步骤类似,只是方向相反。

数据结构_第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 ;与折半查找相同。

广工数据结构实验报告平衡二叉树

广工数据结构实验报告平衡二叉树

数据结构实验报告题目:平衡二叉树学院专业年级班别学号学生姓名指导教师2015年7月1日1.题目:采用字符类型为整型类型和链式存储结构,实现抽象数据类型BTree。

ADT BTree{数据对象:D={a i | a i∈ElemSet,i=1,2,。

.。

,n,n≥0 }数据关系:R1={<a i—1,a i>|a i—1, a i∈D, i=2,。

.,n }基本操作:Adj_balance(T)操作结果:创建平衡二叉树。

InsertA VL(T,search,taller)初始条件:二叉树T已存在。

操作结果:增加新结点。

SetA VL(T,search,taller)初始条件:二叉树T已存在。

操作结果:在平衡二叉树上增加新结点并调平衡.DeleteA VL(T,search,shorter)初始条件:二叉树T已存在.操作结果:删除结点。

}ADT BTree2.存储结构定义公用头文件DS0。

h:#include〈stdio。

h〉#include 〈malloc.h>树的内部变量typedef struct BTNode{int data;int bf; //平衡因子struct BTNode *lchild,*rchild;//左、右孩子}BTNode,*BTree;/*需要的函数声明*/void Right_Balance(BTree &p);void Left_Balance(BTree &p);void Left_Root_Balance(BTree &T);void Right_Root_Balance(BTree &T);bool InsertA VL(BTree &T,int i,bool &taller);void PrintBT(BTree T);void Left_Root_Balance_det(BTree &p,int &shorter);void Right_Root_Balance_det(BTree &p,int &shorter);void Delete(BTree q,BTree &r,int &shorter);int DeleteA VL(BTree &p,int x,int &shorter);void Adj_balance(BTree &T);bool SetA VL(BTree &T,int i,bool &taller);bool Insert_Balance_A VL(BTree &T,int i,bool &taller);int menu();3.算法设计/*对以*p为根的二叉排序树作右旋处理*/void Right_Balance(BTree &p){BTree lc;lc =p-〉lchild;//lc指向的*p左子树根结点p->lchild = lc-〉rchild;//rc的右子树挂接为*p的左子树lc—〉rchild = p;p = lc; //p指向新的结点}/*对以*p为根的二叉排序树作左旋处理*/void Left_Balance(BTree &p){BTree rc;rc = p-〉rchild;//指向的*p右子树根结点p—〉rchild = rc—〉lchild;//rc左子树挂接到*p的右子树rc->lchild = p;p = rc; //p指向新的结点}/*对以指针T所指结点为根的二叉树作左平衡旋转处理*/void Left_Root_Balance(BTree &T){BTree lc,rd;lc = T-〉lchild;//指向*T的左子树根结点switch(lc->bf)//检查*T的左子树的平衡度,并作相应平衡处理{case 1://新结点插入在*T的左孩子的左子树上,要作单右旋处理T—〉bf = lc—>bf = 0;Right_Balance(T);break;case -1://新结点插入在*T的左孩子的右子树上,要作双旋处理rd = lc—〉rchild; //rd指向*T的左孩子的右子树根switch(rd-〉bf)//修改*T及其左孩子的平衡因子{case 1:T-〉bf = -1;lc—>bf = 0;break;case 0:T->bf = lc—>bf = 0;break;case —1:T-〉bf = 0;lc—〉bf = 1;break;}rd—〉bf = 0;Left_Balance(T->lchild); //对*T的左子树作左旋平衡处理Right_Balance(T);//对*T作右旋平衡处理}}/*对以指针T所指结点为根的二叉树作右平衡旋转处理*/void Right_Root_Balance(BTree &T){BTree rc,ld;rc = T—>rchild;//指向*T的左子树根结点switch(rc—〉bf)//检查*T的右子树的平衡度,并作相应平衡处理{case -1://新结点插入在*T的右孩子的右子树上,要作单左旋处理T-〉bf = rc-〉bf =0;Left_Balance(T);break;case 1://新结点插入在*T的右孩子的左子树上,要作双旋处理ld = rc—〉lchild; //ld指向*T的右孩子的左子树根switch(ld—>bf)//修改*T及其右孩子的平衡因子{case 1:T->bf = 0;rc—>bf = -1;break;case 0:T—>bf = rc->bf =0;break;case -1:T—>bf = 1;rc—>bf = 0;break;}ld—〉bf = 0;Right_Balance(T-〉rchild);//对*T的右子树作左旋平衡处理Left_Balance(T); //对*T作左旋平衡处理}}/*插入结点i,若T中存在和i相同关键字的结点,则插入一个数据元素为i的新结点,并返回1,否则返回0*/bool InsertA VL(BTree &T,int i,bool &taller){if(!T)//插入新结点,树“长高”,置taller为true{T = (BTree)malloc(sizeof(BTNode));T-〉data = i;T—>lchild = T—>rchild =NULL;T-〉bf = 0;taller = true;}else{if(i==T—〉data) //树中已存在和有相同关键字的结点{taller = 0;printf("已存在相同关键字的结点\n”);return 0;}if(i〈T—〉data) //应继续在*T的左子树中进行搜索{if(!InsertA VL(T->lchild,i,taller))return 0;}else //应继续在*T的右子树中进行搜索{if(!InsertA VL(T—〉rchild,i,taller))return 0;}}return 1;}/*输出二叉树*/void PrintBT(BTree T){if(T){printf(”%d",T->data);if(T-〉lchild||T-〉rchild){printf("(");PrintBT(T—〉lchild);printf(",”);PrintBT(T->rchild);printf(”)”);}}}/*删除结点时左平衡旋转处理*/void Left_Root_Balance_det(BTree &p,int &shorter){BTree p1,p2;if(p->bf==1)//p结点的左子树高,删除结点后p的bf减,树变矮{p—>bf=0;shorter=1;}else if(p->bf==0)//p结点左、右子树等高,删除结点后p的bf减,树高不变{p-〉bf=—1;shorter=0;}else //p结点的右子树高{p1=p—>rchild;//p1指向p的右子树if(p1—〉bf==0)//p1结点左、右子树等高,删除结点后p的bf为—2,进行左旋处理,树高不变{Left_Balance(p);p1—>bf=1;p-〉bf=-1;shorter=0;}else if(p1-〉bf==-1)//p1的右子树高,左旋处理后,树变矮{Left_Balance(p);p1—〉bf=p—>bf=0;shorter=1;}else //p1的左子树高,进行双旋处理(先右旋后左旋),树变矮{p2=p1—〉lchild;p1—〉lchild=p2—>rchild;p2—〉rchild=p1;p—>rchild=p2-〉lchild;p2—>lchild=p;if(p2—〉bf==0){p->bf=0;p1—>bf=0;}else if(p2-〉bf==—1){p-〉bf=1;p1—>bf=0;}else{p-〉bf=0;p1—>bf=—1;}p2-〉bf=0;p=p2;shorter=1;}}}/*删除结点时右平衡旋转处理*/void Right_Root_Balance_det(BTree &p,int &shorter){BTree p1,p2;if(p-〉bf==-1){p->bf=0;shorter=1;}else if(p-〉bf==0){p—>bf=1;shorter=0;}else{p1=p->lchild;if(p1—〉bf==0){Right_Balance(p);p1—>bf=—1;p—>bf=1;shorter=0;}else if(p1->bf==1){Right_Balance(p);p1->bf=p—>bf=0;shorter=1;}else{p2=p1—>rchild;p1—〉rchild=p2—〉lchild;p2-〉lchild=p1;p->lchild=p2—>rchild;p2->rchild=p;if(p2-〉bf==0){p—〉bf=0;p1->bf=0;}else if(p2-〉bf==1){p—〉bf=—1;p1—>bf=0;}else{p-〉bf=0;p1->bf=1;}p2->bf=0;p=p2;shorter=1;}}}/*删除结点*/void Delete(BTree q,BTree &r,int &shorter) {if(r-〉rchild==NULL){q—〉data=r->data;q=r;r=r—>lchild;free(q);shorter=1;}else{Delete(q,r—>rchild,shorter);if(shorter==1)Right_Root_Balance_det(r,shorter);}}/*二叉树的删除操作*/int DeleteA VL(BTree &p,int x,int &shorter){int k;BTree q;if(p==NULL){printf("不存在要删除的关键字!!\n");return 0;}else if(x<p-〉data)//在p的左子树中进行删除{k=DeleteA VL(p-〉lchild,x,shorter);if(shorter==1)Left_Root_Balance_det(p,shorter);return k;}else if(x>p->data)//在p的右子树中进行删除{k=DeleteA VL(p—>rchild,x,shorter);if(shorter==1)Right_Root_Balance_det(p,shorter);return k;}else{q=p;if(p->rchild==NULL)//右子树空则只需重接它的左子树{p=p—>lchild;free(q);shorter=1;}else if(p->lchild==NULL)//左子树空则只需重接它的右子树{p=p—>rchild;free(q);shorter=1;}else//左右子树均不空{Delete(q,q->lchild,shorter);if(shorter==1)Left_Root_Balance_det(p,shorter);p=q;}return 1;}}/*调平二叉树具体方法*/bool SetA VL(BTree &T,int i,bool &taller){if(!T)//插入新结点,树“长高”,置taller为true{T = (BTree)malloc(sizeof(BTNode));T-〉data = i;T—〉lchild = T—〉rchild =NULL;T—>bf = 0;taller = true;}else{if(i==T-〉data) //树中已存在和有相同关键字的结点{taller = false;printf("已存在相同关键字的结点\n”);return 0;}if(i〈T—〉data)//应继续在*T的左子树中进行搜索{if(!SetA VL(T->lchild,i,taller))return 0;if(taller) //已插入到*T的左子树中且左子树“长高”switch(T—>bf)//检查*T的平衡度{case 1://原本左子树比右子树高,需要作左平衡处理Left_Root_Balance(T);taller = false;break;case 0: //原本左子树、右子等高,现因左子树增高而使树增高T->bf = 1;taller = true;break;case -1: //原本右子树比左子树高,现左、右子树等高T—〉bf = 0;taller = false;break;}}else //应继续在*T的右子树中进行搜索{if(!SetA VL(T—〉rchild,i,taller))return 0;if(taller) //已插入到*T的右子树中且右子树“长高”switch(T-〉bf)//检查*T的平衡度{case 1://原本左子树比右子树高,现左、右子树等高T-〉bf = 0;taller = false;break;case 0: //原本左子树、右子等高,现因右子树增高而使树增高T-〉bf = -1;taller = true;break;case —1://原本右子树比左子树高,需要作右平衡处理Right_Root_Balance(T);taller = false;break;}}return 1;}}/*二叉树调平操作*/void Adj_balance(BTree &T){int i;bool taller=false;T = NULL;printf(”\n请输入关键字(以—1结束建立平衡二叉树):");scanf("%d",&i);getchar();while(i != -1){SetA VL(T,i,taller);printf("\n请输入关键字(以-1结束建立平衡二叉树):”);scanf(”%d",&i);getchar();taller=false;}printf("平衡二叉树创建结束。

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

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

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) 链地址法

设有MAXSIZE=5,H(K)=K mod 5,关键字值序例 5,21,17,9,15,36,41,24,按外链地址法所建 立的哈希表如图10.12所示:
外链地址的存储结构


IZE = 100; // 哈希表的最大长度,数组的容量 typedef int KeyType; // 关键字的类型 struct ElemNode //每个记录结点的结构 { KeyType key ; //其他属性……; ElemNode *next; }; class SqHash { private: ElemType *ht; // ht将作为动态分配的数组 //其它代码……; };
GOSUB
IF

………
哈稀(散列)查找的关键 问题
一、选择什么样的
哈稀函数?
二、用什么方法
解决地址冲突?
8.4.2

构造哈希函数的常用方法
构造哈希函数的方法很多,杂凑。 这里只介绍一些常用的计算简便的方法。



(1) 平方取中法 (2) 除留余数法 (3) 数字分析法
(1) 平方取中法

(2) 链地址法 解决冲突的主要方法与存储结构相关。

哈稀(散列)查找的关键 问题
一、选择什么样的

哈稀函数?
除留余数等
二、用什么方法

解决地址冲突?
相关与存储结构
(1) 开放地址法




typedef int KeyType; // 关键字的类型 const int MAXSIZE=100; // 数组的容量 struct ElemType { KeyType key ; //其他属性 ……; }; class SqHash { private: ElemType *ht; //ht将作为动态分配的一 维数组 //其他代码……; };

平衡二叉树构造方法

平衡二叉树构造方法

平衡二叉树构造方法构造平衡二叉树的方法有很多,其中一种绝妙的方法是通过AVL树进行构造。

AVL树是一种平衡二叉树,它的左子树和右子树的高度差不超过1、利用这种特性,我们可以通过以下步骤构造平衡二叉树:1.将需要构造平衡二叉树的数据按照升序或者降序排列。

2.选择数据的中间元素作为根节点。

3.将数据分成左右两个部分,分别作为根节点的左子树和右子树的数据。

4.递归地对左子树和右子树进行构造。

下面我们通过一个例子来具体说明这个方法:假设我们需要构造一个平衡二叉树,并且数据为1,2,3,4,5,6,7,8,9首先,我们将数据按照升序排列得到1,2,3,4,5,6,7,8,9、选择中间的元素5作为根节点。

然后,我们将数据分成两部分:1,2,3,4和6,7,8,9、递归地对这两个部分进行构造。

对于左子树,我们选择中间元素2作为根节点,将数据分成两部分:1和3,4、递归地构造这两个部分。

对于右子树,我们选择中间元素8作为根节点,将数据分成两部分:6,7和9、递归地构造这两个部分。

重复这个过程,直到所有的数据都被构造为节点。

最后得到的树就是一个平衡二叉树。

这个构造方法的时间复杂度是O(nlogn),其中n是数据的数量。

虽然它的时间复杂度比较高,但是它保证了构造的树是一个平衡二叉树,从而提高了数据的查找、插入和删除等操作的效率。

总结起来,通过AVL树进行构造是一种有效的方法来构造平衡二叉树。

它将数据按照升序或者降序排列,选择中间元素作为根节点,然后递归地对左子树和右子树进行构造。

这种方法保证了构造的树是一个平衡二叉树,从而提高了数据的查找、插入和删除等操作的效率。

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

二叉排序树变成平衡二叉树对于二叉查找树,尽管查找、插入及删除操作的平均运行时间为O(logn),但是它们的最差运行时间都是O(n),原因在于对树的形状没有限制。

平衡二叉树又称为AVL树,它或者是一棵空树,或者是有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左右子树的深度之差的绝对值不超过1。

二叉树的的平衡因子BF为:该结点的左子树的深度减去它的右子树的深度,则平衡二叉树的所有结点的平衡因子为只可能是:-1、0和1一棵好的平衡二叉树的特征:(1)保证有n个结点的树的高度为O(logn)(2)容易维护,也就是说,在做数据项的插入或删除操作时,为平衡树所做的一些辅助操作时间开销为O(1)一、平衡二叉树的构造在一棵二叉查找树中插入结点后,调整其为平衡二叉树。

若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。

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

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

当失去平衡的最小子树被调整为平衡子树后,原有其他所有不平衡子树无需调整,整个二叉排序树就又成为一棵平衡二叉树1.调整方法(1)插入点位置必须满足二叉查找树的性质,即任意一棵子树的左结点都小于根结点,右结点大于根结点(2)找出插入结点后不平衡的最小二叉树进行调整,如果是整个树不平衡,才进行整个树的调整。

2.调整方式(1)LL型LL型:插入位置为左子树的左结点,进行向右旋转(LL表示的是在做子树的左结点进行插入)由于在A的左孩子B的左子树上插入结点F,使A的平衡因子由1变为2,成为不平衡的最小二叉树根结点。

此时A结点顺时针右旋转,旋转过程中遵循“旋转优先”的规则,A结点替换D结点成为B结点的右子树,D结点成为A结点的左孩子。

(2)RR型RR型:插入位置为右子树的右孩子,进行向左旋转由于在A的右子树C的右子树插入了结点F,A的平衡因子由-1变为-2,成为不平衡的最小二叉树根结点。

此时,A结点逆时针左旋转,遵循“旋转优先”的规则,A结点替换D结点成为C的左子树,D结点成为A的右子树。

(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型)。

#include<iostream>#include<fstream>#include<malloc.h>using namespace std;#define LH 1//左高#define EH 0//等高#define RH -1//右高struct TreeNode{int m_nValue;int BF;//平衡因子TreeNode *lchild;TreeNode *rchild;};class AVLTree{public:AVLTree(){};~AVLTree(){};void CreateTree(TreeNode *&root,int data);//创建AVLvoid PreTraver(TreeNode *root);//先序遍历void RR_Rotate(TreeNode *&r);//右旋转处理int GetHeight(TreeNode *root);//获得树的高度int GetBF(TreeNode *root);//获得树的平衡因子void LL_Rotate(TreeNode *&r);//左旋转处理void RL_Rotate(TreeNode *&r);//双旋处理,先右旋转,再左旋转void LR_Rotate(TreeNode *&r);//双旋处理,先左旋转,再右旋转void LeftBalance(TreeNode *&T);//左平衡处理void RightBalance(TreeNode *&T);//右平衡处理};int Max(int a,int b){if(a>b)return a;else return b;}int AVLTree::GetHeight(TreeNode *root){int len;if(root==NULL)len=0;else{len=Max(GetHeight(root->lchild),GetHeight(root->rchild))+1;}return len;}int AVLTree::GetBF(TreeNode *root){int bf;//平衡因子bf=GetHeight(root->lchild)-GetHeight(root->rchild);return bf;}void AVLTree::CreateTree(TreeNode *&root,int data){if(root==NULL){root=(TreeNode*)malloc(sizeof(TreeNode));root->m_nValue=data;root->lchild=NULL;root->rchild=NULL;// root->BF=GetBF(root);root->BF=EH;//初始叶子结点的平衡因子为等高}else if(data<root->m_nValue){CreateTree(root->lchild,data);switch(root->BF)//检查root的平衡度{ case LH://原来树root的左子树比右子树高,现在左子树更高LeftBalance(root);//对树进行左平衡处理break; case EH://原来树root的左右子树等高,现在左子树高root->BF=LH;//root的平衡因子由0变为1 break; case RH://原来树root的右子树比左子树高,现在左右子树等高root->BF=EH;}}else if(data>root->m_nValue){CreateTree(root->rchild,data);switch(root->BF) { case LH:root->BF=EH;//原来树root的左子树比右子树高,现在root的左右子树等高break; case EH://原来树root的左右子树等高,现在root的右子树更高root->BF=RH; break; case RH://原来右子树比左子树高,现在root右子树高RightBalance(root);//对树root作右平衡处理}}}void AVLTree::PreTraver(TreeNode *root){if(root){ cout.width(3);cout<<root->m_nValue;}if(root->lchild)PreTraver(root->lchild);if(root->rchild)PreTraver(root->rchild);}void AVLTree::LL_Rotate(TreeNode *&r)//插入位置为右子树右孩子,要进行左旋转{TreeNode *p;p=r->rchild;//p指向r的右孩子结点r->rchild=p->lchild;//r结点左旋转成为p的左子树,p原来的左子树成为r的右子树p->lchild=r;//r成为p的左孩子r=p;}void AVLTree::RR_Rotate(TreeNode *&r)//插入位置为左子树左孩子,进行右旋转{TreeNode *p;p=r->lchild;r->lchild=p->rchild;p->rchild=r;r=p;}void AVLTree::RL_Rotate(TreeNode *&r)//插入位置为右子树左孩子,先进行右旋转,再进行左旋转{TreeNode *p;p=r->rchild;RR_Rotate(p);//最小失衡树的根结点的右子树根结点进行右旋转r->rchild=p;//更新最小失衡树根结点的右孩子LL_Rotate(r);//最小失衡树的根结点进行左旋转}void AVLTree::LR_Rotate(TreeNode *&r)//插入位置为左子树右孩子,先进行左旋转,再进行右旋转{TreeNode *p;p=r->lchild;LL_Rotate(p);//最小失衡树根结点的左子树根结点进行左旋转r->lchild=p;//更新最小失衡树根结点的左孩子RR_Rotate(r);//最小失衡树根结点进行右旋转}void AVLTree::LeftBalance(TreeNode *&T)//左平衡处理{//初始条件:原来平衡的二叉排序树T的左子树比右子树高(T->bf=1) // 又在左子树中插入了结点,并导致左子树更高,破坏了树T的平衡性//操作结果:对不平衡的树T 作左平衡旋转处理,使树T的重心右移实现新的平衡TreeNode *lc,*rd; lc=T->lchild;//lc指向T的左孩子结点switch(lc->BF)//检查T左子树的平衡因子{ case LH://新结点插入在T的左孩子的左子树上,导致左子树的平衡因子为左高,进行右旋转处理T->BF=lc->BF=EH;//旋转后,原根结点和左孩子结点平衡因子都为0 RR_Rotate(T);//右旋转处理break; case RH://新结点插入在T的左孩子的右子树上,导致左子树的平衡因子为右高,进行LR处理rd=lc->rchild; switch(rd->BF) { case LH://新结点插入在T的左孩子的右子树的左子树上T->BF=RH;//旋转后,原根结点的平衡因子为右高lc->BF=EH;//旋转后,原根结点的左孩子结点平衡因子为等高break; case EH://新结点插入到T的左孩子的右孩子(叶子)T->BF=lc->BF=EH;//旋转后,原根和左孩子结点的平衡因子都为等高break; case RH://新结点插入在T的左孩子的右子树的右子树上T->BF=EH;//旋转后,原根结点的平衡因子为等高lc->BF=LH;//旋转后,原根结点的左孩子结点平衡因子为左高} rd->BF=EH;//旋转后的新结点的平衡因子为等高//双旋转处理LL_Rotate(T->lchild);//对T的左子树左旋转处理RR_Rotate(T);//对T 作右旋转处理} }void AVLTree::RightBalance(TreeNode *&T)//右平衡处理{//初始条件:原来平衡二叉排序树T的右子树比左子树高,又在右子树中插入结点,导致右子树更高//操作结果:对不平衡的树T作右平衡旋转处理TreeNode *rc,*ld; rc=T->rchild; switch(rc->BF) { case RH://新结点插入在T的右孩子的右子树上,导致右子平衡因子为右高,进行左旋转处理T->BF=rc->BF=EH;//旋转后,原根结点和右孩子结点的平衡因子均为0 LL_Rotate(T); break; case LH://新结点插入在T的右孩子的左子树上,导致右子树的平衡因子为左高,进行双旋处理ld=rc->lchild; switch(ld->BF) { case RH://新结点插入在T的右孩子的左子树的右子树上T->BF=LH;//旋转后,原根结点的平衡因子为左高rc->BF=EH;//旋转后,原根结点的右孩子结点平衡因子为等高break; case EH://新结点插入到T的右孩子的左孩子(叶子)T->BF=rc->BF=EH;//旋转后,原根和右孩子结点的平衡因子等高break; case LH://新结点插入到T的右孩子的左子树的左子树T->BF=EH;//旋转后,原根结点的平衡因子等高rc->BF=RH;//旋转后,原根结点的右孩子结点的平衡因子为右高}ld->BF=EH;//旋转后的新根结点的平衡因子为等高//双旋转处理RR_Rotate(T->rchild);//对T的右子树作右旋转处理LL_Rotate(T);//对T作左旋转处理} }int main(){const char *file="data.txt";AVLTree AVL=AVLTree();TreeNode *root=NULL;int data;ifstream fin;fin.open(file);if(fin.is_open()){while(1){fin>>data;if(data==-1)break;AVL.CreateTree(root,data);}}AVL.PreTraver(root);cout<<endl<<endl;fin.close();return 1;}。

相关文档
最新文档