树之完全二叉树(AVL树)

2019年3月20日 292次阅读 来源: AVL树

目录

  1. AVL树的简介
  2. AVL举例以及详细分析
  3. 代码块
  4. 测试结果和参考图纸
  5. 备注

AVL树的简介

AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。
它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于”二叉查找树”，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。

这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。

《树之完全二叉树(AVL树)》
上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。
AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。
如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理。学AVL树，重点的地方也就是它的旋转算法；在后文的介绍中，再来对它进行详细介绍。

AVL举例以及详细分析

AVL树的自平衡操作——旋转：
前面说过，如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：
《树之完全二叉树(AVL树)》
《树之完全二叉树(AVL树)》
上面的两张图都是为了便于理解，而列举的关于”失去平衡的AVL树”的例子。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：

**(1) LL：LeftLeft，也称为”左左”。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于”根节点(8)的左子树(4)的左子树(2)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。
(2) LR：LeftRight，也称为”左右”。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于”根节点(8)的左子树(4)的左子树(6)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。
(3) RL：RightLeft，称为”右左”。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于”根节点(8)的右子树(12)的左子树(10)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。
(4) RR：RightRight，称为”右右”。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于”根节点(8)的右子树(12)的右子树(14)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。**

LL的旋转：

《树之完全二叉树(AVL树)》
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
对于LL旋转，你可以这样理解为：LL旋转是围绕”失去平衡的AVL根节点”进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着”左孩子，即k1”使劲摇。将k1变成根节点，k2变成k1的右子树，”k1的右子树”变成”k2的左子树”。

RR的旋转 ：

《树之完全二叉树(AVL树)》
理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！

LR的旋转 ：

《树之完全二叉树(AVL树)》
LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。

RL的旋转 ：

《树之完全二叉树(AVL树)》
RL是与LR的对称情况！第一次旋转是围绕”k3”进行的”LL旋转”，第二次是围绕”k1”进行的”RR旋转”。

代码块

#include<stdio.h>
#include<stdlib.h>
#define HEIGHT(p) ((p==NULL)?-1:(((Node *)(p))->height))
#define MAX(a,b) ((a)>(b)?(a):(b))
typedef int Type;

typedef struct AVLTreeNode
{
    Type key;//关键字（键值）
    int height;
    struct AVLTreeNode *left;
    struct AVLTreeNode *right;
}Node, *AVLTree;

int avltree_height(AVLTree tree);
void preorder_avltree(AVLTree tree);
void inorder_avltree(AVLTree tree);
void postorder_avltree(AVLTree tree);


AVLTree avltree_search(AVLTree x,Type key);
AVLTree avltree_minimum(AVLTree tree);
AVLTree avltree_maximum(AVLTree tree);

AVLTree avltree_insert(AVLTree tree, Type key);
AVLTree avltree_delete(AVLTree tree, Type key);

void destory_avltree(AVLTree tree);

int avltree_height(AVLTree tree)
{
    return HEIGHT(tree);
}

void preorder_avltree(AVLTree tree)
{
    if (tree != NULL)
    {
        printf("%d ", tree->key);
        preorder_avltree(tree->left);
        preorder_avltree(tree->right);
    }
}

void inorder_avltree(AVLTree tree)
{
    if (tree != NULL)
    {
        inorder_avltree(tree->left);
        printf("%d ", tree->key);
        inorder_avltree(tree->right);
    }
}

void postorder_avltree(AVLTree tree)
{
    if (tree != NULL)
    {
        postorder_avltree(tree->left);
        postorder_avltree(tree->right);
        printf("%d ", tree->key);
    }
}

AVLTree avltree_search(AVLTree x, Type key)
{
    if (x == NULL || x->key == key)
        return x;

    if (key < x->key)
        return avltree_search(x->left, key);
    else
        return avltree_search(x->right, key);
}

AVLTree avltree_minimum(AVLTree tree)
{
    if (tree == NULL)
    {
        return NULL;
    }
    while (tree->left != NULL)
    {
        tree = tree->left;
    }
    return tree;
}

AVLTree avltree_maximum(AVLTree tree)
{
    if (tree == NULL)
    {
        return NULL;
    }
    while (tree->right != NULL)
    {
        tree = tree->right;
    }
    return tree;
}

AVLTree left_left_rotation(AVLTree k2)//LL左左对应情况（左单旋转）
{
    AVLTree k1;
    k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k2->height = MAX(HEIGHT(k2->left), HEIGHT(k2->right)) + 1;
    k1->height = MAX(HEIGHT(k1->left), k2->height) + 1;

    return k1;//返回值为旋转后的根节点
}

AVLTree right_right_rotation(AVLTree k1)//RR右右对应情况（右单旋转）
{
    AVLTree k2;
    k2 = k1->right;
    k1->right = k2->left;
    k2->left = k1; 

    k1->height = MAX(HEIGHT(k1->left), HEIGHT(k1->right)) + 1;
    k2->height = MAX(HEIGHT(k2->right), k1->height)+ 1;

    return k2;//返回值为旋转后的根节点
}

AVLTree left_right_rotation(AVLTree k3)//LR
{
    k3->left = right_right_rotation(k3->left);
    return left_left_rotation(k3);//返回值为旋转后的根节点
}

AVLTree right_left_rotation(AVLTree k1)//RL
{
    k1->right = left_left_rotation(k1->right);
    return right_right_rotation(k1);//返回值为旋转后的根节点
}

AVLTree avltree_insert(AVLTree tree, Type key)
{
    //key是要插入的键值
    if (tree == NULL)
    {
        tree = (Node *)malloc(sizeof(Node));
        if (tree == NULL)
        {
            printf("ERROR:creat avltree node failed!\n");
        }
        tree->key = key;
        tree->height = 0;
        tree->left = NULL;
        tree->right = NULL;
    }
    else if (key < tree->key)//key应该插入tree的左子树中
    {
        tree->left = avltree_insert(tree->left, key);
        //插入节点后若avl树失去平衡，则应该进行相应的调节
        if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
        {
            if (key < tree->left->key)
            {
                tree = left_left_rotation(tree);
            }
            else
            {
                tree = left_right_rotation(tree);
            }
        }
    }
    else if (key > tree->key)//key应该插入tree的右子树中
    {
        tree->right = avltree_insert(tree->right, key);
        //插入节点后若avl树失去平衡，则应该进行相应的调节
        if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
        {
            if (key>tree->right->key)
            {
                tree = right_right_rotation(tree);
            }
            else
            {
                tree = right_left_rotation(tree);
            }
        }
    }
    else//key==tree->key
    {
        printf("添加失败，不允许添加相同的节点!\n");
    }
    tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;

    return tree;
}

AVLTree delete_node(AVLTree tree, AVLTree z)
{
    if (tree == NULL || z == NULL)
    {
        return NULL;
    }
    if (z->key < tree->key)// 待删除的节点在"tree的左子树"中
    {
        tree->left = delete_node(tree->left, z);
        //删除左子树的节点后后左子树如果比右子树高度小2，进行调整
        if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
        {
            AVLTree r = tree->right;//对右子树进行调整
            //如果右子树的左子树比其右子树高度大为RL否则为RR
            if (HEIGHT(r->left) > HEIGHT(r->right))
            {
                tree = right_left_rotation(tree);
            }
            else
            {
                tree = right_right_rotation(tree);
            }
        }
    }
    else if (z->key>tree->key)// 待删除的节点在"tree的右子树"中
    {
        tree->right = delete_node(tree->right, z);
        //删除右子树的节点后，左子树高度比右子树大2时，进行调整
        if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
        {
            AVLTree l = tree->left;//对左子树进行调整
            //如果左子树的右子树比其左子树高度大，为LR,否则为LL
            if (HEIGHT(l->right) > HEIGHT(l->left))
            {
                tree = left_right_rotation(tree);
            }
            else
            {
                tree = left_left_rotation(tree);
            }
        }
    }
    else//tree对应的是要删除的点
    {
        if ((tree->left) && (tree->right))// tree的左右孩子都非空 
        {
            if (HEIGHT(tree->left) > HEIGHT(tree->right))
            {
                // 如果tree的左子树比右子树高；
                // 则(01)找出tree的左子树中的最大节点 
                // (02)将该最大节点的值赋值给tree。 
                // (03)删除该最大节点。 
                // 这类似于用"tree的左子树中最大节点"做"tree"的替身； 
                // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。 
                AVLTree max = avltree_maximum(tree->left);
                tree->key = max->key;
                tree->left = delete_node(tree->left, max);
            }
            else
            {
                // 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1) 
                // 则(01)找出tree的右子树中的最小节点 
                // (02)将该最小节点的值赋值给tree。 
                // (03)删除该最小节点。 
                // 这类似于用"tree的右子树中最小节点"做"tree"的替身； 
                // 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。 
                AVLTree min = avltree_minimum(tree->right);
                tree->key = min->key;
                tree->right = delete_node(tree->right, min);
            }
        }
        else
        {
            AVLTree tmp = tree;
            tree = tree->left ? tree->left:tree->right;
            free(tmp);
        }
    }

    return tree;
}

AVLTree avltree_delete(AVLTree tree, Type key)
{
    AVLTree z;
    //查看要被删除的节点是否在树中，是则删除！
    if ((z = avltree_search(tree, key)) != NULL)
    {
        tree = delete_node(tree, z);
    }
    return tree;
}

int main(void)
{
    int i, n;
    AVLTree root = NULL;
    Type tmp;
    printf("Number of Elements:");
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        printf("Element %d：", i + 1);
        scanf("%d", &tmp);
        root = avltree_insert(root, tmp);
    }

    printf("\n== 前序遍历: ");
    preorder_avltree(root);

    printf("\n== 中序遍历: ");
    inorder_avltree(root);

    printf("\n== 后序遍历: ");
    postorder_avltree(root);
    printf("\n");

    printf("== 高度: %d\n", avltree_height(root));
    printf("== 最小值: %d\n", avltree_minimum(root)->key);
    printf("== 最大值: %d\n", avltree_maximum(root)->key);

    printf(" \nNode that will be deteleted:");
    int m;
    scanf("%d", &m);
    printf("\n== 删除根节点: %d", m);
    root = avltree_delete(root, m);

    printf("\n== 高度: %d", avltree_height(root));
    printf("\n== 中序遍历: ");
    inorder_avltree(root);

    system("pause");
    return 0;

}

测试结果与参考图纸

《树之完全二叉树(AVL树)》
《树之完全二叉树(AVL树)》

《树之完全二叉树(AVL树)》

备注

下面，我们对测试程序的流程进行分析！
1. 新建AVL树
新建AVL树的根节点root。

  1. 依次添加”3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9” 到AVL树中，过程如下。
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》
    《树之完全二叉树(AVL树)》

输出下面树的信息：
《树之完全二叉树(AVL树)》

    原文作者：AVL树
    原文地址: https://blog.csdn.net/gailyyelp/article/details/64934050
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞