AVL树

最新推荐文章于 2022-10-09 18:18:21 发布
最新推荐文章于 2022-10-09 18:18:21 发布
阅读量218 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxucx/article/details/69388151
版权

1.AVL树的概念

  • AVL树
    AVL树又称为高度平衡的二叉搜索树，是1962年有俄罗斯的数学家G.M.Adel’son-Vel’skii和E.M.Landis提出来的。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度
  • AVL树的性质
    1.左子树和右子树的高度之差的绝对值不超过1
    2.中的每个左子树和右子树都是AVL树
    3.每个节点都有一个平衡因子(balance factor–bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )

2.平衡化旋转

（1）左单旋转

如下图所示，a，b，c均为高度为h的子树。当插入节点d时，影响了c子树的高度及平衡因子，以及节点2的平衡因子。
此时，需要调整这棵树（左旋），使得平衡因子的绝对值小于2；
这里写图片描述
代码：

//左旋
    void _RotateL(Node* parent)
    {
        assert(parent);
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL)
        {
            subRL->_parent = parent;
        }
        Node* ppNode = parent->_parent;
        subR->_left = parent;
        parent->_parent = subR;
        if (ppNode == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subR;
                subR->_parent = ppNode;
            }
            else
            {
                ppNode->_right = subR;
                subR->_parent = ppNode;
            }
        }
        parent->_bf = subR->_bf = 0;
    }
（2）右单旋转

右旋与左旋类似，只是方向方向刚好相反。
这里写图片描述
代码：

//右旋
    void _RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
        {
            subLR->_parent = parent;
        }
        Node* ppNode = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;

        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subL;
                subL->_parent = ppNode;
            }
            else
            {
                ppNode->_right = subL;
                subL->_parent = ppNode;
            }
        }
        parent->_bf = subL->_bf = 0;
    }
（3）先左后右双旋转

先左后右双旋转分为三种情况
1>subLR的平衡因子为0
只有当a，b不存在且节点2为插入的节点时，才需要左右旋转。
先以节点1为轴左旋，再以节点3为轴右旋，完成旋转。
这里写图片描述
2>subLR的平衡因子为1
先以节点1为轴左旋，再以节点3为轴右旋，完成旋转。
这里写图片描述
3>subLR的平衡因子为-1
先以节点1为轴左旋，再以节点3为轴右旋，完成旋转。
这里写图片描述
旋转完成后更新平衡因子
旋转后的平衡因子如下：

subLR->_bfparentsubLsubLR
0000
10-10
-1100

代码：

void _RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;
        _RotateL(subL);
        _RotateR(parent);

        if (bf == 0)
        {
            parent->_bf = subL->_bf = subLR->_bf = 0;
        }

        else if (bf == 1)
        {
            parent->_bf = 0;
            subL->_bf = -1;
            subLR->_bf = 0;
        }
        else  //bf == -1
        {
            parent->_bf = 1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
    }
（4）先右后左双旋转

与先左后右双旋转类似，就不详细介绍了。
代码：

void _RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;

        _RotateR(parent->_right);
        _RotateL(parent);

        if (bf == 0)
        {
            parent->_bf = 0;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else    //bf == -1
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
    }

3.AVL树的插入

（1）找到要插入的位置
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        Node* cur = _root;
        Node* parent = NULL;
        //找到要插入的节点的位置
        while (cur)
        {
            if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;   //表示已经存在，就不再插入了
            }
        }
（2）插入节点
        cur = new Node(key);
        if (key > parent->_key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
（3）更新平衡因子
//更新平衡因子,分三种情况
        while (parent)
        {
            if (parent->_left == cur)
                parent->_bf--;
            else
                parent->_bf++;
            //1.
            if (parent->_bf == 0)
            {
                return true;
            }
            //2.
            else if (abs(parent->_bf) == 1)
            {
                cur = parent;
                parent = cur->_parent;
            }
            //3.
            else   //abs(parent->_bf) == 2
            {
                Node* subL = parent->_left;
                Node* subR = parent->_right;
                if (parent->_bf == -2 && subL->_bf == -1)
                {
                    _RotateR(parent);
                    return true;
                }
                else if (parent->_bf == 2 && subR->_bf == 1)
                {
                    _RotateL(parent);
                    return true;
                }
                else if (parent->_bf == -2 && subL->_bf == 1)
                {
                    _RotateLR(parent);
                    return true;
                }
                else // (parent->_bf == 2 && subR->_bf == -1)
                {
                    _RotateRL(parent);
                    return true;
                }
            }
        }

4.判断一个二叉树是否AVL树

一颗二叉树为AVL，得同时满足是搜索二叉树（节点左孩子的值小于节点的值，节点右孩子的值大于节点的值）及这棵树平衡（左右子树的高度差不超过1）。
代码：

bool IsAVL()
    {
        if (IsBST(_root) && IsBalance(_root))
        {
            return true;
        }
        return false;
    }
bool IsBST(Node* root)
    {
        if (root == NULL)
        {
            return true;
        }   
        Node* left = root->_left;
        Node* right = root->_right;
        if (left && left->_key < root->_key)
        {
            return IsBST(root->_left);
        }
        else if (right && right->_key > root->_key)
        {
            return IsBST(root->_right);
        }

    }
    bool IsBalance(Node* root)
    {
        if (root == NULL)
            return true;
        int rightHeight = _Height(root->_right);
        int leftHeight = _Height(root->_left);
        int diff = rightHeight - leftHeight;
        return abs(diff) < 2 && IsBalance(root->_left) && IsBalance(root->_right);
    }
    int _Height(Node* node)
    {
        if (node == NULL)
            return 0;
        int right = _Height(node->_right) + 1;
        int left = _Height(node->_left) + 1;
        return right > left ? right : left;
    }

5.完整代码：

#pragma once
#include <iostream>
#include <assert.h>
#include <stdlib.h>
using namespace std;

template <class K>
struct AVLTreeNode
{
    K _key;
    int _bf;    //平衡因子
    AVLTreeNode<K>* _left;
    AVLTreeNode<K>* _right;
    AVLTreeNode<K>* _parent;
    AVLTreeNode(const K& key)
        :_key(key)
        , _bf(0)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
    {}
};

template <class K>
class AVLTree
{
public:
    typedef AVLTreeNode<K> Node;
public:
    AVLTree()
        :_root(NULL)
    {}

    ~AVLTree()
    {
        _Destroy(_root);
    }

    bool Insert(const K& key)
    {
        if (_root == NULL)
        {
            _root = new Node(key);
            return true;
        }
        Node* cur = _root;
        Node* parent = NULL;
        //找到要插入的节点的位置
        while (cur)
        {
            if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;   //表示已经存在，就不再插入了
            }
        }
        //插入节点
        cur = new Node(key);
        if (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)
            {
                return true;
            }

            else if (abs(parent->_bf) == 1)
            {
                cur = parent;
                parent = cur->_parent;
            }
            else   //abs(parent->_bf) == 2
            {
                Node* subL = parent->_left;
                Node* subR = parent->_right;
                if (parent->_bf == -2 && subL->_bf == -1)
                {
                    _RotateR(parent);
                    return true;
                }
                else if (parent->_bf == 2 && subR->_bf == 1)
                {
                    _RotateL(parent);
                    return true;
                }
                else if (parent->_bf == -2 && subL->_bf == 1)
                {
                    _RotateLR(parent);
                    return true;
                }
                else // (parent->_bf == 2 && subR->_bf == -1)
                {
                    _RotateRL(parent);
                    return true;
                }
            }
        }
        return true;
    }
    void InOrder()//中序遍历
    {
        _InOrder(_root);
        cout << endl;
    }
    bool IsAVL()
    {
        if (IsBST(_root) && IsBalance(_root))
        {
            return true;
        }
        return false;
    }
protected:
    bool IsBST(Node* root)
    {
        if (root == NULL)
        {
            return true;
        }   
        Node* left = root->_left;
        Node* right = root->_right;
        if (left && left->_key < root->_key)
        {
            return IsBST(root->_left);
        }
        else if (right && right->_key > root->_key)
        {
            return IsBST(root->_right);
        }

    }
    bool IsBalance(Node* root)
    {
        if (root == NULL)
            return true;
        int rightHeight = _Height(root->_right);
        int leftHeight = _Height(root->_left);
        int diff = rightHeight - leftHeight;
        return abs(diff) < 2 && IsBalance(root->_left) && IsBalance(root->_right);
    }
    int _Height(Node* node)
    {
        if (node == NULL)
            return 0;
        int right = _Height(node->_right) + 1;
        int left = _Height(node->_left) + 1;
        return right > left ? right : left;
    }
    void _InOrder(Node* root)
    {
        if (root != NULL)
        {
            _InOrder(root->_left);
            cout << root->_key << " ";
            _InOrder(root->_right);
        }
    }
    //左旋
    void _RotateL(Node* parent)
    {
        assert(parent);
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL)
        {
            subRL->_parent = parent;
        }
        Node* ppNode = parent->_parent;
        subR->_left = parent;
        parent->_parent = subR;
        if (ppNode == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subR;
                subR->_parent = ppNode;
            }
            else
            {
                ppNode->_right = subR;
                subR->_parent = ppNode;
            }
        }
        parent->_bf = subR->_bf = 0;
    }

    //右旋
    void _RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
        {
            subLR->_parent = parent;
        }
        Node* ppNode = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;

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

    void _RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;
        _RotateL(subL);
        _RotateR(parent);

        if (bf == 0)
        {
            parent->_bf = subL->_bf = subLR->_bf = 0;
        }

        else if (bf == 1)
        {
            parent->_bf = 0;
            subL->_bf = -1;
            subLR->_bf = 0;
        }
        else  //bf == -1
        {
            parent->_bf = 1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
    }
    void _RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;

        _RotateR(parent->_right);
        _RotateL(parent);

        if (bf == 0)
        {
            parent->_bf = 0;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else    //bf == -1
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
    }
    void _Destroy(Node* root)
    {
        if (root == NULL)
            return;
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
        root = NULL;
    }
    protected:
        Node* _root;
};

void TestAVLTree()
{
    /*int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };*/
    int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
    int size = sizeof(a) / sizeof(a[0]);
    AVLTree<int> a1;
    for (int i = 0; i < size; i++)
    {
        a1.Insert(a[i]);
        cout << a[i]<<"IsAVL:" << a1.IsAVL() << endl;
    }
    a1.InOrder();
    cout << "IsAVL:" << a1.IsAVL() << endl;
}
哎呀呀呦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL 树
sqjddb的博客
03-10 389
一、AVL树的由来及概念 二、AVL树的原理（旋转） 三、AVL树的实现 四、AVL树的性能
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
平衡二叉树（AVL）平衡化旋转详解
最新发布
sunnyoldboy博客
10-09 4286
平衡二叉树的全称是平衡二叉排序树，也称为AVL树，这是因为该树结构是由Adelson-Velskii和Landis在1963年提出的。AVL树是BST树的改进结构，使得平均查找长度得到了减少，进而提高了查找的效率。
【数据结构】AVL树及平衡化旋转
Cheng_913的博客
01-26 1184
   二叉搜索树可以缩短查找的效率，但是如果数据有序或接近有序时二叉搜索树将退化为单支树，查找效率将会下降。因此，我们通过向二叉搜索树种插入结点后，保证左右子树的高度之差的绝对值不超过1来调节结点，降低树的高度。 一. AVL树概念：   一颗AVL树是一颗空树或者具有如下性质的二叉搜索树: 1.它的左右子树都是AVL树； 2.左子树和右子树高度之差（简称平衡因子）的绝对值不超过1； ...
平衡二叉树旋转平衡（要看）！
kllihuang的专栏
08-20 4371
这个恐怕是整个《数据结构》教科书里面最难的和最“没用”的数据结构了（现在的教科书还有部分算法内容）。说它没用，恰恰是因为它太有用——有着和普通的二叉搜索树完全一样的接口界面，绝大多数情况下比普通的二叉搜索树效率高（很多）。因此，通常情况下，人们都是一劳永逸的——写完后就重用，而不
AVL树的平衡化旋转
单打乔的Log
05-23 317
左单旋：右单旋： 左右双旋： 右左双旋：
图示讲解AVL平衡二叉树的左旋和右旋
热门推荐
江城的博客
07-22 2万+
AVLTree 高度平衡的搜索二叉树 一棵平衡树，或是空树，或是具有以下性质的二叉搜索树：左子树和右子树都是AVL树，且左右子树的高度之差的绝对值不超过1。 该二叉树，根结点的右子树高度为3，左子树高度为2。结点上方的数字为平衡因子，因为右子树高度比左子树高度大1，所以根结点的平衡因子为1。 一颗平衡二叉树，如果有n个结点，其高度可保持O(log2^n),平均搜索长度也可以保持在O(l...
AVL.rar_AVL树
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作后能自动调整...
AVL.zip_AVL树
09-14
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是每个节点的两个子树的高度差不超过1，确保了树的...
avl.rar_AVL树
09-19
AVL树是一种自平衡二叉查找树（Self-Balancing Binary Search Tree，简称SBT），由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树，其中AV代表两位发明者的名字首字母。这种数据结构在计算机科学中...
avl.rar_AVL树_树
09-23
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AVL是两位发明者名字的首字母缩写。在AVL树中，每个节点的两个子树的高度差...
AVL.rar_AVL树_avl
09-19
AVL树是一种自平衡二叉查找树（Binary Search Tree, BST），由Georgy Adelson-Velsky和Emanuel Landis于1962年提出，因此得名AVL树，其中AVL是两位发明者姓氏的首字母。这种数据结构在计算机科学中被广泛用于实现...
AvlTree.rar_AVL树
09-19
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL，两位作者的名字首字母组合而成。AVL树的主要特点是任何节点的两个子树的高度...
图解平衡二叉树的四种旋转
hywo的博客
12-18 2296
这周写到平衡二叉树的题，在写旋转代码的时候写的有点晕，于是动笔画了个草图，总算是把四种旋转搞明白了。为了强化记忆，我用ppt做了四种旋转的图示，也希望看了这篇博客的各位能有所收获。四张图分别是LL旋转，RR旋转，LR旋转和RL旋转。（顺便吐槽一句，CSDN的markdown真难用，经常找不到光标，写的时候图片的的注解也没显示出来，不知道发出来会怎样） ...
有关AVL树的平衡化旋转和插入
apt1203JN的博客
03-17 391
一、AVL树的概念 1、定义：一棵高度平衡的二叉搜索树，就是AVL树。 2、性质： (1) 它的左右子树均为AVL树 (2) 左子树和右子树的高度之差（简称平衡因子）的绝对值不超过1（-1、0、1） 3、平衡因子的计算方法：左右子树的高度差 二、AVL树的平衡化旋转 1、左单旋：插入的节点位于较高右子树的右侧（右...
【数据结构】AVL树的平衡化旋转及实现AVL树的插入操作
sofia_m的博客
04-05 988
1、AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 “An algorithm for the organization of ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值