概述
平衡二叉搜索树又被称为AVL树，且具有以下性质：
在AVL树中任何节点的两个子树的高度最大差别不超过1，所以它也被称为高度平衡树，并且它的左右两个子树都是一棵平衡二叉树。AVL树的增加和删除可能需要通过一次或多次旋转来重新平衡这个树。
性能：
AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log2(N) 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但如果一个结构经常修改，就不太适合使用AVL树。
平衡因子
一个结点的右子树高度减去左子树高度所得的值，就是该节点的平衡因子，范围：[-1,1]
例如：下图中，红字标注的就是这些结点的平衡因子
实现
结点的定义：
template <class T>
struct AVLNode {
AVLNode<T>* parent_;
AVLNode<T>* left_;
AVLNode<T>* right_;
T val_;
int bf_; //平衡因子
AVLNode(const T&val=T())
:parent_(nullptr)
,left_(nullptr)
,right_(nullptr)
,val_(val)
,bf_(0)
{}
private:
AVLNode* root_ = nullptr;
};
树的定义：
template <class T>
struct AVLtree
{
public:
typedef AVLNode<T> Node;
//插入
bool insert(const T&val);
private:
Node* root_=nullptr;
};
插入操作详解：
步骤：
1、插入：从根结点开始搜索，将结点插入到正确的位置
这里的搜索和普通二叉搜索树的搜索操作相同
//二叉搜索树的插入
if (root_ == nullptr)
{
root_ = new Node(val);
return true;
}
Node* cur = root_;
Node* parent = nullptr;
while (cur)
{
parent = cur;
if (cur->val_ == val)
return false;
else if (cur->val_ > val)
cur = cur->left_;
else
cur = cur->right_;
}
cur = new Node(val);
if (parent->val_ > val)
parent->left_ = cur;
else
parent->right_ = cur;
cur->parent_ = parent;
2、调整：插入一个结点后，这个结点所在路径的平衡因子可能会发生变化，所以需要向上调整，保证结构的正确性。
平衡结构遭到破坏后应该如何调整呢？
右旋
新结点插入到较高的左子树的左侧，就需要进行右旋来调整树的结构
//右旋
void RotateR(Node* cur)
{
Node* curL = cur->left_;
Node* curLR = curL->right_;
curL->right_ = cur;
cur->left_ = curLR;
if (curLR)
{
curLR->parent_ = cur;
}
if (cur == root_)
{
root_ = curL;
curL->parent_ = nullptr;
}
else
{
Node* pparent = cur->parent_;
if (pparent->left_ == cur)
pparent->left_ = curL;
else
pparent->right_ = curL;
curL->parent_ = pparent;
}
cur->parent_ = curL;
curL->bf_ = cur->bf_ = 0;
}
左旋
新结点插入到较高的右子树的右侧，左旋调整。
//左旋
void RotateL(Node* cur)
{
Node* curR = cur->right_;
Node* curRL = curR->left_;
curR->left_ = cur;
cur->right_ = curRL;
if (curRL)
{
curRL->parent_ = cur;
}
if (cur == root_)
{
root_ = curR;
curR->parent_ = nullptr;
}
else
{
Node* pparent = cur->parent_;
if (pparent->left_ == cur)
pparent->left_ = curR;
else
pparent->right_ = curR;
curR->parent_ = pparent;
}
cur->parent_ = curR;
cur->bf_ = curR->bf_ = 0;
}
左旋+右旋
新节点插入较高左子树的右侧—先左旋再右旋
代码操作：分别对两个结点调用上面的左旋和右旋接口即可，旋转后要修正平衡因子
右旋+左旋
新节点插入较高右子树的左侧—先右旋再左旋
代码操作：分别对两个结点调用上面的右旋和左旋接口即可，旋转后要修正平衡因子
双旋后的平衡因子调整
通过观察上面双旋的示意图不难发现，在较高的子树插入新结点后，这个子树的根会成为新的根结点（60），它的左子树连在了它新的左节点的右侧（30的右侧），它的右子树连载了它新的右节点的左侧（90的左侧），所以这里我们只要知道插入的结点在60的那一侧，就能更新平衡因子。
左-右双旋：
//保存subRL的平衡因子
Node* subLR = cur->right_;
int bf = subLR->bf_;
//左-右双旋
RotateL(cur);
RotateR(parent);
//调整平衡因子
if (1 == bf)
{
cur->bf_ = -1;
parent->bf_ = 0;
}
else if (-1 == bf)
{
cur->bf_ = 0;
parent->bf_ = 1;
}
右-左双旋：
//保存subRL的平衡因子
Node* subRL = cur->left_;
int bf = subRL->bf_;
//右-左双旋
RotateR(cur);
RotateL(parent);
//调整平衡因子
if (1 == bf)
{
cur->bf_ = 0;
parent->bf_ = -1;
}
else if (-1 == bf)
{
cur->bf_ = 1;
parent->bf_ = 0;
}
树的平衡性检测
用于检测AVL树是否达成高度平衡结构：
思路：
1、检测所有节点的平衡因子绝对值是否小于2；
2、检测所有结点的平衡因子是否等于其右子树高度减去左子树高度所得的值；
3、空树是平衡的结构。
bool _isBalance(Node* root)
{
if (root == nullptr)
return true;
//查看平衡因子是否等于右子树高度减去左子树高度
int left = getHight(root->left_);
int right = getHight(root->right_);
if (right - left != root->bf_)
{
cout << "Node: " << root->val_ << " bf_: "
<< root->bf_ << " hight gap: " << right - left << endl;
return false;
}
return abs(root->bf_) < 2
&& _isBalance(root->left_)
&& _isBalance(root->right_);
}
void isBalance()
{
_isBalance(root_);
}
完整代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<time.h>
using namespace std;
template <class T>
struct AVLNode {
AVLNode<T>* parent_;
AVLNode<T>* left_;
AVLNode<T>* right_;
T val_;
int bf_; //平衡因子
AVLNode(const T&val=T())
:parent_(nullptr)
,left_(nullptr)
,right_(nullptr)
,val_(val)
,bf_(0)
{}
private:
AVLNode* root_ = nullptr;
};
template <class T>
struct AVLtree
{
public:
typedef AVLNode<T> Node;
bool insert(const T&val)
{
//二叉搜索树的插入
if (root_ == nullptr)
{
root_ = new Node(val);
return true;
}
Node* cur = root_;
Node* parent = nullptr;
while (cur)
{
parent = cur;
if (cur->val_ == val)
return false;
else if (cur->val_ > val)
cur = cur->left_;
else
cur = cur->right_;
}
cur = new Node(val);
if (parent->val_ > val)
parent->left_ = cur;
else
parent->right_ = cur;
cur->parent_ = parent;
//调整
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 = parent->parent_;
}
else if (abs(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)
{
//保存subRL的平衡因子
Node* subLR = cur->right_;
int bf = subLR->bf_;
//左-右双旋
RotateL(cur);
RotateR(parent);
//调整平衡因子
if (1 == bf)
{
cur->bf_ = -1;
parent->bf_ = 0;
}
else if (-1 == bf)
{
cur->bf_ = 0;
parent->bf_ = 1;
}
}
else if (parent->bf_ == 2 && cur->bf_ == -1)
{
//保存subRL的平衡因子
Node* subRL = cur->left_;
int bf = subRL->bf_;
//右-左双旋
RotateR(cur);
RotateL(parent);
//调整平衡因子
if (1 == bf)
{
cur->bf_ = 0;
parent->bf_ = -1;
}
else if (-1 == bf)
{
cur->bf_ = 1;
parent->bf_ = 0;
}
}
break;
}
}
return true;
}
//右旋
void RotateR(Node* cur)
{
Node* curL = cur->left_;
Node* curLR = curL->right_;
curL->right_ = cur;
cur->left_ = curLR;
if (curLR)
{
curLR->parent_ = cur;
}
if (cur == root_)
{
root_ = curL;
curL->parent_ = nullptr;
}
else
{
Node* pparent = cur->parent_;
if (pparent->left_ == cur)
pparent->left_ = curL;
else
pparent->right_ = curL;
curL->parent_ = pparent;
}
cur->parent_ = curL;
curL->bf_ = cur->bf_ = 0;
}
//左旋
void RotateL(Node* cur)
{
Node* curR = cur->right_;
Node* curRL = curR->left_;
curR->left_ = cur;
cur->right_ = curRL;
if (curRL)
{
curRL->parent_ = cur;
}
if (cur == root_)
{
root_ = curR;
curR->parent_ = nullptr;
}
else
{
Node* pparent = cur->parent_;
if (pparent->left_ == cur)
pparent->left_ = curR;
else
pparent->right_ = curR;
curR->parent_ = pparent;
}
cur->parent_ = curR;
cur->bf_ = curR->bf_ = 0;
}
void inorder()
{
_inorder(root_);
cout << endl;
}
void _inorder(Node* root)
{
if (root)
{
_inorder(root->left_);
cout << root->val_ << " ";
_inorder(root->right_);
}
}
int getHight(Node* root)
{
if (root == nullptr)
return 0;
int left = getHight(root->left_);
int right = getHight(root->right_);
return left > right ? left + 1 : right + 1;
}
bool _isBalance(Node* root)
{
if (root == nullptr)
return true;
//查看平衡因子是否和左右子树的高度差一致
int left = getHight(root->left_);
int right = getHight(root->right_);
if (right - left != root->bf_)
{
cout << "Node: " << root->val_ << " bf_: "
<< root->bf_ << " hight gap: " << right - left << endl;
return false;
}
return abs(root->bf_) < 2
&& _isBalance(root->left_)
&& _isBalance(root->right_);
}
void isBalance()
{
_isBalance(root_);
}
private:
Node* root_=nullptr;
};
void test()
{
srand(time(nullptr));
cout << "num: " << endl;
AVLtree<int> avl;
int num ;
cin >> num;
for (int i = 0; i < num; i++)
{
avl.insert(rand());
}
avl.inorder();
avl.isBalance();
}
int main()
{
test();
return 0;
}
运行结果：
插入100个数据后，检测是否平衡
2140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
