★ C++进阶篇 ★ AVL树实现

Ciallo～(∠・ω< )⌒☆ ~ 今天，我将继续和大家一起学习C++进阶篇第五章----AVL树实现 ~

❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
澄岚主页：椎名澄嵐-CSDN博客
C++专栏：★ C++进阶篇 ★_椎名澄嵐的博客-CSDN博客
❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️

一 AVL的概念

二 AVL树的实现

2.1 AVL树的结构

2.2 AVL树的插入

2.2.1 AVL树插入⼀个值的大概过程

2.2.2 平衡因子更新

2.2.3 插入结点及更新平衡因子的代码实现

2.3 旋转

2.3.1 旋转的原则

2.3.2 右单旋

2.3.3 右单旋代码实现

2.3.4 左单旋

2.3.5 左单旋代码实现

2.3.6 左右双旋

2.3.7 左右双旋代码实现

2.3.8 右左双旋

2.3.9 右左双旋代码实现

2.4 插入最终代码

2.4 AVL树的查找

2.6 AVL树平衡检测

一 AVL的概念

AVL树是最先发明的自平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的 左右子树都是AVL树，且左右子树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。

平衡因子：每个结点都有⼀个平衡因⼦，任何结点的平衡因⼦等于右子树的高度减去左子树的高度，也就是说任何结点的平衡因⼦等于0/1/-1， AVL树并不是必须要平衡因子，但是有了平衡因⼦可以更方便我们去进⾏观察和控制树是否平衡，就像⼀个⻛向标⼀样。

AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在logN ，那么增删查改的效率也可以控制在O(logN)，相⽐⼆叉搜索树有了本质的提升。

下树就不是AVL树~

二 AVL树的实现

2.1 AVL树的结构

template<class K, class V>
struct AVLTreeNode
{
	// 需要parent指针，后续更新平衡因⼦可以看到
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf; // balance factor
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}
};
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	//...

private:
	Node* _root = nullptr;
};

2.2 AVL树的插入

2.2.1 AVL树插入⼀个值的大概过程

插入⼀个值按⼆叉搜索树规则进行插入。
新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
更新平衡因⼦过程中没有出现问题，则插入结束
更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树的⾼度，不会再影响上⼀层，所以插⼊结束。

2.2.2 平衡因子更新

更新原则：

平衡因子=右子树高度 - 左子树高度 。
只有子树高度变化才会影响当前结点平衡因子。
插入结点，会增加高度，所以新增结点在parent的右⼦树，parent的平衡因子++，新增结点在 parent的左子树，parent平衡因子 -- 。
parent所在子树的高度是否变化决定了是否会继续往上更新。

更新停止条件：

更新后parent的平衡因子等于0，更新中parent的平衡因⼦变化为-1->0或者1->0，说明更新前 parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会影响parent的父亲结点的平衡因子，更新结束。
更新后parent的平衡因子等于1或-1，更新前更新中parent的平衡因⼦变化为0->1或者0->-1，说明更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响parent的⽗亲结点的平衡因⼦，所以要继续向上更新。
更新后parent的平衡因子等于2或-2，更新前更新中parent的平衡因⼦变化为1->2或者-1->-2，说明更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：1、把 parent子树旋转平衡。2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。

左图更新到10结点，平衡因⼦为2，10所在的子树已经不平衡，需要旋转处理。

右图是最坏情况，更新到根停止。

2.2.3 插入结点及更新平衡因子的代码实现

bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    } 
    cur = new Node(kv);
    if (parent->_kv.first < kv.first)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = 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)
        {
            // 旋转
            // ...
            break;
        }
        else
        {
            assert(false);
        }
    return true;
}

2.3 旋转

2.3.1 旋转的原则

1. 保持搜索树的规则
2. 让旋转的树从不满足变平衡，其次降低旋转树的高度

旋转总共分为四种，左单旋 / 右单旋 / 左右双旋 / 右左双旋。

2.3.2 右单旋

本图1展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的子树的根。这⾥a/b/c是⾼度为h的⼦树，是⼀种概括抽象表示，他代表了所有右单旋的场景，实际右单旋形态有很多种，具体图2/图3/图4/图5进⾏了详细描述。
在a子树中插⼊一个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平衡因子从-1变成-2，10为根的树左右⾼度差超过1，违反平衡规则。10为根的树左边太⾼了，需要往右边旋转，控制两棵树的平衡。
旋转核⼼步骤，因为5 < b子树的值 < 10 ，将b变成10的左子树，10变成5的右子树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原则。如果插⼊之前10整棵树的⼀个局部子，旋转后不会再影响上⼀层，插⼊结束了。

2.3.3 右单旋代码实现

void  RotateR(Node * parent) // 右单旋
{
    // 拿到parent的左结点和左结点的右结点
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    Node* pParent = parent->_parent;
    // 旋转 (注意更改父亲结点)
    parent->_left = subLR;
    if(subLR) // subLR不为空才能访问父亲结点
    {
        subLR->_parent = parent;
    }
    subL->_right = parent;
    parent->parent = subL;

    if (parent == _root) // 若parent为根结点 
    {
        _root = subL;
        _root->_parent = nullptr;
    }
    else // 若parent不是根结点 
    {
        if (pParent->_left == parent) // parent结点为pParent的左结点
        {
            pParent->_left = subL;
        }
        else // parent结点为pParent的右结点
        {
            pParent->_right = subL;
        }
        subL->_parent = pParent; // 更改父亲结点
    }
}

2.3.4 左单旋

本图6展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的子树的根。这里a/b/c是⾼度为h的子树，是⼀种概括抽象表示，他代表了所有右单旋的场景，实际右单旋形态有很多种，具体跟上面左旋类似。
在a⼦树中插入⼀个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平衡因子从1变成2，10为根的树左右高度差超过1，违反平衡规则。10为根的树右边太高了，需要往左边旋转，控制两棵树的平衡。
旋转核⼼步骤，因为10 < b⼦树的值 < 15，将b变成10的右子树，10变成15的左⼦树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的高度恢复到了插入之前的h+2，符合旋转原则。如果插⼊之前10整棵树的⼀个局部子树，旋转后不会再影响上⼀层，插⼊结束了。

2.3.5 左单旋代码实现

和右单旋差不多~

void RotateL(Node* parent) // 左单旋
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    parent->_right = subRL;
    if (subRL)
        subRL->_parent = parent;
    Node* parentParent = parent->_parent;
    subR->_left = parent;
    parent->_parent = subR;

    if (parentParent == nullptr)
    {
        _root = subR;
        subR->_parent = nullptr;
    }
    else
    {
        if (parent == parentParent->_left)
        {
            parentParent->_left = subR;
        }
        else
        {
            parentParent->_right = subR;
        }
        subR->_parent = parentParent;
    }
    parent->_bf = subR->_bf = 0;
}

2.3.6 左右双旋

通过下图可以看到，左边⾼时，如果插⼊位置不是在a⼦树，⽽是插⼊在b⼦树，b⼦树⾼度从h变成h+1，引发旋转，右单旋⽆法解决问题，右单旋后，我们的树依旧不平衡。右单旋解决的纯粹的左边⾼，但是插⼊在b⼦树中，10为跟的⼦树不再是单纯的左边⾼，对于10是左边⾼，但是对于5是右边⾼，需要⽤两次旋转才能解决，以5为旋转点进⾏⼀个左单旋，以10为旋转点进⾏⼀个右单旋，这棵树这棵树就平衡了。

上图分别为左右双旋中h==0和h==1具体场景分析，下⾯我们将a/b/c⼦树抽象为⾼度h的AVL ⼦树进⾏分析，另外我们需要把b⼦树的细节进⼀步展开为8和左⼦树⾼度为h-1的e和f⼦树，因为我们要对b的⽗亲5为旋转点进⾏左单旋，左单旋需要动b树中的左⼦树。b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察8的平衡因⼦不同，这⾥我们要分三个场景讨论。
场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1并为h并不断更新8->5->10平衡因⼦，引发旋转，其中8的平衡因⼦为-1，旋转后8和5平衡因⼦为0，10平衡因⼦为1。
场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新8->5->10平衡因⼦，引发旋转，其中8的平衡因⼦为1，旋转后8和10平衡因⼦为0，5平衡因⼦为-1。
场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新5->10平衡因⼦，引发旋转，其中8的平衡因⼦为0，旋转后8和10和5平衡因⼦均为0。

上图就结果来看，左右双旋就是把8推为根，8的左子树和右子树分别给到5的右子树和10的左子树。注意要看8的平衡因子。

2.3.7 左右双旋代码实现

void RotateLR(Node* parent)
{
    // 记录重要结点
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    int bf = subLR->_bf;
    // 左右单旋核心
    RotateL(parent->_left);
    RotateR(parent);
    // 根据平衡因子分类讨论
    if (bf == -1)
    {
        subLR->_bf = 0;
        subL->_bf = 0;
        parent->_bf = 1;
    }
    else if (bf == 1)
    {
        subLR->_bf = 0;
        subL->_bf = -1;
        parent->_bf = 1;
    }
    else if (bf == 0)
    {
        subLR->_bf = 0;
        subL->_bf = 0;
        parent->_bf = 0;
    }
    else // 意外情况
    {
        assert(false);
    }
}

2.3.8 右左双旋

跟左右双旋类似，下⾯我们将a/b/c⼦树抽象为⾼度h的AVL⼦树进⾏分析，另外我们需要把b⼦树的细节进⼀步展开为12和左⼦树⾼度为h-1的e和f⼦树，因为我们要对b的⽗亲15为旋转点进⾏右单旋，右单旋需要动b树中的右⼦树。b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察12的平衡因⼦不同，这⾥我们要分三个场景讨论。
场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转，其中12的平衡因⼦为-1，旋转后10和12平衡因⼦为0，15平衡因⼦为1。
场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转，其中12的平衡因⼦为1，旋转后15和12平衡因⼦为0，10平衡因⼦为-1。
场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新15->10平衡因⼦，引发旋转，其中12的平衡因⼦为0，旋转后10和12和15平衡因⼦均为0。

2.3.9 右左双旋代码实现

void RotateRL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    int bf = subRL->_bf;
    RotateR(parent->_right);
    RotateL(parent);
    if (bf == 0)
    {
        subR->_bf = 0;
        subRL->_bf = 0;
        parent->_bf = 0;
    }
    else if (bf == 1)
    {
        subR->_bf = 0;
        subRL->_bf = 0;
        parent->_bf = -1;
    }
    else if (bf == -1)
    {
        subR->_bf = 1;
        subRL->_bf = 0;
        parent->_bf = 0;
    }
    else
    {
        assert(false);
    }
}

2.4 插入最终代码

bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }
    cur = new Node(kv);
    if (parent->_kv.first < kv.first)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = 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 && cur->_bf == -1)
            {
                RotateR(parent);
            }
            else if (parent->_bf == 2 && cur->_bf == 1)
            {
                RotateL(parent);
            }
            else if (parent->_bf == -2 && cur->_bf == 1)
            {
                RotateLR(parent);
            }
            else if (parent->_bf == 2 && cur->_bf == -1)
            {
                RotateRL(parent);
            }
            else
            {
                assert(false);
            }
            break;
        }
        else
        {
            assert(false);
        }
    }
    return true;
}

2.4 AVL树的查找

时间复杂度O(LogN)~

Node* Find(const K& key)
{
    Node* cur = _root;
    while (cur) 
    {
        if (cur->_kv.first < key)
        {
            cur = cur->_right;
        }
        else if (cur->_kv.first > key)
        {
            cur = cur->_left;
        }
        else
        {
            return cur;
        }
    }
    return nullptr;
}

2.6 AVL树平衡检测

我们实现的AVL树是否合格，我们通过检查左右⼦树⾼度差的的程序进⾏反向验证，同时检查⼀下结点的平衡因⼦更新是否出现了问题。

int _Height(Node* root)
{
    if (root == nullptr)
        return 0;
    int leftHeight = _Height(root->_left);
    int rightHeight = _Height(root->_right);
    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
bool _IsBalanceTree(Node* root)
{
    // 空树也是AVL树
    if (nullptr == root)
        return true;

    // 计算pRoot结点的平衡因⼦：即pRoot左右⼦树的⾼度差
    int leftHeight = _Height(root->_left);
    int rightHeight = _Height(root->_right);
    int diff = rightHeight - leftHeight;

    // 如果计算出的平衡因⼦与pRoot的平衡因⼦不相等，或者
    // pRoot平衡因⼦的绝对值超过1，则⼀定不是AVL树
    if (abs(diff) >= 2)
    {
        cout << root->_kv.first << "⾼度差异常" << endl;
            return false;
    }
    if (root->_bf != diff)
    {
        cout << root->_kv.first << "平衡因⼦异常" << endl;
            return false;
    }

    // pRoot的左和右如果都是AVL树，则该树⼀定是AVL树
    return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}

~ 完 ~