概念
产生原因:搜索二叉树在有序的数组进行插入时,会导致搜索二叉数的查找效率为o(n),为了避免这种情况引入了二叉搜索树
AVL树又叫高度平衡搜索二叉数,它保证了每个节点的左右子树高度差的绝对值不超过1
AVL树要求:1,他的左右子树都是AVL树 2,左右子树高度之差(简称平衡因子)即左子树高度减去右子树高度的绝对值不超过1
AVL树不一定需要平衡因子,使用平衡因子是一种实现控制方式
结构体
template<class K,class V>
struct AVLTreeNode//在C++中,结构体(struct)的默认访问权限是公有的
//,而类(class)的默认访问权限是私有的。
{
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
pair<K, V> _kv;
int _bf;
AVLTreeNode(const pair<K, V>& kv)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_bf(0)
,_kv(kv)
{
}
};
这里一定要用struct来定义结构体而不是用class,struct默认访问权限是公有的,class默认访问权限是私有的。如果用class会导致下面插入操作时_kv和_bf等变量不能够使用
插入节点及平衡因子的调节
插入操作即先找到再插入,最后进行平衡因子的调节
插入节点
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(kv);
cur->_bf = 0;
if (kv.first > parent->_kv.first)
{
parent->_right = cur;
cur->_parent = parent;
}
else
{
parent->_left = cur;
cur->_parent = parent;
}
AVL树插入和搜索二叉数的插入思路是一样的,但是多了一个三叉链用来链接父节点
插入关键就在于平衡因子的调节
平衡因子调节
平衡因子有五种情况
1,平衡因子是1/-1 2,平衡因子是0 3,平衡因子是2/-2
新增节点在当前节点的左边或者右边,平衡因子就减1或者加1
当平衡因子是0时就表示当前树已经平衡
当父节点的平衡因子是2或者-2时就表示当前树有一边已经失衡了,需要调节
while(parent)//平衡因子的调节
{
if (cur == parent->_left)
{
parent->_bf--;
}
if (cur == parent->_right)
{
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)
{
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == -1)
{
RotateR(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;
}
右旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
{
subLR->_parent = parent;
}
Node* parentparent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root=subL;
_root->_parent = nullptr;
}
else
{
if (parentparent->_left == parent)
{
parentparent->_left = subL;
}
else
{
parentparent->_right = subL;
}
subL->_parent = parentparent;
}
subL->_bf = parent->_bf = 0;
}
左旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
{
subRL->_parent = parent;
}
Node* parentparent = parent->_parent;//这个parent一定要放在中间,后面parent位置会变
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
_root->_parent = nullptr;
}
else
{
if (parentparent->_left == parent)
{
parentparent->_left = subR;
}
else
{
parentparent->_right = subR;
}
subR->_parent = parentparent;
}
subR->_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);
if (bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 1;
subL->_bf = 0;
subLR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subL->_bf = 0;
subLR->_bf = 0;
}
else
{
assert(false);
}
}
左右双旋有三种情况
右左双旋
右左双旋同理
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
RotateR(parent->_right);
RotateL(parent);
int bf = subRL->_bf;
if (bf == -1)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
parent->_bf = -1;
subRL->_bf = 0;
subR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 0;
}
else
{
assert(false);
}
}
AVL树的检验
要满足AVL树就要左右子树都满足AVL树,即左右子树高度差的绝对值要小于2
bool IsBalance()
{
return _IsBalance(_root);
}
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
int lefthigh = high(root->_left);
int righthigh = high(root->_right);
if (righthigh - lefthigh != root->_bf)
{
cout << root->_kv.first << "现在是" << root->_bf << endl;
cout << root->_kv.first << "因该是是" << righthigh-lefthigh << endl;
return false;
}
return (abs(lefthigh - righthigh) < 2)
&& _IsBalance(root->_left) && _IsBalance(root->_right);
}
int high(Node* root)
{
if (root == nullptr)
{
return 0;
}
int left = high(root->_left);
int right = high(root->_right);
return left > right ? left + 1 : right + 1;
}