AVL树

最新推荐文章于 2024-07-24 12:42:40 发布
最新推荐文章于 2024-07-24 12:42:40 发布
阅读量151 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_fearless_engineer/article/details/102493214
版权

文章目录

简介

  AVL树是最早发明的自平衡二叉查找树。AVL树要求任意节点的两个子树的高度差不大于一，所以是一种高度平衡的二叉查找树。AVL树的高度平衡性使得其查找性能十分优越，但也正是由于其高度平衡性使得每插入或删除一个节点需要一次或多次树旋转来平衡这棵树。因为在大多数环境中AVL树查找快速的优点无法掩盖它插入或删除时操作复杂的缺点，所以UNIX和C++STL中的平衡树大部分使用的是红黑树而不是AVL树。
  AVL树是一棵二叉搜索树，在阅读此篇博客前需要读者具备二叉搜索树的相关知识以及二叉搜索树插入和删除节点的算法基础。

树的高度

  所谓树的高度在AVL树中的定义是：空指针的高度为零，叶子节点的高度为一，非叶子节点的高度为高度较高的子节点的高度加一。
  AVL树时刻要保持平衡，所以如果插入或删除一个节点后树发生了失衡，就需要立即对树进行旋转以保持树的平衡。在AVL树中插入或删除一个节点可以让树的高度不变或者高度加一，不可能出现其他情况。由于AVL树的任意节点的两个子树的高度差不大于一，所以插入或删除节点后若发生树的失衡，其两棵子树的高度差只可能为二。

树的旋转

  AVL树失衡时其高度差只能为二，高度差为二失衡总共有以下六种。

失衡情况一
A
B
H
C
F
D
E
失衡情况二
A
B
H
D
C
E
F
失衡情况三
A
B
K
C
D
E
F
H
I
失衡情况四
A
D
B
E
C
F
H
失衡情况五
A
D
B
C
H
E
F
失衡情况六
A
E
B
C
D
F
G
H
I

  在以上六种情况中情况三和情况六不可能在AVL中出现，因为在出现情况三之前已经出现了情况一和情况二，出现情况六之前已经出现了情况四和情况五。所以最终我们只需要解决四种失衡情况，对应这四种情况有以下四种旋转方式来调节平衡。

左左旋转
A
B
H
C
F
D
E
B
C
A
F
H
D
E

左右旋转
A
B
H
D
C
E
F
C
B
A
D
E
F
H

右右旋转
A
D
B
E
C
F
H
B
A
C
D
E
F
H

右左旋转
A
D
B
C
H
E
F
C
A
B
D
E
F
H

实现代码

C语言

#include <stdio.h>
#include <stdlib.h>
typedef int ELEMENT;
typedef struct __tree_node{
    ELEMENT data;///节点元素
    size_t high;///当前节点的高度
    struct __tree_node *left, *right;///左右子节点指针
}TREE_NODE;
/** \brief 元素比较函数
 *
 * \param x ELEMENT
 * \param y ELEMENT
 * \return int
 *
 */
int element_compare(ELEMENT x,ELEMENT y){
    return x-y;
}
/** \brief 获取节点高度
 *
 * \param root TREE_NODE* 节点或空节点
 * \return int 节点高度，空节点为零
 *
 */
size_t __avl_get_high(TREE_NODE *root){
    return root ? root->high : 0;
}
/** \brief 计算节点高度
 *
 * \param root TREE_NODE* 非空节点
 * \return int 节点高度
 *
 */
size_t __avl_calculate_high(TREE_NODE *root){
    return ((__avl_get_high(root->left)>__avl_get_high(root->right))?__avl_get_high(root->left):__avl_get_high(root->right))+1;
}
/** \brief 左左旋转
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后根节点
 *
 */
TREE_NODE *__avl_rotate_left_left(TREE_NODE *root){
    TREE_NODE *temp = root->left;
    root->left = temp->right;
    temp->right = root;
    root->high = __avl_calculate_high(root);
    temp->high = __avl_calculate_high(temp);
    return temp;
}
/** \brief 右右旋转
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后根节点
 *
 */
TREE_NODE *__avl_rotate_right_right(TREE_NODE *root){
    TREE_NODE *temp = root->right;
    root->right = temp->left;
    temp->left = root;
    root->high = __avl_calculate_high(root);
    temp->high = __avl_calculate_high(temp);
    return temp;
}
/** \brief 左右旋转
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后根节点
 *
 */
TREE_NODE *__avl_rotate_left_right(TREE_NODE *root){
    TREE_NODE *temp = root->left->right;
    root->left->right = temp->left;
    temp->left = root->left;
    root->left = temp->right;
    temp->right = root;
    root->high = __avl_calculate_high(root);
    temp->high = __avl_calculate_high(temp);
    temp->left->high = __avl_calculate_high(temp->left);
    return temp;
}
/** \brief 右左旋转
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后根节点
 *
 */
TREE_NODE *__avl_rotate_right_left(TREE_NODE *root){
    TREE_NODE *temp = root->right->left;
    root->right->left = temp->right;
    temp->right = root->right;
    root->right = temp->left;
    temp->left = root;
    root->high = __avl_calculate_high(root);
    temp->high = __avl_calculate_high(temp);
    temp->right->high = __avl_calculate_high(temp->right);
    return temp;
}
/** \brief 左旋转（非右子树旋转）
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后的根节点
 *
 */
TREE_NODE *__avl_rotate_left(TREE_NODE *root){
    if(__avl_get_high(root->left->left) < __avl_get_high(root->left->right)){  ///左子树的右子树高度高则左右旋转
        root = __avl_rotate_left_right(root);
    }else{
        root = __avl_rotate_left_left(root);
    }
    return root;
}
/** \brief 右旋转（非左子树旋转）
 *
 * \param root TREE_NODE* 旋转前根节点
 * \return TREE_NODE* 旋转后根节点
 *
 */
TREE_NODE *__avl_rotate_right(TREE_NODE *root){
    if(__avl_get_high(root->right->right) < __avl_get_high(root->right->left)){  ///右子树的左子树高度高则右左旋转
        root = __avl_rotate_right_left(root);
    }else{
        root = __avl_rotate_right_right(root);
    }
    return root;
}
/** \brief 左调整（非右子树调整）
 *
 * \param root TREE_NODE* 调整前的根节点
 * \return TREE_NODE* 调整后的根节点
 *
 */
TREE_NODE *__avl_adjust_left(TREE_NODE *root){
    if(__avl_get_high(root->left)-__avl_get_high(root->right) == 2){///左子树是否过高
        root = __avl_rotate_left(root);
    }else{///旋转函数中含有高度计算，如果树并未失衡则需要单独计算高度
        root->high = __avl_calculate_high(root);
    }
    return root;
}
/** \brief 右调整（非左子树调整）
 *
 * \param root TREE_NODE* 调整前的根节点
 * \return TREE_NODE* 调整后的根节点
 *
 */
TREE_NODE *__avl_adjust_right(TREE_NODE *root){
    if(__avl_get_high(root->right)-__avl_get_high(root->left) == 2){///右子树是否过高
        root = __avl_rotate_right(root);
    }else{///旋转函数中含有高度计算，如果树并未失衡则需要单独计算高度
        root->high = __avl_calculate_high(root);
    }
    return root;
}
/** \brief 创建节点
 *
 * \param data ELEMENT 节点内的数据
 * \return TREE_NODE* 节点指针
 *
 */
TREE_NODE *create_node(ELEMENT data){
    TREE_NODE *temp = (TREE_NODE *)malloc(sizeof(TREE_NODE));
    if(temp){
        temp->data = data;
        temp->high = 1;
        temp->left = NULL;
        temp->right = NULL;
    }
    return temp;
}
/** \brief 向树中插入节点
 *
 * \param root TREE_NODE* 旋转前根节点
 * \param data ELEMENT 需要插入的节点
 * \return TREE_NODE* 插入后的根节点
 *
 */
TREE_NODE *avl_insert(TREE_NODE *root,ELEMENT data){
    int diff;
    if(root){
        diff = element_compare(data,root->data);
        if(diff < 0){///向左子树中插入节点
            root->left = avl_insert(root->left,data);///递归插入节点
            root = __avl_adjust_left(root);
        }else if(0 < diff){///向右子树中插入节点
            root->right = avl_insert(root->right,data);///递归插入节点
            root = __avl_adjust_right(root);
        }
    }else{///根节点为空则将插入节点作为根节点
        root = create_node(data);
    }
    return root;
}
/** \brief 移出树中最左侧节点
 *
 * \param root TREE_NODE** 指向根节点指针的指针
 * \return TREE_NODE* 指向移出节点的指针
 *
 */
TREE_NODE *avl_remove_leftmost(TREE_NODE **root){
    TREE_NODE *temp;
    if((*root)->left){
        temp = avl_remove_leftmost(&(*root)->left);///递归找到最左侧节点
        *root = __avl_adjust_right(*root);
    }else{
        temp = *root;
        *root = temp->right;
    }
    return temp;
}
/** \brief 移出树中最右侧节点
 *
 * \param root TREE_NODE** 指向根节点指针的指针
 * \return TREE_NODE* 指向移出节点的指针
 *
 */
TREE_NODE *avl_remove_rightmost(TREE_NODE **root){
    TREE_NODE *temp;
    if((*root)->right){
        temp = avl_remove_rightmost(&(*root)->right);///递归找到最右侧节点
        *root = __avl_adjust_left(*root);
    }else{
        temp = *root;
        *root = temp->left;
    }
    return temp;
}
/** \brief 移出树的根节点
 *
 * \param root TREE_NODE** 指向根节点指针的指针
 * \return TREE_NODE* 指向移出节点的指针
 *
 */
TREE_NODE *remove_root(TREE_NODE **root){
    TREE_NODE *temp = *root;
    if(temp->left||temp->right){///该节点是否存在子节点
        if(__avl_get_high(temp->right) < __avl_get_high(temp->left)){///如果左子树高则从左子树中选取新的根节点
            *root = avl_remove_rightmost(&(temp->left));///移出左子树中最右侧节点作为新的根节点
            (*root)->left = temp->left;
            (*root)->right = temp->right;
            *root = __avl_adjust_right(*root);
        }else{
            *root = avl_remove_leftmost(&(temp->right));///移出右子树中最左侧节点作为新的根节点
            (*root)->left = temp->left;
            (*root)->right = temp->right;
            *root = __avl_adjust_left(*root);
        }
    }else{
        *root = NULL;
    }
    return temp;
}
/** \brief 移出节点
 *
 * \param root TREE_NODE** 指向根节点指针的指针
 * \param data ELEMENT 需要移出的数据
 * \return TREE_NODE* 指向移出的节点，如果没有返回为空
 *
 */
TREE_NODE *avl_remove(TREE_NODE **root,ELEMENT data){
    TREE_NODE *temp;
    int diff;
    if(*root){
        diff = element_compare(data,(*root)->data);
        if(diff<0){
            temp = avl_remove(&(*root)->left,data);///递归
            *root = __avl_adjust_right(*root);
        }else if(diff>0){
            temp = avl_remove(&(*root)->right,data);///递归
            *root = __avl_adjust_left(*root);
        }else{///找到目标节点
            temp = remove_root(root);
        }
        return temp;
    }
    return NULL;///空节点返回空
}
/** \brief 查找节点
 *
 * \param root TREE_NODE* 根节点指针
 * \param data ELEMENT 目标元素
 * \return TREE_NODE* 指向目标节点的指针
 *
 */
TREE_NODE *avl_find(TREE_NODE *root,ELEMENT data){
    int diff;
    if(root){
        diff = element_compare(data,root->data);
        if(diff<0){///目标值小于该节点向左子树递归查找
            root = avl_find(root->left,data);
        }else if(diff>0){///目标值大于该节点向右子树递归查找
            root = avl_find(root->right,data);
        }///目标值等于该节点则不会陷入递归直接返回该节点
    }
    return root;
}

void print(TREE_NODE *node){
    printf("%d %d\n",node->data,node->high);
}
void preorder_base(TREE_NODE *root){
    if(root){
        print(root);
        preorder_base(root->left);
        preorder_base(root->right);
    }
}
void preorder(TREE_NODE *root){
    printf("preoder:\n");
    preorder_base(root);
}
void inorder_base(TREE_NODE *root){
    if(root){
        inorder_base(root->left);
        print(root);
        inorder_base(root->right);
    }
}
void inorder(TREE_NODE *root){
    printf("inorder:\n");
    inorder_base(root);
}

int main(){
    int test[] = {
        89,70,52,48,78,52,47,55,99
    };
    TREE_NODE *root = NULL;
    for(size_t i=0;i<sizeof(test)/sizeof(ELEMENT);i++){
        root = avl_insert(root,test[i]);
    }
    inorder(root);
    preorder(root);

    if(avl_find(root,test[2])){
        printf("find success\n");
    }else{
        printf("find fail\n");
    }
    if(avl_remove(&root,test[2])){
        printf("remove success\n");
    }else{
        printf("remove fail\n");
    }
    if(avl_find(root,test[2])){
        printf("find success\n");
    }else{
        printf("find fail\n");
    }

    printf("remove min: %d\n",avl_remove_leftmost(&root)->data);
    inorder(root);
    preorder(root);

    printf("remove min: %d\n",avl_remove_leftmost(&root)->data);
    inorder(root);
    preorder(root);

    printf("remove min: %d\n",avl_remove_leftmost(&root)->data);
    inorder(root);
    preorder(root);

    printf("remove max: %d\n",avl_remove_rightmost(&root)->data);
    inorder(root);
    preorder(root);

    printf("remove max: %d\n",avl_remove_rightmost(&root)->data);
    inorder(root);
    preorder(root);

    return 0;
}
电器爆破专家
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL 树
sqjddb的博客
03-10 386
一、AVL树的由来及概念 二、AVL树的原理（旋转） 三、AVL树的实现 四、AVL树的性能
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 1万+
AVL树（C++实现）
AVL树详解
北川_的博客
03-09 1602
目录AVL树的概念AVL树节点的定义AVL树如何高度平衡？右单旋左单旋左右双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)， 即可降低树的高度，从而减少平均搜索长度。 AVL
数据结构：AVL树
decade777555的博客
03-07 1365
两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
【 C++ 】AVL树
bit_zyx的博客
09-04 870
目录 1、底层结构 2、AVL树的概念 3、AVL树节点的定义 4、基本框架 5、AVL树的插入 6、AVL树的旋转 左单旋 右单旋 左右双旋 右左双旋 7、AVL树的验证 8、AVL树的查找 9、AVL树的删除（了解） 10、AVL树的性能 11、源码链接.........
C++ AVL树
weixin_53946312的博客
01-27 1047
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
构建AVL树
weixin_43796767的博客
06-02 988
AVL（Adelson-Velskii and Landis）树是满足平衡条件的二叉搜索树：左右子树的深度差不大于1。 一、理解AVL树 目标：通过调整二叉树结构，提高二叉查找的效率。 构建手段：左旋转、右旋转、双旋转。 类似抖葡萄那样，找到合适的节点作为新的根，拎起来抖两下，树结构就得到了调整。 四种失衡情况： 1）LL（left-left）型： 失衡位置从名字可以看出，左子树的左侧挂了太多节点； 此时需要的调整是右旋，顺时针旋转一下，即可恢复平衡。 2）RR（right-right）型 3）LR
AVL树的 插入 和 删除
潜心钻研技术
03-11 1881
AVL树的 插入 和 删除
c++——AVL树
Britney_dark的博客
11-08 1447
如果结果不如你所愿，就在尘埃落定前奋力一搏！
AVL.rar_AVL树
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作后能自动调整...
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 636
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1086
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 964
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 678
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 379
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1182
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
AVL树：平衡搜索树的优化策略
AVL树是一种自平衡的二叉搜索树，它是在1962年由G.M.Adelson-Velsky和E.M.Landis发明的，用于优化二叉搜索树的性能，特别是减少搜索时间。引入AVL树的主要目的是为了提高二叉搜索树的效率，确保树的高度保持在最优...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值