AVL树:
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。
因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度。
一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
如果一棵二叉搜索树是高度平衡的,它就是AVL树。如果它有n个结点,搜索时间复杂度O(log2 N )。
AVL树节点的定义:
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
template<class T>
struct AVLTreeNode {
AVLTreeNode(const T& data)
:_pLeft(nullptr),
_pRight(nullptr),
_pParent(nullptr),
_data(data),
_bf(0)
{}
AVLTreeNode<T>* _pLeft; // 该节点的左孩子
AVLTreeNode<T>* _pRight; // 该节点的右孩子
AVLTreeNode<T>* _pParent; // 该节点的双亲
T _data;
int _bf; // 该节点的平衡因子
};
AVL树的插入:
AVL树就是在二叉搜索树的基础上引入了平衡因子,因此AVL树也可以看成是二叉搜索树。
那么AVL树的插入 过程可以分为两步:
- 按照二叉搜索树的方式插入新节点
- 调整节点的平衡因子
如果在一棵原本是平衡的AVL树中插入一个新节点,可能造成不平衡,此时必须调整树的结构,使之平衡化。
根据节点插入位置的不同,AVL树的旋转分为四种:
- 新节点插入较高左子树的左侧---左左:右单旋
- 新节点插入较高右子树的右侧---右右:左单旋
- 新节点插入较高左子树的右侧---左右:先左单旋再右单旋
- 新节点插入较高右子树的左侧---右左:先右单旋再左单旋
左单旋示例图:
左单旋代码示例:
//左单旋的代码
void RotateLeft(Node* parent) {
Node* pSubR = pParent->right;
Node* pSubRL = pSubR->left;
pParent->right = pSubRL;
if(pSubRL) { //单支情况就不用更新
pSubRL->parent = pParent;
}
pSubR->left = pParent;
//30的上面可能有双亲,就是要更新50的双亲
Node* pPParent = pParent->parent;
pParent->parent = pSubR;
pSubR->parent = pPParent;
//让parent原来的双亲指向pSubR
if(pPParent == nullptr) {
_pRoot = pSubR;
}
else if(pPParent->left == parent) {
pPParent->left = pSubR;
}
else {
pPParent->right = pSubR;
}
}
右左双旋的小演示:
AVL树其他完整代码:
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
template<class T>
struct AVLTreeNode {
AVLTreeNode(const T& data)
:_pLeft(nullptr),
_pRight(nullptr),
_pParent(nullptr),
_data(data),
_bf(0)
{}
AVLTreeNode<T>* _pLeft; // 该节点的左孩子
AVLTreeNode<T>* _pRight; // 该节点的右孩子
AVLTreeNode<T>* _pParent; // 该节点的双亲
T _data;
int _bf; // 该节点的平衡因子
};
template<class T>
class AVLTree {
typedef AVLTreeNode<T> Node;
public:
AVLTree()
:_pRoot(nullptr);
{}
bool Insert(const T& data) {
//空树
if(_pRoot ==nullptr) {
_pRoot =new Node(data);
return true;
}
//非空树
//1.找到插入位置
Node* pCur=_pRoot;
Node* pParent = nullptr;
while(pCur) {
pParent = pCur;
else if(data < pCur->_data)
pCur=pCur->_pLeft;
else
pCur=pCur->_pRight;
else
return false;
}
//2.插入数据
pCur = new Node(data);
if(data < pParent->_data) {
pParent->_pLeft = pCur;
}
else
pParent->_pRight = pCur;
pCur->_pParent = pParent;
//可能会不满足平衡因子
while(pParent) {
//必须检测平衡因子
//新节点肯定插入在双亲的左侧或者右侧,parent的平衡因子 - 1 就好了。
//右子树高度 - 左子树高度
//所有叶子节点高度0
if(pCur == pParent->_pLeft)
pParent->_bf--; //左侧减1
else
pParent->_bf++; //右侧加1
if(pParent->_bf == 0) {
return true; //高度没变
}
else (pParent->_bf == -1 || pParent->_bf == 1) {
pCur = pParent;
pParent = pCur->_pParent;
}
else {
//双亲平衡因子不满足了
if(pPParent->_bf == 2) {
//右子树高
if(pCur->_bf == 1) {
RotateLeft(pParent); //左单旋
}
else {
//异号——右左双旋
_RorateRL(pParent);
}
}
else {
//左子树高
if(pCur->_bf == -1) {
RotateRight(pParent); //右单旋
}
else {
//异号——左右双旋
_RorateLR(pParent);
}
}
}
break;
}
return true;
}
void Inorder() {
_Inorder(_pRoot);
}
//检测平衡因子
bool IsValiAVLTree() {
return _IsValiAVLTree(_pRoot);
}
protected:
bool _IsValiAVLTree(Node* pRoot) {
if(pRoot == nullptr) {
return ture;
}
int left = _Height(pRoot->_pLeft);
int right = _Height(pRoot->_pRight);
if(pRoot->_bf >= -1 && pRoot->_bf <= 1 && pRoot->_bf ==right - left) {
return ture;
}
else {
return false;
}
}
//求高度
int _Height((Node* pRoot) {
if(pRoot == nullptr) {
return 0;
}
int left =_Height(pRoot->_pLeft);
int right = _Height(pRoot->_pRight);
return left>right?left + 1 : right + 1;
}
//左单旋的代码
void RotateLeft(Node* parent) {
Node* pSubR = pParent->right;
Node* pSubRL = pSubR->left;
pParent->right = pSubRL;
if(pSubRL) { //单支情况就不用更新
pSubRL->parent = pParent;
}
pSubR->left = pParent;
//30的上面可能有双亲,就是要更新50的双亲
Node* pPParent = pParent->parent;
pParent->parent = pSubR;
pSubR->parent = pPParent;
//让parent原来的双亲指向pSubR
if(pPParent == nullptr) {
_pRoot = pSubR;
}
else if(pPParent->left == parent) {
pPParent->left = pSubR;
}
else {
pPParent->right = pSubR;
}
}
void _RorateRL(Node* pParent) { //右左双旋
RotateRight(pParent->_pRight);
RotateLeft(pParent);
}
void _RorateLR(Node* pParent) { //做头双旋
RotateLeft(pParent->_pRight);
RotateRight(pParent);
}
void _Inorder(Node* pRoot) {
if(pRoot) {
_InOrder(pRoot->_pLeft);
cout<< pRoot->_data <<" ";
_InOrder(pRoot->_pRight);
}
}
private:
Node* _pRoot;
}
旋转总结:
假如以pParent为根的子树不平衡,即pParent的平衡因子为2或者-2,分以下情况考虑
1. pParent的平衡因子为2,说明pParent的右子树高,设pParent的右子树的根为pSubR
- 当pSubR的平衡因子为1时,执行左单旋
- 当pSubR的平衡因子为-1时,执行右左双旋
2. pParent的平衡因子为-2,说明pParent的左子树高,设pParent的左子树的根为pSubL
- 当pSubL的平衡因子为-1是,执行右单旋
- 当pSubL的平衡因子为1时,执行左右双旋
旋转完成后,原pParent为根的子树个高度降低,已经平衡,不需要再向上更新。
AVL树的验证:
AVL树是在二叉搜索树的基础上加入了平衡性的限制,因此要验证AVL树,可以分两步:
1. 验证其为二叉搜索树
- 如果中序遍历可得到一个有序的序列,就说明为二叉搜索树
2. 验证其为平衡树
- 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
- 节点的平衡因子是否计算正确
AVL树的性能:
AVL树是一棵绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1,这样可以保证查询时高效的时间复杂度,但是如果要对AVL树做一些结构修改的操作,性能非常低下,比如: 插入时要维护其绝对平衡,旋转的次数比较多,更差的是在删除时,有可能一直要让旋转持续到根的位置。
因此:如果需要一种查询高效且有序的数据结构,而且数据的个数为静态的(即不会改变),可以考虑AVL树, 但一个结构经常修改,就不太适合。