之前的搜索二叉树大家明显可以看出它的缺点，搜索二叉树的效率为logN，插入节点有序的时候效率退化为O(N)
平衡二叉树
解决这一问题用一个平衡因子来控制左右子树的高度差不超过1，使二叉树避免单支，保持平衡，避免单支
平衡英子
右子树-左子树的高度差
AVL树节点定义：
templete<class K,class V>
struct AVLTreeNode
{
AVLTreeNode<K,V> * _left;
AVLTreeNode<K,V> * _right;
AVLTreeNode<K,V> * _parent;
pair<K,V> _val;
int _bf;//平衡英子
AVLTreeNode(const pair<K,V> & kv)//构造函数
:_left(nullptr)
,right(nullptr)
,_parent(nullptr)
,_bf(0)
,_val(kv)
{}
}
AVL树
class AVL
{
typedef AVLTreeNode<K,V> Node;
public:
//………………
private:
Node *_root;
}
AVL树插入
- 判断插入
- 更新平衡英子
- 旋转
- 左旋
- 右旋
- 双旋
更新平衡英子
- 插入左边–，右边++
- 一直向上更新父亲节点(如果为2或者-2发生旋转停止更新，1，-1停止更新)
如图所示：
旋转
- 左旋
节点插入在C时平衡英子已不满足了，那当前树根节点高度差一定相差1，用肉眼看，把30插入60左边就平衡了，但插入b就丢失了，但b刚好可以当30的右子树(
搜索二叉左<根>右)，那么树久保持平衡了
-
右旋
-
双旋
代码
bool inster(const pair<K,V> & kv)
{
//没有节点的时候
if(_root==nullptr)
{
_root=new Node(kv);
}
//1.判断插入
Node * parent=nullptr;
Node * cur=_root;
while(cur)
{
if(cur->_val.first>kv.first)
{
parent=cur;
cur=cur->left;
}
else if(cur->_val.first<kv.first)
{
parent=cur;
cur=cur->right;
}
else
{
return false;
}
}
//插入节点
Node * present = new Node(kv);
if(parent->_val.first > kv.first)
{
parent->left=present;
present->_parent=parent;
}
else
{
parent->right=present;
present->_parent=parent;
}
//更新平衡英子
while(parent)
{
if(present==parent->right)
{
parent->_bf++;
}
else
{
parent->_bf--;
}
//parent为0的时候不需要在更新
if( parent->_bf==0)
{
break;
}
else if(parent->_bf ==2 || parent->_bf ==-2)
{
//旋转
if(parent->_bf==-2 && present->bf==-1)//右旋
{
RotateR(parent);
}
else if(parent->_bf==2 && present->bf==1)//左旋
{
RotateL(parent);
}
else if(parent->_bf==2 &&present->_bf==-1)//双旋 右 ，左
{
RotateRL(parent);
}
else if(parent->_bf==-2 && present->_bf==1)//双旋 左右
{
RotateLR(parent);
}
break;
}
}
}
void RotateR(Node* parent)//右
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* ppNode = 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 RotateL(Node* parent)//左
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* ppNode = 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;
}
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);
if (bf == -1)
{
subL->_bf = 0;
parent->_bf = 1;
subLR->_bf = 0;
}
else if (bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subL->_bf = 0;
subLR->_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)
{
subR->_bf = 0;
parent->_bf = -1;
subRL->_bf = 0;
}
else if (bf == -1)
{
parent->_bf = 0;
subR->_bf = 1;
subRL->_bf = 0;
}
else if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
subRL->_bf = 0;
}
else
{
assert(false);
}
}
总结
其实就是
把平衡因子为2的节点变为根，那么原来根要放哪里呢？那就要看平衡因子2的节点是根的左节点还是右节点了，如果是左节点，那么就可以把平衡因子为2节点的右子树给根的左子树（原来的根指向的是平衡因子为2的节点），再把根变为平衡因子为2节点的右子树（根比平衡因子为2的节点大）
红黑树
AVL用平衡英子旋转来避免了单支的效率低的情况，但是旋转的效率也很高，那么就衍生出来红黑树，他减少了二叉树旋转的次数，所以红黑树是近似平衡。
红黑树的规则
- 每个节点不是黑色就是红色
根节点必须是黑色一个红色节点的子节点一定是黑色的每条路径中的黑色节点都相等- 叶子节点都为黑(叶子==空)（不重要）
- 最长路径不超过最短路径的俩倍
如图所示：
问：
上述二叉树有多少路径？
答：
14条 ，一条完整的路径是从根到空
问：
如何控制最长路径不超过最短路径的俩倍？
答：
这个是由规则推出来的，1. 节点不是黑的就是红的 2.根一定是黑的 3.
红节点的子节点一定是黑的4.每条路径黑色节点个数一定相同，最短路径就是全黑，最长路径一定是一黑一红
如图所示：
问：
那最长节点超过最短节点的2倍咋办？
答：
emmmm,这是一个蠢问题，当然是旋转了呀哈哈
红黑树的实现
- 插入的节点是红是黑
- 如何旋转 （与平衡二叉一致）
答 1：
插入最好是红色节点，如果是黑色节点插入，那么规则4就不满足了（每条路径的黑色节点个数相同），红色只需判断父亲的颜色，黑色不更改，红色则需要做对应的处理
如图所示:
处理
处理的方法之万物看叔叔
- 如果父亲为红色，叔叔为红的话，父亲叔叔变黑，并向上更新
- 如果父亲为红，叔叔为黑或不存在的话，进行旋转，父亲为黑，祖父为变红
如图所示：
旋转也是有单旋或者双旋，其实只需要判定 parent 在grendfatehr那边，且new_node在parent的那边（p在g左，n在p左单旋 ， n在p右双旋）
红黑树节点
template<class K,class V>
struct RBTNode
{
RBTNode<K,V> *_left;
RBTNode<K,V> *_right;
RBTNode<K,V> *_parent;
pair<K,V> _val;
Color _col;
RBTNode(const pair<K,V>& kv)//构造函数
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_val(kv)
,_col(RED)
{}
};
红黑树的插入接口
其余接口与平衡二叉一致不实现
template<class K,class V>
class RBT
{
typedef RBTNode<K,V> Node;
void RotateR(Node* parent)//右
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* ppNode = 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;
}
}
void RotateL(Node* parent)//左
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* ppNode = 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;
}
}
public:
bool insert(const pair<K,V> &kv)
{
if(_root== nullptr)//没有节点的时候
{
Node * new_node=new Node(kv);
_root=new_node;
_root->_col=BLACK;
return true;
}
//寻找插入的节点位置
Node *cur=_root;
Node *parent=nullptr;
while(cur)
{
if(cur->_val.first > kv.first)
{
parent=cur;
cur=cur->_left;
}
else if(cur->_val.first < kv.first)
{
parent=cur;
cur=cur->_right;
}
else
{
return false;
}
}
//插入节点
Node * new_node =new Node(kv);
if(parent->_val.first > kv.first)//比节点小左边
{
parent->_left=new_node;
new_node->_parent=parent;
}
else//节点大右边
{
parent->_right=new_node;
new_node->_parent=parent;
}
//判断父亲节点颜色并对其进行更改
while(parent && parent->_col== RED)
{
Node * grandfather=parent->_parent;
Node * uncle;
if(grandfather->_left == parent)
{
uncle=grandfather->_right;
if(uncle!= nullptr && uncle->_col ==RED)//为红色的情况
{
uncle->_col=parent->_col=BLACK;
grandfather->_col=RED;
new_node=grandfather;
parent=new_node->_parent;
}
else //为黑色或空 且可能是双旋
{
if((uncle== nullptr || uncle->_col==BLACK) && parent->_left==new_node)//单旋
{
RotateR(grandfather);
grandfather->_col= RED;
parent->_col=BLACK;
}
else//双旋
{
RotateL(parent);
RotateR(grandfather);
new_node->_col=BLACK;
grandfather->_col=parent->_col=RED;
}
//旋转后没有新增节点
// 所以这条路径的黑色节点没边则不需要在向上更新
return true;
}
}
else
{
uncle=grandfather->_left;
if(uncle!= nullptr && uncle->_col ==RED)//为红色的情况
{
uncle->_col=parent->_col=BLACK;
grandfather->_col=RED;
new_node=grandfather;
parent=new_node->_parent;
}
else //为黑色或空 且可能是双旋
{
if((uncle== nullptr || uncle->_col==BLACK )&& parent->_right==new_node)//单旋
{
RotateL(grandfather);
grandfather->_col= RED;
parent->_col=BLACK;
}
else
{
RotateR(parent);
RotateL(grandfather);
new_node->_col=BLACK;
grandfather->_col=parent->_col=RED;
}
//旋转后没有新增节点
// 所以这条路径的黑色节点没边则不需要在向上更新
return true;
}
}
}
//根节点一定是黑色
_root->_col=BLACK;
}
private:
Node * _root=nullptr;
};
结尾
二叉搜索树的底层就到此为止了，那么现在map与set的底层是红黑树，毕竟旋转次数较少，虽然查找会差一点，但是数据越多其实没差别
扫一扫
1776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
