平衡二叉树 平衡因子

数据结构中平衡二叉树的教学探讨与研究作者：朱洪浩来源：《赤峰学院学报·自然科学版》 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);}。

AVL树自平衡的二叉搜索树AVL树是一种自平衡的二叉搜索树，它是根据其发明者 G.M. Adelson-Velsky 和 Evgenii Landis 的姓氏首字母而得名。

AVL树解决了传统二叉搜索树由于插入或删除操作导致树结构不平衡而引发的性能问题。

1. 什么是二叉搜索树？二叉搜索树，又称二叉排序树或二叉查找树，是一种特殊的二叉树结构。

在二叉搜索树中，每个节点都包含一个键值，并且节点的左子树中的键值小于节点的键值，右子树中的键值大于节点的键值。

2. 为什么需要自平衡？传统的二叉搜索树在执行插入或删除操作时，可能会导致树结构不平衡，使得树的高度远大于理想情况下的最小高度。

当树的高度增加后，查找、插入、删除等操作的时间复杂度也会增加，进而影响整体性能。

3. AVL树的自平衡特性AVL树通过保持树的平衡性来提高性能。

对于每一个节点，AVL 树通过计算其左右子树的高度差（平衡因子）来判断是否需要进行旋转操作来保持树的平衡。

当平衡因子超过一定阈值时，进行相应的旋转操作来维持平衡。

4. AVL树的旋转操作AVL树的旋转操作包括左旋和右旋。

左旋操作将当前节点的右子树变为新的根节点，而右旋操作则恰恰相反。

通过旋转操作，AVL树可以在保持二叉搜索树性质的同时，实现树的自平衡。

5. AVL树的插入操作在进行插入操作时，AVL树首先按照二叉搜索树的规则找到插入位置，并插入新的节点。

然后，从插入节点开始沿着路径向上逐层检查平衡因子，若遇到不平衡的节点，执行相应的旋转操作来恢复树的平衡。

6. AVL树的删除操作在进行删除操作时，AVL树首先按照二叉搜索树的规则找到待删除的节点，并执行删除操作。

然后，从删除节点的父节点开始沿着路径向上逐层检查平衡因子，若遇到不平衡的节点，执行相应的旋转操作来恢复树的平衡。

7. AVL树的平衡性保证AVL树的自平衡操作保证了树的高度始终保持在理想情况下的最小高度的常数倍。

通过对平衡因子的检查并执行旋转操作，AVL树能够有效地保持树的平衡性，使得查找、插入、删除等操作能够在较快的时间内完成。

C平衡⼆叉树（AVL）创建和删除 AVL是最先发明的⾃平衡⼆叉查找树算法。

在AVL中任何节点的两个⼉⼦⼦树的⾼度最⼤差别为⼀，所以它也被称为⾼度平衡树，n个结点的AVL树最⼤深度约1.44log2n。

查找、插⼊和删除在平均和最坏情况下都是O（log n）。

增加和删除可能需要通过⼀次或多次树旋转来重新平衡这个树。

定义 ⽤LH，EH，RH分别表⽰左⼦树⾼，等⾼，右⼦树⾼，即平衡因⼦1、0、-1#include <stdio.h>#include <stdlib.h>#include <stdbool.h>#define LH 1 // 左⾼#define EH 0 // 等⾼#define RH -1 // 右⾼typedef struct TreeNode{int data;int bf;struct TreeNode *left, *right;}TreeNode; 旋转处理 左旋和右旋，记住“左逆右顺”就可以/************************************************* 对以*p为根的⼆叉排序树作右旋处理，处理之后p指向新的树根结点，* A B* / / \* B 旋转后变为 C A* / \ /* C D D* 即旋转处理之前的左⼦树的结点。

************************************************/void r_rotate(TreeNode **p){TreeNode *l = (*p)->left;(*p)->left = l->right;l->right = (*p);*p = l;}/************************************************* 对以*p为根的⼆叉排序树作左旋处理，处理之后p指向新的树根结点，* A B* \ / \* B 旋转后变为 A D* / \ \* C D C* 即旋转处理之前的右⼦树的结点。

平衡二叉树实现代码平衡二叉树（Balanced Binary Tree），也叫 AVL 树，是一种特殊的二叉树，它的每个节点的左子树和右子树的高度差不超过1、当插入或删除一个节点后，如果导致树的不平衡，就通过旋转操作来恢复平衡。

下面是平衡二叉树的实现代码：```python#定义平衡二叉树的节点类class AVLNode:def __init__(self, key):self.key = keyself.left = Noneself.right = Noneself.height = 1#定义平衡二叉树类class AVLTree:def __init__(self):self.root = None#获取节点的高度def get_height(self, node):if node is None:return 0return node.height#计算平衡因子def get_balance(self, node):if node is None:return 0return self.get_height(node.left) -self.get_height(node.right)#左旋操作def left_rotate(self, z):y = z.rightT2 = y.lefty.left = zz.right = T2z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))return y#右旋操作def right_rotate(self, z):y = z.leftT3 = y.righty.right = zz.left = T3z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))return y#插入节点def insert(self, key):def insert_node(node, key):if node is None:return AVLNode(key)elif key < node.key:node.left = insert_node(node.left, key)else:node.right = insert_node(node.right, key)node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))balance = self.get_balance(node)#如果节点不平衡，进行旋转操作来恢复平衡if balance > 1:if key < node.left.key:return self.right_rotate(node)else:node.left = self.left_rotate(node.left)return self.right_rotate(node)if balance < -1:if key > node.right.key:return self.left_rotate(node)else:node.right = self.right_rotate(node.right)return self.left_rotate(node)return nodeself.root = insert_node(self.root, key)#删除节点def delete(self, key):def delete_node(node, key):if node is None:return nodeelif key < node.key:node.left = delete_node(node.left, key) elif key > node.key:node.right = delete_node(node.right, key) else:if node.left is None:temp = node.rightnode = Nonereturn tempelif node.right is None:temp = node.leftnode = Nonereturn temptemp = self.get_min_value_node(node.right)node.key = temp.keynode.right = delete_node(node.right, temp.key)if node is None:return nodenode.height = 1 + max(self.get_height(node.left), self.get_height(node.right))balance = self.get_balance(node)#如果节点不平衡，进行旋转操作来恢复平衡if balance > 1:if self.get_balance(node.left) >= 0:return self.right_rotate(node)else:node.left = self.left_rotate(node.left)return self.right_rotate(node)if balance < -1:if self.get_balance(node.right) <= 0:return self.left_rotate(node)else:node.right = self.right_rotate(node.right)return self.left_rotate(node)return nodeself.root = delete_node(self.root, key) #获取以一些节点为根的子树中的最小值节点def get_min_value_node(self, node):if node is None or node.left is None: return nodereturn self.get_min_value_node(node.left) #中序遍历树def inorder_traversal(self):def inorder(node):if node is None:returninorder(node.left)print(node.key, end=" ")inorder(node.right)inorder(self.root)#测试代码if __name__ == '__main__':tree = AVLTreenodes = [50, 30, 70, 20, 40, 60, 80, 25, 10, 55]for node in nodes:tree.insert(node)print("平衡二叉树中序遍历结果：")tree.inorder_traversalprint("\n删除节点 40 后的平衡二叉树中序遍历结果：")tree.delete(40)tree.inorder_traversal```以上就是平衡二叉树的实现代码，代码中包含了平衡二叉树节点类的定义，以及插入节点、删除节点、左旋和右旋操作等方法的实现。

平衡二叉树调整算法在平衡二叉树中插入一个结点后造成不平衡，设最低的不平衡结点为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 型处理成平衡型。

平衡树——特点：所有结点左右子树深度差≤1排序树——特点：所有结点―左小右大字典树——由字符串构成的二叉排序树判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重）带权树——特点：路径带权值（例如长度）最优树——是带权路径长度最短的树，又称Huffman树，用途之一是通信中的压缩编码。

1.1 二叉排序树：或是一棵空树；或者是具有如下性质的非空二叉树：（1）若左子树不为空，左子树的所有结点的值均小于根的值；（2）若右子树不为空，右子树的所有结点均大于根的值；（3）它的左右子树也分别为二叉排序树。

例：二叉排序树如图9.7：二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。

中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。

每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。

搜索,插入,删除的复杂度等于树高，期望O(logn),最坏O(n)(数列有序,树退化成线性表).虽然二叉排序树的最坏效率是O(n),但它支持动态查询,且有很多改进版的二叉排序树可以使树高为O(logn),如SBT,AVL,红黑树等.故不失为一种好的动态排序方法.2.2 二叉排序树b中查找在二叉排序树b中查找x的过程为：1. 若b是空树，则搜索失败，否则：2. 若x等于b的根节点的数据域之值，则查找成功；否则：3. 若x小于b的根节点的数据域之值，则搜索左子树；否则：4. 查找右子树。

[cpp]view plaincopyprint?1.Status SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p){2. //在根指针T所指二叉排序樹中递归地查找其关键字等于key的数据元素，若查找成功，3. //则指针p指向该数据元素节点，并返回TRUE，否则指针P指向查找路径上访问的4. //最好一个节点并返回FALSE，指针f指向T的双亲，其初始调用值为NULL5. if(!T){ p=f; return FALSE;} //查找不成功6. else if EQ(key, T->data.key) {P=T; return TRUE;} //查找成功7. else if LT(key,T->data.key)8. return SearchBST(T->lchild, key, T, p); //在左子树继续查找9. else return SearchBST(T->rchild, key, T, p); //在右子树继续查找10.}2.3 在二叉排序树插入结点的算法向一个二叉排序树b中插入一个结点s的算法，过程为：1. 若b是空树，则将s所指结点作为根结点插入，否则：2. 若s->data等于b的根结点的数据域之值，则返回，否则：3. 若s->data小于b的根结点的数据域之值，则把s所指结点插入到左子树中，否则：4. 把s所指结点插入到右子树中。

平衡二叉树平衡因子
平衡二叉树平衡因子是指该节点的左子树高度减去右子树高度
的绝对值。

平衡因子的取值范围为-1、0、1，若平衡因子的绝对值大于1，则该节点所在的子树不平衡，需要进行旋转操作使其重新平衡。

平衡二叉树的平衡因子是实现平衡的关键，通过平衡因子的计算和调整，可以保证平衡二叉树的高度始终保持在O(log n)的范围内，从而保证了树的查找、插入和删除操作的时间复杂度都能够达到
O(log n)的级别。

平衡因子的计算方法是通过递归遍历左右子树来计算节点的左
右子树高度之差，然后求绝对值。

当平衡因子的绝对值大于1时，需要根据不同情况进行旋转操作，如左旋、右旋、左右旋或右左旋等，以达到平衡二叉树的目的。

总之，平衡二叉树平衡因子是实现平衡的关键，对于平衡二叉树的构建和维护都至关重要。

- 1 -。

alv 树变换原理Alv 树变换原理Alv 树，也称平衡二叉树，是一种自平衡的二叉搜索树，它能够保证在最坏情况下，查找、插入和删除等操作的时间复杂度为 O(log n)。

但是，当我们进行一系列的插入和删除操作后，Alv 树可能会失去平衡，从而影响其性能。

为了解决这一问题，我们需要进行树的变换操作。

1. 旋转操作旋转操作是 Alv 树的核心变换操作，它通过旋转子树使得树重新平衡。

旋转操作一般分为左旋和右旋两种，具体操作如下：左旋：将当前节点的右子节点替换其位置，使其成为左子节点的父节点，将原左子节点成为其右子节点。

右旋：将当前节点的左子节点替换其位置，使其成为右子节点的父节点，将原右子节点成为其左子节点。

2. 小幅度调整除了旋转操作，我们还可以进行一些小幅度的调整操作，例如：节点的高度调整：每次插入或删除节点后，计算其子树高度并更新到当前节点。

节点的平衡因子调整：对于根节点的任意一个节点，其平衡因子为其左子树高度减去右子树高度。

插入或删除节点时，需要更新其平衡因子并进行相应的旋转操作。

3. 变换原理利用上述操作，我们可以实现 Alv 树的平衡。

具体操作步骤如下：1. 插入节点向 Alv 树中插入一个节点后，从该节点开始向根节点遍历，依次进行以下操作：1. 计算并更新节点的高度和平衡因子；2. 判断当前节点是否平衡，即左右子树的高度差是否大于 1；3. 若当前节点平衡，则继续向其父节点遍历；4. 若当前节点不平衡，则进行旋转操作，以使其重新平衡，并向其父节点遍历。

2. 删除节点从 Alv 树中删除一个节点后，从该节点的父节点开始向根节点遍历，依次进行以下操作：1. 计算并更新节点的高度和平衡因子；2. 判断当前节点是否平衡，即左右子树的高度差是否大于 1；3. 若当前节点平衡，则继续向其父节点遍历；4. 若当前节点不平衡，则进行旋转操作，以使其重新平衡，并向其父节点遍历。

4. 总结Alv 树变换原理是实现 Alv 树高效平衡的核心，旋转操作和小幅度调整是其关键操作。

【数据结构与算法笔记03】详解平衡⼆叉树的失衡类型划分及调整策略设计1. 平衡⼆叉树平衡⼆叉树对于树中的每个节点要求：左⼦树和右⼦树的深度差不超过1左右⼦树都是平衡⼆叉树平衡因⼦ = 左⼦树深度 - 右⼦树深度==> 在⼀棵平衡⼆叉树中，所有节点的平衡因⼦只可能有三种取值：-1, 0, 12. 失衡原因分析及失衡情况分类平衡⼆叉树是⼀种特殊的⼆叉排序树，插⼊新节点的⽅法与在⼆叉排序树中插⼊节点相同：先查找，然后在查找失败的位置插⼊新节点。

但是在⼀棵平衡⼆叉树中新插⼊⼀个节点可能会导致树的失衡，因此每次插⼊新节点之后要对树进⾏调整。

书上和⽹上的资料很多，但⼤部分都只给出了最终的结论，没有给出为什么要这样做的原因，现在我试图⽤⾃⼰的⽅式来理解AVL树的调整⽅法：1. 在平衡⼆叉树中新插⼊节点会造成树中某些节点平衡因⼦的改变，从⽽有失衡的风险。

==> 只有插⼊路径上的节点的平衡因⼦可能会改变。

==> 在插⼊路径上的节点中，只有那些原本的平衡因⼦为1, -1的节点可能会失衡（平衡因⼦变为2）。

==> 原本平衡因⼦为1的节点失衡后平衡因⼦会变为2；原本平衡因⼦为-1的节点失衡后平衡因⼦会变为-2。

并且这两种情况是对称的。

2. 在插⼊路径上可能会有多个节点失衡，但是⾼层节点的失衡是由低层节点的失衡造成的，因此存在⼀个最低失衡节点，只要将这个最低失衡节点调整平衡，并且保证以该节点为根的⼦树的⾼度和原来⼀样，那么⾼层节点的失衡就会⾃动恢复。

3. 所谓对失衡节点的调整，其实就是在已知⼀些⼦树和节点相互之间的⼤⼩关系以及他们的⾼度等信息时⽤这些⼦树和节点重新组装成⼀棵满⾜平衡⼆叉树要求的树。

下⾯仅考虑最低失衡节点原本的平衡因⼦为1的情况：==> 该节点失衡后平衡因⼦变为2，说明新节点的插⼊导致该节点的左⼦树的⾼度增加了1，这也间接说明了新节点插在了该节点的左⼦树上。

==> 插在该节点的左⼦树上有两种可能的情况：①该节点原本就没有左孩⼦，②该节点原本是有左孩⼦的。