AVL树

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

以下图的平衡因子统一为左子树高度减去右子树高度。

附上：单个节点声明的代码
struct AVLTreeNode
{
    AVLTreeNode(const K& key, const V& value)
    : _pLeft(NULL)
    , _pRight(NULL)
    , _pParent(NULL)
    , _key(key)
    , _value(value)
    , _bf(0)
    {}


    AVLTreeNode<K, V> *_pLeft;
    AVLTreeNode<K, V> *_pRight;
    AVLTreeNode<K, V> *_pParent;
    K _key;
    V _value;
    int _bf;       // 平衡因子：right-left
};
左单旋 （右右 - 在较高右子树的右侧插入节点）

这里写图片描述

具体列子

这里写图片描述

分析

如图能引发左单旋，那必定是在引起不平衡的节点的较高右字树的右侧插入，至于这个点是在节点C的左边插入还是右边插入都没有关系，都可以通过左旋转达到平衡，这个平衡后的图如上所示，真正发生变化的点，一个SubR一个引发不平衡的节点，而再引发旋转后这俩个点都平衡了，平衡因子为0。

附上 - 左单旋代码：
void _RotateL(Node* pParent)
    {
        if (pParent)
        {
            Node *pPParent = pParent->_pParent;
            Node * pSubR = pParent->_pRight;
            Node * pSubRL = pParent->_pLeft;
            if (pSubRL)
            {
                pSubRL->_pParent = pParent;
            }
            pParent->_pRight = pSubRL;
            pSubR->_pLeft = pParent;
            pParent->_pParent = pSubR;
            pSubR->_pParent = pPParent;
            if (pPParent == NULL)
            {
                _pRoot = pSubR;
            }
            else
            {
                if (pPParent->_pLeft == pParent) pPParent->_pLeft = pSubR;
                else
                    pPParent->_pRight = pSubR;
            }
            pSubR->_bf = 0;
            pParent->_bf = 0;
        }
    }
右单旋 （左左-在较高左子树中的左侧插入节点）
图示

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

附上 -右单旋代码：
void _RotateR(Node* pParent)
    {
        if (pParent)
        {
            Node*pPParent = pParent->_pParent;
            Node*pSubL = pParent->_pLeft;
            Node*pSubLR = pSubL->_pRight;
            if (pSubLR)
            {
                pSubLR->_pParent = pParent;
            }
            pParent->_pLeft = pSubLR;
            pParent->_pParent = pSubL;
            pSubL->_pRight = pParent;
            pSubL->_pParent = pPParent;  
            if (pPParent==NULL)
            {
                _pRoot = pSubL;
            }
            else
            {
                if (pParent->_pRight == pParent)pParent->_pRight = pSubL;
                else
                    pParent->_pLeft = pSubL;
            }
            pSubL->_bf = 0;
            pParent->_bf = 0;

        }
    }
右左双旋（右左-在较高右子树的左侧插入）
分析

如下面这个图，这里双旋有三种情况：
1.h为0的时候，那么 10 无左子树，30无右子树，20这个节点必定是新增节点，因为20和它子树高度和为h ， h 为0说明20不存在，它这里是新增节点。那这个时候20的平衡因子是0。
2.当新增节点在20这个节点的左子树的情况下，20 节点为-1。这个时候双旋完后 , b的高度新增完后为h , 它给了10之后，10的节点的平衡因子平衡了，但是 c 跟了30，30 此时 平衡因子为1。
3.当新增节点在C，20节点平衡因子为1。这时候双旋完后，C跟了30，C的高度新增后为 h ,那么 30此时是平衡的，相反 高度 为 h-1 的 b跟了10,那么此时10的平衡因子是-1。

图示

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

void _RotateRL(Node* pParent)
    {
        Node *PsubR = pParent->_pRight;
        Node* pSubRL = PsubR->_pLeft;
        int bf = pSubRL->_bf;
        _RotateR(pParent->_pRight);
        _Rotate(pParent);
        if (bf == -1) pParent->_bf = 1;
        else PsubR->_bf = -1;
    }
左右双旋（左右-在较高左子树的右侧插入）

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

void _RotateLR(Node* pParent)
    {
        Node * PsubL = pParent->_pLeft;
        Node * psubLR = PsubL->_pRight;
        int bf = psubLR->_bf;
        _RotateL(pParent->_pLeft);
        _RotateR(pParent);
        if (bf == 1) pParent->_bf = -1;
        else PsubL->_bf = 1;
    }

整个AVL树的实现

#include<iostream>
#include<assert.h>
using namespace std;
template<class K , class V>
struct AVLTreeNode
{
public:
    using Node = AVLTreeNode<K, V>;
    AVLTreeNode(const K & key, const V & value)
        :_pLeft(NULL), _pRight(NULL), _pParent(NULL), _Key(key), _value(value), _bf(0)
    {}


    Node * _pLeft;
    Node * _pRight;
    Node * _pParent;
    K _Key;
    V _value;
    int _bf;
};
template<class K , class V>
class AVLTree
{
    typedef AVLTreeNode<K,V> Node;
public:
    AVLTree()
        :_root(nullptr)
    {}
    AVLTree(const K arr[], size_t size)
    {
        for (size_t idx = 0 l idx < size; ++idx)
        {
            Insert(idx, arr[idx]);
        }
    }
    bool Insert(const K& key, const V & value)
    {
        if (nullptr == _root)
        {
            _root = new Node(key, value);
            return false;
        }
        else
        {
            Node * pCur = _root;
            Node * parent = nullptr;
            while (pCur)
            {
                if (key < pCur->_Key)
                {
                    parent = pCur;
                    pCur = pCur->_pLeft;
                }
                else if (key > pCur->_Key)
                {
                    parent = pCur;
                    pCur = pCur->_pRight;
                }
                else
                {
                    return false;
                }
            }
            pCur = new Node(key, value);
            if (key < parent->_Key)
            {
                parent->_pLeft = pCur;
                pCur->_pParent = parent;
            }
            else
            {
                parent->_pRight = pCur;
                pCur->_pParent = parent;
            }
            while (parent)
            {
                if (pCur == parent->_pLeft)
                    parent->_bf--;
                else
                    parent->_bf++;
                if (parent->_bf == 0)
                    return true;
                else if (parent->_bf == -1 || parent->_bf == 1)
                {
                    pCur = parent;
                    parent = pCur->_pParent;

                }
                else if (parent->_bf==-2||parent->_bf == 2)
                {
                    /*旋转*/
                    if (parent->_bf == 2 && parent->_pRight->_bf == 1) // bf==2 说明parent的右子树高 ， 那么我们可以查看右子树的bf的值，bf==1在右子树右侧插入，bf==-1 在右子树左侧插入
                        RotateL(parent);
                    else if (parent->_bf == 2 && parent->_pRight->_bf == -1)
                        RotateRL(parent);
                    else if (parent->_bf == -2 && parent->_pLeft->_bf == -1)
                        RotateR(parent);
                    else if (parent->_bf == -2 && parent->_pLeft->_bf == 1)
                        RotateLR(parent);
                    break;
                }
                else
                {
                    cerr << "有bug!!!!在插入的时候" << endl;
                    assert(false);
                }
            }
        }
    }
protected:
    void RotateL(Node * parent) // 向左旋转
    {
        Node*SubR = parent->_pRight;
        Node*SubRL = SubR->_pLeft;
        Node*grandfather = parent->_pParent;
        if (SubRL)
            SubRL->_pParent = parent;
        parent->_pRight = SubRL;
        SubR->_pLeft = parent;
        if (grandfather)
        {
            if (grandfather->_pLeft == parent)
                grandfather->_pLeft = SubR;
            else
                grandfather->_pRight = SubR;
        }
        else
        {
            _root = SubR;
            SubR->_pParent = NULL;
        }
        parent->_pParent = SubR;
        SubR->_pParent = grandfather;
        parent->_bf = 0;
        SubR->_bf = 0;
    }
    void RotateR(Node * parent) //向右旋转
    {
        Node * SubL = parent->_pLeft;
        Node * SubLR = SubL->_pRight;
        Node * grandfather = parent->_pParent;
        if (SubLR)
            SubLR->_pParent = parent;
        parent->_pLeft = SubLR;
        SubL->_pRight = parent;
        if (grandfather)
        {
            if (grandfather->_pLeft == parent)
                grandfather->_pLeft = SubL;
            else
                grandfather->_pRight = SubL;
        }
        else
        {
            _root = SubL;
            SubL->_pParent = NULL;
        }
        parent->_pParent = SubL;
        SubL->_pParent = grandfather;
        parent->_bf = 0;
        SubL->_bf = 0;
    }
    void RotateLR(Node* parent)
    {
        Node*SubL = parent->_pLeft;
        Node*SubLR = SubL->_pRight;
        int bf = SubLR->_bf;
        RotateL(SubL);
        RotateR(parent);
        if (bf == 1)
            SubL->_bf = -1;
        if (bf == -1)
            parent->_bf = 1;
    }
    void RotateRL(Node* parent)
    {
        Node*SubR = parent->_pRight;
        Node*SubRL = SubR->_pLeft;
        int bf = SubRL->_bf;
        RotateR(SubR);
        RotateL(parent);
        if (bf == 1)
            parent->_bf = -1;
        if (bf == -1)
            SubR->_bf = 1;
    }
public:
     Node * const GetRoot()
    {
        return _root;
    }
    void Inorder(Node*Root)
    {
        if (Root==NULL)
            return;
        Inorder(Root->_pLeft);
        cout << Root->_Key<<" " ;
        Inorder(Root->_pRight);
    }
    bool IsBalance(Node*Root)
    {
        int Height=0;
        return _IsBalance(Root, Height);
    }
    private:
    bool _IsBalance(Node*Root, int & Height)
    {
        if (Root == NULL)
        {
            Height = 0;
            return true;
        }
        int left = 0;
        if (!_IsBalance(Root->_pLeft, left))
            return false;
        int right = 0;
        if (!_IsBalance(Root->_pRight, right))
            return false;
        Height = (left > right) ? left + 1 : right + 1;
        return abs(left-right) < 2;
    }

private:
    Node * _root;
};
void TesTAVL()
{
    int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    AVLTree<int,int> Tree;
    for (int i = 0; i<sizeof(arr) / sizeof(arr[0]);++i)
    {
        Tree.Insert(arr[i],i);
    }
     AVLTreeNode<int, int> * Root = Tree.GetRoot();
    Tree.Inorder(Root);
    if (Tree.IsBalance(Root))
        co(left-right) < 2;
    }ut << "AVL树平衡的" << endl;
}
int main()
{
    TesTAVL();
    return 0;
}

判断平衡的方法

方法1 时间复杂度 O(N^2)
bool  Height (Node * Root)
{
     if(Root == NULL )
        return 0;
     if(Root->_pleft==NULL&&Root->_pRight==NULL)
     {
           return 1;
     }
     int left = Height(Root->_pleft);
     int Right = Height(Root->_pRight);
     return (left>right)? left+1: right+1;
}
bool IsBalance(Node*Root)
{
      if(Root==NULL)
         true;
      int left = Height(Root->_pLeft);
      int Right = Height(Root->_pRight);
     return abs(left-Right)<2&&IsBalance(Root->_pLeft)&&IsBalance(Root->_pRight);
}
方法2 时间复杂度O(N)
bool IsBalance(Node*Root)
    {
        int Height=0;
        return _IsBalance(Root, Height);
    }
    private:
    bool _IsBalance(Node*Root, int & Height)
    {
        if (Root == NULL)
        {
            Height = 0;
            return true;
        }
        int left = 0;
        if (!_IsBalance(Root->_pLeft, left))
            return false;
        int right = 0;
        if (!_IsBalance(Root->_pRight, right))
            return false;
        Height = (left > right) ? left + 1 : right + 1;
        return abs(left-right) < 2;
    }
sdoyuxuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL 树
sqjddb的博客
03-10 401
一、AVL树的由来及概念 二、AVL树的原理（旋转） 三、AVL树的实现 四、AVL树的性能
C++ AVL树
weixin_53946312的博客
01-27 1194
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
leetcode110---Balanced Binary Tree
爱橙子的OK绷的专栏
01-02 291
问题描述：Given a binary tree, determine if it is height-balanced.For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never diffe
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 2万+
AVL树（C++实现）
数据结构：AVL树
最新发布
decade777555的博客
03-07 1438
两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
AVL树详解
北川_的博客
03-09 1625
目录AVL树的概念AVL树节点的定义AVL树如何高度平衡？右单旋左单旋左右双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)， 即可降低树的高度，从而减少平均搜索长度。 AVL
【 C++ 】AVL树
bit_zyx的博客
09-04 1173
目录 1、底层结构 2、AVL树的概念 3、AVL树节点的定义 4、基本框架 5、AVL树的插入 6、AVL树的旋转 左单旋 右单旋 左右双旋 右左双旋 7、AVL树的验证 8、AVL树的查找 9、AVL树的删除（了解） 10、AVL树的性能 11、源码链接.........
构建AVL树
weixin_43796767的博客
06-02 1006
AVL（Adelson-Velskii and Landis）树是满足平衡条件的二叉搜索树：左右子树的深度差不大于1。 一、理解AVL树 目标：通过调整二叉树结构，提高二叉查找的效率。 构建手段：左旋转、右旋转、双旋转。 类似抖葡萄那样，找到合适的节点作为新的根，拎起来抖两下，树结构就得到了调整。 四种失衡情况： 1）LL（left-left）型： 失衡位置从名字可以看出，左子树的左侧挂了太多节点； 此时需要的调整是右旋，顺时针旋转一下，即可恢复平衡。 2）RR（right-right）型 3）LR
AVL树的 插入 和 删除
潜心钻研技术
03-11 1990
AVL树的 插入 和 删除
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
二叉查找树，AVL树
01-07
AVL树（平衡二叉查找树） 具有二叉查找树的全部特性。 每个节点的左子树的高度和右子树高度差值小于等于1（平衡二叉树的性质） 左旋：逆时针旋转两个节点，原先的右节点成为新的父节点，原先的父节点成为原先的右...
avlTree:通用AVL树数据结构
06-18
在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何时候它们相差超过 1，则进行重新平衡以恢复此属性。 查找、插入和删除在平均和最坏情况下都需要 O(log n) 时间，其中 n 是操作之前树中的节点数。 ...
链表面试题 解法总结
我喜欢雨天的清新的博客
04-04 1381
从尾打印链表 1 用递归的方法，如果当前节点不为空，继续调打印函数传过去的参数下一个节点。 If(PNode) {   Print_list(PNode->PNext);   Printf(“%d->”,PNode->data); } 2 删除一个非头节点的非尾节点（不能遍历链表）   用代替法，把当前节点的下一个节点的值赋值给当前节点，在delete掉当前节点的下一个节点
顺序表实现之C语言（附加各种顺序表排序问题）
我喜欢雨天的清新的博客
11-02 1369
seqlist.h: #include <stdio.h> #include <assert.h> #ifndef _SEQLIST_H #define _SEQLIST_H #define MAX 10 typedef int Datatype; typedef struct { Datatype array[MAX]; Datatype size; }seqlist; void
图的实现（带有深度/广度优先遍历/最小生成树算法）
我喜欢雨天的清新的博客
11-27 1065
#pragma once #include<string> #include<iostream> #include<vector> #include<unordered_map> #include<queue> #include"Union.h" using namespace std; struct Edge { Edge( size_t src, size_t dst,int weigh
Trie 树实现与应用 与 Double Array Trie 进阶
我喜欢雨天的清新的博客
01-24 950
Trie树 基本概念  Trie树又称字典树，它是用来查询字符串的一种数据结构。一般它每一个节点都有26个子节点，所以是26叉树。优点查询字符串的时候速度快，缺点浪费大量空间。但是也可以实现255个子节点对应ASCII码0~255，具体看需求吧。  当一个字符串长为M的时候，假设数据结构中已经有了N个字符串了。对于平衡树而言，查找一个字符串 O(log^n)。对于字典树来说就O(M)。 ...
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、付费专栏及课程。

余额充值