目录
一.AVL树的概念
AVL树是最早发明的平衡二叉树，一颗AVL树要求左右子树都是AVL树
他们的高度差最大为1---怎么实现这一操作呢?
AVL树最关键的点是引入了平衡因子的概念，规定这个结点的平衡因子的值=右子树的高度-左子树的高度，也就是说该结点的平衡因子有1/0/-1这几个值如果是0的化说明该节点的左右两个结点是平衡的(完全二叉树)
AVL树整颗树的结点类似于我们的平衡搜索二叉树因此他的增删查的时间复杂度是O(logN)，相比于二叉搜索树，避免了出现像链表一样的结构
图示就是一颗AVL树--他是根据我们的搜索树的框架加上这个地方平衡因子的，我们先把框架给搭出来
cpp
template<class K,class T>
struct AVLTreeNode
{
pair<K, T> _kv;
AVLTreeNode<K, T>* _left;
AVLTreeNode<K, T>* _right;
AVLTreeNode<K, T>* _parent;
int _bf;
AVLTreeNode(const pair<K,T> kv)
:_kv(kv)
,_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0)
{}
};
template<class K, class T>
class AVLTree
{
typedef AVLTreeNode Node
private:
Node* _root = nullptr;
int size = 0;
};这里我们使用的kv的结构，AVLTree加入了一个size，便于我们的查看其中的数据，我们在结点里面增加了一个平衡因子_bf能帮我们控制这个二叉树的高度
二.AVLTree的函数实现
1.插入的实现
讲代码之前，我们理解一下平衡因子控制高度这一概念--他是怎么做的
1.首先AVL的插入跟前面的搜索二叉树是一样的-
2.在找到位置插入后->只会影响祖先的平衡因子，根据之前的平衡因子做计算(父亲与插入结点之间的关系)如果新插入结点在父亲结点的左边，需要我们对于父亲结点的平衡因子-1，如果在后面就+1.
3.更新平衡因子的过程没有出现问题的话，则插入即结束
4.更新平衡因子如果出现了高度差>=2，我们就认为这棵树不平衡了，我们需要左特殊的处理，ok我们先来实现以下插入的框架和插入更新平衡因子的逻辑
更新平衡因子结束的条件?
我们知道如果更新平衡因子肯定需要往祖先更新 那平衡因子更新结束的条件是什么呢?--更新到_root结点吗?
1.如果插入结点之后，父亲结点从-1/1变到了0，好像这个循环就可以结束了，平衡因子是0意味着他已经平衡了
2.插入的时候如果祖先结点不断从0-1/0- -1，就需要我们不断向上调整知道调整到跟结点
3.遇到平衡因子从1->2/-1->-2这种情况，需要旋转来保证他的高度，图示其实是一个左旋
我们更新以下代码
cpp
bool Insert(const pair<K, T> kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
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);
cur->_parent = parent;
if (kv.first < parent->_kv.first)
parent->_left = cur;
else parent->_right = cur;
//更新平衡因子
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 (parent->_bf == 2 || parent->_bf == -2)
{
//需要旋转
}
else
{
assert(false);
}
}
}2.AVL树不平衡的调整问题
如果AVL树不平衡了---意思就是需要我们进行旋转了，来调整树的结构
2.1左单旋
我们看到这个图是插入之后，更新完平衡因子的图--这两颗树都出现了不平衡，因此需要我们进行调整，单选默认调整的都是平衡因子是2的位置结点因此我们怎么调整呢？
什么时候调整呢?
我们发现这两个图都是右边cur==1，parent==2---就意味着parent的不平衡是因为右孩子的右孩子增加了纯是右边的增加我们使用左单旋
1.如图1，我们需要换一个结点来当_root因此我们肯定选择10这个结点，那如何来调整呢，我们就需要把9结点给摁到左边去，9去了左边，10去了根--我们就不得考虑一个问题那9结点原来是有右孩子的，我们把他摁下去他的右孩子变成谁了呢?奥根据搜索树的规则，9的右得比10小比9大--那么我们就锁定10的左边结点就符合我们直接让9的右变成即可
2.如图二，我们就需要想象一下了，其实也是根左边的一样的逻辑，需要注意的是可能出现不平衡的位置不是根，所以我们调整之后还要把祖先指向新的孩子
这个就是旋转之后的图像把结点就给调整好了结点都平衡了，我们编写一下代码
cpp
void RotateL(Node* parent)
{
Node* subR = parent->_right;
parent->_right = subR->_left;
if (subR->_left)
{
subR->_left->_parent = parent;
}
Node* parParent = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parent->_parent == nullptr)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parParent->_left == parent)
{
parParent->_left = subR;
}
else
{
parParent->_right = subR;
}
subR->_parent = parParent;
}
subR->_bf = parent->_bf = 0;
}2.3右单旋
同理，其实我们也可以得到右旋的代码(左边的树高度太高了)--
cpp
void RotateR(Node* parent)
{
Node* subL = parent->_left;
parent->_left = subL->_right;
if (subL->_right)
{
subL->_right->_parent = parent;
}
subL->_right = parent;
Node* parParent = parent->_parent;
parent->_parent = subL;
if (parParent == nullptr)
{
_root = subL;
}
else
{
if (parParent->_left == parent)
{
parParent->_left = subL;
subL->_parent = parParent;
}
else
{
parParent->_right = subL;
subL->_parent = parParent;
}
}
subL->_bf = parent->_bf = 0;
}2.4左右双旋
上面的单旋代码其实一句话总结就是：
父节点引起的不平衡是因为子节点相同方向上插入一个值(不知道你能理解不能)--例如就是父亲是2cur结点是1 他们都是由于插入到右边引起的平衡因子的变化所以单旋就能解决
可是还有两种情况呢就是cur在parent的左边但是他是因为右边树插入一个值引起的从0-1
普通的右单旋没办法解决这个问题，因此我们是需要旋转两次的，我们旋转第一次的目的就是让左边高---右边高 变成 纯左边高，因此我们还需要展开一层
第一次旋转我们看一下subL这个结点的是右边树高--我们先来一个左旋把8结点给弄到左边来这样他就变成左边纯高了，这样我们的单选就能解决任务了，然后旋转完之后我们在旋转p结点，由于我们已经详细讲解了右旋，逻辑是类似但是要转两次，看代码自行理解--他这里8这个结点更新之后是1/-1只能从之前是0开始9结点也是他之前就是0所以他左右孩子没插入前是平衡的--我刚才在这绕来绕去没想明白8结点下面的结点高度问题
2.5右左双选
图1忽略红色框内的--刚才那个双选没有化一开始的状态给我绕晕了，这个图是一开始没有插入的位置我们的插入要插入在9结点的左边我们需要在展开一层
这两个图是一样的，但是我们插入的情况会有两种插入8.5的左或者插入8.5的右所以我们看一下这个区别还是插入后引起p == 2 但是cur == -1需要双选因为cur==-1(左边高)先对他右旋让其变成单边纯高
旋转的逻辑不再考虑看旋转之后的逻辑平衡因子的更新怎么走
其实是看subRL更新前的平衡因子值，因为subRL的左右子树会被分别分给parent和subL这两结点所以判断就行了还是比较符合常理的
cpp
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
//更新平衡因子
if (bf == 0)
{
subRL->_bf = 0;
subR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1)
{
subR->_bf = 1;
parent->_bf = 0;
subRL->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
subRL->_bf = 0;
}
else
{
assert(false);
}
}3.AVL树的查找
他是根据搜索二叉树的逻辑来的比较容易想到和写出来
cpp
Node* Find(const pair<K, T> kv)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}4.AVL树的平衡检测机制
验证一个树是不是满足AVL树,我们就需要算得其左右子树得高度差如果每个结点得高度差都不大于1,那么它就是一个AVL树,增删查改的效率就是log(N)
卧槽，我真绝望了，小鼠刚才一直在调代码不知道哪里出错了，结果是递归没写推出的判断条件我服了，搞了一个小时，还有就是上面代码有很多错了，我改一下.卧槽，昨天打了十个小时的瓦估计给自己打晕了，我在像为啥打游戏能这么爽，自己学习就没有这种爽感。
这个上面我大概看了一下，应该没有bug了，下面我还会贴一个正常的带有测试的案例，可以看下面的代码
cpp
int _Height(Node* root)
{
if (root == nullptr)
{
return 0;
}
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
bool _IsBalance(Node* root)
{
if (nullptr == root)
return true;
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
if (root->_bf != diff)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}三.完整代码
cpp
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<utility>
#include<assert.h>
#include<vector>
#include<iostream>
using namespace std;
template<class K,class T>
struct AVLTreeNode
{
pair<K, T> _kv;
AVLTreeNode<K, T>* _left;
AVLTreeNode<K, T>* _right;
AVLTreeNode<K, T>* _parent;
int _bf;
AVLTreeNode(const pair<K,T> kv)
:_kv(kv)
,_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0)
{}
};
template<class K, class T>
class AVLTree
{
typedef AVLTreeNode<K,T> Node;
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < key)
{
cur = cur->_right;
}
else if (cur->_kv.first > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}
bool Insert(const pair<K, T> kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
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);
cur->_parent = parent;
if (kv.first < parent->_kv.first)
parent->_left = cur;
else parent->_right = cur;
//更新平衡因子
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 (parent->_bf == 2 || parent->_bf == -2)
{
//需要旋转
if (parent->_bf == 2 && cur->_bf == 1)
{
RotateL(parent);
break;
}
else if (parent->_bf == -2 && cur->_bf == -1)
{
RotateR(parent);
break;
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
break;
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
break;
}
}
else
{
assert(false);
}
}
return true;
}
int Height()
{
return _Height(_root);
}
bool IsBalanceTree()
{
return _IsBalance(_root);
}
void InOrder()
{
_InOrder(_root);
}
private:
int _Height(Node* root)
{
if (root == nullptr)
{
return 0;
}
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
bool _IsBalance(Node* root)
{
if (nullptr == root)
return true;
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
if (root->_bf != diff)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
//更新平衡因子
if (bf == 0)
{
subRL->_bf = 0;
subR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1)
{
subR->_bf = 1;
parent->_bf = 0;
subRL->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
subRL->_bf = 0;
}
else
{
assert(false);
}
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
{
subRL->_parent = parent;
}
Node* parParent = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parParent == nullptr)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parParent->_left == parent)
{
parParent->_left = subR;
}
else
{
parParent->_right = subR;
}
subR->_parent = parParent;
}
subR->_bf = parent->_bf = 0;
}
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if(subLR)
{
subLR->_parent = parent;
}
subL->_right = parent;
Node* parParent = parent->_parent;
parent->_parent = subL;
if (parParent == nullptr)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parParent->_left == parent)
{
parParent->_left = subL;
subL->_parent = parParent;
}
else
{
parParent->_right = subL;
subL->_parent = parParent;
}
}
subL->_bf = parent->_bf = 0;
}
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
//更新平衡因子
if (bf == 0)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = -1;
parent->_bf = 0;
subLR->_bf = 0;
}
else if (bf == -1)
{
subL->_bf = 0;
parent->_bf = 1;
subLR->_bf = 0;
}
else
{
assert(false);
}
}
void _InOrder(Node* root)
{
if (nullptr == root)
return;
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
Node* _root = nullptr;
//在private里面的
public:
// 测试代码
//这里是有一个参数的this指针
void TestAVLTree1()
{
AVLTree<int, int> t;
// 常规的测试⽤例
//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
// 特殊的带有双旋场景的测试⽤例
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
t.Insert({ e, e });
}
t.InOrder();
cout << t.IsBalanceTree() << endl;
}
void TestAVLTree2()
{
const int N = 10000000;
vector<int> v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; i++)
{
v.push_back(rand() + i);
}
size_t begin2 = clock();
AVLTree<int, int> t;
for (auto e : v)
{
t.Insert(make_pair(e, e));
}
size_t end2 = clock();
cout << "Insert:" << end2 - begin2 << endl;
cout << t.IsBalanceTree() << endl;
cout << "Height:" << t.Height() << endl;
size_t begin1 = clock();
// 随机值
for (size_t i = 0; i < N; i++)
{
t.Find((rand() + i));
}
size_t end1 = clock();
cout << "Find:" << end1 - begin1 << endl;
}
};
int main()
{
AVLTree<int,int>().TestAVLTree2();
return 0;
}