文章目录
- 前言
- [1. AVL树的概念](#1. AVL树的概念)
- [2. AVL树节点的定义](#2. AVL树节点的定义)
- [3. AVL树的插入](#3. AVL树的插入)
-
- [3.1 新节点插入较高左子树的左侧---左左:右单旋](#3.1 新节点插入较高左子树的左侧---左左:右单旋)
- [3.2 新节点插入较高右子树的右侧---右右:左单旋](#3.2 新节点插入较高右子树的右侧---右右:左单旋)
- [3.3 新节点插入较高左子树的右侧---左右:先左单旋再右单旋](#3.3 新节点插入较高左子树的右侧---左右:先左单旋再右单旋)
- [3.4 新节点插入较高右子树的左侧---右左:先右单旋再左单旋](#3.4 新节点插入较高右子树的左侧---右左:先右单旋再左单旋)
- [4. AVL树的验证](#4. AVL树的验证)
-
- [4.1 验证其为二叉搜索树](#4.1 验证其为二叉搜索树)
- [4.2 验证其为平衡树](#4.2 验证其为平衡树)
- [5. AVL树的删除](#5. AVL树的删除)
- [6. AVL树的性能](#6. AVL树的性能)
- [7. 代码实现](#7. 代码实现)
-
- [7.1 AVL.h](#7.1 AVL.h)
- [7.2 Test.cpp](#7.2 Test.cpp)
- [8. 总结](#8. 总结)
前言
在二叉搜索树中我们发现这种情况下查询效率依旧很低下:
如果插入的顺序有序,那么就会变成成单支树,二叉搜索树的性能就失去了,而AVL树和红黑树就是为了解决这个问题而发明的。本章主要讲解的是AVL树,下一篇文章将会讲解红黑树。
1. AVL树的概念
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度。
一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)(平衡因子:某一结点的右子树的高度减左子树的高度)
如果一棵二叉搜索树是高度平衡的,它就是AVL树。如果它有n个结点,其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2n),搜索时间复杂度O( l o g 2 n log_2 n log2n)。
AVL树的解决方法其实是将树平衡因子超过1的树进行旋转,我们来看个例子:
这样就将一个平衡因子为了2的树变成了平衡因子为0的树,如此就完美的解决了单支树的问题。
2. AVL树节点的定义
cpp
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)
{}
};
AVL树我们采用的是三叉链,相比较二叉链多存储了父亲节点,它会更好的帮助我们进行调整节点的操作。
3. AVL树的插入
AVL树就是在二叉搜索树的基础上引入了平衡因子,因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步:
- 按照二叉搜索树的方式插入新节点
- 调整节点的平衡因子
- 先按照二叉搜索树的规则将节点插入到AVL树中
- 新节点插入后,AVL树的平衡性可能会遭到破坏,此时就需要更新平衡因子,并检测是否破坏了AVL树的平衡性cur插入后,parent的平衡因子一定需要调整,在插入之前,parent 平衡因子分为三种情况:-1,0, 1, 分以下两种情况:
- 如果cur插入到parent的左侧,只需给parent的平衡因子-1即可
- 如果cur插入到parent的右侧,只需给parent的平衡因子+1即可
此时:parent的平衡因子可能有三种情况:0,正负1, 正负2
- 如果parent的平衡因子为0,说明插入之前parent的平衡因子为正负1,插入后被调整成0,此时满足AVL树的性质,插入成功
- 如果parent的平衡因子为正负1,说明插入前parent的平衡因子一定为0,插入后被更新成正负1,此时以parent为根的树的高度增加,需要继续向上更新
- 如果parent的平衡因子为正负2,则parent的平衡因子违反平衡树的性质,需要对其进行旋转处理
cpp
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 (kv.first > cur->_kv.first)
{
parent = cur;
cur = cur->_right;
}
else if(kv.first < cur->_kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(kv);
if (cur->_kv.first < parent->_kv.first)
{
parent->_left = cur;
cur->_parent = parent;
}
else
{
parent->_right = cur;
cur->_parent = parent;
}
//更新平衡因子
while (parent)
{
if (cur == parent->_left)
{
parent->_bf--;
}
else
{
parent->_bf++;
}
// 更新后检测双亲的平衡因子
if (parent->_bf == 0)
{
break;
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
// 插入前双亲的平衡因子是0,插入后双亲的平衡因为为1 或者 -1 ,说明以双亲为根的二叉树的高度增加了一层,因此需要继续向上调整
cur = parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
// 双亲的平衡因子为正负2,违反了AVL树的平衡性,需要对以pParent为根的树进行旋转处理
//............
}
}
return true;
}
调整一共分为四种情况,分别为右单旋、左单旋、右左单旋,左右单旋,我们分别来看。
3.1 新节点插入较高左子树的左侧---左左:右单旋
上图在插入前,AVL树是平衡的,新节点插入到10的左子树(注意:此处不是左孩子)中,10左子树增加了一层,导致以20为根的二叉树不平衡,要让20平衡,只能将20左子树的高度减少一层,右子树增加一层,即将左子树往上提,这样20转下来,因为20比10大,只能将其放在10的右子树,而如果10有右子树,右子树根的值一定大于10,小于20,只能将其放在20的左子树,旋转完成后,更新节点的平衡因子即可。在旋转过程中,有以下几种情况需要考虑:
- 10节点的右孩子可能存在,也可能不存在
- 20可能是根节点,也可能是子树
如果是根节点,旋转完成后,要更新根节点
如果是子树,可能是某个节点的左子树,也可能是右子树
a、b、c分别代表着各种情况,高度为0(也就是为空),高度为1,(为一个节点),高度为2(见图,可以为图中的任意一种),高度为3......等等。
此处是画出了一个抽象图来讲解,可以映射为各种各样的情况。注意:我们是每插入一个节点就会进行平衡,因此a、b、c一定也为AVL树。
旋转方式:我们将平衡因子为正负2的节点命名为parent,它的左子树命名为subL,subL的右子树命名为subLR,旋转时只需要调整这个几个节点就可以了。
旋转就是以平衡因子为正负2的节点为基础进行的。将subLR链接到parent的左,再将parent链接到subL的右。
cpp
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
Node* ppNode = parent->_parent;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
parent->_bf = subL->_bf = 0;
}
但是subLR有可能为空,也就是当a、b、c高度为0时,subLR就会出现为空的情况,因此在使用时需要判断一下。
但是要注意:我们使用的是三叉链,在进行链接时是需要进行相互链接的,尤其是需要注意parent,如果它不是根节点的话,说明parent的上面还有节点,因此在链接时不能把此处的链接给忘记了。总结一共存在三处链接:第一处是subLR链接到parent的左,第二处链接是将parent链接到subL的右,第三处链接是将subL链接到parent的父亲节点。
旋转完成后还需要调整平衡因子,根据我们画出的图可以看出,在这种调整情况下,最后的平衡因子都变成了0。
3.2 新节点插入较高右子树的右侧---右右:左单旋
左单旋与右单旋相差无几,仅仅只是调换了一下方向:
具体情况与右单旋一模一样,在此处我就不进行详细讲解了。
cpp
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* ppNode = parent->_parent;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else
{
ppNode->_right = subR;
}
subR->_parent = ppNode;
}
parent->_bf = subR->_bf = 0;
}
3.3 新节点插入较高左子树的右侧---左右:先左单旋再右单旋
在这种情况下,我们发现对节点20无论是左单旋还是右单旋都无法减少平衡因子,因此就出现了双旋的情况,我们先对节点10进行左单旋。
将其变成了只有左边高,这样就转化成了右单旋的问题。
再对节点20进行右单旋,如此下来我们就发现它们的平衡因子减小了。
左右双旋我们可以直接复用前面的代码就可以了,但是需要注意平衡因子的调节,新插入节点的位置可能是subLR,也可能是subLR的左,也可能是subLR的右,插入位置不同,平衡因子的调节就不同,大家可以自行画图来观察。
cpp
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 0)
{
parent->_bf = subL->_bf = subLR->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = -1;
parent->_bf = subLR->_bf = 0;
}
else if(bf = -1)
{
parent->_bf = 1;
subLR->_bf = subL->_bf = 0;
}
else
{
assert(false);
}
}
3.4 新节点插入较高右子树的左侧---右左:先右单旋再左单旋
具体的过程与左右双旋情况一致,我这里找了一份图,大家对左右双旋理解透彻了相信对于右左双旋也不在话下,我就偷个懒不做详细解释了。
这里的平衡因子的调节同样与插入位置有关,可以多画几种情况来观察。
cpp
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
if (bf == 0)
{
parent->_bf = subR->_bf = subRL->_bf = 0;
}
else if(bf == 1)
{
parent->_bf = -1;
subR->_bf = subRL->_bf = 0;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
总结:
假如以parent为根的子树不平衡,即parent的平衡因子为2或者-2,分以下情况考虑
- parent的平衡因子为2,说明parent的右子树高,设parent的右子树的根为subR
当subR的平衡因子为1时,执行左单旋
当subR的平衡因子为-1时,执行右左双旋
- parent的平衡因子为-2,说明parent的左子树高,设parent的左子树的根为subL
当subL的平衡因子为-1是,执行右单旋
当subL的平衡因子为1时,执行左右双旋
旋转完成后,原parent为根的子树个高度降低,已经平衡,不需要再向上更新。
4. AVL树的验证
AVL树是在二叉搜索树的基础上加入了平衡性的限制,因此要验证AVL树,可以分两步:
- 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列,就说明为二叉搜索树
- 验证其为平衡树
每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确
4.1 验证其为二叉搜索树
使用中序进行遍历即可。
cpp
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
4.2 验证其为平衡树
因此还需要写一个计算高度的函数来辅助检查,相信有了前面二叉树的学习,这部分对大家构不成威胁。
cpp
int _Hight(Node* _root)
{
if (_root == nullptr)
return 0;
int LeftHight = _Hight(_root->_left);
int RightHight = _Hight(_root->_right);
return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
}
bool _IsBalance(Node* _root)
{
if (_root == nullptr)
return true;
int LeftHight = _Hight(_root->_left);
int RightHight = _Hight(_root->_right);
if (RightHight - LeftHight != _root->_bf)
{
cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
return false;
}
return abs(LeftHight - RightHight) < 2
&& _IsBalance(_root->_left)
&& _IsBalance(_root->_right);
}
bool IsBalance()
{
return _IsBalance(_root);
}
5. AVL树的删除
因为AVL树也是二叉搜索树,可按照二叉搜索树的方式将节点删除,然后再更新平衡因子,只不错与删除不同的时,删除节点后的平衡因子更新,最差情况下一直要调整到根节点的位置。
删除的情况更多也更为复杂,具体实现大家们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。
6. AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1,这样可以保证查询时高效的时间复杂度,即 l o g 2 ( N ) log_2 (N) log2(N)。但是如果要对AVL树做一些结构修改的操作,性能非常低下,比如:插入时要维护其绝对平衡,旋转的次数比较多,更差的是在删除时,有可能一直要让旋转持续到根的位置。因此:如果需要一种查询高效且有序的数据结构,而且数据的个数为静态的(即不会改变),可以考虑AVL树,但一个结构经常修改,就不太适合。
7. 代码实现
7.1 AVL.h
cpp
#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
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 (kv.first > cur->_kv.first)
{
parent = cur;
cur = cur->_right;
}
else if(kv.first < cur->_kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(kv);
if (cur->_kv.first < parent->_kv.first)
{
parent->_left = cur;
cur->_parent = parent;
}
else
{
parent->_right = cur;
cur->_parent = parent;
}
//平衡因子
while (parent)
{
if (cur == parent->_left)
{
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 (parent->_bf == 2 || 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)
{
RotateLR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
}
// 1、旋转让这颗子树平衡了
// 2、旋转降低了这颗子树的高度,恢复到跟插入前一样的高度,所以对上一层没有影响,不用继续更新
break;
}
else
{
assert(false);
}
}
return true;
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
Node* ppNode = parent->_parent;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
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;
Node* ppNode = parent->_parent;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
parent->_bf = subL->_bf = 0;
}
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
if (bf == 0)
{
parent->_bf = subR->_bf = subRL->_bf = 0;
}
else if(bf == 1)
{
parent->_bf = -1;
subR->_bf = subRL->_bf = 0;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
if (bf == 0)
{
parent->_bf = subL->_bf = subLR->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = -1;
parent->_bf = subLR->_bf = 0;
}
else if(bf = -1)
{
parent->_bf = 1;
subLR->_bf = subL->_bf = 0;
}
else
{
assert(false);
}
}
int _Hight(Node* _root)
{
if (_root == nullptr)
return 0;
int LeftHight = _Hight(_root->_left);
int RightHight = _Hight(_root->_right);
return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
}
bool _IsBalance(Node* _root)
{
if (_root == nullptr)
return true;
int LeftHight = _Hight(_root->_left);
int RightHight = _Hight(_root->_right);
if (RightHight - LeftHight != _root->_bf)
{
cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
return false;
}
return abs(LeftHight - RightHight) < 2
&& _IsBalance(_root->_left)
&& _IsBalance(_root->_right);
}
bool IsBalance()
{
return _IsBalance(_root);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
Node* _root = nullptr;
};
7.2 Test.cpp
cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include"AVL.h"
void Test1()
{
int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
AVLTree<int, int> t;
for (auto e : a)
{
t.insert(make_pair(e, e));
}
t.InOrder();
cout << t.IsBalance() << endl;
}
void Test2()
{
const int N = 100;
vector<int> v;
v.reserve(N);
srand(time(0));
for (int i = 0; i < N; i++)
{
v.push_back(rand());
}
AVLTree<int, int> t;
for (auto e : v)
{
t.insert(make_pair(e, e));
cout << "insert:" << e << "->" << t.IsBalance() << endl;
}
cout << t.IsBalance() << endl;
}
int main()
{
//Test1();
Test2();
return 0;
}
8. 总结
AVL树最主要的是如何进行旋转,此部分比较难以理解,大家可以通过多画图来反复进行学习。希望大家都能有所收获。
如果大家发现有什么错误的地方,可以私信或者评论区指出喔。我会继续深入学习C++,希望能与大家共同进步,那么本期就到此结束,让我们下期再见!!觉得不错可以点个赞以示鼓励!!