一、定义
AVL树本质上还是一棵二叉搜索树，它的特点是：
1.本身首先是一棵二叉搜索树。
2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。
搜索二叉树可能出现单边树的情况，导致搜索效率低下。AVL树的作用就是调整搜索二叉树使其最接近完全二叉树的形状，使得效率最高
二、AVL树的结构
采用<K,V>模型，每个节点都同时保存关键字和关键字值。这里采用三叉链的结构，对于除根节点外的每一个节点都链接一个父节点和左右子节点
template<class K,class V>
class AVLTreeNode
{
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),_kv(kv),_bf(0)
{}
};也可以不采用三叉链的结构。如果使用二叉链，也就是只链接左右子节点，不包含父节点。在后续的插入删除以及平衡因子的调节中会更加繁琐
三、平衡因子的调节
平衡因子是每个节点右子树与左子树的高度差，即平衡因子bf=右树高度-左树高度
为了方便对每个节点平衡因子的记录，如果再右子树上插入节点，则将平衡因子bf++；如果在左子树上插入节点，则将平衡因子bf--
由于当前节点的平衡因子在操作后进行了改变，其祖宗节点的平衡因子也都需要进行改变
节点的平衡因子总共有三种可能：
①插入后父节点平衡因子为0
说明插入前父节点平衡因子为1或-1，插入后该子树平衡。满足AVL树要求，平衡因子调整结束
②插入后父节点平衡因子为1或-1
说明插入前父节点平衡因子为0，插入后该子树高度改变。父节点的祖宗节点平衡因子也需要改变，所以更新父节点位置，向上调整平衡因子
③插入后父节点平衡因子为2或-2
说明插入前父节点平衡因子为1或-1，插入节点后，父节点平衡因子不满足AVL树要求，因此需要旋转调整节点位置（调整树形）使得该树满足AVL树的要求
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->_left = cur;
}
else
{
parent->_right = cur;
}
cur-> _parent = parent;
//更新平衡因子
while (parent)
{
if (cur == parent->_right)
{
parent->_bf++;
}
else
{
parent->_bf--;
}
//更新祖宗节点
if (parent->_bf == 1 || parent->_bf == -1)//子树高度改变，向上调节
//如果当前父节点平衡因子为1或-1，则调节前平衡因子一定为0
{
parent = parent->_parent;
cur = cur-> _parent;
}
else if (parent->_bf == 0)//子树平衡，更新结束
//如果当前父节点平衡因子为0，则调节前平衡因子一定为1或-1
{
break;
}
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;
}四、旋转
如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构， 使之平衡化
树的结构大致有以下四种，其中C节点为插入节点
1.右单旋
左左插入为右单旋
右单旋的目的是为了是不平衡的左分支向右调整，使得二叉树整体符合AVL树特征
如图，在根节点左孩子的左子树上插入新节点，左子树的高度变为h+1，其父节点30的平衡因子变为-1，右子树高度不变，根节点平衡因子变为-2。因此需要旋转调整，采用右单旋
将中间节点30上提，使得a与60分别为其左右子树。由于二叉树的性质，可知b子树中左右的关键字值一定小于60，因此将其调整至60节点的左子树处。旋转完成后需要调整各个节点的平衡因子值
注意：①需要考虑右子树b是否存在②需要考虑60是否是根节点。如果是根节点，则需要更新根节点；如果是子树，则需要考虑是左子树还是右子树，并与60的父节点链接
void RotateR(Node* parent)//右单转
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)//如果有右子树则调整位置
{
subLR->_parent = parent;
}
Node* ppnode = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
if (ppnode->_left == parent)
{
ppnode->_left = subL;
}
else
{
ppnode->_right = subL;
}
subL->_parent = ppnode;
}
subL->_bf = parent->_bf = 0;
}2.左单旋
左单旋与右单旋类似
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 (ppnode == nullptr)
{
_root = subR;
_root->_parent = nullptr;
}
else
{
if (parent == ppnode->_left)
{
ppnode-> _left = subR;
}
else
{
ppnode->_right = subR;
}
subR->_parent = ppnode;
}
parent->_bf = subR->_bf = 0;//更新平衡因子
}3.双旋--先左旋后右旋
先通过左旋，使其满足左左插入的形式，再通过右旋调整形状。旋转后更新平衡因子
插入有三种可能：①60为插入节点②在b子树插入③在c子树插入。三种情况插入的平衡因子调节不同
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;
subLR->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1)
{
parent->_bf = 1;
subLR->_bf = 0;
subL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subLR->_bf = 0;
subL->_bf = 0;
}
else
{
assert(false);
}
}4.双旋--先右旋后左旋
与先左旋后右旋类似
插入有三种可能：①60为插入节点②在b子树插入③在c子树插入。三种情况插入的平衡因子调节不同
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
//平衡因子的更新有多种情况
if (bf == 1)
{
parent->_bf = -1;
subRL->_bf = 0;
subR->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 0)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 0;
}
else
{
assert(false);
}
}五、完整实现
#pragma once
#include<assert.h>
#include<iostream>
using namespace std;
template<class K,class V>
struct AVLTreeNode
{
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)
,_kv(kv)
,_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->_left = cur;
}
else
{
parent->_right = cur;
}
cur-> _parent = parent;
//更新平衡因子
while (parent)
{
if (cur == parent->_right)
{
parent->_bf++;
}
else
{
parent->_bf--;
}
//更新祖宗节点
if (parent->_bf == 1 || parent->_bf == -1)//子树高度改变，向上调节
//如果当前父节点平衡因子为1或-1，则调节前平衡因子一定为0
{
parent = parent->_parent;
cur = cur-> _parent;
}
else if (parent->_bf == 0)//子树平衡，更新结束
//如果当前父节点平衡因子为0，则调节前平衡因子一定为1或-1
{
break;
}
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 InOrder()
{
_InOrder(_root);
}
bool IsBalance()
{
return _IsBalance(_root);
}
int Height()
{
return _Height(_root);
}
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 (ppnode == nullptr)
{
_root = subR;
_root->_parent = nullptr;
}
else
{
if (parent == ppnode->_left)
{
ppnode-> _left = subR;
}
else
{
ppnode->_right = subR;
}
subR->_parent = ppnode;
}
parent->_bf = subR->_bf = 0;//更新平衡因子
}
void RotateR(Node* parent)//右单转
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)//如果有右子树则调整位置
{
subLR->_parent = parent;
}
Node* ppnode = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
if (ppnode->_left == parent)
{
ppnode->_left = subL;
}
else
{
ppnode->_right = subL;
}
subL->_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);
//平衡因子的更新有多种情况
if (bf == 1)
{
parent->_bf = 0;
subLR->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1)
{
parent->_bf = 1;
subLR->_bf = 0;
subL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subLR->_bf = 0;
subL->_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);
//平衡因子的更新有多种情况
if (bf == 1)
{
parent->_bf = -1;
subRL->_bf = 0;
subR->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 0)
{
parent->_bf = 0;
subRL->_bf = 0;
subR->_bf = 0;
}
else
{
assert(false);
}
}
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
bool _IsBalance(Node* root)
{
if (root == NULL)
{
return true;
}
int leftH = _Height(root->_left);
int rightH = _Height(root->_right);
if (rightH - leftH != root->_bf)
{
cout <<root->_kv.first<< "节点平衡因子异常" << endl;
return false;
}
return abs(leftH - rightH) < 2 && _IsBalance(root->_left) && _IsBalance(root->_right);
}
int _Height(Node* root)
{
if (root == NULL)
return 0;
int leftH = _Height(root->_left);
int rightH = _Height(root->_right);
return leftH > rightH ? leftH + 1 : rightH + 1;
}
private:
Node* _root = nullptr;
};
345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
