平衡二叉树操作演示

平衡二叉树操作的演示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)
所以平衡⼆叉树的搜索性能⽐⼆叉搜索树（⼆叉排序树）好。

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

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

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

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

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

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

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

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

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

在任意⼀棵⾮空树中：⑴有⼀个特定的称为根（root）的结点。

⑵当n>1时，其余结点分为ｍ（ｍ≥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 路径上的所有结点（不包括指定结点）。

一、平衡二叉树的概念平衡二叉树(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结点的位置。

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

常见的树表：二叉排序树平衡二叉树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性质。

平衡二叉树调整算法在平衡二叉树中插入一个结点后造成不平衡，设最低的不平衡结点为A，并已知A的左孩子平衡因子为0，右孩子平衡因子为1，则应该做（C）型调整以使其平衡A LLB LRC RLD RR若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。

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

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

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

失去平衡的最小子树是指以离插入结点最近，且平衡因子绝对值大于 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 结点的位置。

即先使之成为LL型，再按LL型处理。

如图中所示，即先将圆圈部分先调整为平衡树，然后将其以根结点接到 A 的左子树上，此时成为LL 型，再按LL 型处理成平衡型。

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

Size Balanced TreeSize Balanced Tree(SBT)是一种平衡二叉查找树。

它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。

由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。

但它的性能并不SB，编写起来也并不BT。

恰恰相反，SBT易于实现，且据陈启峰论文中所言，“这是目前为止速度最快的高级二叉搜索树”。

它能在O(logn)的时间内完成所有BST的相关操作。

而且由于SBT赖以保持平衡的是Size域而不是其他“无用”的域，它可以很方便地实现动态顺序统计中的select和rank。

性质Size Balanced Tree（SBT）是一种通过大小（Size）域来保持平衡的二叉搜索树，它也因此得名。

它总是满足：对于SBT的每一个结点t：1. 性质(a) s[right[t] ]≥s[left[left[t]]]，s[right[left[t]]]2. 性质(b) s[left[t] ]≥s[right[right[t]]]，s[left[right[t]]]即每棵子树的大小不小于其兄弟的子树大小。

图1如图（圈代表结点，三角代表SBT，下同）：1. s[R] ≥s[A]，s[B]2. s[L] ≥s[C]，s[D]旋转SBT的旋转（Rotations）与其他许多高级BST相同。

它是下面提到的Maintain操作的基础。

图2[编辑]左旋转右旋转保持性质(Maintain)当我们插入或删除一个结点后，SBT的大小就发生了改变。

这种改变有可能导致性质(a)或(b)被破坏。

这时，我们需要用Maintain操作来修复这棵树。

Maintain操作是SBT中最具活力的一个独特过程；Maintain(T)用于修复以T为根的SBT。

调用Maintain(T)的前提条件是T的子树都已经是SBT了。

平衡二叉树构造过程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如果要删除的节点有两个子节点，则找到当前节点的后继节点（即比当前节点大的最小节点）或前驱节点（即比当前节点小的最大节点），将后继节点或前驱节点的值复制到当前节点，并删除后继节点或前驱节点。

平衡二叉树的调整方法
平衡二叉树是一种具有左右子树高度差不超过1的二叉树结构。

但是在实际应用中，由于插入、删除等操作会导致树的不平衡，所以需要对二叉树进行调整以保持平衡。

常见的平衡二叉树调整方法包括AVL树和红黑树。

AVL树是一种严格的平衡二叉树，它通过旋转操作来调整树的平衡性。

AVL树的调整过程需要通过计算节点的平衡因子（左右子树高度差）来确定需要进行的旋转操作，具体包括左旋、右旋、左右旋和右左旋四种操作。

这些旋转操作可以通过改变节点的指针关系来调整树的平衡，保持树的高度平衡性。

红黑树是一种近似平衡的二叉搜索树，它通过染色和旋转操作来调整树的平衡性。

红黑树的调整过程相对于AVL树来说更加简单，具有较低的调整成本。

红黑树的特点是每个节点有一个颜色属性（红色或黑色），并且满足以下四个条件：1. 根节点是黑色；2. 所有叶子节点（NIL节点）是黑色；3. 任意两个相邻节点不能同时为红色；4. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

通过对节点的染色和旋转操作，红黑树可以保持树的平衡性。

除了AVL树和红黑树，还有其他一些平衡二叉树的调整方法，如Treap树、Splay 树等。

这些方法在特定场景下可以提供更好的性能，但它们的实现复杂度较高，适用性有一定的限制。

总而言之，平衡二叉树的调整方法是为了保持树的平衡性，以提高树的查询和插入等操作的效率。

不同的调整方法适用于不同的应用场景，根据实际需求选择合适的平衡二叉树调整方法是非常重要的。

平衡二叉树算法
平衡二叉树是一种特殊的二叉搜索树（BST），它通过限制每个节点的左右子树高度差不超过1来确保查找、插入和删除等操作具有良好的性能，时间复杂度接近O(log n)。

以下简要介绍其主要算法：
1. 构造：
- 初始化时可能为空树。

- 插入新节点时，需保持平衡性，若插入后破坏了平衡条件（即任意节点的左子树和右子树的高度差大于1），则需要进行旋转操作重新平衡树。

2. 旋转操作：
- 单旋转：包括左旋（LL旋转）和右旋（RR旋转），用于解决单边过高问题。

- LL旋转：当某个节点的左孩子与其左孩子的右孩子相比过高时进行。

- RR旋转：当某个节点的右孩子与其右孩子的左孩子相比过高时进行。

- 双旋转：包括LR旋转（先左旋后右旋）和RL旋转（先右旋后左旋），用于解决两边交替过高的情况。

3. 插入和删除后的调整：
- 在插入或删除节点导致树失去平衡时，从受影响节点向上回溯至根节点，沿途检查并更新节点的平衡因子，并在必要时执行相应的旋转操作以恢复平衡。

4. AVL树：
- 最早提出且广泛应用的平衡二叉搜索树类型是AVL树，它严格要求所有节点的平衡因子绝对值不大于1。

5. 其他实现：
- 红黑树也是一种平衡二叉搜索树，它的平衡条件相对宽松，允许任何路径的最大黑色高度相同，通过颜色标记和旋转/变色操作维护平衡。

总结来说，平衡二叉树算法的核心在于如何在保证二叉搜索树性质的基础上，通过特定规则的旋转操作实时维护树的平衡状态，从而保证高效的查询和修改性能。

数据结构实验报告题目：平衡二叉树学院专业年级班别学号学生姓名指导教师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的新结点,并返回１,否则返回０*/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("平衡二叉树创建结束。

平衡二叉树的旋转操作平衡二叉树（AVL树）是一种自平衡的二叉搜索树，它的左子树和右子树的高度差（平衡因子）最多为1。

当插入或删除操作导致树的平衡被破坏时，需要进行旋转操作来恢复平衡。

本文将介绍平衡二叉树的旋转操作以及其实现原理。

1. 左旋操作左旋操作是一种将树向左偏移的操作，它可以用来处理右子树高度过高的情况。

具体步骤如下：(1). 将当前节点的右子节点作为新的根节点。

(2). 将新的根节点的左子节点作为当前节点的右子节点。

(3). 将当前节点作为新的根节点的左子节点。

左旋操作示意图如下：A B/ \ / \T1 B ---> A T3/ \ / \T2 T3 T1 T2在这个示例中，节点A的右子树过高，通过左旋操作将节点B作为新的根节点，节点A成为节点B的左子节点，节点T2成为节点A的右子节点。

2. 右旋操作右旋操作是一种将树向右偏移的操作，它可以用来处理左子树高度过高的情况。

具体步骤如下：(1). 将当前节点的左子节点作为新的根节点。

(2). 将新的根节点的右子节点作为当前节点的左子节点。

(3). 将当前节点作为新的根节点的右子节点。

右旋操作示意图如下：A C/ \ / \C T1 ---> T3 A/ \ / \T3 T2 T2 T1在这个示例中，节点A的左子树过高，通过右旋操作将节点C作为新的根节点，节点A成为节点C的右子节点，节点T2成为节点A的左子节点。

3. 左右旋和右左旋操作有时候仅通过单次旋转操作无法恢复平衡，需要进行左右旋或右左旋操作。

左右旋操作是先对当前节点的左子节点进行左旋，再对当前节点进行右旋。

右左旋操作是先对当前节点的右子节点进行右旋，再对当前节点进行左旋。

左右旋和右左旋操作的示意图如下：左右旋操作：A A C/ \ / \ / \B T4 --->C T4 ---> B A/ \ / \ / \ / \T1 C B T3 T1 T2 T3 T4/ \ / \T2 T3 T1 T2右左旋操作：A A B/ \ / \ / \T1 B ---> T1 C ---> A C/ \ / \ / \ / \C T4 T2 B T1 T2 T3 T4/ \ / \T2 T3 T3 T4通过左右旋和右左旋操作可以处理各种情况下的树平衡问题。

满⼆叉树、完全⼆叉树、平衡⼆叉树、最优⼆叉树
⼀、满⼆叉树
⼀棵⼆叉树的结点要么是叶⼦结点，要么它有两个⼦结点（如果⼀个⼆叉树的层数为K，且结点总数是(2^k) -1，则它就是满⼆叉树。

）
⼆、完全⼆叉树
若设⼆叉树的深度为k，除第 k 层外，其它各层 (1～k-1) 的结点数都达到最⼤个数，第k 层所有的结点都连续集中在最左边，这就是完全⼆叉树。

三、平衡⼆叉树
它或者是⼀颗空树，或它的左⼦树和右⼦树的深度之差(平衡因⼦)的绝对值不超过1，且它的左⼦树和右⼦树都是⼀颗平衡⼆叉树。

四、最优⼆叉树（哈夫曼树）
树的带权路径长度达到最⼩，称这样的⼆叉树为最优⼆叉树，也称为哈夫曼树(Huffman Tree)。

哈夫曼树是带权路径长度最短的树，权值较⼤的结点离根较近。

平衡二叉树构造方法构造平衡二叉树的方法有很多，其中一种绝妙的方法是通过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树进行构造是一种有效的方法来构造平衡二叉树。

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

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