AVL树是一棵平衡二叉搜索树
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查
找元素相当于在顺序表中搜索元素，效率低下
一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度，平衡二叉搜索树就诞生了。
在这里，主要实现他的调节功能。
首先在每一个节点了都需要一个平衡因子bf，通过平衡因子判断是否平衡。
template<class T, class V >
struct AVLTreeNode
{
AVLTreeNode<T,V>* _parent; // 指向其父节点
AVLTreeNode<T,V>* _left;
AVLTreeNode<T,V>* _right;
T _key;
V _value;
int bf; // 平衡因子
AVLTreeNode(const T& key = T(), const V& value = V())
:_parent(nullptr)
,_left(nullptr)
,_right(nullptr)
,_key(key)
,_value(value)
,bf(0)
{}
};
bf为右子树的高度减左子树的高度，也就是说，平衡搜索二叉树要保持每一个节点里的bf都小于2，大于-2。
在之前，已经实现了通过插入就可以保持一颗搜索树。
插入代码(未调节)
template<class T, class V >
class AVLTree
{
typedef AVLTreeNode<T, V> AVLTreeNode;
public:
AVLTree()
:_node(nullptr)
{ }
bool Insert(const T& key = T(), const V& value = V())
{
if (_node == nullptr)
{
_node = new AVLTreeNode(key,value);
return true;
}
AVLTreeNode* cur = _node;
AVLTreeNode* parent = nullptr;
while (cur != nullptr)
{
if (cur->_key == key)
{
return false;
}
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
parent = cur;
cur = cur->_right;
}
}
if (key < parent->_key)
{
parent->_left = new AVLTreeNode(key, value);
parent->_left->_parent = parent;
}
else
{
parent->_right = new AVLTreeNode(key, value);
parent->_right->_parent = parent;
}
接下来就是对平衡因子的判断的对树的调节，因为当我们插入一个节点，其祖先节点可能都会发生改变。
可以看出，当插入一个节点时，其祖先节点可能受影响，其他节点不受影响。
只需要向上调节并排查祖先的平衡因子。当某个祖先的平衡因子bf==0的时候结束。
如何调节祖先的平衡因子与为什么bf==0就结束呢？
蓝色方框表示将要插入的节点
这里的bf指2的bf。
图一，bf==1，左插入后，bf==0。
图二，bf==-1，右插入后，bf=0。
图三，bf==0，右插入后，bf=1。
图四，bf==0，左插入后，bf=-1。
可以发现，左插入，bf--，右插入，bf++
当插入后bf==0，其所有祖先的高度并没有被影响。
当插入后bf==1/-1，就要去向上判断祖先是否被影响，图三，图四(2的父节点)的bf均改变，变为了1，图五2的父节点的bf变为2，需要调节了。
写一下向上的代码
while (parent)
{
if (parent->_key > key) // 通过key判断改变的是parent的左边还是右边
{
parent->bf--;
}
else
{
parent->bf++;
}
if (parent->bf == 0) // 原来是1或-1，说明并没有改变高度
{
break;
}
else if (parent->bf == 1 || parent->bf == -1) // 原来是为0 ，其所有的祖先都可能被影响了
{ // 往上走，判断其祖先
cur = parent;
parent = parent->_parent;
}
// 开始旋转
else if((parent->bf == 2 || parent->bf == -2))
}
看看是如何旋转的
将bf==2/-2的节点定义为parent，上调之前的parent定义为cur(cur->_parent==parent)
左旋转:将cur->left给parent->right(原来cur是parent->right)，parent变为cur->left。
右旋转：将cur->right给parent->left(原来cur是parent->left)，parent变为cur->right。
注意，这里也很复杂，需要考虑他们的_parent节点的连接和parent是否是头节点。
接下来具体讲一讲他们的分类
bf==1/-1继续往上走，看父节点的bf变化。
旋转一经过左旋转后就可以break了
旋转二就要复杂一点，看看旋转二的分析
可以看到在parent->bf==2，cur->bf==-1，需要双旋的，需要将左右旋结合。
左单旋
//左单旋
void RotateL(AVLTreeNode* parent)
{
if (parent == nullptr || parent->_right == nullptr)
return;
AVLTreeNode* subr = parent->_right;
AVLTreeNode* subrL = subr->_left; //记录，保证对cur->bf的正确修改
parent->_right = subr->_left;
if (subr->_left)
{
subr->_left->_parent = parent;
}
subr->_left = parent;
AVLTreeNode* ppnode = parent->_parent;
parent->_parent = subr;
//对subr进行处理
if (ppnode == nullptr) // parent是头节点
{
subr->_parent = nullptr;
_node = subr;
}
else
{
subr->_parent = ppnode;
if (ppnode->_left == parent)
{
ppnode->_left = subr;
}
else
{
ppnode->_right = subr;
}
}
// 进行bf的修改
if (parent->bf == 2)
{
if (subr->bf == 1)
{
parent->bf = subr->bf = 0;
}
if (subr->bf == -1)
{
if (subrL->bf == 0)
{
parent->bf = subrL->bf = subr->bf = 0;
}
if (subr->bf == -1)
{
parent->bf = subrL->bf = 0;
subr->bf = 1;
}
}
}
}
右单旋
void RotateR(AVLTreeNode* parent)
{
if (parent == nullptr)
{
return;
}
AVLTreeNode* subl = parent->_left;
AVLTreeNode* sublR = subl->_right;
parent->_left = subl->_right;
if (subl->_right) // 为空就不用去管他的_parent
{
subl->_right->_parent = parent;
}
subl->_right = parent;
AVLTreeNode* ppnode = parent->_parent;
parent->_parent = subl;
if (ppnode == nullptr)
{
subl->_parent = nullptr;
}
else
{
subl->_parent = ppnode;
if (ppnode->_left == parent)
{
ppnode->_left = subl;
}
else
{
ppnode->_right = subl;
}
}
if (parent->bf == -2)
{
if (subl->bf == -1)
{
subl->bf = parent->bf = 0;
}
if (subl->bf == 1)
{
if (sublR->bf == 0)
{
parent->bf = sublR->bf = subl->bf = 0;
}
if (sublR->bf == 1)
{
parent->bf = sublR->bf = 0;
subl->bf = -1;
}
}
}
}
旋转代码
// 开始旋转
else if((parent->bf == 2 || parent->bf == -2))
{
if (parent->bf == 2)
{
if (cur->bf == 1)
{
RotateL(parent);
}
if (cur->bf == -1)
{
RotateR(cur); // 不会给平衡因子，因为cur->parent!=-2
RotateL(parent);
}
}
if (parent->bf == -2)
{
if (cur->bf == -1)
{
RotateR(parent);
}
if (cur->bf == 1)
{
RotateL(cur); // 不会给平衡因子，因为cur->parent!=-2
RotateR(parent);
}
}
break; // 旋转了就保证了当前的树是平衡树，其祖先不需要判断了
}
对代码进行测试
void _InOrder(AVLTreeNode* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " " << root->_value << endl;
_InOrder(root->_right);
}
void InOrder()
{
_InOrder(_node);
}
bool _IsbalanceTree(AVLTreeNode* root, int& high)
{
if (root == nullptr)
{
high = 0;
return true;
}
int left_high = 0;
if (_IsbalanceTree(root->_left, left_high) == false)
{
return false;
}
int right_high = 0;
if (_IsbalanceTree(root->_right, right_high) == false)
{
return false;
}
if (left_high - right_high > 1 || left_high - right_high < -1)
{
return false;
}
high = 1 + (left_high > right_high ? left_high : right_high);
return true; // 满足左子树为平衡二叉树 右子树为平衡二叉树 该树为平衡二叉树
}
//判断平衡
bool IsbalanceTree()
{
int k = 0;
return _IsbalanceTree(_node, k);
}
void test4()
{
AVLTree<string, int> avl;
avl.Insert("a", 1);
avl.Insert("b", 2);
avl.Insert("c", 3);
avl.Insert("d", 4);
avl.Insert("e", 5);
avl.Insert("f", 6);
avl.Insert("g", 7);
avl.Insert("h", 8);
avl.Insert("i", 9);
avl.Insert("j", 10);
//判断是否是平衡二叉搜索树
// 搜索树
avl.InOrder();
// 平衡树
if (avl.IsbalanceTree())
{
cout << "是平衡树" << endl;
}
}
结果：
a 1
b 2
c 3
d 4
e 5
f 6
g 7
h 8
i 9
j 10
是平衡树其实在耦合这块的话并不是很好，将左右旋和右左旋单独实现并修改平衡因子能够实现高内聚，低耦合。
希望能够彻底帮助你理解AVL树的旋转，而不是仅依靠一张结论图搬公式！！！
扫一扫
703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
