AVL 树

最新推荐文章于 2020-05-06 12:27:33 发布
最新推荐文章于 2020-05-06 12:27:33 发布
阅读量160 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hudazhe/article/details/79262311
版权

由于之前的搜索二叉树在单支树的情况下，时间复杂度依然为 O(N)，所以我们应该对其进行调整，此时遍出现了 AVL 树，AVL 树是最先发明的自平衡二叉搜索树。在AVL树中，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是 O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

特点 ：
1. AVL树本身依然是搜索二叉树。
2. 每个节点的左右子树高度差的绝对值小于等于1.

插入：
向 AVL 树中插入，首先如同二叉搜索树一样，先找到插入的位置，然后将节点插入。此时插入节点的平衡因子值为 0(因为其左右子树高度差为0)，接着自底向上折
回并更新双亲节点的平衡因子(左树-1，右树+1)，如果某个节点的平衡因子等于 +2或 -1 时，此时该树是不平衡的，需要对这个树进行平衡调整：

左旋：
这里写图片描述
右旋：
这里写图片描述
这里写图片描述
左右旋：
这里写图片描述
这里写图片描述
左右旋特殊场景
这里写图片描述
右左旋：
这里写图片描述
这里写图片描述
右左旋特殊场景
这里写图片描述

上面的四种算法即是AVL 树的平衡调整算法，经过调整后的 AVL树，高度会控制在 log(N)的范围内，插入和查找的时间复杂度也会控制在 log(N)的范围内。
实现：

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 (cur)
        {
            if (cur->_key < key) // key 大于 根节点 key 向右移动
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)  // key 值小于 根节点 key 向左移动
            {
                parent = cur;
                cur = cur->_left;
            }
            else // 存在相同 key 值
                return false;
        }
        // 插入
        cur = new Node(key, value);
        if (cur->_key < parent->_key) // 判断插左还是插右
            parent->_left = cur;
        else
            parent->_right = cur;
        cur->_parent = parent;

        //更新平衡因子
        while (parent)
        {
            if (cur == parent->_left) // 左右
                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)  // 右树的右树
                    {
                        //左单旋
                        RotateLeft(parent);
                    }
                    else  // 右树的左树
                    {  //  右左旋
                        int inode = cur->_left->_bf; // 特殊场景
                        RotateRight(cur);
                        RotateLeft(parent);
                        if (inode == 1)
                            parent->_bf = -1;
                        else if (inode == -1)
                            cur->_bf = 1;
                    }
                }
                if (parent->_bf == -2)  // 左树失衡
                {
                    if (cur->_bf == -1)
                    {  // 左树的左树
                        // 右单旋
                        RotateRight(parent);
                    }
                    else
                    {  // 左树的右树
                        // 左右双旋
                        int inode = cur->_right->_bf;
                        RotateLeft(cur);
                        RotateRight(parent);
                        if (inode == 1)
                            cur->_bf = -1;
                        else if (inode == -1)
                            parent->_bf = 1;
                    }
                }
                return true;
            }
        }
        return true;
    }
void RotateLeft(Node* parent) // 左单旋
    {
        Node * subR = parent->_right;
        Node * subRL = subR->_left;
        // 旋转 
        parent->_right = subRL;
        if (subRL)  // 存在的话
            subRL->_parent = parent;

        subR->_left = parent;
        Node* pParent = parent->_parent;
        parent->_parent = subR;
        if (pParent == NULL)  // 根节点的情况
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else  //不是根节点
        {
            if (subR->_key < pParent->_key)  // 如果在双亲的左侧
            {
                pParent->_left = subR;
            }
            else  // 在双亲节点的右侧
            {
                pParent->_right = subR;
            }
            subR->_parent = pParent;
        }  
        // 更新平衡因子
        parent->_bf = subR->_bf = 0;
    }
    void RotateRight(Node * parent)  // 右单旋
    {
        Node *subL = parent->_left;
        Node *subLR = subL->_right;
        //旋转
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        subL->_right = parent;
        Node* pParent = parent->_parent;
        parent->_parent = subL;
        if (pParent == NULL)  //如果是根节点
        {   
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (subL->_key < pParent->_key)
                pParent->_left = subL;
            else
                pParent->_right = subL;
            subL->_parent = pParent;
        }
        parent->_bf = subL->_bf = 0;
    }

插入完成后，我们需要对整棵树进行判断，判断其是否平衡，为了避免插入时平衡因子的计算错误，所以我们不能根据平衡因子进行判断，而是根据其每个节点的左右子树的高度差来进行判断：
实现：

bool _IsBalance(Node* root)
    {
        if (abs(Heigh(root->_left) - Heigh(root->_right)) >= 2)
            return false;
        return true;
    }
private:
    int Heigh(Node* root)
    {
        if (root == 0)
            return 0;
        if (Heigh(root->_left) > Heigh(root->_right))
            return 1 + Heigh(root->_left);
        else
            return 1 + Heigh(root->_right); 
    }

此时二叉搜索树已经实现了平衡，打完收工。
所有代码：

#pragma once
#include <iostream>
#include <assert.h>
#include <math.h>
using namespace std;
template<class K, class V>
struct AVLTreeNode
{
    AVLTreeNode<K, V> *_left;
    AVLTreeNode<K, V> *_right;
    AVLTreeNode<K, V> *_parent;  //父节点
    K _key;  //键值
    V _value;
    int _bf; //平衡因子
    AVLTreeNode(K key, V value)
        :_left(NULL)
        ,_right(NULL)
        ,_parent(NULL)
        ,_key(key)
        ,_value(value)
        ,_bf(0)
    {}
};
template<class K, class V>
class AVLTree
{
public:
    typedef AVLTreeNode<K, V> Node;

    AVLTree()
        :_root(NULL)
    {}
    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 (cur)
        {
            if (cur->_key < key) // key 大于 根节点 key 向右移动
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)  // key 值小于 根节点 key 向左移动
            {
                parent = cur;
                cur = cur->_left;
            }
            else // 存在相同 key 值
                return false;
        }
        // 插入
        cur = new Node(key, value);
        if (cur->_key < parent->_key) // 判断插左还是插右
            parent->_left = cur;
        else
            parent->_right = cur;
        cur->_parent = parent;

        //更新平衡因子
        while (parent)
        {
            if (cur == parent->_left) // 左右
                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)  // 右树的右树
                    {
                        //左单旋
                        RotateLeft(parent);
                    }
                    else  // 右树的左树
                    {  //  右左旋
                        int inode = cur->_left->_bf; // 特殊场景
                        RotateRight(cur);
                        RotateLeft(parent);
                        if (inode == 1)
                            parent->_bf = -1;
                        else if (inode == -1)
                            cur->_bf = 1;
                    }
                }
                if (parent->_bf == -2)  // 左树失衡
                {
                    if (cur->_bf == -1)
                    {  // 左树的左树
                        // 右单旋
                        RotateRight(parent);
                    }
                    else
                    {  // 左树的右树
                        // 左右双旋
                        int inode = cur->_right->_bf;
                        RotateLeft(cur);
                        RotateRight(parent);
                        if (inode == 1)
                            cur->_bf = -1;
                        else if (inode == -1)
                            parent->_bf = 1;
                    }
                }
                return true;
            }
        }
        return true;
    }
    void RotateLeft(Node* parent) // 左单旋
    {
        Node * subR = parent->_right;
        Node * subRL = subR->_left;
        // 旋转 
        parent->_right = subRL;
        if (subRL)  // 存在的话
            subRL->_parent = parent;

        subR->_left = parent;
        Node* pParent = parent->_parent;
        parent->_parent = subR;
        if (pParent == NULL)  // 根节点的情况
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else  //不是根节点
        {
            if (subR->_key < pParent->_key)  // 如果在双亲的左侧
            {
                pParent->_left = subR;
            }
            else  // 在双亲节点的右侧
            {
                pParent->_right = subR;
            }
            subR->_parent = pParent;
        }  
        // 更新平衡因子
        parent->_bf = subR->_bf = 0;
    }
    void RotateRight(Node * parent)  // 右单旋
    {
        Node *subL = parent->_left;
        Node *subLR = subL->_right;
        //旋转
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        subL->_right = parent;
        Node* pParent = parent->_parent;
        parent->_parent = subL;
        if (pParent == NULL)  //如果是根节点
        {   
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (subL->_key < pParent->_key)
                pParent->_left = subL;
            else
                pParent->_right = subL;
            subL->_parent = pParent;
        }
        parent->_bf = subL->_bf = 0;
    }
    bool IsBalance()//判断是否平衡
    {
        return _IsBalance(_root);
    }
    void InOrder()
    {
        _Inorede(_root);
    }
private:
    void _Inorede(Node* root)
    {
        if (root == NULL)
            return;
        _Inorede(root->_left);
        printf("%d\n", root->_value);
        _Inorede(root->_right);
    }

    bool _IsBalance(Node* root)
    {
        if (abs(Heigh(root->_left) - Heigh(root->_right)) >= 2)
            return false;
        return true;
    }
private:
    int Heigh(Node* root)
    {
        if (root == 0)
            return 0;
        if (Heigh(root->_left) > Heigh(root->_right))
            return 1 + Heigh(root->_left);
        else
            return 1 + Heigh(root->_right); 
    }

    Node *_root;
};

void test()
{
    AVLTree<int, int> t;
    int array[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    for (int i = 0; i < sizeof(array) / sizeof(int); i++)
        t.Insert(array[i],array[i]);
    if (t.IsBalance())
        cout << "平衡" << endl;
    else
        cout << "不平衡" << endl;
    t.InOrder();
}
胡小哲
关注
专栏目录
AVL的详细讲解
linkedin_39403967的博客
07-26 1604
http://www.cnblogs.com/vamei/archive/2013/03/21/2964092.html 存在的问题:AVL能够使得二叉树维持绝对的平衡：最大深度与最小深度之差最多为1。而Red-black通过红黑树的五条性质，使得红黑树的最大深度能为h≤2log(n+1)h \le 2log(n+1)，并不能有AVL这样的绝对平衡性。但他们的深度都能在O(lgn)O(lgn)。
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
AVL
STEPHEN的专栏
05-11 527
AVL目录 AVL 概述 单旋转 右旋转 左旋转 双旋转 左-右旋转 右-左旋转 代码实现 Summary 概述二叉搜索树(BST)可能会造成如下图所示的问题:查找的时间复杂度会达到O(N)，这个时候AVL树就派上用场了。 一棵AVL树是其每个节点的左子树和右子树的高度最多差1的二叉搜索树(空树的高度定义为-1)。把失去平衡的节点叫做α，由于任意节点最多有两个孩子，因此出现高度不平衡的α的两棵子树
AVL模板
weixin_30569033的博客
11-01 66
感谢此博客 #include <bits/stdc++.h> #define pb push_back #define mp make_pair #define de(x) cout << #x << " = " << x << endl #define clr(a,b) memset(a,b,sizeof(a)) using names...
AVL树
03-04
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作时能保持树的...
二叉查找树，AVL树
01-07
AVL树（平衡二叉查找树） 具有二叉查找树的全部特性。 每个节点的左子树的高度和右子树高度差值小于等于1（平衡二叉树的性质） 左旋：逆时针旋转两个节点，原先的右节点成为新的父节点，原先的父节点成为原先的右...
avlTree:通用AVL树数据结构
06-18
在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何时候它们相差超过 1，则进行重新平衡以恢复此属性。 查找、插入和删除在平均和最坏情况下都需要 O(log n) 时间，其中 n 是操作之前树中的节点数。 ...
AVL介绍
weixin_44980072的博客
05-06 3282
AVL树概念 AVL树是带有平衡条件的二叉查找树。这个平衡条件必须要容易保持。而且要保证它的深度是O(logN). AVL的条件是左右树的高度差（平衡因子）不大于1；并且它的每个子树也都是平衡二叉树。 对于平衡二叉树的最小个数，n0=0;n1=1;nk=n(k-1)+n(k-2)+1;(求法可以类比斐波那契！) 难点：AVL是一颗二叉排序树，用什么样的规则或者规律让它能够在复杂度不太高的情况下实现...
AVL实现
weixin_44980072的博客
05-06 1029
前言： 前面是Avl树的介绍写的比较详细，这一篇主要写怎么实现 最简单的旋转 依次插入1 2 3节点，1的左子树为空高度为0，而右子树高度为2，旋转后，左右高度都为1 单旋转 依次插入6 3 7 1 4，插入2时，树的平衡被破坏 步骤： 获取k1节点=k2的左边节点 设置k2的左边节点为k1的右边节点Y 设置k1的右边节点为k2 重新计算k2和k1的高度 private AvlNode&l...
AVL树学习
Liam Q的专栏
11-18 3147
1.什么是AVL树           AVL树是带有平衡条件的二叉查找树，是其每个结点的左子树和右子树的高度差最多差1的二叉查找树。如图1，左边的树是AVL树，但右边的不是。 图1 左边的是AVL树，右边的不是 2.AVL树的基本操作          当向一棵AVL树中插入一个结点时，可能破坏AVL树的特性（例如，将6插入图1的AVL树中将会破坏项为8的结点平衡条件）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值