代码的讲解如下: 首先是需要改进二叉排序树的结点结构,增加一个bf,用来存储平衡因子。
/* 二叉树的二叉链表结点结构定义 */
/* 结点结构 */
typedef struct BiTNode
{
/* 结点数据 */
int data;
/* 结点的平衡因子 */
int bf;
/* 左右孩子指针 */
struct BiTNode *lchild, *rchild;
}
BiTNode, *BiTree;
然后,对于右旋操作,我们的代码如下。
/* 对以p为根的二叉排序树作右旋处理, */
/* 处理之后p指向新的树根结点,即旋转处理之前的左子树的根结点 */
void R_Rotate(BiTree *P)
{
BiTree L;
/* L指向P的左子树根结点 */
L = (*P)->lchild;
/* L的右子树挂接为P的左子树 */
(*P)->lchild = L->rchild;
L->rchild = (*P);
/* P指向新的根结点 */
*P = L;
}
此函数代码的意思是说,当传入一个二叉排序树P,将它的左孩子结点定义为L,将L的右子树变成P的左子树,再将P改成L的右子树,最后将L替换P成为根结点。这样就完成了一次右旋操作。
左旋操作代码如下。
/* 对以P为根的二叉排序树作左旋处理, */
/* 处理之后P指向新的树根结点,即旋转处理之前的右子树的根结点0 */
void L_Rotate(BiTree *P)
{
BiTree R;
/* R指向P的右子树根结点 */
R = (*P)->rchild;
/* R的左子树挂接为P的右子树 */
(*P)->rchild = R->lchild;
R->lchild = (*P);
/* P指向新的根结点 */
*P = R;
}
这段代码与右旋代码是对称的,在此不做解释了。
现在我们来看左平衡旋转处理的函数代码。
#define LH +1
/* 左高 */
#define EH 0
/* 等高 */
#define RH -1
/* 右高 */
/* 对以指针T所指结点为根的二叉树作左平衡旋转处理 */
/* 本算法结束时,指针T指向新的根结点 */
void LeftBalance(BiTree *T)
{
BiTree L,Lr;
/* L指向T的左子树根结点 */
L = (*T)->lchild;
switch (L->bf){
/* 检查T的左子树的平衡度,并作相应平衡处理 */
/* 新结点插入在T的左孩子的左子树上,要作单右旋处理 */
case LH:
(*T)->bf = L->bf = EH;
R_Rotate(T);
break;
/* 新结点插入在T的左孩子的右子树上,要作双旋处理 */
case RH:
/* Lr指向T的左孩子的右子树根 */
Lr = L->rchild;
/* 修改T及其左孩子的平衡因子 */
switch (Lr->bf)
{
case LH: (*T)->bf = RH;
L->bf = EH;
break;
case EH: (*T)->bf = L->bf = EH;
break;
case RH: (*T)->bf = EH;
L->bf = LH;break;
}
Lr->bf = EH;
/* 对T的左子树作左旋平衡处理 */
L_Rotate(&(*T)->lchild);
/* 对T作右旋平衡处理 */
R_Rotate(T);
}}
首先,我们定义了三个常数变量,分别代表1、0、-1。
1. 第1行表示函数被调用时,传入一个需要调整平衡性的子树T。根据调用时的条件,可以确定当前子树是不平衡状态,且左子树的高度大于右子树的高度。
2. 第4行将T的左孩子赋值给L,这是为了方便后续操作。
3. 第5至第27行是一个分支判断的过程,根据L的平衡因子的情况进行不同的处理。
4. 当L的平衡因子为1(表示左子树高度大于右子树),说明它与根结点的平衡因子符号相同。在第8行,将它们的BF值都改为0,表示调整后的平衡状态。然后,在第9行进行右旋操作。
- 右旋操作是将L作为根结点,将T作为L的右孩子,将L的右孩子作为T的左孩子,并且更新对应的平衡因子。这样旋转后,原本不平衡的子树T就变得平衡了。
5. 当L的平衡因子为-1(表示左子树高度小于右子树),说明它与根结点的平衡因子符号相反,此时需要进行双旋处理。
- 第13至第22行对L的右孩子Lr的平衡因子作判断,根据不同情况修改根结点T和L的BF值。
- 第24行将当前Lr的平衡因子BF改为0,表示调整后的平衡状态。
- 第25行对根结点T的左子树进行左旋操作,具体操作如图示所示。
- 第26行对根结点T进行右旋操作,具体操作如图示所示。完成双旋操作后,使得子树T重新平衡。
总结:
左平衡旋转处理函数和右平衡旋转处理函数的代码逻辑类似,都是根据平衡因子的情况进行不同的旋转操作,从而调整子树的平衡性。左平衡旋转处理函数主要针对左子树高度大于右子树的情况,而右平衡旋转处理函数主要针对右子树高度大于左子树的情况。通过旋转操作,可以使得原本不平衡的子树重新达到平衡状态。
有了这些准备,我们的主函数才算是正式登场了。
/* 若在平衡的二叉排序树T中不存在和e有相同关键字的结点,则插入一个 */
/* 数据元素为e的新结点并返回1,否则返回0。若因插入而使二叉排序树 */
/* 失去平衡,则作平衡旋转处理,布尔变量taller反映T长高与否。 */
Status InsertAVL(BiTree *T, int e, Status *taller)
{
if (!*T)
{
/* 插入新结点,树“长高”,置taller为TRUE */
*T = (BiTree)malloc(sizeof(BiTNode));
(*T)->data = e;
(*T)->lchild = (*T)->rchild = NULL;
(*T)->bf = EH;
*taller = TRUE;
}
else
{
if (e == (*T)->data)
{
/* 树中已存在和e有相同关键字的结点则不再插入 */
*taller = FALSE;
return FALSE;
}
if (e < (*T)->data)
{
/* 应继续在T的左子树中进行搜索 */
/* 未插入 */
if (!InsertAVL(&(*T)->lchild, e, taller))
return FALSE;
/* 已插入到T的左子树中且左子树“长高” */
if (*taller)
{
/* 检查T的平衡度 */
switch ((*T)->bf)
{
/* 原本左子树比右子树高,需要作左平衡处理 */
case LH:
LeftBalance(T);
*taller = FALSE;
break;
/* 原本左右子树等高,现因左子树增高而树增高 */
case EH:
(*T)->bf = LH;
*taller = TRUE;
break;
/* 原本右子树比左子树高,现左右子树等高 */
case RH:
(*T)->bf = EH;
*taller = FALSE;break;
}
}
else
{
/* 应继续在T的右子树中进行搜索 */
/* 未插入 */
if (!InsertAVL(&(*T)->rchild, e, taller))
return FALSE;
/* 已插入到T的右子树且右子树“长高” */
if (*taller)
{
/* 检查T的平衡度 */
switch ((*T)->bf)
{
/* 原本左子树比右子树高,现左、右子树等高 */
case LH:
(*T)->bf = EH;
*taller = FALSE;
break;
/* 原本左右子树等高,现因右子树增高而树增高 */
case EH:
(*T)->bf = RH;
*taller = TRUE;
break;
/* 原本右子树比左子树高,需要作右平衡处理 */
case RH:
RightBalance(T);
*taller = FALSE;
break;
}
}
}
}
return TRUE;
}
- 程序开始执行时,如果当前树为空,则申请内存新增一个节点。
- 如果存在相同节点,则不需要插入。
- 当新节点e小于当前树T的根节点值时,向左子树查找插入位置。
- 如果左子树不为空,则递归调用本函数,直到找到插入位置,返回false。否则,说明插入节点成功,执行下面的语句。
- 如果插入了节点,需要判断T的平衡因子。如果平衡因子是1,说明左子树高于右子树,需要进行左平衡旋转处理。如果平衡因子是0或-1,则新插入节点未使整棵二叉排序树失去平衡性,只需要修改相关的BF值即可。
- 如果新节点e大于当前树T的根节点值,则向右子树查找插入位置。代码与之前类似,不再详述。
平衡二叉树是一种特殊的二叉排序树,其左右子树的高度差不超过1,可以通过旋转操作来保持平衡性。
int i;
int a[10] = { 3, 2, 1, 4, 5, 6, 7, 10, 9, 8 };
BiTree T = NULL;
Status taller;
for (i = 0; i < 10; i++)
{
InsertAVL(&T, a[i], &taller);
}
本算法代码很长,是有些复杂,编程中容易在很多细节上出错,要想真正掌握它,需要自己多练习。不过其思想还是不难理解的,总之就是把不平衡消灭在最早时刻。
如果我们需要查找的集合本身没有顺序,在频繁查找的同时也需要经常的插入和删除操作,显然我们需要构建一棵二叉排序树,但是不平衡的二叉排序树,查找效率是非常低的,因此我们需要在构建时,就让这棵二叉排序树是平衡二叉树,此时我们的查找时间复杂度就为O(logn),而插入和删除也为O(logn)。这显然是比较理想的一种动态查找表算法。