手撕AVL树(详解插入时的4种旋转)
Posted 楠c
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撕AVL树(详解插入时的4种旋转)相关的知识，希望对你有一定的参考价值。
目录
1. 为什么要有AVL树
1.1 基本概念
二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接
近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。
所以科学家对二叉搜索树采取平衡处理，实现出AVL树。
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
1.2 性质
当这棵树是AVL树的时候，它的左右子树都是AVL树
且左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
如果一棵二叉搜索树的高度是平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，搜索时间复杂度O(logN)。内存足够的话，将中国所有人的身份证号存入AVL树，只需要31次就可以查找到想要找的人。确实很厉害，但是后面要讲的哈希表，效率更加的高。
1.3 节点组成
这里定义出AVL树的节点，这里我选择用三叉链，即记录每个节点的父亲，以及记录每个节点的平衡因子，来判断是否平衡。
他们两个不是必须要有的。
2. 实现AVL树
2.1 插入
插入与二叉搜索树并无差别，但是他多了一项工作，调节平衡因子。且调节平衡因子有以下几种情况。
因为情况过于复杂，下面几种旋转均采用抽象图。
2.1.1 左单旋
void rotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
Node* parentParent = parent->_parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
subR->_bf = parent->_bf = 0;
}
2.1.2 右单旋
void rotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)//可能为空
subLR->_parent = parent;
//假如他是一颗子树，就需要这个节点，连接上一棵树
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
//完整的树
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else//一颗子树
{
if (parentParent->_left == parent)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
//位置调好后处理平衡因子
subL->_bf = parent->_bf = 0;
}
2.1.3 左右双旋
复用之前的代码即可，需要注意
假如60存在左右孩子，在任意孩子插入均会引起左右双旋，且90，60，30的平衡因子变化都不一样。另一种情况是60为新插入节点，也就是说原来只有90，30的时候。平衡因子变化也会不同。所以对这三种情况需要分别进行讨论（即subLR的平衡因子为，-1，0，1三种情况）
将60的左给30，60的右给90，自己去做根
void rotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;//旋转会修改，保存一下
rotateL(parent->_left);
rotateR(parent);
//此时由于插入位置不同，导致subLR的平衡因子情况不同，1,-1,0。从而导致旋转后平衡因子情况不同
if (bf == -1)//新增节点在subLR的左
{
subLR->_bf = subL->_bf= 0;
parent ->_bf= 1;
}
else if (bf == 1)//新增节点在subLR的右
{
parent->_bf = subLR->_bf = 0;
subL->_bf = -1;
}
else if(bf==0)//subLR本身为新增节点
{
subLR ->_bf= subL->_bf = parent->_bf=0;
}
else
{
assert(false);
}
}
2.1.4 右左双旋
这里就不啰嗦了，镜像处理且判断平衡因子的三种情况
void rotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
rotateR(parent->_right);
rotateL(parent);
if (bf == -1)
{
parent->_bf = subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
subR->_bf = subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf==0)
{
subR->_bf = subRL->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
2.1.5 插入整体代码
//插入
//STL库中是iteator,这里用Node*代替
pair<Node*, bool> insert(const pair<K,V>& kv)
{
// 0. 假如根节点为空
if (_root == nullptr)
{
_root = new Node(kv);
return make_pair(_root, true);
}
Node* cur = _root;
Node* parent = nullptr;
//1. 从根节点开始，cur寻找合适的地方,准备插入
while (cur)
{
//小于走左边
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
//大于走右边
else if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
//等于的话,返回当前节点指针与false
else
{
return make_pair(cur, false);
}
}
//2. 找到位置，准备插入
cur = new Node(kv);
//parent为插入位置的父亲，判断插入到左还是右
//插入对象比他大，插入到右边
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
cur->_parent = parent;
}
else//小，插入到左边
{
parent->_left = cur;
cur->_parent = parent;
}
Node* newNode = cur;//cur会变化，先把它保存下来
//3. 调节平衡因子
while(parent)
{
//插入在右边，平衡因子++
if (cur == parent->_right)
{
parent->_bf++;
}
else//插入在左边,平衡因子--
{
parent->_bf--;
}
if (parent->_bf == 0)//平衡因子为0，说明插入的节点把父亲的一侧填补了，那么不会影响其他树
{
break;
}
else if (abs(parent->_bf )==1)//当平衡因子为1,或者-1，说明会影响其他树,迭代上去修改
{
//迭代上去，改变平衡因子
cur = parent;
parent = parent->_parent;
}
else if (abs(parent->_bf)==2)//当平衡因子为2或者-2，说明此时，已经不平衡，需要进行旋转
{
//因子为-2时
if (parent->_bf == -2)
{
//假如长的一侧在左侧,且新增节点在最左的，右或者左，右单旋
if (cur->_bf == -1)
{
rotateR(parent);
}
else//右侧，会引发左右双旋
{
rotateLR(parent);
}
}
else//因子为2时
{
//假如长的一侧在右侧，且新增节点在最右的，右或者左，左单旋
if (cur->_bf == 1)
{
rotateL(parent);
}
else//左侧，引发右左双旋
{
rotateRL(parent);
}
}
break;//旋转完成break
}
else
{
assert(false);
}
}
return make_pair(newNode, true);
}
2.2 删除大概思路
从以往学习经验来看，任何数据结构的删除都是要比插入更加复杂的。
首先，删除肯定是先find到节点。然后
- 按照搜索二叉树的方式删除
- 更新平衡因子
- 如果不平衡旋转
假如在右边删除，平衡因子–，左边删除平衡因子++。插入的时候当平衡因子由-1或1变为0的时候，不需要更新，因为已经平衡，但是删除不一样，平衡因子由-1或1变为0，说明高度发生了变化，高度发生变化，就会影响到祖先。反而是平衡因子由0变为-1或1时，不需要处理，因为高度没有变，不会影响祖先。
3. 调试验证
4. AVLTree代码
#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;
template<class K,class V>
class AVLTreeNode
{
public:
AVLTreeNode(const pair<K, V>& kv)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _kv(kv)
, _bf(0)
{}
public:
AVLTreeNode<K, V>* _left;//左孩子
AVLTreeNode<K, V>* _right;//右孩子
AVLTreeNode<K, V>* _parent;//父亲
pair<K, V> _kv;
int _bf;//平衡因子
};
#include<utility>
template<class K,class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
private:
void rotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)//可能为空
subLR->_parent = parent;
//假如他是一颗子树，就需要这个节点，连接上一棵树
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
//完整的树
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else//一颗子树
{
if (parentParent->_left == parent)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
//位置调好后处理平衡因子
subL->_bf = parent->_bf = 0;
}
void rotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
Node* parentParent = parent->_parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parentParent->_left == parent)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
subR->_bf = parent->_bf = 0;
}
void rotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;//旋转会修改，保存一下
rotateL(parent->_left);
rotateR(parent);
//此时由于插入位置不同，导致subLR的平衡因子情况不同，1,-1,0。从而导致旋转后平衡因子情况不同
if (bf == -1)//新增节点在subLR的左
{
subLR->_bf = subL->_bf= 0;
parent ->_bf= 1;
}
else if (bf == 1)//新增节点在subLR的右
{
parent->_bf = subLR->_bf = 0;
subL->_bf = -1;
}
else if(bf==0)//subLR本身为新增节点
{
subLR ->_bf= subL->_bf = parent->_bf=0;
}
else
{
assert(false);
}
}
void rotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
rotateR(parent->_right);
rotateL(parent);
if (bf == -1)
{
parent->_bf = subRL->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1)
{
subR->_bf = subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf==0)
{
subR->_bf = subRL->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
public:
//插入
//STL库中是iteator,这里用Node*代替
pair<Node*, bool> insert(const pair<K,V>& kv)
{
// 0. 假如根节点为空
if (_root == nullptr)
{
_root = new Node(kv);
return make_pair(_root, true);
}
Node* cur = _root;
Node* parent = nullptr;
//1. 从根节点开始，cur寻找合适的地方,准备插入
while (cur)
{
//小于走左边
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
//大于走右边
else if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
//等于的话,返回当前节点指针与false
else
{
return make_pair(cur, false);
}
}
//2. 找到位置，准备插入
cur = new Node(kv);
//parent为插入位置的父亲，判断插入到左还是右
//插入对象比他大，插入到右边
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
cur->_parent = parent;
}
else//小，插入到左边
{
parent->_left = cur;
cur->_parent = parent;
}
Node* newNode = cur;//cur会变化，先把它保存下来
//3. 调节平衡因子
while(parent)
{
//插入在右边，平衡因子++
if (cur == parent->_right)
{
parent->_bf++;
}
else//插入在左边,平衡因子--
{
parent->_bf--;
}
if (parent->_bf == 0)//平衡因子为0，说明插入的节点把父亲的一侧填补了，那么不会影响其他树
{
break;<以上是关于手撕AVL树(详解插入时的4种旋转)的主要内容，如果未能解决你的问题，请参考以下文章