平衡二叉树构造过程

合集下载

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

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

勾股树的证明方法

勾股树的证明方法勾股定理是数学中的一个重要定理，描述了直角三角形的边长关系。

勾股树是一种递归构造的平衡二叉树，树中的每个节点都代表一个整数三元组(a,b,c)，满足勾股定理的条件，即a^2+b^2=c^2勾股树的构造方法如下：1.根节点：根节点代表最小的勾股三元组(3,4,5)，因为3^2+4^2=5^22.左子树：左子树的节点代表形如(a-2b,2a-b,a+b)的勾股三元组，其中a和b是父节点的值。

左子树的值来自于将父节点的a和b代入上述公式得到的新的a和b。

3.右子树：右子树的节点代表形如(a+2b,2a+b,a+b)的勾股三元组，其中a和b是父节点的值。

右子树的值来自于将父节点的a和b代入上述公式得到的新的a和b。

下面，我将详细证明勾股树中所有节点的勾股定理。

证明方法如下：1.根节点：根据上述构造过程，根节点的值是(3,4,5)，显然满足a^2+b^2=c^2，即3^2+4^2=5^2成立。

2.递归证明：我们假设其中一节点(n,m,k)满足勾股定理，即n^2+m^2=k^2证明左子树节点满足勾股定理：左子树节点的值为(n-2m,2n-m,n+m)。

根据递归假设，有(n-2m)^2+(2n-m)^2=(n+m)^2展开后得到：n^2 - 4nm + 4m^2 + 4n^2 - 4nm + m^2 = n^2 + 2nm + m^2整理后得到 3n^2 - 8nm + 3m^2 = n^2 + 2nm + m^2移项整理可得 2n^2 - 10nm + 2m^2 = 0。

因此，左子树节点(n-2m,2n-m,n+m)也满足勾股定理。

证明右子树节点满足勾股定理：右子树节点的值为(n+2m,2n+m,n+m)。

根据递归假设，有(n+2m)^2+(2n+m)^2=(n+m)^2展开后得到：n^2 + 4nm + 4m^2 + 4n^2 + 2nm + m^2 = n^2 + 2nm + m^2整理后得到 5n^2 + 6nm + 5m^2 = n^2 + 2nm + m^2移项整理可得 4n^2 + 4nm + 4m^2 = 0。

详解平衡二叉树

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

故需进行两次旋转操作（先逆时针，后顺时针）。

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

平衡二叉树的旋转操作及多路平衡树算法

平衡二叉树的旋转操作及多路平衡树算法平衡二叉树是一种二叉搜索树，它的每个节点的左右子树高度差不超过1，以保证树的高度不会退化到倾斜的情况，从而保证了树的查找、删除、插入等操作的高效性。

平衡二叉树的常见实现有AVL树、红黑树等。

其中，AVL树是以其创始人Adelson-Velsky和Landis的姓氏命名的。

平衡二叉树的平衡性是通过旋转操作来实现的。

旋转操作可以分为左旋和右旋，它们的本质是交换树中的节点和其孩子节点的位置。

以左旋为例，对于一个节点x，如果其右孩子y的左子树高度大于右子树，则进行左旋操作。

左旋操作会使得y成为x的父节点，y的左子树成为x的右子树，而x则成为y的左子树。

右旋操作也类似，不再赘述。

多路平衡树是一种类似于平衡二叉树的树结构，它允许节点有多个孩子节点。

常见的多路平衡树有B树、B+树、B*树等。

多路平衡树通过将节点的孩子节点个数限制在某个范围内，来保证树的高度不会过高。

这样一来，对于大规模数据的存储和查找操作，多路平衡树比平衡二叉树更加适用。

以B树为例，它的每个节点可以有多个孩子节点，通常包括一个元素序列和比它小的子树数序列。

一个2-3-4 B树（也称为2-3-4树）是一种B树，其中每个节点可以有1、2或3个元素和2、3或4个子节点。

当一个节点中的元素个数达到3时，需要进行分裂操作。

例如，当4插入到一个节点中，它会导致节点分裂成两个，其中3为左子节点，5为右子节点。

此时，中间的元素4会被提升成为父节点，并且左右子树分别指向新的节点。

在多路平衡树中，同样可以通过旋转操作来保持树的平衡性。

不过，与平衡二叉树不同的是，对于多路平衡树来说，旋转操作需要考虑不止一个节点的位置关系。

例如，在2-3-4 B树中，左旋操作会导致3个节点的位置变化，右旋操作会导致4个节点的位置变化。

因此，多路平衡树的旋转操作相对平衡二叉树而言，更加复杂。

同时，多路平衡树也因此在存储和查询效率上更加卓越。

总而言之，平衡二叉树和多路平衡树都是目前常见的数据结构，它们都通过树型结构的特性实现了高效的查找、删除、插入操作。

二叉树再平衡的方法

二叉树再平衡的方法二叉树再平衡是指在二叉树失衡的情况下，调整二叉树的结构，使其恢复平衡的过程。

二叉树的失衡是指左子树或右子树的深度与另一侧的深度差大于1。

失衡的二叉树会影响查找、插入、删除等操作的效率，因此需要进行再平衡处理。

二叉树再平衡一般有两种方法：旋转和重构。

旋转是指通过对节点之间的旋转来达到平衡的目的。

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

左旋：将节点的右子节点变为该节点的父节点，该节点成为其右子节点的左子节点，并将其右子节点的左子节点变为该节点的右子节点。

右旋：将节点的左子节点变为该节点的父节点，该节点成为其左子节点的右子节点，并将其左子节点的右子节点变为该节点的左子节点。

重构是指通过重新构建一棵新的平衡二叉树来达到平衡的目的。

重构有两种方法：AVL树和红黑树。

AVL树是一种严格平衡的二叉树，它的每个节点的左子树和右子树的高度差不超过1。

插入或删除节点时，如果会导致AVL树失衡，则需要通过旋转操作使其恢复平衡。

AVL树的查询、插入和删除操作的时间复杂度都是O(logn)，但是需要频繁地进行旋转操作，导致空间复杂度较高。

红黑树是一种近似平衡的二叉树，它的每个节点要么是红色要么是黑色，并且满足以下性质：1. 根节点是黑色的。

2. 每个叶子节点是黑色的空节点（NIL节点）。

3. 每个红色节点的两个子节点都是黑色的。

4. 从任意一个节点到其子树中每个叶子节点的路径上都包含相同数目的黑色节点。

通过这些性质，红黑树保证了其近似平衡的特点。

插入或删除节点时，通过变换节点颜色和旋转操作来保证红黑树的平衡。

红黑树的查询、插入和删除操作的时间复杂度都是O(logn)，且旋转操作较少，空间复杂度较低，因此应用广泛。

综上所述，二叉树再平衡可以通过旋转和重构两种方法来实现。

不同的方法适用于不同的场景和需求，我们需要根据具体情况选择合适的再平衡方法，以提高二叉树的效率和稳定性。

平衡二叉树

2算法
编辑
红黑树
红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目。
伸展树
伸展树（Splay Tree）是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
SBT
Size Balanced Tree（简称SBT）是一自平衡二叉查找树，是在计算机科学中用到的一种数据结构。它是由中国广东中山纪念中学的陈启峰发明的。陈启峰于2006年底完成论文《Size Balanced Tree》，并在2007年的全国青少年信息学奥林匹克竞赛冬令营中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的信息学竞赛选手和ACM/ICPC选手们戏称为“傻B树”、“Super BT”等。相比红黑树、AVL树等自平衡二叉查找树，SBT更易于实现。据陈启峰在论文中称，SBT是“目前为止速度最快的高级二叉搜索树”。SBT能在O(log n)的时间内完成所有二叉搜索树（BST）的相关操作，而与普通二叉搜索树相比，SBT仅仅加入了简洁的核心操作Maintain。由于SBT赖以保持平衡的是size域而不是其他“无用”的域，它可以很方便地实现动态顺序统计中的select和rank操作。

平衡二叉树详解

平衡⼆叉树详解平衡⼆叉树详解简介平衡⼆叉树（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;}。

算法（平衡二叉树）

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

平衡二叉树-构造方法(绝妙)

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

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

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

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

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

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

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

（1）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的右子树。

平衡二叉树构造过程

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

平衡二叉树算法

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

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

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

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

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

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

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

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

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

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

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

平衡二叉树的算法

(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将作为动态分配的一维数组 //其他代码……; };

数据结构复习题11

一、选择题1．数据结构被形式地定义为（K ，R ），其中K 是数据元素的有限集合，R 是K 上的关系有限集合。

2．链表不具备的特点是可随机访问任一结点。

3．若某表最常用的操作是在最后一个结点之间插入一个结点或删除最后一个结点，则采用带头结点的双循环链表存储方式最节省运算时间。

4．栈的特点是先进先出，队列的特点是先进后出。

5．一个栈的进栈序列是A ，B ，C ，D ，E ，则栈的不可能的输出序列是 DCEAB 。

A ．EDCBAB 。

DECBAC 。

DCEABD 。

ABCDE6．串是一种特殊的线性表，其特殊性体现在数据元素是一个字符。

7．一维数组和线性表的区别是前者长度固定，后者长度可变。

8.稀疏矩阵一般的压缩存储方法有两种，即三元组和十字链表。

9．在线索化二叉树中，t 所指结点没有左子树的充要条件是 B 。

A ．t->left==NULLB. t->ltag==1（P189）C. t->ltag==1且t->left==NULLD ．以上都不对10．设高度为h 的二叉树上只有度为0和度为2 的结点，则此类二叉树中所包含的结点数至少为 B 。

（P158的例题）A ．2h B. 2h-1 C. 2h+1 D.h+111．如图所示二叉树的中序遍历序列是 B 。

（P173）A ．abcdger B. dfebagc C.dbaefcg D. defbagc中序遍历：先左子树，再根，再右子树先序遍历：先根，再左，后右后序遍历：先左，后右，最后根则该二叉树一定是高度等于其结点数。

此种情况只有单只子树才会出现13．在一个图中，所有顶点的度数之和等于所有边数的2倍。

P205(每条边分别作为两个邻接点的度各计了一次)14．在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的B 倍。

A 1/2B 1C 2D 417、一个有n 个顶点的无向图最多有n(n-1)/2条边。

平衡二叉树构造方法

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

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

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