二叉平衡树的插入和删除操作

Posted 大-雄

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了二叉平衡树的插入和删除操作相关的知识,希望对你有一定的参考价值。

1.      二叉*衡树

二叉排序树查找、插入和删除操作的时间复杂度和树的深度n有关。构建树时,当先后插入的结点按关键字有序时,二叉排序树退化为单枝树,*均查找长度为(n+1)/2,查找效率比较低。提高查找效率,关键在于最大限度地降低树的深度n。因此需要在构建二叉排序树的过程中进行“*衡化”处理,使之成为二叉*衡树。

二叉*衡树,又称AVL树。它或者是一棵空树,或者是具有下列性质的树:

1)      具备二叉排序树的所有性质;

2)      左子树和右子树深度差的绝对值不超过1;

3)      左子树和右子树都是二叉*衡树。

二叉*衡树结点的*衡因子定义为左子树与右子树的深度之差。二叉*衡树结点的*衡因子只可能取-1,0,1三个值。含有n个结点的二叉*衡树的深度与logn同数量级,*均查找长度也和logn同数量级。

二叉*衡树采用二叉链表的结构进行存储。结构体中增加结点的高度,用以计算结点的*衡因子。结点高度定义:空结点的高度为0;非空结点的高度为以该结点为根结点的树的高度。

二叉链表:

1
2
3
4
5
6
7
8
9
10
11
12
/*
 * 二叉树的二叉链表存储结构。
 * 额外添加树的高度,以判断结点的*衡度。
 */
typedef int TElemType;
typedef struct BiNode
{
    TElemType data;
    struct BiNode *lchild;
    struct BiNode *rchild;
    int height;
}BiNode, *BiTree;

结点高度:

1
2
3
4
5
6
7
8
9
/*
 * 当T=NULL ,即树为空树时,无法通过T->height获取树的高度0,所以要额外编写该函数。
 */
int GetHeight(BiTree T)
{
    if (T)
        return T->height;
    return 0;
}

2.      处理失衡的四种旋转方式

如何在插入结点的时候进行“*衡化”处理?当在树中插入一个结点时,检查树是否因插入操作而失衡,若失衡,则找出其中的最小不*衡二叉树,对最小不*衡二叉树进行调整,以达到新的*衡。最小不*衡二叉树定义为以离插入结点最*,且*衡因子绝对值大于1的结点作为根结点的树。

对最小不*衡树进行调整的操作是旋转,共有4种旋转方式LL型,LR型,RL型,RR型,分别介绍如下:

1)        LL型(单次右旋)

当根结点左子树的左子树中的节点导致根结点的*衡因子为2时,采用LL型旋转进行调整。图示为两种需进行单次右旋的不*衡树。

 

LL型旋转即单次右旋,是将根结点的左孩子作为新的根结点,根结点左孩子的右子树作为老根结点的左子树。图示如下:

 

注意:旋转之后,整个树中只有结点k1,k2的高度发生变化,而x,y,z三棵子树中所有结点的高度均未发生变化。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 * 当T的左子树的左子树上的节点使得T的*衡度为2时,以T为中心进行右旋。
 */
bool LLRotate(BiTree *T)
{
    BiTree lc;
    lc = (*T)->lchild;
    (*T)->lchild = lc->rchild;
    lc->rchild = (*T);
 
    //注意要更新结点的高度。整个树中只有*T的左子树和lc的右子树发生了变化,所以只需更改这两棵树的高度。
    (*T)->height = max(GetHeight((*T)->lchild), GetHeight((*T)->rchild)) + 1;
    lc->height = max(GetHeight(lc->lchild), GetHeight(lc->rchild)) + 1;
 
    *T = lc;
    return true;
}

2)        RR型(单次左旋)

当根结点右子树的右子树中的节点导致根结点的*衡因子为-2时,采用RR型旋转进行调整。图示为两种需进行单次左旋的不*衡树。RR型旋转与LL型旋转相对称。

 

RR型旋转即单次左旋,是将根结点的右孩子作为新的根结点,根结点右孩子的左子树作为老根结点的右子树。图示如下:

 

注意:旋转之后,整个树中只有结点k1,k2的高度发生变化,而x,y,z三棵子树中所有结点的高度均未发生变化。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 * 当T的右子树的右子树上的节点使得T的*衡度为-2时,以T为中心进行左旋。
 */
bool RRRotate(BiTree *T)
{
    BiTree rc;
    rc = (*T)->rchild;
    (*T)->rchild = rc->lchild;
    rc->lchild = (*T);
 
    //注意要更新结点的高度。整个树中只有*T的左子树和lc的右子树发生了变化,所以只需更改这两棵树的高度。
    (*T)->height = max(GetHeight((*T)->lchild), GetHeight((*T)->rchild)) + 1;
    rc->height = max(GetHeight(rc->lchild), GetHeight(rc->rchild)) + 1;
 
    *T = rc;
    return true;
}

3)        LR型(先单次左旋,再单次右旋)

当根结点左子树的右子树中的节点导致根结点的*衡因子为2时,采用LR型旋转进行调整。图示为两种需进行LR型旋转的不*衡树。

 

LR型旋转是先以根结点的左孩子为中心进行单次左旋,再以根结点为中心进行单次右旋。图示如下:

 

代码:

1
2
3
4
5
6
7
8
9
10
/*
 * 当T的左子树的右子树上的节点使得T的*衡度为2时,
 * 先以T的左子树为中心进行左旋,再以T为中心进行右旋。
 */
bool LRRotate(BiTree *T)
{
    RRRotate(&((*T)->lchild));
    LLRotate(T);
    return true;
}

4)        RL型(先单次右旋,再单次左旋)

当根结点右子树的左子树中的节点导致根结点的*衡因子为-2时,采用RL型旋转进行调整。图示为两种需进行RL型旋转的不*衡树。RL型旋转与LR型旋转相对应。

 

RL型旋转是先以根结点的右孩子为中心进行单次右旋,再以根结点为中心进行单次左旋。图示如下:

 

代码:

1
2
3
4
5
6
7
8
9
10
/*
 * 当T的右子树的左子树上的节点使得T的*衡度为-2时,
 * 先以T的右子树为中心进行右旋,再以T为中心进行左旋。
 */
bool RLRotate(BiTree *T)
{
    LLRotate(&((*T)->rchild));
    RRRotate(T);
    return true;
}

3.      插入操作

插入操作的代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/*
 * 插入操作。
 * 如果以*T为根结点的二叉*衡树中已有结点key,插入失败,函数返回FALSE;
 * 否则将结点key插入到树中,插入结点后的树仍然为二叉*衡树,函数返回TRUE。
 */
bool AVLInsert(BiTree *T, TElemType key)
{
    BiTree t;
 
    //如果当前查找的根结点为空树,表明查无此结点,故插入结点。
    if (!*T)
    {
        t = (BiTree)malloc(sizeof(BiNode));
        t->data = key;
        t->height = 1;
        t->lchild = NULL;
        t->rchild = NULL;
        *T = t;
        return true;
    }
    //已有此结点,不再插入。
    else if (key == (*T)->data)
    {
        return false;
    }
    //在左子树中递归插入。
    else if (key < (*T)->data)
    {
        if (!AVLInsert(&((*T)->lchild), key))
            return false;
        else
        {
            //插入成功,修改树的高度。
            (*T)->height = max(GetHeight((*T)->lchild), GetHeight((*T)->rchild)) + 1;
 
            //已在*T的左子树插入结点key,判断是否需要进行旋转以保持二叉*衡树的特性。
            if (2 == GetHeight((*T)->lchild) - GetHeight((*T)->rchild))
            {
                //在左子树的左子树中插入结点。
                if (GetHeight((*T)->lchild->lchild) > GetHeight((*T)->lchild->rchild))
                {
                    LLRotate(T);
                }
                //在左子树的右子树中插入结点。
                else
                {
                    LRRotate(T);
                }
            }
            return true;
        }
    }
    //在右子树中递归插入。
    else // (key > (*T)->data)
    {
        if (!AVLInsert(&(*T)->rchild, key))
            return false;
        else
        {
            //插入成功,修改树的高度。
            (*T)->height = max(GetHeight((*T)->lchild), GetHeight((*T)->rchild)) + 1;
 
            //已在*T的右子树插入结点key,判断是否需要进行旋转以保持二叉*衡树的特性。
            if (-2 == GetHeight((*T)->lchild) - GetHeight((*T)->rchild))
            {
                //在右子树的左子树中插入结点。
                if (GetHeight((*T)->rchild->lchild) > GetHeight((*T)->rchild->rchild))
                {
                    RLRotate(T);
                }
                //在右子树的右子树中插入结点。
                else
                {
                    RRRotate(T);
                }
            }
            return true;
        }
    }
}

以下图为例进行两个关键点的说明:进行旋转的树为最小不*衡二叉树;插入结点之后父结点高度的递归修正。

假如要在图一二叉*衡树中插入结点1,

 

函数调用步骤:

1

调用函数AVLInsert(&9,1)(为表述方便,以&9代表指向结点9的指针);

2

由于1<9,继续调用AVLInsert(&7,1);

3

由于1<7,继续调用AVLInsert(&3,1);

4

由于1<3,继续调用AVLInsert(&2,1);

5

由于2<1,继续调用AVLInsert(NULL,1),此时由于*T为空树,增加结点1,并把结点1的高度设置为1,左右孩子分别为空树,如图二所示。函数返回TRUE;

6

AVLInsert(NULL,1)函数返回TRUE,并返回至AVLInsert(&2,1),因插入成功,所以更新结点2的高度为max(1,0)+1=2,结点2的*衡因子为1,不进行旋转操作,函数返回TRUE;

7

AVLInsert(&2,1)函数返回TRUE,并返回至AVLInsert(&3,1),因插入成功,所以更新结点3的高度为max(2,1)+1=3,结点3的*衡因子为1,不进行旋转操作,函数返回TRUE;

8

AVLInsert(&3,1)函数返回TRUE,并返回至AVLInsert(&7,1),因插入成功,所以更新结点7的高度为max(3,1)+1=4,结点7的*衡因子为2,进行旋转操作,旋转之后,更新结点3的高度为2,结点7的高度为2,如图三所示。函数返回TRUE;

9

AVLInsert(&7,1)函数返回TRUE,并返回至AVLInsert(&9,1),因插入成功,所以更新结点9的高度为max(2,1)+1=4,结点9的*衡因子为1,不进行旋转操作,函数返回TRUE,插入过程结束。

插入的结点一定为叶子结点,插入结点之后依次进行递归调用的返回操作,在返回之后,修正父结点的高度(2->3->7->9),之后判断父结点的*衡因子,当*衡因子超范围(结点7)时,以该结点为根结点的树为最小不*衡二叉树,此时进行旋转操作。当AVLInsert(&7,1)函数返回之后,以结点7的父结点9为根结点的树将不再需要进行旋转操作。因此每次通过函数AVLInsert()插入一个结点时,旋转操作只在最小不*衡二叉树中进行一次。已插入结点的父结点的高度是在递归过程中依次进行修正的。

4.      删除操作

删除操作的代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/*
 * 删除操作。
 * 如果以*T为根结点的树中存在结点key,将结点删除,函数返回TRUE,
 * 否则删除失败,函数返回FALSE。
 */
bool AVLDelete(BiTree *T, TElemType key)
{
    BiTree pre, post;
 
    //没有找到该结点。
    if (!*T)
        return false;
    //找到结点,将它删除。
    else if (key == (*T)->data)
    {
        //待删除节点为叶子结点。
        if (!(*T)->lchild && !(*T)->rchild)
            *T = NULL;
        //待删除结点只有右孩子。
        else if (!(*T)->lchild)
            *T = (*T)->rchild;
        //待删除结点只有左孩子。
        else if (!(*T)->rchild)
            *T = (*T)->lchild;
        //待删除结点既有左孩子,又有右孩子。
        else
        {
            //当待删除结点*T左子树的高度大于右子树的高度时,用*T的前驱结点pre代替*T,
            //再将结点pre从树中删除。这样可以保证删除结点后的树仍为二叉*衡树。
            if (GetHeight((*T)->lchild) > GetHeight((*T)->rchild))
            {
                //寻找前驱结点pre。
                pre = (*T)->lchild;
                while (pre->rchild)
                {
                    pre = pre->rchild;
                }
                //用pre替换*T。
                (*T)->data = pre->data;
                 
                //删除节点pre。
                //虽然能够确定pre所属最小子树的根结点为&pre,
                //但是不采用AVLDelete(&pre,pre->data)删除pre,目的是方便递归更改节点的高度。
                AVLDelete(&((*T)->lchild), pre->data);
            }
            //当待删除结点*T左子树的高度小于或者等于右子树的高度时,用*T的后继结点post代替*T,
            //再将结点post从树中删除。这样可以保证删除结点后的树仍为二叉*衡树。
            else
            {
                //寻找后继节点post。
                post = (*T)->rchild;
                while (post->lchild)
                    post = post->lchild;
                //用post替换*T。
                (*T)->data = post->data;
 
                //删除节点post。
                //虽然能够确定post所属最小子树的根结点为&post,
                //但是不采用AVLDelete(&post,post->data)删除post,目的是方便递归更改节点的高度。
                AVLDelete(&((*T)->rchild), post->data);
            }
        }
        return true;
    }
    //在左子树中递归删除。
    else if (key < (*T)->data)
    {
        if (!AVLDelete(&((*T)->lchild), key))
            return false;
        else
        {
            //删除成功,修改树的高度。

以上是关于二叉平衡树的插入和删除操作的主要内容,如果未能解决你的问题,请参考以下文章

平衡二叉树的操作(高手进)

红黑树平衡二叉查找树

红黑树平衡二叉查找树

红黑树的插入与删除

了解数据结构之平衡二叉树 (AVL)-插入和删除

平衡二叉树的删除

(c)2006-2024 SYSTEM All Rights Reserved IT常识