1.什么是AVL树
AVL树就是在搜索二叉树的基础上通过控制左右子树的高度差实现的，在搜索二叉树的基础上，通过旋转来控制，是左右子树高度差的绝对值严格控制为不超过1（通过旋转来控制树的高度）。由于搜索二叉树的效率最差为O(N-1)次，(n为节点个数），所以为了减少查找时间而创造了AVL树，
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
2.AVL树的定义
一颗AVL树或者是空树，是具有以下性质的树：
1.他的左右子树都是AVL树
2.左右高度差的绝对值不超过1(即1，0，-1）
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在
O(log_2 n)，搜索时间复杂度O(log_2 n)。AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么，AVL树的插入过程可以分为两步：
1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子
标准AVL树
3. AVL树的实现
AVL树最重要的就是旋转，需要控制左右子树高度差的绝对值不超过1，因此，平衡因子可能存在三种情况，即0，正负1，正负2，
1. 如果平衡因子为0，说明插入之前pParent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功
2. 如果平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负1，此时以pParent为根的树的高度增加，需要继续向上更新。
3. 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理。
如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，
使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：
1.新节点插入较高左子树的左侧---左左：右单旋
2.新插入节点较高右子树的右侧：左旋转
3.新节点插入较高左子树的右侧---左右：先左单旋再右单旋
4.. 新节点插入较高右子树的左侧---右左：先右单旋再左单旋
4.代码实现
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
namespace _3s
{
template<class K, class V>
struct AVLTreeNode
{
AVLTreeNode* _left;
AVLTreeNode* _right;
AVLTreeNode* _parent;
std::pair<K, V> _KV;
int bf;
AVLTreeNode(const std::pair<K, V> kv)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _KV(kv)
, bf(0)
{}
};
//节点
template<class K, class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
//插入
bool insert(const std::pair<K, V>& kv)
{
if (root == nullptr)
{
root = new Node(kv);
return true;
}
Node* parent = nullptr;
Node* cur = root;
while (cur)
{
if (cur->_left.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_left.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(kv);
if (parent->_kv.first > kv.first)
{
parent->left = cur;
parent->bf--;
}
else
{
parent->right = cur;
parent->bf++;
}
cur->_parent = parent;
while (parent)
{
if (abs(parent->bf) == 1)
{
parent = parent->_parent;
cur = cur->_parent;
}
else if (abs(parent->bf) == 2)
{
if (parent->_bf == 2 && cur->_bf == 1)
{
RotateL(parent);
}
else if ((parent->_bf == -2 && cur->_bf == -1))
{
RotateR(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
}
break;
}
else
{
assert(false);
}
}
return true;
}
private:
//左旋转
void RotateL(Node* 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 (root == parent)
{
root = subR;
subR->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else
{
ppNode->_right = subR;
}
subR->_parent = ppNode;
}
subR->_bf = parent->_bf = 0;
}
//右旋转
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subR->_right;
parent->_left = subRL;
if (subRL)
subRL->_parent = parent;
Node* ppNode = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (root == parent)
{
root = subL;
subL->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subR->_parent = ppNode;
}
subL->_bf = parent->_bf = 0;
}
//左右旋转
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int _bf = subLR->bf;
RotateL(parent->_left);
RotateR(parent);
subLR->bf = 0;
if (_bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
}
else if (_bf == -1)
{
parent->bf = 1;
subL->bf = 0;
}
else if (_bf == 0)
{
parent->bf = 0;
subL->bf = 0;
}
else
{
assert(false);
}
}
//右左旋转
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subL->_left;
int _bf = subLR->bf;
RotateR(parent->_right);
RotateL(parent);
subRL->_bf = 0;
if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
parent->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
}
else
{
assert(false);
}
}
private:
Node* root = nullptr;
};
}