高级数据结构之AVL树

最新推荐文章于 2024-02-02 20:58:11 发布
原创 最新推荐文章于 2024-02-02 20:58:11 发布 · 586 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树 #AVL树

AVL树的简单介绍

百度百科
AVL树又叫做二叉平衡排序树，是平衡二叉树的一种改进版本。因为普通的平衡二叉树存在左右失衡，退化为链表的风险，因此需要某种策略来进行平衡调整。AVL树是根据左右子树的树高作为调整策略。也有一种叫做SB 树（size balance tree)，是根据左右子树节点的数量作为调整策略。

性质

  • 拥有二叉排序树所有性质：
    任意节点的值大于左孩子，小于右孩子。
    即：通过中序遍历二叉排序树就可以得到一个有序序列。
  • 任意节点满足左右子树高度差不大于1

失衡条件

AVL树的最重要性质就是左右子树是平衡的，因此打破了平衡就会导致失衡。也就是左右子树的高度差大于1。一般来说只会到达2。

失衡类型及调整方案

四种不平衡状态：

  • LL：即某节点A的左子树失衡，（意味着A左子树高度= A 右左子树高度+ 2），且A左子树的左子树比A左子树的右子树更高。如图：
    在这里插入图片描述
# 先看左边的图：

此时K1为失衡节点。假设ABCD的树高分别为HA,HB,HC,HD.
则根据失衡条件：
Hk2 = Hk3 + 2 //左子树树高比右子树大2
Hk2 = HA + 1 = HB + 2 // 因为是LL类型，左-左大于左-右
Hk3 = max(HC,HD) + 1; //显然HC HD 的差值最多为1
因此可以得到关系式：HA = HB + 1 = max(HC,HD) + 2
凡是满足这个式子的节点，它必然是LL类型的失衡。

在看右边的图：

旋转完成后：
K3 依然平衡
分析K1：由于 HB = max(HC,HD) + 1 因此K1显然也是平衡的
分析K2: 由于HA = HB + 1 所以K2也是平衡的。
所以旋转的本质是什么？就是把存在高度差的子树重新安排一个新的合适的位置。

  • LR：显然LR的意思就是A的左子树失衡，且其右子树高度高于左子树。
    在这里插入图片描述
    这种情况，需要先对A的左子树进行一次左旋，再对A进行右旋。（先小左旋，后大右旋）
    还是按照上面的套路分析树高：
    Hk2 = HD + 2 // 左子树失衡
    Hk2 = Hk3 + 1=HA + 2 = max(HB,HC) + 2 // HA+1 = Hk3
    可知： HA= HD = max(HB,HC）
    这就是LR失衡的四颗子树的高度关系。

  • RR：与LL对称，只有左右顺序的差别 可以自行分析。
    调整操作为：对A左旋。(大左旋)

  • RL：与LR对称，也不细说了。
    调整操作：先对A的左子树右旋，然后对A左旋。（先小右旋，后大左旋）

核心代码实现

//AVL树结构定义
#define L(n) (n->lchild)
#define R(n) (n->rchild)
#define H(n) (n->h)
typedef struct Node {
    int key;
    int h; //高度
    struct Node *lchild,*rchild;
} Node;
//虚拟空节点，替代NULL，可以访问
Node __NIL;
#define NIL (&__NIL)
__attribute__((constructor))
void init__NIL() {
    NIL->key = 0, NIL->h = 0;
    NIL->lchild = NIL->rchild = NIL;
    return;
}
//在main函数之前初始化上面这段代码


//左旋函数
Node *left_rotate(Node *root) {
    Node *temp = root->rchild; // 新根节点
    root->rchild = temp->lchild; //新的根节点的左成为了旧的根节点的右子树
    temp->lchild = root; //旧根成新左
    update_height(root);
    update_height(temp);
    return temp;
}
//右旋，记这个
Node *right_rotate(Node *root){
    Node *temp = root->lchild; // 新根
    root->lchild = temp->rchild; //新右成旧左
    temp->rchild = root; //旧根成新左
    update_height(root);
    update_height(temp);
    return temp;
}
//调整函数
Node *maintain(Node *root) {
    if (abs(H(L(root)) - H(R(root))) <= 1) return root;
        if (root->lchild->h > root->rchild->h) {
            //LR先小左旋
            if(root->lchild->lchild->h < root->lchild->rchild->h)
                root->lchild = left_rotate(root->lchild);
            //LL 只需大右旋
            root = right_rotate(root);
        } else {
                //RL 先小右旋
                if (root->rchild->rchild->h < root->rchild->lchild->h)
                    root->rchild = right_rotate(root->rchild);
                //RR 大左旋
                root = left_rotate(root);
        }

        return root;
}

附录 完整代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;

#define L(n) (n->lchild)
#define R(n) (n->rchild)
#define H(n) (n->h)
typedef struct Node {
    int key;
    int h; //高度
    struct Node *lchild,*rchild;
} Node;
//虚拟空节点，替代NULL
Node __NIL;
#define NIL (&__NIL)
__attribute__((constructor))
void init__NIL() {
    NIL->key = 0, NIL->h = 0;
    NIL->lchild = NIL->rchild = NIL;
    return;
}
//优先初始化上面这段代码



Node *maintain(Node *root);

Node *getNewNode(int key) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = key;
    p->h = 1;
    p->lchild = p->rchild = NIL;
    return p;
}
void clear(Node *root) {
    if(root == NIL)
        return;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return;
}

void update_height(Node *root){
    root->h = H(L(root)) > H(R(root)) ? H(L(root)) + 1 : H(R(root)) + 1;
    return;
}
Node *insert(Node *root, int key) {
    if (root == NIL) return getNewNode(key);
    if (root->key == key) return root;
    if (key < root->key)
        root->lchild = insert(root->lchild, key);
    else
        root->rchild = insert(root->rchild,key);
    update_height(root);
    return maintain(root);
}


//找前驱
Node *predecessor(Node *root) {
    Node* temp = root->lchild;
    //左节点的最右节点
    while(temp->rchild) temp = temp->rchild;
    return temp;
}
//左旋 和右旋对称
Node *left_rotate(Node *root) {
    Node *temp = root->rchild; // 新根节点
    root->rchild = temp->lchild; //新左挂旧右
    temp->lchild = root; //旧根挂新左
    update_height(root);
    update_height(temp);
    return temp;
}
//右旋，记这个
Node *right_rotate(Node *root){
    Node *temp = root->lchild; // 新根
    root->lchild = temp->rchild; //新右成旧左
    temp->rchild = root; //旧根成新左
    update_height(root);
    update_height(temp);
    return temp;
}
//调整
Node *maintain(Node *root) {
    if (abs(H(L(root)) - H(R(root))) <= 1) return root;
        if (root->lchild->h > root->rchild->h) {
            //LR先小左旋
            if(root->lchild->lchild->h < root->lchild->rchild->h)
                root->lchild = left_rotate(root->lchild);
            //LL 只需大右旋
            root = right_rotate(root);
        } else {
                //RL 先小右旋
                if (root->rchild->rchild->h < root->rchild->lchild->h)
                    root->rchild = right_rotate(root->rchild);
                //RR 大左旋
                root = left_rotate(root);
        }

        return root;
}
//删除
Node *erase(Node *root, int key){
    if ( root == NIL) return NIL;
    if (key < root->key)
        root->lchild = erase(root->lchild,key);
    else if(key > root->key)
        root->rchild = erase(root->rchild,key);
    else {
        // 叶子节点 或者 度为1
        if(root->lchild == NIL || root->rchild == NIL) {
            Node *temp = root->lchild ? root->lchild : root->rchild;
            free(root);
            return temp;
        } else {
            Node *temp = predecessor(root); // 找前驱
            root->key = temp->key; //覆盖当前值
            root->lchild = erase(root->lchild,root->key); //从左子树删除重复节点
        }

    }
    update_height(root);
    return maintain(root);
}

void printf(Node *root) {
    printf("(%d[%d],%d,%d)\n",
           root->key,root->h,
           root->lchild->h,
           root->rchild->h
          );
    return;
}
void output(Node *root) {
    if(root == NIL) return;
    printf(root);
    output(root->lchild);
    output(root->rchild);
    return;
}
//测试时，不断输入成对的数值。
int main() {
     int op, val;
    Node *root = NIL;
    while (~scanf("%d%d",&op,&val)) {
        switch (op) {
            case 0:
                root = erase(root, val);
                break;
            case 1:
                root = insert(root, val);
                break;
        }
        output(root);
    }
     return 1;
}

代码执行

在这里插入图片描述
3[3],2,2 表示节点值为3，高度为3，左子树高度为2，右子树高度为2.可以观察到我们无论怎么插入，都能够保持平衡。

Python高级数据结构——AVL树
Echo_Wish
12-06 896
AVL树是一种自平衡二叉搜索树，通过旋转操作保持树的平衡。在Python中，我们可以使用类似上述示例的。
大数据最新【高阶数据结构】AVL树（动图详解）_avl tree(2)，2024年最新12道大数据开发高级面试题
2401_84182020的博客
05-12 924
此处我们定义成三叉链结构 ，方便后序的操作；也在每个节点引入了平衡因子（右子树高度-左子树高度），还需要实现一下构造函数，左右子树以及父节点都是空，再把平衡因子设置为0即可//定义三叉链//存储的键值对//平衡因子(balance factor)int _bf;//构造函数,\_kv(kv),\_bf(0){}注意：平衡因子不是必须的，只是我们实现高度平衡的一种方式，不用平衡因子也是可以实现的。
平衡二叉树（AVL树，一种二叉排序树）
一个搬运知识的笨小孩
08-29 1478
平衡二叉树 下面的图片来自教材《大话数据结构》 以下二叉排序树和右斜树的查找效率不是最高的，引出平衡二叉树来提高查找效率 平衡二叉树是一种二叉排序树，其中每一个结点的左子树和右子树的高度差至多为1 平衡因子BF（Balance Factor）=== 结点的左子树高度 −-− 结点的右子树高度 平衡二叉树上所有结点的BF只可能是{−1,0，1}\{-1,0，1\}{−1,0，1} 1.判断是否为平衡二叉树 图2中59大于58不满足二叉排序树，故不可能是平衡二叉树 图3中结点58的左子树高度为3，结点58的
二叉排序树与AVL树
qq_28053699的博客
04-11 1997
二叉排序树 定义：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：  （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；  （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；  （3）左、右子树也分别为二叉排序树； 算法思想：  查找：查找keykeykey值，由二叉排序树的定义可以知道，在进行查找操作时，可以先与根节点比较，若比根节点的值小则再与左子树的根...
AVL树
FBI_BAIGOU的博客
02-02 643
这里直接实现KV模型的AVL树。用pair键值对作为树的元素值。为了后续实现更简单将AVL树定义为三叉链的结构(左子树，右子树，父结点)。并且在结点中引入平衡因子。//结点的左子树//结点的右子树//结点的父结点pair<K,V> _kv//结点元素(用键值对进行存储)int _bf;//结点的平衡因子,_kv(kv),_bf(0){}
数据结构之AVL树
lvyoucang的专栏
04-17 708
二叉排序树的查找与树的形态密切相关，当树的形态比较均衡时查找效率最高，当树的形态偏向于某一个方向是时效率迅速降低，当二叉排序树蜕变为单支树，树的深度为n时，其平均查找长度为(n+1)/2(和顺序查找相同） 1. 概述 AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-V
数据结构之树（3）——二叉平衡树（AVL）
二木成林
02-23 2629
AVL树 AVL树即是平衡二叉树，是一种特殊的二叉排序树。 它的左右子树都是平衡二叉树，并且左右子树的高度之差的绝对值不超过1。 注意：平衡二叉树就是一棵二叉排序树，是二叉排序树的改进，提高了查找效率。 AVL树的插入结点根二叉排序树是一样的，都是遵循左小右大的原则。 但在插入过程中，每插入一个新的结点，就需要检查新结点的插入是否使得原平衡二叉树失去平衡，如果失去平衡则需要进行平衡调整。 为了判断一棵二叉排序树是否是平衡二叉树，引进了平衡因子的概念。平衡因子是针对树中的结点来说的，一个结点的平衡
手撕，高级数据结构——AVL树的实现和插入方法
回水的博客
07-31 1500
AVL树的实现和插入方法
数据结构AVL树插入删除操作中的平衡调整机制：二叉搜索树动态维护高度平衡的旋转策略解析
最新发布
12-07
适合人群：具备数据结构基础知识，正在学习高级树形结构的计算机专业学生或开发人员。; 使用场景及目标：①深入理解AVL树的自平衡原理；②掌握插入与删除操作中各类旋转（左单旋、右单旋、先左后右、先右后左）的...
精选资源
深入理解高级数据结构之红黑树
09-11
红黑树之所以被称为“近似平衡”，是因为它并不像AVL树那样严格要求左右子树的高度差不超过1，而是允许一定的不平衡存在。尽管如此，红黑树依然能够保持较低的高度，一般情况下，最坏情况下红黑树的高度不超过2log2...
关于AVL（自平衡二叉排序树）的旋转名称的解释
smstong的成长轨迹
09-19 4296
关于二叉树、二叉排序数、（自）平衡二叉（排序）树的含义、算法等基本理论就不在这里说了，教材资料到处是。 本人学习过程中遇到的困惑是，为什么明明是逆时针旋转（向左），旋转类型的名字却叫做RR（Right Right）？为什么明明是顺时针旋转（向右），旋转类型的名字却叫做LL(Left,Left)。 别看这是个小问题，网上大多数文章都没有进行说明，对于初学者往往造成困惑。最后还是在大名鼎鼎的维基百
AVL树简介
小白的博客
02-24 1万+
一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是...
看图说话之平衡二叉排序树(AVL树)
涂印的博客
10-20 7732
介绍了平衡二叉排序树的基本原理，重点介绍了AVL树的基本实现方法，并且给出了完整java代码实现
图解：什么是AVL树？
Z景明的博客
05-19 2621
平衡二叉树基础篇什么是平衡二叉树？平衡二叉树（Balanced Binary Tree 或 Height-Balanced Tree）又称为 AVL 树，其实就是一颗 平衡的二叉排序树 ...
平衡搜索二叉树——AVL树
h1091068389的博客
06-03 529
正常的搜索二叉树中，一般而言查找一个数的时间复杂度几乎可以等价于log2N，但是正常的搜索二叉树可能会遇到一些极端情况，例如按照1，2，3，4插入数组，此时的搜索二叉树便会变为如下的情况： 这种数据有序或者接近有序的插入数据此时的搜索二叉树会退化为一个单分支，此时查找效率就变成了O(n)，并不能体现搜索二叉树的优势。此时，有两位数学家提出了一种方法来解决这种问题：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜
高度为H的AVL树最少节点数
热门推荐
wusecaiyun的专栏
11-08 2万+
在这里，我们用f(h)代表高度为h的AVL树最少的节点数。 由此，我们知道f(0)=0, f(1)=1, f(2)=2。 当AVL树的高度为h，并且要保证此树满足AVL树的性质(即左右子树的高度相差不超过1)时，我们假设左子树的高度为h-1，则右子树的高度为h-2。 因此得到如下递归公式 f(h)=f(h-1)+f(h-2)+1。 因此可知f(3)=4, f(4)=7。。。
AVL树及其C++实现
Nim的辙迹
01-26 4499
AVL树（高度平衡二叉树）的介绍及其C++实现
数据结构_平衡二叉搜索树(AVL树)
xc13212777631的博客
06-21 8841
平衡二叉搜索树 在二叉搜索树中，已经知道search、insert和remove等主要接口的运行时间均正比于树的高度。但是在最坏的情况下，二叉搜索树可能退化成列表，此时查找的效率会降至O(n)。因此，通常通过控制树高，来控制最坏情况下的时间复杂度。 对于节点数目固定的BST，越是平衡，最坏情况下的查找速度越快，如下图所示： 为了理解平衡二叉树，我们首先要理解几个主要概念，理想平衡与适度平...
掌握高级数据结构：AVL树与平衡操作详解
高级数据结构是计算机科学中的重要概念，它深入研究了如何更高效地组织和操作数据，以便在各种复杂应用中提高算法性能。本资源主要涵盖了平衡二叉树、可并优先队列、线段树和树状数组基础，以及区间查询（RMQ）和...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值