目录
AVL树的概念
- AVL树是最先发明的⾃平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的 左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树， 通过控制⾼度差去控制平衡。
- AVL树实现这⾥我们引⼊⼀个平衡因⼦(balancefactor)的概念，每个结点都有⼀个平衡因⼦，任何 结点的平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度，也就是说任何结点的平衡因⼦等于0/1/-1， AVL树并不是必须要平衡因⼦，但是有了平衡因⼦可以更⽅便我们去进⾏观察和控制树是否平衡， 就像⼀个⻛向标⼀样。
- 思考⼀下为什么AVL树是⾼度平衡搜索⼆叉树，要求⾼度差不超过1，⽽不是⾼度差是0呢？0不是更 好的平衡吗？画画图分析我们发现，不是不想这样设计，⽽是有些情况是做不到⾼度差是0的。⽐如⼀棵树是2个结点，4个结点等情况下，⾼度差最好就是1，⽆法做到⾼度差是0
- AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在 ，那么增删查改的效率也可 以控制在O(logN),相⽐⼆叉搜索树有了本质的提升.
注意：AVL树它的前提是二叉搜索树（左小右大）！
AVL树的实现
准备工作：
树的节点是一个类，树是一个类。
AVL树的插入
插入过程
- 插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
- 新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
- 更新平衡因⼦过程中没有出现问题，则插⼊结束。
- 更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树 的⾼度，不会再影响上⼀层，所以插⼊结束。
因为插入一个节点，可能会影响它的祖先节点平衡，所以我们需要一路去调整，可能会出现旋转来使节点平衡！
平衡因子的更新
更新原则
- 平衡因⼦=右⼦树⾼度-左⼦树⾼度。
- 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
- 插⼊结点，会增加⾼度，所以新增结点在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⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不 需要继续往上更新，插⼊结束。
- 不断更新，更新到根，跟的平衡因⼦是1或-1也停⽌了。
开始写部分代码：
旋转
旋转的原则
- 保持搜索树的规则。
- 让旋转的树从不满⾜变平衡，其次降低旋转树的⾼度。
- 旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。
右单旋
这里不过多赘述，直接看图：
实例：
我们不难理解右单旋的判断条件就是：parent平衡因子是-2，subL（cur）平衡因子是-1。
代码实现：
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
//不要忘了也要链接parent的父亲节点
Node* pParent = parent->_parent;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
//parent可能是根
if (parent==_root)
{
_root = subL;
subL->_parent = nullptr;
}
else //不是根
{
if (pParent->_left == parent)
pParent->_left = subL;
else
pParent->_right = subL;
subL->_parent = pParent;
}
subL->_bf = parent->_bf = 0;
}左单旋
同理，直接上图：
我们不难理解左单旋的判断条件就是：parent平衡因子是2，subR（cur）平衡因子是1。
代码实现：
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* pParent = parent->_parent;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
//可能parent就是根了
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else //不是根
{
if (pParent->_left == parent)
pParent->_left = subR;
else
pParent->_right = subR;
subR->_parent = pParent;
}
subR->_bf = parent->_bf = 0;
}左右双旋
左右双选有三种情况，我们直接上图理解：
多看图理解！！！
我们不难理解左右单旋的判断条件就是：parent平衡因子是-2，subL（cur）平衡因子是1。
而分成三种情况的判断条件是subLR的平衡因子（0或-1或1）！
代码实现：
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 0)
{
subLR->_bf = subL->_bf = parent->_bf = 0;
}
else if (bf == 1)
{
subLR->_bf = parent->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1)
{
subL->_bf = subLR->_bf = 0;
parent->_bf = 1;
}
else
assert(false);
}右左双旋
同理，上图理解：
我们不难理解右左单旋的判断条件就是：parent平衡因子是2，subR（cur）平衡因子是-1。
而分成三种情况的判断条件是subRL的平衡因子（0或-1或1）！
代码实现：
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 = subRL->_bf = parent->_bf = 0;
}
else if (bf == -1)
{
subRL->_bf = parent->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
subRL->_bf = subR->_bf = 0;
parent->_bf = -1;
}
else
assert(false);
}AVL树的查找
这里的查找和二叉搜索树类似，不过多赘述！
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv < key)
cur = cur->_right;
else if (cur->_kv > key)
cur = cur->_left;
else
return cur;
}
return nullptr;
}AVL树的平衡检测
我们知道平衡因子等于右子树高度减去左子树高度，我们可以检测当它们的高度差（正数）大于或者等于2，那么就不平衡，就可以检测我们代码写错了。
同时，当高度差不等于存储的那个平衡因子，我们也错了！
代码：
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 (root == nullptr)
return true;
//计算高度差
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
//平衡因子大于或等于2，则不是AVL树
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
//平衡因子不等于diff，也不是AVL树
if (diff != root->_bf)
{
cout << root->_bf << "平衡因子异常" << endl;
return false;
}
//根的左右子树都是AVL树，才是AVL树
return _IsBalanceTree(root->_left)
&& _IsBalanceTree(root->_right);
}全部代码
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);
cur->_parent = parent;
if (parent->_kv.first < kv.first)
parent->_right = cur;
else
parent->_left = cur;
//更新平衡因子
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 = cur->_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;
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv < key)
cur = cur->_right;
else if (cur->_kv > key)
cur = cur->_left;
else
return cur;
}
return nullptr;
}
void Inorder()
{
_Inorder(_root);
}
bool IsBalanceTree()
{
return _IsBalanceTree(_root);
}
private:
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 (root == nullptr)
return true;
//计算高度差
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
//平衡因子大于或等于2，则不是AVL树
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
//平衡因子不等于diff，也不是AVL树
if (diff != root->_bf)
{
cout << root->_bf << "平衡因子异常" << endl;
return false;
}
//根的左右子树都是AVL树，才是AVL树
return _IsBalanceTree(root->_left)
&& _IsBalanceTree(root->_right);
}
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
//不要忘了也要链接parent的父亲节点
Node* pParent = parent->_parent;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
//parent可能是根
if (parent==_root)
{
_root = subL;
subL->_parent = nullptr;
}
else //不是根
{
if (pParent->_left == parent)
pParent->_left = subL;
else
pParent->_right = subL;
subL->_parent = pParent;
}
subL->_bf = parent->_bf = 0;
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* pParent = parent->_parent;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
//可能parent就是根了
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else //不是根
{
if (pParent->_left == parent)
pParent->_left = subR;
else
pParent->_right = subR;
subR->_parent = pParent;
}
subR->_bf = parent->_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)
{
subLR->_bf = subL->_bf = parent->_bf = 0;
}
else if (bf == 1)
{
subLR->_bf = parent->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1)
{
subL->_bf = subLR->_bf = 0;
parent->_bf = 1;
}
else
assert(false);
}
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 = subRL->_bf = parent->_bf = 0;
}
else if (bf == -1)
{
subRL->_bf = parent->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
subRL->_bf = subR->_bf = 0;
parent->_bf = -1;
}
else
assert(false);
}
void _Inorder(Node* root)
{
if (root == nullptr)
return;
_Inorder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_Inorder(root->_right);
}
private:
Node* _root = nullptr;
};好了，我们下期见！