AVL树

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

#树

本文介绍了AVL树的基本概念，作为自平衡二叉查找树的一种，AVL树通过保持树的平衡来确保高效的查找、插入和删除操作。文章还详细解释了如何通过旋转操作来维持AVL树的平衡，并提供了具体的实现代码。

AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。

这里写图片描述

AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。

LL : 左侧深度高
RR : 右侧深度高
LR : 根的左子树的高度比根的右子树的高度深
RL : 根的右子树的高度比根的左子树的高度深

struct AVL;
typedef struct AVL *T;
typedef int Instead_Int;

struct AVL
{
    Instead_Int Instead;
    int hight;
    T Left;
    T Right;
    AVL() : hight(0), Left(NULL), Right(NULL) {}
};

这里写图片描述

这是RR的可能

将节点 v1 右侧的节点保存为 v2, 将 v1 插入到 v2 的左侧, 实现平衡

T Right_One(T avl)
{
    T cpy_avl = avl->Right;
    avl->Right = cpy_avl->Left;
    cpy_avl->Left = avl;

    cpy_avl->hight = Max(Hight(cpy_avl->Right), Max(Hight(avl->Right), Hight(avl->Left)) + 1) + 1;

    return cpy_avl;
}

同理LL

T Left_One(T avl)
{
    T cpy_avl = avl->Left;
    avl->Left = cpy_avl->Right;
    cpy_avl->Right = avl;

    avl->hight = Max(Hight(avl->Right), Hight(avl->Left)) + 1;
    cpy_avl->hight = Max(Hight(cpy_avl->Left), avl->hight) + 1;

    return cpy_avl;
}

这里写图片描述
这里写图片描述

LR的旋转, 只需要将其先RR 的方式旋转, 在LL方式旋转即可

这里写图片描述

T Left_Two(T avl)
{
    avl->Left = Right_One(avl->Left);

    return Left_One(avl);
}

RL也同理

T Right_Two(T avl)
{
    avl->Right = Left_One(avl->Right);

    return Right_One(avl);
}

在插入与删除,都与查询二叉树是一样的, 只有在部分上有点区别, 这是为了保证二叉树的平衡, 即AVL树

//插入
T Insert(T avl, Instead_Int insert)
{
    if (avl == NULL)
    {
        avl = new AVL;
        avl->Instead = insert;
    }

    else
        if (avl->Instead > insert)
        {
            avl->Left = Insert(avl->Left, insert);
            //当不保持平衡时, 进入
            if (Hight(avl->Left) - Hight(avl->Right) >= 2)
            //LL还是LR进行判断
                if (avl->Left->Instead > insert)
                    avl = Left_One(avl);
                else
                    avl = Left_Two(avl);
        }
        else if (avl->Instead < insert)
        {
            avl->Right = Insert(avl->Right, insert);
            if (Hight(avl->Right) - Hight(avl->Left) >= 2)
            //RR还是RL进行判断
                if (avl->Right->Instead < insert)
                    avl = Right_One(avl);
                else
                    avl = Right_Two(avl);
        }

    avl->hight = Max(Hight(avl->Right), Hight(avl->Left)) + 1;
    return avl;
}

源代码

#include <stdlib.h>
#include <stdio.h>

struct AVL;
typedef struct AVL *T;
typedef int Instead_Int;

struct AVL
{
    Instead_Int Instead;
    int hight;
    T Left;
    T Right;
    AVL() : hight(0), Left(NULL), Right(NULL) {}
};

#define Max(a, b) (a > b ? a : b)

T Insert(T avl, Instead_Int inset);
T Dele(T avl, Instead_Int dele);
T Left_One(T avl);
T Right_One(T avl);
T Left_Two(T avl);
T Right_Two(T avl);
T Find_Max(T avl);
T Find_Min(T avl);
T Find(T avl, Instead_Int find);
void Print(T avl);
int Hight(T avl);

int main()
{
    T avl = NULL;
    for (int i = 0; i < 10; i++)
        avl = Insert(avl, i + 1);

    avl = Dele(avl, 5);
    Print(avl);

    system("pause");
    return 0;
}

T Find_Min(T avl)
{
    if (avl == NULL)
        return NULL;

    if (avl->Left == NULL)
        return avl;
    else
        Find_Min(avl->Left);
}

T Find_Max(T avl)
{
    if (avl == NULL)
        return NULL;
    while (avl->Right != NULL)
        Find_Max(avl->Right);

    return avl;
}

int Hight(T avl)
{
    if (avl == NULL)
        return -1;
    else
        return avl->hight;
}

//LL
T Left_One(T avl)
{
    T cpy_avl = avl->Left;
    avl->Left = cpy_avl->Right;
    cpy_avl->Right = avl;

    avl->hight = Max(Hight(avl->Right), Hight(avl->Left)) + 1;
    cpy_avl->hight = Max(Hight(cpy_avl->Left), avl->hight) + 1;

    return cpy_avl;
}

//RR
T Right_One(T avl)
{
    T cpy_avl = avl->Right;
    avl->Right = cpy_avl->Left;
    cpy_avl->Left = avl;

    cpy_avl->hight = Max(Hight(cpy_avl->Right), Max(Hight(avl->Right), Hight(avl->Left)) + 1) + 1;

    return cpy_avl;
}

//LR
T Left_Two(T avl)
{
    avl->Left = Right_One(avl->Left);

    return Left_One(avl);
}

//RL
T Right_Two(T avl)
{
    avl->Right = Left_One(avl->Right);

    return Right_One(avl);
}

//插入
T Insert(T avl, Instead_Int insert)
{
    if (avl == NULL)
    {
        avl = new AVL;
        avl->Instead = insert;
    }

    else
        if (avl->Instead > insert)
        {
            avl->Left = Insert(avl->Left, insert);
            if (Hight(avl->Left) - Hight(avl->Right) >= 2)
                if (avl->Left->Instead > insert)
                    avl = Left_One(avl);
                else
                    avl = Left_Two(avl);
        }
        else if (avl->Instead < insert)
        {
            avl->Right = Insert(avl->Right, insert);
            if (Hight(avl->Right) - Hight(avl->Left) >= 2)
                if (avl->Right->Instead < insert)
                    avl = Right_One(avl);
                else
                    avl = Right_Two(avl);
        }

    avl->hight = Max(Hight(avl->Right), Hight(avl->Left)) + 1;
    return avl;
}

T Dele(T avl, Instead_Int dele)
{
    T cpy_avl = NULL;

    if (avl == NULL)
    {
        avl = new AVL;
        avl->Instead = dele;
    }

    else
        if (avl->Instead > dele)
        {
            avl->Left = Dele(avl->Left, dele);
            if (Hight(avl->Left) - Hight(avl->Right) >= 2)
                if (avl->Left->Instead > dele)
                    avl = Left_One(avl);
                else
                    avl = Left_Two(avl);
        }
        else if (avl->Instead < dele)
        {
            avl->Right = Dele(avl->Right, dele);
            if (Hight(avl->Right) - Hight(avl->Left) >= 2)
                if (avl->Right->Instead < dele)
                    avl = Right_One(avl);
                else
                    avl = Right_Two(avl);
        }
        else if (avl->Left && avl->Right)
        {
            cpy_avl = new AVL;
            cpy_avl = Find_Min(cpy_avl->Right);
            avl->Instead = cpy_avl->Instead;
            avl->Right = Dele(avl->Right, avl->Instead);
        }
        else
        {
            if (avl->Right == NULL)
                avl = avl->Left;
            else
                avl = avl->Right;

            free(cpy_avl);
        }


    return avl;
}

T Find(T avl, Instead_Int find)
{
    if (avl == NULL)
        return NULL;
    else if (avl->Instead > find)
        avl->Left = Find(avl->Left, find);
    else if (avl->Instead < find)
        avl->Right = Find(avl->Right, find);

    return avl;
}

void Print(T avl)
{
    if (avl != NULL)
    {
        printf("%d ", avl->Instead);
        Print(avl->Left);
        Print(avl->Right);
    }

}
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
构造AVL树
weixin_30273175的博客
05-19 532
AVL数是平衡的二叉排序树的一种，AVL树中任一节点的左右子树的高度之差的绝对值不超过1。什么是平衡的二叉树呢？树中任一节点的左右子树的高度大致相同，若任一结点的左右子树的高度均相同（如满二叉树），则二叉树是完全平衡的。二叉排序树（Binary Sort Tree）的性质：（1）若它的左子树非空，则左子树上的所有结点的值均小于根结点的值。（2）若它的右子树非空，则右子树上的所有结点的值均大于根结...
AVL树练习
weixin_30306905的博客
09-26 367
#ifndef MY_AVLTREE #define MY_AVLTREE #include<iostream> #include<cmath> #define PRINTS(x) std::cout<<x<<std::ends struct AvlNode; typedef AvlNode* AvlTree; typede...
数据结构与算法之树（三）AVL树
JT同学的博客
09-18 784
数据结构与算法之树 数据结构与算法之树（一）二叉树概念及遍历方式（图文并茂） 数据结构与算法之树（二）二叉查找树 数据结构与算法之树（三）AVL树 数据结构与算法之树（四）红黑树 数据结构与算法之树（三）AVL树 文章目录数据结构与算法之树（三）AVL树一、什么是平衡二叉树？二、什么是AVL树？三、AVL树的调整策略3.1 旋转操作3.1.1 左旋3.1.2 右旋3.2 需要调整的节点3.3 情况...
Java学习——数据结构——AVL树
qq_41853002的博客
05-30 359
学习尚硅谷韩顺平老师的Java数据结构笔记，详情请移步网站 1、说明二叉排序树可能的问题 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在. 左边 BST 存在的问题分析: （1) 左子树全部为空，从形式上看，更像一个单链表. （2) 插入速度没有影响 （3) 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢 （4) 解决方案-平衡二叉树(AVL) 2、介绍 （1) 平衡二叉树也叫平衡二叉搜索树（Sel
数据结构与算法(九)：AVL树详细讲解
weixin_30340745的博客
12-11 635
数据结构与算法(一):基础简介 数据结构与算法(二):基于数组的实现ArrayList源码彻底分析 数据结构与算法(三):基于链表的实现LinkedList源码彻底分析 数据结构与算法(四):基于哈希表实现HashMap核心源码彻底分析 数据结构与算法(五):LinkedHashMap核心源码彻底分析 数据结构与算法(六):树与二叉树 数据结构与算法(七):赫夫曼树 数据结构与算法(...
二叉查找树，AVL树
01-07
AVL树（平衡二叉查找树） 具有二叉查找树的全部特性。 每个节点的左子树的高度和右子树高度差值小于等于1（平衡二叉树的性质） 左旋：逆时针旋转两个节点，原先的右节点成为新的父节点，原先的父节点成为原先的右...
avlTree:通用AVL树数据结构
06-18
在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何时候它们相差超过 1，则进行重新平衡以恢复此属性。 查找、插入和删除在平均和最坏情况下都需要 O(log n) 时间，其中 n 是操作之前树中的节点数。 ...
数据结构第二次作业第二题（AVL树）
MysteriousL的博客
10-23 487
#include <stdio.h> #include <stdlib.h> typedef struct treenode { int data; int height; struct treenode *left; struct treenode *right; } TreeNode, *AVL; int Max(int a, int b) { return (a > b) ? a : b; } int Height(AVL .
AVL树的插入
qq_39208237的博客
05-22 5715
什么是AVL树？ AVL树又称为高度平衡的二叉搜索树。 一棵AVL树如果不是空树，则符合以下性质： 1.左子树与右子树的高度之差的绝对值不超过1 2.左右子树均是AVL树 易知，二叉搜索树可以将查询效率提高至O(logh),h为二叉搜索树的高度。但当数据的插入是严格有序时，二叉搜索的效率会恶化至O(n)，即线性复杂度。如下，有一组数据： 不可否认，这还真是一棵二叉搜索树，但这棵树好嘛？不好！为什么不好？当我们想要查找数据时，查询路径和遍历查数组有什么区别？没有区别！都是线性复杂度。 所以，两个俄罗斯数学家
蓝桥杯练习-3.7
qq_52633682的博客
03-07 497
蓝桥杯练习-3.7 代码练习 ▪ FJ的字符串 问题描述 最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。 　　不妨设 　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…) 　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1 　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。 输入格式 仅有一个数：N<20
AVL树（C语言实现）
mayfly_strive的博客
02-09 2795
AVL树的相关操作，包括插入，删除，查找，调整。（C语言实现）
第四章第三小节(AVL树实现)
保持热爱，持续学习
11-19 160
AVL树带有平衡条件的二叉查找树，这个平衡条件必须要保持，必须保证树的深度是O(log N)，要求左右子树具有相同的高度； 一棵AVL树是其每个节点的左子树和右子树的高度最多差1的二叉查找树。 在进行插入或删除操作时可能会破坏平衡条件，需要对树进行修正，保证每个节点都符合平衡条件。可以通过简单的旋转保证； 在插入以后，只有那些从插入点到根节点的路径上的节点的平衡可能被改变，我们可能沿着这条路径上找到根并更新平衡信息，如果有节点破坏了平衡条件，必须重新平衡树； 可能造成不平衡的四种情况： 1.对α的左儿子的左
图解数据结构树之AVL树
weixin_30552811的博客
03-31 433
AVL树(平衡二叉树)： 　　AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图： 　　平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1<=bf<=1...
AVL树的创建
zyl_1102179268的博客
05-22 6424
平衡二叉树下面是每个模块的代码，AVL树创建的完整版代码以上传GitHub AVLTree的创建；平衡二叉树(Balanced Binary Tree或Height-Balanced Tree)又称为AVL树。它或者是一颗空树，或者是具有下列性质的二叉树：1、它的左子树和右子树都是平衡二叉树； 2、左子树和 右子树的深度之差的绝对值不超过1； 若将二叉树上结点的**平衡因子**BF定义为该节点的右子
Avl树
最新发布
07-07
AVL树是一种自平衡的二叉查找树，它确保了树的高度始终保持在对数级别，从而保证了查找、插入和删除操作的时间复杂度为O(log n)。这种数据结构以它的发明者G.M. Adelson-Velsky和E.M. Landis的名字命名[^1]。 ### AVL树的定义 - **平衡因子**：每个节点都有一个平衡因子，它是该节点左子树的高度减去右子树的高度。对于AVL树来说，所有节点的平衡因子只能是-1, 0或1。 - **空树**：如果T是空树，则它自然是一个AVL树。 - **非空树**：若T不是空树，则其左右子树TL和TR都必须是AVL树，并且对于任意节点，|HL - HR| ≤ 1（其中HL和HR分别表示左子树和右子树的高度）。 ### AVL树的操作 当进行插入或删除操作时，可能会破坏AVL树的平衡性，这时需要通过旋转来重新恢复平衡： - **单旋转**： - 左单旋（Single Rotate with Left）用于处理左孩子的左子树过高。 - 右单旋（Single Rotate with Right）用于处理右孩子的右子树过高。 - **双旋转**： - 左右双旋（Double Rotate with Left）用于处理左孩子的右子树过高的情况。 - 右左双旋（Double Rotate with Right）用于处理右孩子的左子树过高的情况。 这些旋转操作可以保持AVL树的性质不变，并且能够快速地调整树的结构以维持平衡。 ### AVL树的实现 下面是一个简单的C语言代码示例，展示了如何定义AVL树的节点以及实现基本的插入操作。这个例子中包含了必要的函数声明和一些核心逻辑。 ```c #include <stdio.h> #include <stdlib.h> // 定义AVL树节点结构体 typedef struct AvlNode { int element; struct AvlNode *left; struct AvlNode *right; int height; // 节点的高度 } *AvlTree, *Position; // 获取两个整数中的较大者 int max(int a, int b) { return (a > b) ? a : b; } // 计算给定节点的高度 static int Height(AvlTree T) { if (T == NULL) return -1; // 空节点高度为-1 else return T->height; } // 单旋转 - 左左情况 AvlTree singlerotatewithLeft(AvlTree K2) { Position 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 singlerotatewithRight(AvlTree K2) { Position K1 = K2->right; K2->right = K1->left; K1->left = K2; // 更新节点高度 K2->height = max(Height(K2->left), Height(K2->right)) + 1; K1->height = max(Height(K1->right), K2->height) + 1; return K1; // 新根 } // 双旋转 - 左右情况 AvlTree doublerotatewithLeft(AvlTree K3) { K3->left = singlerotatewithRight(K3->left); return singlerotatewithLeft(K3); } // 双旋转 - 右左情况 AvlTree doublerotatewithRight(AvlTree K3) { K3->right = singlerotatewithLeft(K3->right); return singlerotatewithRight(K3); } // 插入新元素到AVL树中 AvlTree Insert(int x, AvlTree T) { if (T == NULL) { // 如果树为空，创建新节点 T = (AvlTree)malloc(sizeof(struct AvlNode)); if (T == NULL) printf("Out of space!!!"); else { T->element = x; T->left = T->right = NULL; T->height = 0; // 新叶节点高度为0 } } else if (x < T->element) { // 向左子树插入 T->left = Insert(x, T->left); // 检查并修复平衡 if (Height(T->left) - Height(T->right) == 2) { if (x < T->left->element) T = singlerotatewithLeft(T); // 左左旋转 else T = doublerotatewithLeft(T); // 左右旋转 } } else if (x > T->element) { // 向右子树插入 T->right = Insert(x, T->right); // 检查并修复平衡 if (Height(T->right) - Height(T->left) == 2) { if (x > T->right->element) T = singlerotatewithRight(T); // 右右旋转 else T = doublerotatewithRight(T); // 右左旋转 } } // 更新高度 T->height = max(Height(T->left), Height(T->right)) + 1; return T; } ``` 上述代码提供了AVL树的基本框架，包括节点定义、插入操作及必要的旋转方法。实际应用中可能还需要添加更多的功能，如删除节点、查找特定值等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值