AVL树的旋转

最新推荐文章于 2024-09-28 17:58:38 发布
最新推荐文章于 2024-09-28 17:58:38 发布
阅读量289 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d_CSDNW/article/details/80981901
版权

···AVL树又称为高度平衡的二叉树。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。
···AVL树有以下几条性质：
·····1.左子树和右子树的高度之差的绝对值不超过1
·····2.树中的每个左子树和右子树都是AVL树
·····3.每个节点都有一个平衡因子，任一节点的平衡因子是-1，1，0.（每个节点的平衡因子等于右子树的高度减去左子树的高度）
···AVL树就是在二叉搜索树的基础上实现的，所以这里主要描述AVL树的旋转过程，最后会附上完整的源代码。

AVL树在进行插入时，要不断更新每个节点的平衡因子，如果插入叶子节点后，父节点的平衡因子变为0，则不用调整。如果父节点的平衡因子变为1或-1，需要调整吗？注意这里虽然父节点的平衡因子是1或-1，满足AVL树的性质，但是它可能会影响上一层的节点，画图说明一下。
这里写图片描述
···插入B节点后，图一图二中的A节点平衡因子都变为-1，图一已经是AVL树，但是图二根节点的平衡因子变为-2，所有插入节点后，如果父节点的平衡 因子变成1或-1，需要继续向上调整。
如果插入节点后父节点的平衡因子变为2或-2，需要立即旋转来调整平衡因子。
右单旋
这里写图片描述
··· 在判断旋转的方式时，最好先标出每个节点的平衡因子（三角形节点是叶节点），这种情况下就要进行右单旋了，我在记忆右单旋的时候就将其理解为：将要旋转的节点变成它左孩子节点的右子树，在此图中，就是把30这个节点变成20的右子树，那么20已经有右孩子了，怎么办呢？很简单，依据二叉搜索树的性质，所有节点都遵循左孩子值比它小，右孩子值比它大这一原则，所以f节点的值大于20，而f的值一定小于30，所以就把f作为30的左子树，然后将30作为20的右子树，就完成右单旋了。
这里写图片描述
这就是旋转后的AVL树。
左单旋
这里写图片描述
和右单旋一样，先标记平衡因子
再把10这个节点转到20的左边就行了
这里写图片描述
左右双旋
什么时候需要进行左右双旋呢？
这里写图片描述
同样的，我们需要先标记平衡因子，当parent和subl的平衡因子分别为-2和1时，就要进行左右双旋了。
双旋需要考虑三种情况（sublr的平衡因子调整前分别为0，-1，1时），如下图
1.这里写图片描述
第一种情况最简单，先让sublr的左孩子指向subl，再让parent变成sublr的右孩子即可。旋转后的三个节点平衡因子都是0.（左右双旋第一步应该先左旋subl，再右旋parent）这里写图片描述
上图就是旋转过程。
2.这里写图片描述
这种情况下调整前sublr的平衡因子为-1，调整后，parent,subl,sublr的平衡因子分别为1, 0, 0.
这里写图片描述
图为调整后的AVL树
3.这里写图片描述
这种情况下调整前sublr的平衡因子是1，调整后parent,subl,sublr的平衡因子分别为0,-1,0。
右左双旋
与左右双旋相对应，当parent和subr的平衡因子分别为2，-1时进行右左双旋
这里写图片描述
右左双旋的步骤是先对subr进行右旋，再对parent进行左旋。
同样分为三种情况:
1.这里写图片描述
这种情况调整前subrl的平衡因子为0，调整后，parent,subr,subrl的平衡因子都是0
调整后如图
这里写图片描述
2.第二种情况调整前subrl的平衡因子是1，调整后parent,subr,subrl分别是-1，0，0
这里写图片描述
调整后:这里写图片描述
3.第三钟情况:调整前subrl的平衡因子是-1，调整后parent,subr,subrl分别是0，1，0
这里写图片描述
调整后:
这里写图片描述
源代码:

#pragma once
#include<iostream>
#include<cstdlib>
#include <algorithm>
#include<cassert>

using namespace std;

template<typename K, typename V>
struct AVLTreeNode
{
    typedef AVLTreeNode<K, V> Node;
    AVLTreeNode(const K& key, const V& value)
        : _left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _key(key)
        , _value(value)
        , _bf(0)
    {}
    Node* _left;
    Node* _right;
    Node* _parent;

    int _bf;
    K _key;
    V _value;
};

template<typename K, typename V>
class AVLTree
{
public:
    typedef AVLTreeNode<K, V> Node;

    //构造
    AVLTree()
        :_root(NULL)
    {}
    //析构
    ~AVLTree()
    {
        _Destroy(_root);
    }
    //插入节点
    bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            return true;
        }

        Node* parent = NULL;
        Node* cur = _root;

        while (NULL != cur)
        {
            parent = cur;
            if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else if(key < cur->_key)
            {
                cur = cur->_left;
            }
            else          //因为搜索树不存在相同的值，所以返回错误
            {
                return false;
            }
        }
        cur = new Node(key, value);
        if (cur->_key > parent->_key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        //插入完成，更新平衡因子
        while (parent)
        {
            if (parent->_left == cur)
            {
                parent->_bf--;
            }
            else
            {
                parent->_bf++;
            }
            if (parent->_bf == 0)
            {
                break;//
            }
            else if (parent->_bf == 1 || parent->_bf == -1)
            {
                cur = parent;
                parent = parent->_parent;
            }//向上调整平衡因子
            else if (parent->_bf == 2 || parent->_bf == -2)
            {
                if (parent->_bf == 2)
                {
                    if (cur->_bf == 1)  //左单旋
                    {
                        _RotateL(parent);
                    }
                    else                //右左旋转
                    {
                        _RotateRL(parent);
                    }
                }
                if(parent->_bf == -2)
                {
                    if (cur->_bf == 1)  //左右旋转
                    {
                        _RotateLR(parent);
                    }
                    else                //右单旋
                    {
                        _RotateR(parent);
                    }
                }
                break;//
            }
        }
    }

    void _RotateL(Node* parent)
    {
        assert(parent);
        Node* ppNode = parent->_parent;
        Node* prNode = parent->_right;
        Node* prlNode = prNode->_left;

        parent->_right = prlNode;      //***
        if (prlNode)
        {
            prlNode->_parent = parent;
        }
        prNode->_left = parent;
        parent->_parent = prNode;
        if (ppNode == NULL)
        {
            _root = prNode;
            prNode->_parent = NULL;
        }
        else
        {
            if (parent == ppNode->_left)
            {
                ppNode->_left = prNode;
            }
            else
            {
                ppNode->_right = prNode;
            }
            prNode->_parent = ppNode;
        }
        parent->_bf = prNode->_bf = 0;
    }

    void _RotateR(Node* parent)
    {
        assert(parent);
        Node* ppNode = parent->_parent;
        Node* plNode = parent->_left;
        Node* plrNode = plNode->_right;

        parent->_left = plrNode;
        if (plrNode)
        {
            plrNode->_parent = parent;
        }
        plNode->_right = parent;
        parent->_parent = plNode;
        if (ppNode == NULL)
        {
            _root = plNode;
            plNode->_parent = NULL;
        }
        else
        {
            if (parent == ppNode->_left)
            {
                plNode = ppNode->_left;
            }
            else
            {
                plNode = ppNode->_right;
            }
            plNode->_parent = ppNode;
        }
        parent->_bf = plNode->_bf = 0;
    }

    void _RotateLR(Node *parent)
    {
        Node* SubL = parent->_left;
        Node* SubLR = SubL->_right;
        int bf = SubLR->_bf;

        _RotateL(SubL);
        _RotateR(parent);
        //如果bf为0，代表插入点就是这个节点，这个时候所有旋转后的bf皆为0
        if (bf == 0)
        {
            SubL->_bf = parent->_bf = 0;
        }
        //当bf为1时，这个时候相当于是给sublr的右树插入
        else if (bf == 1)
        {
            SubL->_bf = -1;
            parent->_bf = 0;
        }
        //bf是-1时，相当于给sublr的左树插入
        else
        {
            SubL->_bf = 0;
            parent->_bf = 1;
        }
        SubLR->_bf = 0;
    }

    void _RotateRL(Node *parent)
    {
        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;

        int bf = SubRL->_bf;
        _RotateR(SubR);
        _RotateL(parent);

        if (bf == 0)
        {
            SubR->_bf = parent->_bf = 0;
        }
        else if (bf == -1)
        {
            parent->_bf = 0;
            SubR->_bf = 1;
        }
        else
        {
            SubR->_bf = 0;
            parent->_bf = -1;
        }
        SubRL->_bf = 0;
    }

    bool _Find(const K& key)
    {
        if (_root == NULL)
            return false;
        Node* cur = _root;
        while (cur)
        {
            if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else if (key > cur->_key)
            {
                cur = cur->_left;
            }
            else
            {
                return true;
            }
        }
        return false;
    }

    int _Height(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        int LeftLen = _Height(root->_left);
        int RightLen = _Height(root->_right);
        return LeftLen > RightLen ? LeftLen + 1 : RightLen + 1;
    }
    O(N^2)
    //bool  _IsBalance(Node* root)
    //{
    //  if (root == NULL)
    //  {
    //      return true;
    //  }
    //  int left = _Height(root->_left);
    //  int right = _Height(root->_right);
    //  int diff = left - right;
    //  if (diff > 1 || diff < -1)
    //  {
    //      return false;
    //  }
    //  return _IsBalance(root->_left) && _IsBalance(root->_right);
    //}

    bool _IsBalance2(Node* root, int &height)
    {
        if (root == NULL)
        {
            height = 0;
            return true;
        }
        int leftHeight = 0, rightHeight = 0;
        bool leftRet = _IsBalance2(root->_left, leftHeight);
        bool rightRet = _IsBalance2(root->_right, rightHeight);

        height = max(leftHeight, rightHeight) + 1;
        if (abs(leftHeight - rightHeight) > 1)
        {
            return false;
        }
        return leftRet && rightRet;
    }

    bool IsBalance()
    {
        int height = 0;
        return _IsBalance2(_root, height);
    }

    void _Destroy(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
        root = NULL;
    }

    void _InOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_key<< "->" << endl;
        _InOrder(root->_right);
    }

    void InOrder()
    {
        _InOrder(_root);
    }

private:
    Node * _root;
    //拷贝构造
    AVLTree(const AVLTree<K, V> & a);
    //赋值
    AVLTree<K, V>& operator=(const AVLTree<K, V> & a);
};


void test()
{
    AVLTree<int, int> AVLtree;
    int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        AVLtree.Insert(a[i], a[i]);
    }
    AVLtree.InOrder();
    bool ret =  AVLtree.IsBalance();
    if (ret)
    {
        cout << "yes" << endl;
    }
    else
    {
        cout << "no" << endl;
    }
}
d_csdnW
关注
avl.rar_AVL树_avl 旋转_树 旋转
09-24
在AVL树中，有四种基本的旋转操作用于维护树的平衡： 1. 左旋（Left Rotation）：当一个节点的右子节点的左子树过高时，需要进行左旋。左旋操作会将该节点的右子节点提升为新的根节点，原根节点则变为新根节点的左...
AVL树的旋转操作详解
张小凡
09-18 2202
图解AVL平衡二叉树的旋转
数据结构——“AVL树”的四种数据旋转的方法
最新发布
2301_79972085的博客
09-28 968
因为上次普通的二叉搜索树在极端情况下极容易造成我们的链式结构（这会导致我们查询的时间复杂度变为O(n)），然而AVL树就很好的解决了这一问题（归功于四种旋转的方法），它让我们的树的查询的时间复杂度变得接近于甚至等于O(logN)。它相比于普通的二叉搜索树，它增加了平衡因子来维持树的高度，增加了纸箱上一个节点的parent指针。另外，平衡因子的计算方法是右子树的高度减去左子树的高度，当当前节点的平衡因子的值为-1、0、1的时候，我们认为当前节点是平衡的，当为其他值的时候就不平衡，需要通过旋转来将树调整平衡。
【C++AVL树】4种旋转详讲
m0_72964546的博客
11-02 1219
如果还没有元素是一课空树，直接插入即可；如果有元素，按pair的first(key)和比较的节点比较结果为大说明为空的哪个位置在右边，和比较的节点比较的结果小说明为空的哪个位置在左边，如果相等说明已经有这个元素了，二叉搜索树不支持冗余，插入失败返回false； 不知道这个已经找到的位置在父节点的左边还是右边，需要判断一下，然后插入元素； 插入元素的后那么平衡因子将发生变化，为0说明这个父亲节点左右平衡不会影响其他节点，为1或者-1需要向上调整，为2或者-2说明已经不平衡需要旋转；
AVL树的四种旋转方式(详细图解)
qq_65786321的博客
11-09 923
新节点插入到左子树的右侧时对parent使用左右双旋。新节点插入到右子树的左侧时对parent使用右左双旋。新节点插入到右子树的右侧时对parent使用左单旋。新节点插入到左子树的左侧时对parent使用右单旋。
【平衡二叉搜索树（AVL）-- 旋转】
m0_熊猫馆主的博客
05-01 1783
打怪升级：第60天旋转是为了在保持平衡树性质的前提下降低树的高度，右子树高AVLTree，也就是我们所说的：自平衡二叉搜索树，AVL命名由来是两位发明者的名字的首字母，并无其他含义。AVL树是一棵搜索树；AVL树左右子树的高度差的绝对值不大于1；AVL树的左右子树也是AVL树。高度差可取0,1,-1。注：我们将左右子树的高度差称为平衡因子，简称为bf既然AVL树是一棵搜索树它就需要满足搜索树的特征：左子树不空，左子树上的值都小于根节点的值；右子树不空，右子树上的值都大于根节点的值；左右子树也都是二叉搜索树。
AVL.rar_AVL树
09-21
3. 自动平衡：在执行插入或删除操作后，AVL树可能会失去平衡，这时需要通过旋转操作来恢复平衡。常见的旋转操作有四种：左旋、右旋、左右旋和右左旋。 AVL树的操作： 1. 插入节点：当向AVL树中插入一个新节点时，...
AVL.zip_AVL树
09-14
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是每个节点的两个子树的高度差不超过1，确保了树的...
一篇搞定AVL树+旋转【附图详解旋转思想】
2301_77509762的博客
03-31 1614
AVL树的介绍，插入的旋转思想,代码实现及性能分析
今天终于懂了AVL树怎样旋转(带图理解)
山鬼谣弋痕夕的博客
02-23 4883
AVL树，也称平衡二叉搜索树，AVL是其发明者姓名简写。 AVL树属于树的一种，而且它也是一棵二叉搜索树，不同的是他通过一定机制能保证二叉搜索树的平衡，平衡的二叉搜索树的查询效率更高。 AVL树特点 AVL树是一棵二叉搜索树。 AVL树的左右子节点也是AVL树。 AVL树拥有二叉搜索树的所有基本特点。 每个节点的左右子节点的高度之差的绝对值最多为1，即平衡因...
AVL树的旋转图解和简单实现
热门推荐
喵了个呜的博客
07-07 5万+
AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN) 原文地址：http://blog.csdn.net/qq_25806863/article/details/74755131 平衡条件 一个最理想的平衡条件是左右两个子树的高度完全相等，但只有节点数量为2^n-1的树才满足这个条件（n是层数，2层要3个，3层要7个）。这个条件太严格，不好用。...
数据结构：AVL树的实现（图解AVL树的四种旋转）及AVL的代码实现
dangzhangjing97的博客
03-25 1976
二叉搜索树虽然可以缩短查找的效率，但如果数据有序或者接近有序，二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率非常低下 AVL树的概念 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 1.它的左右子树都是AVL树； 2.左子树和右子树高度之差（简称平衡因子）的绝对值不超过1（故一个结点的平衡因子可以是-1/0/1） 如果一棵二叉搜索树是高度平衡的，它...
图解AVL树的旋转操作
weixin_66831846的博客
10-06 282
我们将树的结点定义为三叉链结构，方便实现回溯更新结点的平衡因子，并定义平衡因子为右子树高度-左子树高度。//三叉链结构//左结点//右结点//父结点//存储的键值//平衡因子int _bf;//右子树的高度-左子树的高度,_kv(kv),_bf(0){}
平衡二叉树（AVL）平衡化旋转详解
sunnyoldboy博客
10-09 4542
平衡二叉树的全称是平衡二叉排序树，也称为AVL树，这是因为该树结构是由Adelson-Velskii和Landis在1963年提出的。AVL树是BST树的改进结构，使得平均查找长度得到了减少，进而提高了查找的效率。
二叉平衡(AVL)树中的 LL旋转、RR旋转、LR旋转、RL旋转 的详细解释
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
06-15 9585
文章目录前言一、旋转的分类1.LL平衡旋转2.RR平衡旋转3.LR平衡旋转4.RL平衡旋转二、实现LL平衡旋转三、实现RR平衡旋转四、实现LR平衡旋转五、实现RL平衡旋转 前言 我们知道在二叉平衡（AVL）树中是存在平衡因子的，平衡因子的作用是判断AVL树是否平衡，当AVL树不平衡时，我们就需要通过旋转使其重回平衡。 一、旋转的分类 1.LL平衡旋转 所谓的LL平衡旋转是指，新插入的节点N使AVL树失去平衡，且最先失去平衡的节点为P。当N是在P的左节点的左子树上时，需要通过LL平衡旋转使AVL树重回平衡。
平衡二叉树(AVL 树)左旋转算法
实践求真知
03-26 622
一平衡二叉树的引入 1 二叉排序树存在的问题 有一个数列{1,2,3,4,5,6}， 创建一颗二叉排序树(BST), 分析它存在的问题。 2上边 BST 存在的问题 a 左子树全部为空，从形式上看，它更像一个单链表。 b 插入速度没有影响。 c 查询速度明显降低，因为需要依次比较，该树不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。 3 解决方案-平衡二叉树(AVL) 平衡二叉树具有以下特点： a 平衡二叉树也叫平衡二叉搜索树（Self-balancing..
269-AVL树(左，右双旋转)
LINZEYU666的博客
04-13 458
AVL树(左，右双旋转) 我们依次插入数据结点56,90,67。最后形成了“折线”，所以我们要进行双旋转 我们依次插入数据结点78,34,45。最后形成了“折线”，所以我们要进行双旋转 我们要求的中序遍历是从小到大，旋转之后使得每个节点的平衡因子尽可能向0靠拢。 我们要借助左单旋转函数和右单旋转函数的能力来进行 我们把34和45，以45为基准，进行左单旋转，34放下来，45放上去，再以45位基准，把78进行右单旋转。 我们来看下面这个问题 (a)是平衡二叉树，我们可能在D或者F或者G插入数据，如果
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值