前言
本系列文章承接C++基础的学习，需要++有C语言的基础++ 才能学会哦~
第20篇主要讲的是有关于C++的++AVL树++ 。
C++才起步，都很简单！！
目录
AVL树概念
AVL树是一颗高度平衡二叉树，通过控制高度差去控制平衡，其左右子树的高度差不超过1。
**平衡因子：**二叉搜索树的每一个结点都有一个平衡因子，平衡因子 = 右子树高度 - 左子树高度。
++当平衡因子∈ [ -1, 0, 1 ] 时，该二叉搜索树为AVL树。++
因为AVL树的均衡分布，所以增删查改的效率也能控制在O(logN)，相比二叉搜索树有明显上升。
图为AVL树，蓝色数字为平衡因子。
AVL树的插入
后称为++bf（balance factor）++。
①先按照二叉搜索树的规则进行插入。
②新增结点之后可能会影响祖先结点的bf。
平衡因子更新原则
Ⅰ.bf = 右子树高度 - 左子树高度
Ⅱ.只有子树高度变化才会影响当前结点的bf。
Ⅲ.插入结点，会增加高度：若新增在parent的右子树，parent的bd++；若新增在parent的左子树，parent的平衡因子--。
平衡因子更新停止条件
Ⅰ.更新后parent的 bf = 0 ，说明更新前parent的 bf = 1 或 -1，更新前一高一低，新结点插入在低的那边，++插入后parent子树所在的子树高度不变++ ，所以不影响parent的bf，更新结束。
Ⅱ.更新后parent的bf = 1 或 -1，说明更新前其 bf = 0，即其两边子树高度相同，新增结点之后，虽然 bf 仍然符合要求，++但是高度增加了 1++ ，所以要向上更新。
Ⅲ.更新后parent的 bf = 2 或 -2，说明更新前其bf = 1 或 -1，即原本其两边子树就一高一低，新增的结点还加在高的一边，破坏了平衡，所以要进行旋转处理，旋转后不需要继续向上更新。
Ⅳ.++不断更新，更新到根，根的 bf = 1 或 -1 就停止++。
旋转处理图解
目标
1、把parent子树旋转平衡。2、降低parent子树的高度，使其恢复原来的高度。3、旋转前后都是AVL树。
原则
旋转分为右单旋/左单旋/左右双旋/右左双旋
右单旋
Ⅰ.
这是高度为h+2(h≥2)的AVL树，其中a，b，c为这个AVL树的AVL子树，
当我们在a中插入一个新结点，使得a子树高度＋1 ，
Ⅱ.
此时，根结点 bf 变为 -2，21结点 bf 变为 -1，AVL树高度变为h+3
进行右单旋处理，以 33 为旋转点进行右单旋，
Ⅲ.
此时21变为根结点，33变为21的右结点，b子树变为33的左子树。
右单旋完成，AVL树高度变回h+2，且再次回归平衡。
左单旋
是右单旋的镜像操作，逻辑完全一样。
Ⅰ.
这是高度为h+2(h≥2)的AVL树，其中a，b，c为这个AVL树的AVL子树，
当我们在a中插入一个新结点，使得a子树高度＋1 ，
Ⅱ.
此时，根结点 bf 变为 2，21结点 bf 变为 1，AVL树高度变为h+3
进行左单旋处理，以 21 为旋转点进行左单旋，
Ⅲ.
此时33变为根结点，21变为33的左结点，b子树变为33的右子树。
左单旋完成，AVL树高度变回h+2，且再次回归平衡。
左右双旋
Ⅰ.
同样的AVL树，
当我们在b子树中插入一个新结，使得b子树高度 + 1，
Ⅱ.
此时，根结点 bf 变为 -2，21结点 bf 变为 1，AVL树高度变为h+3
进行左右单旋处理，先拆解b子树为，b子树根结点（此处以25为例，视实际情况而定）和e、f子树
Ⅲ.
此处新结点插入e子树(插入f子树,只影响最终平衡因子的结果)。
再以21为旋转点进行左单旋，此次左单旋不需要达到平衡。
Ⅳ.
(插入在e子树)
(插入在f子树)
接着以33为旋转点进行右单旋，此次旋转后达到平衡。
Ⅴ.
(插入在e子树)
(插入在f子树)
可见不管新结点插入在e子树还是f子树，不会影响达到平衡。
最后一步旋转可以把21结点和a、e(f)子树看为一个整体。
右左双旋
同上，右左双旋为左右双旋的镜像操作。（略）
AVL树的模拟实现
cpp
#include<iostream>
#include<assert.h>
using namespace std;
template <class K, class V>
struct AVLTreeNode
{
pair<K, V> _kv;
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf;//平衡因子
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:
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->_right)
{
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 == -1)
{
RotateR(parent);
}
else if (parent->_bf == 2 && cur == 1)
{
RotateL(parent);
}
else if (parent->_bf == -2 && cur == 1)
{
RotateLR(parent);
}
else if (parent->_bf == 2 && cur == -1)
{
RotateRL(parent);
}
else
{
assert(false);
}
break;
}
else
{
assert(false);
}
}
return true;
}
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
//b子树可能为空
if (subLR)
{
subLR->_parent = parent;//为空就不用考虑subLR的parent指针了
}
Node* ppNode = parent->_parent;
subLR->_right = parent;
parent->_parent = subL;
//若parent为根结点
if (parent == _root)
{
_root = subL;//b子树成为根
subL->_parent = nullptr;//根的parent为空
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left == subL;
}
else
{
ppNode->_right == subL;
}
subL->_parent = ppNode;
}
parent->_bf = 0;
subL->_bf = 0;
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
//b子树可能为空
if (subRL)
{
subRL->_parent = parent;//为空就不用考虑subRL的parent指针了
}
Node* ppNode = parent->_parent;
subRL->_left = parent;
parent->_parent = subR;
//若parent为根结点
if (parent == _root)
{
_root = subR;//b子树成为根
subR->_parent = nullptr;//根的parent为空
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left == subR;
}
else
{
ppNode->_right == subR;
}
subR->_parent = ppNode;
}
parent->_bf = 0;
subR->_bf = 0;
}
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);//先左旋父结点的左孩子
RotateR(parent);//再右旋父结点
//插入到e子树
if (bf == -1)
{
subL->_bf = 0;
parent->_bf = 1;
subLR->_bf = 0;
}
//插入到f子树
else if (bf == 1)
{
subL->_bf = -1;
parent->_bf = 0;
subLR->_bf = 0;
}
//a、b、c都是空树
else if(bf == 0)
{
subL->_bf = 0;
parent->_bf = 0;
subLR->_bf = 0;
}
else
{
assert(false);
}
}
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);//先右旋父结点的左孩子
RotateL(parent);//再左旋父结点
//插入到e子树
if (bf == -1)
{
subR->_bf = 1;
parent->_bf = 0;
subRL->_bf = 0;
}
//插入到f子树
else if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
subRL->_bf = 0;
}
//a、b、c都是空树
else if (bf == 0)
{
subR->_bf = 0;
parent->_bf = 0;
subRL->_bf = 0;
}
else
{
assert(false);
}
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void IsBalanceTree()
{
_IsBalanceTree(_root);
}
int Height()
{
return _Height(_root);
}
int Size()
{
return _Size(_root);
}
void 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;
}
}
}
private:
int _Size(Node* root)
{
if (root == nulptr)
{
return 0;
}
return _Size(root->_left) + _Size(root->_right) + 1;
}
bool _IsBalanceTree(Node* root)
{
if (nullptr == root)
{
return true;
}
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return(false);
}
if (root->_bf != diff)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}
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;
}
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root-> kv.second << endl;
_InOrder(root->_right);
}
Node* _root = nullptr;
};❤~~本文完结！！感谢观看！！接下来更精彩！！欢迎来我博客做客~~❤