转载:https://blog.csdn.net/yanerhao/article/details/61198487
BST树,AVL树详解及B树和红黑树原理分析
互联网面试中树尤其是BST,AVL是提问的重点也是难点,甚至B树乃至高级数据结构红黑树都是提问的重点,像阿里云面试就曾经问过map实现机制(红黑树)及其原理,这里我们要做到对BST/AVL完全熟悉能给出全部代码实现,红黑树、b树之类,有能力的需要完全理解,代码就不用掌握了。红黑树和b树看会就行了,当碰到你感觉他们不懂这方面的面试官的时候,可以逮着他们狂扯这部分,然后让他们感觉你很高大上。
以二叉树或者树作为表的组织形式,称为树表。树表在进行增删操作时可以方便维护表有序,不需要移动记录,比顺序存储的表效率要高,开销要低。常见树表BST/AVL,B树等。
一 二查搜索树BST
二叉排序树BST其定义:
1 首先它也是一个二叉树,故满足递归定义;
2 其次每个节点只存在一个值;
3 需满足左子树值<=根值<=右子树,故按照中序遍历会得到一个非递减序列。
BST涉及操作主要增,删,查,除了删麻烦一点,其他操作均可递归实现,二叉查找树的一般性质:1.在一棵二叉查找树上,执行查找、插入、删除等操作,的时间复杂度为O(lgn)。因为,一棵由n个结点,随机构造的二叉查找树的高度为lgn,所以顺理成章,一般操作的执行时间为O(lgn)。2.但若是一棵具有n个结点的线性链,则此些操作最坏情况运行时间为O(n)。
代码:
-
struct node{
-
int key;
-
node*left;
-
node*right;
-
};
-
int bstinsert(node*&p,int k){
-
if(p==
NULL){p=(node*)
malloc(
sizeof(node));p->key=k;p->left=p->right=
NULL;
return
1;}
-
else {
if(k==p->key)
return
0;
-
else
if(k<p->key)
return bstinsert(p->left,k);
-
else
return bstinsert(p->right,k);
-
}
-
}
-
void bstcreate(node*&r,int a[],int n)
-
{
-
int i;
-
r==
NULL;
-
for(i=
0;i<n;i++)
-
bstinsert(r,a[i]);
-
}
-
node* bstsearch(node*root,int k){
-
if(root==
NULL)
return root;
-
else
if(k==root->key)
return root;
-
else
if(k<root->key)
return bstsearch(root->left,k);
-
else
return bstsearch(root->right,k);
-
}
-
int bstdelete(node*&root,int k){
-
node *p=root,*pa,*r;
-
pa=
NULL;
//父节点
-
while(p&&p->key!=k){
-
pa=p;
-
if(p->key>k)p=p->left;
-
else p=p->right;
-
}
-
if(p==
NULL)
//没有找到k
-
{
cout<<
"Not Found!"<<
endl;
return
0;}
-
//分四种情况讨论
-
if(p->left==
NULL&p->right==
NULL){
-
if(pa==
NULL)root=
NULL;
-
else
if(pa->left==p)pa->left=
NULL;
-
else pa->right=
NULL;
-
delete p;}
//叶子直接删除
-
else
if(p->left==
NULL){
-
if(pa==
NULL)root=p->right;
//p是根节点
-
else
if(pa->left==p){pa->left=p->right;
delete p;}
//p是父节点左孩子,则用其右孩子取代
-
else {pa->right=p->right;
delete p;}
//p是父节点右孩子,则用其右孩子取代
-
}
//只含右节点
-
else
if(p->right==
NULL){
-
if(pa==
NULL)root=p->left;
//p是根节点
-
else
if(pa->left==p){pa->left=p->left;
delete p;}
//p是父节点左孩子,则用其右孩子取代
-
else {pa->right=p->left;
delete p;}
//p是父节点右孩子,则用其右孩子取代
-
}
//只含左节点
-
else {
-
//需要找左子树最左下或者右子树最左下孩子r取代p故先找到r
-
node*p1=p;r=p->left;
-
while(r->right){p1=r;r=r->right;}
-
//找到r节点,且该节点一定无右子树,符合上面的无右子树情况
-
if(p1->left==r){p1->left=r->left;}
-
else
if(p1->right==r){p1->right=r->left;}
-
//删除r后再把r替代p
-
r->left=p->left;
-
r->right=p->right;
-
if(pa==
NULL)root=r;
-
else
if(pa->left==p)pa->left=r;
-
else pa->right=r;
-
delete p;
-
}
//既有左孩子又有右孩子
-
p=
NULL;
-
return
1;
-
}
-
void inorder(node*r){
-
if(r){
-
inorder(r->left);
-
cout<<r->key<<
" ";
-
inorder(r->right);
-
}
-
}
-
void bstdis(node *r){
-
inorder(r);
-
cout<<
endl;
-
}
特点:就时间复杂度来说,BST的查找与二分查找性能差不多,但是增删时BST无需移动记录,只需移动指针比顺序存储好很多;一般性能都在O(log n)。
缺点:面对序列原本就是顺序:
如右边顺序序列所示,此时性能和顺序存储无异。所以,使用BST树还要考虑尽可能让BST树保持左图的结构,和避免右图的结构,也就是所谓的“平衡”问题j 进而引出AVL。
二 平衡二叉树AVL
平衡二叉树AVL是带有平衡条件的BST,这个平衡条件必须容易保持,且需要保持树的深度O(log N),一般想法是要求每个节点都必须要有相同高度,但是这样要求太严格,难以实现,故退一步引出AVL:
1 首先仍是一棵二叉树,满足递归定义;
2 其次又是一棵BST,满足有序;
3 每个节点左右子树高度差的绝对值不能超过1
AVL树各节点的平衡因子定义为左子树深度减去右子树深度,AVL的平衡因子一般都只能-1,0,1,当绝对值大于1时则AVL失去平衡。例如在完成插入后,失衡只有那些从插入点到根节点路径上的平衡可能被打破,当沿着这条路径上溯到根,找到插入新节点后失去平衡的最小子树根节点的指针x,然后再调整这个子树使之重新平衡。注意当失去平衡的最小子树(这样的最小子树指的是离插入点最近)调整平衡后,原有的其他所有不平衡树无需调整,整个二叉树回归平衡,使得BST操作性能始终维持在对数级别。这种调整所需要的主要技术就是旋转,下面具体介绍:
1 插入点位于x的左孩子的左子树中--左左LL;
2 插入点位于x的左孩子的右子树-中-左右LR;
3 插入点位于x的右孩子的左子树-中-右左RL;
4 插入点位于x的右孩子的右子树-中-右右RR;
1和4是对称的,成为外侧插入,通过单旋转解决;2和3是对称的,成为内侧插入,通过单旋转解决。
1 LL型调整(右旋)
设最深节点k2,最深节点左孩子k1,在k1左子树再插入一个新节点,使得k2平衡因子大于1不平衡,如图,k2原始平衡因子为1,矩形代表一个高度h的子树,带阴影方框为插入的一个节点,采用的方法单向右转:
-
class avlnode{
-
private:
-
int key;
-
int height;
-
int freq;
-
avlnode*left;
-
avlnode*right;
-
avlnode(
int h=
1):left(
NULL),right(
NULL),height(h),freq(
1){}
-
};
-
int get_height(avlnode *r){
-
if(r)
return r->height;
-
else
return
0;
-
}
-
void singlerotate_left(avlnode *&r){
-
avlnode *k2=r;
-
avlnode *k1=k2->left;
-
k2->left=k1->right;
-
k1->right=k2;
-
k2->height=max(get_height(k2->left),get_height(k2->right))+
1;
-
k1->height=max(get_height(k1->left),get_height(k1->right))+
1;
-
}
2 RR型调整
如图,采用方法单向左旋:
-
void singlerotate_right(avlnode*&r){
-
avlnode*k2=r;
-
avlnode*k1=k2->right;
-
k2->right=k1->left;
-
k1->left=k2;
-
k2->height=max(get_height(k2->left),get_height(k2->right))+
1;
-
k1->height=max(get_height(k1->left),get_height(k1->right))+
1;
-
}
3 LR型调整
此时在最深节点k2的左孩子k1的右子树插入节点,使得k2平衡因子大于1,调整的方法是先单向左旋即将k2,最后单向右旋:
-
void doubleLeft_right(avlnode*&r){
-
avlnode*k2=r;
-
avlnode*k1=r->left;
-
singlerotate_right(k1);
-
singlerotate_left(k2);
-
}
4 RL型调整
类似LR型直接贴出代码就行。
-
void doubleright_left(avlnode*&r){
-
avlnode*k2=r;
-
avlnode*k1=r->right;
-
singlerotate_left(k1);
-
singlerotate_right(k2);
-
}
相应增删查操作如下:
注意增加操作类似BST,只不过在完成插入后需要进行调整;查找操作一样;删除操作也分为几种情况:
首先在树中搜寻是否有节点的元素值等于需要删除的元素。如未搜索到,直接返回。否则执行以下操作。
(1)要删除的节点是当前根节点T。如果左右子树都非空。在高度较大的子树中实施删除操作。分两种情况:A、左子树高度大于右子树高度,将左子树中最大的那个元素赋给当前根节点,然后删除左子树中元素值最大的那个节点。B、左子树高度小于右子树高度,将右子树中最小的那个元素赋给当前根节点,然后删除右子树中元素值最小的那个节点。如果左右子树中有一个为空,那么直接用那个非空子树或者是NULL替换当前根节点即可。
(2)要删除的节点元素值小于当前根节点T值,在左子树中进行删除。递归调用,在左子树中实施删除。这个是需要判断当前根节点是否仍然满足平衡条件,如果满足平衡条件,只需要更新当前根节点T的高度信息。否则,需要进行旋转调整:如果T的左子节点的左子树的高度大于T的左子节点的右子树的高度,进行相应的单旋转。否则进行双旋转。(3)要删除的节点元素值大于当前根节点T值,在右子树中进行删除。过程与上述步骤类似。
代码:
-
//AVL
-
int max1(int x,int y){
-
return (x>y? x:y);
-
}
-
class avlnode{
-
public:
-
int key;
-
int height;
-
int freq;
-
avlnode*left;
-
avlnode*right;
-
avlnode(
int h=
0):left(
NULL),right(
NULL),height(h),freq(
1){}
-
};
-
int get_height(avlnode *r){
-
if(r)
return r->height;
-
else
return
0;
-
}
-
avlnode* singlerotate_left(avlnode *k2){
-
avlnode *k1=k2->left;
-
k2->left=k1->right;
-
k1->right=k2;
-
k2->height=max1(get_height(k2->left),get_height(k2->right))+
1;
-
k1->height=max1(get_height(k1->left),get_height(k1->right))+
1;
-
return k1;
-
}
-
avlnode* singlerotate_right(avlnode*k2){
-
avlnode*k1=k2->right;
-
k2->right=k1->left;
-
k1->left=k2;
-
k2->height=max1(get_height(k2->left),get_height(k2->right))+
1;
-
k1->height=max1(get_height(k1->left),get_height(k1->right))+
1;
-
return k1;
-
}
-
avlnode* doubleLeft_right(avlnode*k2){
-
avlnode*k1=k2->left;
-
k2->left=singlerotate_right(k1);
-
return singlerotate_left(k2);
-
}
-
avlnode* doubleright_left(avlnode*k2){
-
avlnode*k1=k2->right;
-
k2->right=singlerotate_left(k1);
-
return singlerotate_right(k2);
-
}
-
avlnode* avlinsert(avlnode*&r,int k){
-
if(r==
NULL){r=
new avlnode();r->key=k;}
-
else{
-
if(r->key>k){
-
r->left=avlinsert(r->left,k);
//类似BST
-
if(get_height(r->left)-get_height(r->right)==
2)
-
{
if(r->left->key>k)r=singlerotate_left(r);
//LL
-
else r=doubleLeft_right(r);
//LR
-
}
//不平衡
-
}
//BST左子树
-
else
if(r->key<k){
-
r->right=avlinsert(r->right,k);
-
if(get_height(r->right)-get_height(r->left)==
2)
-
{
if(r->right->key<k)r=singlerotate_right(r);
//RR
-
else r=doubleright_left(r);
-
}
-
}
//BST右子树
-
else ++(r->freq);
-
}
-
r->height=max1(get_height(r->left),get_height(r->right))+
1;
-
return r;
-
}
-
void avlinsert1(avlnode*&r,int k){
-
if(r==
NULL){r=
new avlnode();r->key=k;}
-
else{
-
if(r->key>k){
-
avlinsert1(r->left,k);
//类似BST
-
-
}
//BST左子树
-
else
if(r->key<k){
-
avlinsert1(r->right,k);
-
-
}
//BST右子树
-
else ++(r->freq);
-
}
-
r->height=max1(get_height(r->left),get_height(r->right))+
1;
-
}
-
void avlcreate(avlnode*&r,int a[],int n){
-
int i;
-
r=
NULL;
-
for(i=
0;i<n;i++)
-
avlinsert(r,a[i]);
-
}
-
int avldelete(avlnode*&root,int k){
-
if(root==
NULL)
return
0;
-
else {
int res;
-
if(k<root->key){
-
res=avldelete(root->left,k);
-
if(res){
-
if(get_height(root->right)-get_height(root->left)==
2)
-
{
if(root->right->left&&get_height(root->right->left)>get_height(root->right->right))
-
doubleright_left(root);
-
else singlerotate_right(root);
-
}
-
}
-
}
//左子树
-
else
if(k>root->key){
-
res=avldelete(root->right,k);
-
if(res){
-
if(get_height(root->left)-get_height(root->right)==
2)
-
{
if(root->left->right&&get_height(root->left->right)>get_height(root->left->left))
-
doubleLeft_right(root);
-
else singlerotate_left(root);
-
}
-
}
-
}
//右子树
-
else{
-
if(root->left&&root->right){
-
if(get_height(root->left)>get_height(root->right))
-
{avlnode*p1=root;avlnode*p=root->left;
-
while(p->right){p1=p;p=p->right;}
-
//选出左子树最大值
-
root->key=p->key;
-
avldelete(root->left,root->key);
//删除左子树最大值
-
}
-
else {
-
avlnode*p1=root;avlnode*p=root->right;
-
while(p->left){p1=p;p=p->left;}
-
//选出右子树最小值
-
root->key=p->key;
-
avldelete(root->right,root->key);
-
}
//选出右子树最小值
-
}
//左右子树非空,看哪边高
-
//这里也可以采用BST写法不是赋值而是节点取代,只不过麻烦一丢
-
else {
-
avlnode*tmp=root;
-
root=(root->left? root->left:root->right);
-
delete tmp;
-
tmp=
NULL;
-
}
//左右子树有一个不为空
-
}
-
}
-
return
1;
-
}
-
void inorder(avlnode*r){
-
if(r){inorder(r->left);
-
cout<<r->key<<
" "<<r->height<<
endl;
-
inorder(r->right);
-
}
-
}
-
void avldis(avlnode*r){
-
inorder(r);
cout<<
endl;
-
}
-
void bfs(avlnode*r){
-
if(r==
NULL)
return;
-
avlnode *q[
100];
-
int front=
-1,rear=
-1;
-
rear++;
-
q[rear]=r;
-
while(front<rear){
-
front++;
-
avlnode*p=q[front];
-
cout<<p->key<<
" ";
-
if(p->left){rear++;q[rear]=p->left;}
-
if(p->right){rear++;q[rear]=p->right;}
-
}
-
}
-
void avlbfs(avlnode*r){
-
bfs(r);
-
cout<<
endl;
-
}
-
-
avlnode* avlsearch(avlnode*r,int k){
-
if(r==
NULL)
return
NULL;
-
else
if(k==r->key)
return r;
-
else
if(k<r->key)
return avlsearch(r->left,k);
-
else
return avlsearch(r->right,k);
-
}
AVL树的测试
首先新建一棵AVL树,然后 依次添加" 3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9 " 到AVL树中;添加完毕之后,再将8 从AVL树中删除。AVL树的添加和删除过程如下图:(01) 添加3,2
添加3,2都不会破坏AVL树的平衡性。
(02) 添加1
添加1之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
(03) 添加4
添加4不会破坏AVL树的平衡性。
(04) 添加5
添加5之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
(05) 添加6
添加6之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
(06) 添加7
添加7之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
(07) 添加16
添加16不会破坏AVL树的平衡性。
(08) 添加15
添加15之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
(09) 添加14
添加14之后,AVL树失去平衡(RL),此时需要对AVL树进行旋转(RL旋转)。旋转过程如下:
(10) 添加13
添加13之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
(11) 添加12
添加12之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
(12) 添加11
添加11之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
(13) 添加10
添加10之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
(14) 添加8
添加8不会破坏AVL树的平衡性。
(15) 添加9
但是添加9之后,AVL树失去平衡(LR),此时需要对AVL树进行旋转(LR旋转)。旋转过程如下:
添加完所有数据之后,得到的AVL树如下:
![](https://i-blog.csdnimg.cn/blog_migrate/03553ccc5e85557e6031f76352393fdc.png)
接着,删除节点8.删除节点8并不会造成AVL树的不平衡,所以不需要旋转,操作示意图如下:
三 红黑树
历史上AVL树流行的另一个版本是红黑树RBT。对红黑树的操作在最坏情况下花费O(log n)时间,而且相对于普通AVL树可能更容易实现。相比较AVL,
1 AVL是严格平衡树,故在增加或者删除节点时,调整所需旋转较多;
2 RBT是平衡与操作复杂性上做了tradeoff,是弱平衡,用非严格的平衡换取增删节点时操作的简单。故当操作主要集中在搜索而非增删时应采用AVL;如果增删操作更多,为了提高可操作性应该选择RBT。其定义:
1 首先是BST,故中序遍历后是非递减序列;
2 弱化的平衡树;
3 不同于BST,AVL,RBT每个节点含有五个域,color/key/left/right/p;
4 根节点一定是黑的(特性2),全空的这种叶子节点也是黑的(特性3),其他每个节点非黑即红(特性1);
5 如果叶子节点是红的,那么两个孩子肯定都是黑的(特性4);
6 对于每一个节点,从该节点到其子孙节点(直到NULL)的所有路径上包含相同数目的黑节点(特性5)
这种着色原则导致RBT高度最多2log(n+1),因此查找肯定是对数操作。通过每条路径上各个节点着色方式的限制,RBT确保没有一条路径会比其他路径长出2倍,因而是一种广泛意义上的平衡。同其他BST一样,问题在于一个新节点的插入,通常做法是将其放在叶子上。如果把它改成黑色,那么肯定违反路径同数目黑色的原则,因此肯定要标为红色:如果它的父节点是黑色,那么插入完成;如果父节点是红色,那么违反父红子黑原则,故需要调整。主要是颜色的改变和旋转。
我们在对红黑树进行插入和删除等操作时,对树做了修改,那么可能会违背红黑树的性质。为了保持红黑树的性质,我们可以通过对树进行旋转,即修改树种某些结点的颜色及指针结构,以达到对红黑树进行插入、删除结点等操作时,红黑树依然能保持它特有的性质.
RBT的旋转:
1 左旋(逆时针旋转)
可以看到类似AVL里的LL型调整,也是逆时针旋转
2 右旋(顺时针旋转)
可以看到类似AVL树里的RR型调整即顺时针旋转。
但是旋转只能保持作为平衡树的性质,而RBT红黑性不能保持,故还需要颜色重涂来保证。总结来看就是两条:1 部分结点颜色,重新着色;2 调整部分指针的指向,即左旋、右旋。
下面将通过图和代码来阐述复杂的插入和删除:
1 RBT的插入
向一棵含有n个结点的红黑树插入一个新结点的操作可以在O(lgn)时间内完成。
插入前:选择的插入节点是红色,按照BST准则找到合适位置;
插入时:
情况1 插入的就是根节点
原树是空树,插入红节点,违背根黑;
对策:需要把节点涂成黑色;
-
void insert_case1(node *n){
-
if(n->parent==
NULL)
-
n->color=BLACK;
//就是根节点没有父节点
-
else
-
insert_case2(n);
-
}
情况2 插入的节点的父节点是黑色
成功插入
-
void insert_case2(node *n){
-
if(n->parent&&n->parent->color==BLACK)
-
return;
-
else insert_case3(n);
-
}
情况3 插入的节点的父节点是红色且叔叔节点是红色
此时祖父节点一定存在,与此同时,又分为父结点是祖父结点的左子还是右子,对于对称性,我们只要解开一个方向就可以,在此,我们只考虑父结点为祖父左子的情况。
对策:将当前节点的父节点和叔叔节点涂黑,祖父结点涂红,把当前结点指向祖父节点,从新的当前节点重新开始算法。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
“当前节点”和“父节点”都是红色,违背“特性(4)”。所以,将“父节点”设置“黑色”以解决这个问题。但是,将“父节点”由“红色”变成“黑色”之后,违背了“特性(5)”:因为,包含“父节点”的分支的黑色节点的总数增加了1。 解决这个问题的办法是:将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”。关于这里,说明几点:第一,为什么“祖父节点”之前是黑色?这个应该很容易想明白,因为在变换操作之前,该树是红黑树,“父节点”是红色,那么“祖父节点”一定是黑色。 第二,为什么将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”;能解决“包含‘父节点’的分支的黑色节点的总数增加了1”的问题。这个道理也很简单。“包含‘父节点’的分支的黑色节点的总数增加了1” 同时也意味着 “包含‘祖父节点’的分支的黑色节点的总数增加了1”,既然这样,我们通过将“祖父节点”由“黑色”变成“红色”以解决“包含‘祖父节点’的分支的黑色节点的总数增加了1”的问题; 但是,这样处理之后又会引起另一个问题“包含‘叔叔’节点的分支的黑色节点的总数减少了1”,现在我们已知“叔叔节点”是“红色”,将“叔叔节点”设为“黑色”就能解决这个问题。 所以,将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”;就解决了该问题。按照上面的步骤处理之后:当前节点、父节点、叔叔节点之间都不会违背红黑树特性,但祖父节点却不一定。若此时,祖父节点是根节点,直接将祖父节点设为“黑色”,那就完全解决这个问题了;若祖父节点不是根节点,那我们需要将“祖父节点”设为“新的当前节点”,接着对“新的当前节点”进行分析。
-
void insert_case3(node *n){
-
if(uncle(n)&&uncle(n)->color==RED)
-
{ n->parent->color=BLACK;
-
uncle(n)=BLACK;
-
grnadpa(n)->color=RED;
-
insert_case1(grandpa(n));}
//把祖父节点当作新节点重新开始
-
else
-
insert_case4(n);
//否则叔叔是黑色节点
-
}
插入4节点变化前后:
情况4 插入的节点的父节点是红色且叔叔节点是黑色或者空NIL,当前节点是父节点右子(父节点仍然是祖父的左孩子)
对策:当前节点的父节点做为新的当前节点,以新当前节点为支点左旋。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
首先,将“父节点”作为“新的当前节点”;接着,以“新的当前节点”为支点进行左旋。 为了便于理解,我们先说明第(02)步,再说明第(01)步;为了便于说明,我们设置“父节点”的代号为F(Father),“当前节点”的代号为S(Son)。为什么要“以F为支点进行左旋”呢?根据已知条件可知:S是F的右孩子。而之前我们说过,我们处理红黑树的核心思想:将红色的节点移到根节点;然后,将根节点设为黑色。既然是“将红色的节点移到根节点”,那就是说要不断的将破坏红黑树特性的红色节点上移(即向根方向移动)。 而S又是一个右孩子,因此,我们可以通过“左旋”来将S上移!按照上面的步骤(以F为支点进行左旋)处理之后:若S变成了根节点,那么直接将其设为“黑色”,就完全解决问题了;若S不是根节点,那我们需要执行步骤(01),即“将F设为‘新的当前节点’”。那为什么不继续以S为新的当前节点继续处理,而需要以F为新的当前节点来进行处理呢?这是因为“左旋”之后,F变成了S的“子节点”,即S变成了F的父节点;而我们处理问题的时候,需要从下至上(由叶到根)方向进行处理;也就是说,必须先解决“孩子”的问题,再解决“父亲”的问题;所以,我们执行步骤(01):将“父节点”作为“新的当前节点”。
-
void insert_case4(node *n){
-
if(n==n->parent->right&&n->parent==grandpa(n)->left)
-
{ rotate_left(n->parent);
-
n=n->left;
//作为新节点
-
}
-
else
if(n==n->parent->left&&n->parent==grandpa(n)->right)
-
{ rotate_right(n->parent);
-
n=n->right;
//作为新节点
-
}
-
insert_case5(n);
-
}
接着上图,7看成新插入的节点:
情况5 当前节点的父节点是红,叔叔是黑或者空NIL,当前节点是父节点的左子(父节点又是祖父的左孩子)
解法:父节点变为黑色,祖父节点变为红色,在祖父节点为支点右旋。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
为了便于说明,我们设置“当前节点”为S(Original Son),“兄弟节点”为B(Brother),“叔叔节点”为U(Uncle),“父节点”为F(Father),祖父节点为G(Grand-Father)。S和F都是红色,违背了红黑树的“特性(4)”,我们可以将F由“红色”变为“黑色”,就解决了“违背‘特性(4)’”的问题;但却引起了其它问题:违背特性(5),因为将F由红色改为黑色之后,所有经过F的分支的黑色节点的个数增加了1。那我们如何解决“所有经过F的分支的黑色节点的个数增加了1”的问题呢? 我们可以通过“将G由黑色变成红色”,同时“以G为支点进行右旋”来解决。
-
void insert_case5(node *n){
-
n->parent->color=BLACK;
-
grandpa(n)->color=RED;
-
if(n==n->parent->left&&n->parent==grandpa(n)->left)
-
rotate_right(grandpa(n));
//顺时针
-
else
-
rotate_left(grandpa(n));/n 是其父节点的右孩子,而父节点P又是其父G的右孩子
-
}
接着上图,相当于新节点为2
2 RBT的删除
下面所有的文字,则是针对红黑树删除结点后,所做的修复红黑树性质的工作:
前面我们将"删除红黑树中的节点"大致分为两步,在第一步中"将红黑树当作一颗二叉查找树,将节点删除"后,可能违反"特性(2)、(4)、(5)"三个特性。第二步需要解决上面的三个问题,进而保持红黑树的全部特性。为了便于分析,我们假设"x包含一个额外的黑色"(x原本的颜色还存在),这样就不会违反"特性(5)"。为什么呢?通过删除算法,我们知道:删除节点y之后,x占据了原来节点y的位置。 既然删除y(y是黑色),意味着减少一个黑色节点;那么,再在该位置上增加一个黑色即可。这样,当我们假设"x包含一个额外的黑色",就正好弥补了"删除y所丢失的黑色节点",也就不会违反"特性(5)"。 因此,假设"x包含一个额外的黑色"(x原本的颜色还存在),这样就不会违反"特性(5)"。现在,x不仅包含它原本的颜色属性,x还包含一个额外的黑色。即x的颜色属性是"红+黑"或"黑+黑",它违反了"特性(1)"。现在,我们面临的问题,由解决"违反了特性(2)、(4)、(5)三个特性"转换成了"解决违反特性(1)、(2)、(4)三个特性"。RB-DELETE-FIXUP需要做的就是通过算法恢复红黑树的特性(1)、(2)、(4)。删除后修正的思想是:将x所包含的额外的黑色不断沿树上移(向根方向移动),直到出现下面的姿态:a) x指向一个"红+黑"节点。此时,将x设为一个"黑"节点即可。b) x指向根。此时,将x设为一个"黑"节点即可。c) 非前面两种姿态。
情况1:当前节点是红色:
解法,直接把当前节点染成黑色,结束。此时红黑树性质全部恢复。
情况2: 当前节点是黑色但也是根节点
-
void delete_case2(node*n){
-
if(n->color==BLACK&&n->parent==
NULL)
-
return;
-
delete_case3(n);
-
}
解法:删除成功,结束
情况3: 当前节点x是黑色且兄弟节点w是红色(则(此时父节点和兄弟节点的子节点分为黑))
解法:把父节点染成红色,把兄弟结点染成黑色,之后重新进入算法(我们只讨论当前节点是其父节点左孩子时的情况)。然后,针对父节点做一次左旋。此变换后把问题转化为兄弟节点为黑色的情况。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
这样做的目的是将“Case 3”转换为“Case 4”、“Case 5”或“Case 6”,从而进行进一步的处理。对x的父节点进行左旋;左旋后,为了保持红黑树特性,就需要在左旋前“将x的兄弟节点设为黑色”,同时“将x的父节点设为红色”;左旋后,由于x的兄弟节点发生了变化,需要更新x的兄弟节点,从而进行后续处理。
-
void delete_case3(node *n){
-
if(w->color==RED)
-
{
-
w->color=BLACK;
-
n->parent->color=RED;
-
rotate_left(n->parent);
//左旋
-
}
-
else
-
delete_case4(n);
-
}
情况4:当前节点是黑色,
解法:把当前节点和兄弟节点中抽取一重黑色追加到父节点上,把父节点当成新的当前节点,重新进入算法。
-
void delete_case4(node *n){
-
if(w->left->color==BLACK&&w->right->color==BLACK){
-
w->color=RED;
-
n=n->parent;
//父节点作为新节点
-
}
-
else delete_case1(n);
//重新进入算法
-
}
情况5:当前节点颜色是黑色,兄弟节点是黑色,兄弟的左子是红色,右子是黑色。
解法:把兄弟结点染红,兄弟左子节点染黑,之后再在兄弟节点为支点解右旋,之后重新进入算法。此是把当前的情况转化为情况6,而性质得以保持。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
我们处理“Case 3”的目的是为了将“Case 5”进行转换,转换成“Case 6”,从而进行进一步的处理。转换的方式是对x的兄弟节点进行右旋;为了保证右旋后,它仍然是红黑树,就需要在右旋前“将x的兄弟节点的左孩子设为黑色”,同时“将x的兄弟节点设为红色”;右旋后,由于x的兄弟节点发生了变化,需要更新x的兄弟节点,从而进行后续处理。
-
void delete_case5(node*n){
-
if(w->left->color==RED&&w->right->color==BLACK){
-
w->left->color=BLACK;
-
w->color=RED;
-
rotate_right(w);
-
w=n->parent->right; }
-
else
-
delete_case6(n);
-
}
情况6:当前节点颜色是黑色,它的兄弟节点是黑色,但是兄弟节点的右子是红色,兄弟节点左子的颜色任意。
解法:把兄弟节点染成当前节点父节点的颜色,把当前节点父节点染成黑色,兄弟节点右子染成黑色,之后以当前节点的父节点为支点进行左旋,此时算法结束,红黑树所有性质调整正确。
下面谈谈为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
我们处理“Case 6”的目的是:去掉x中额外的黑色,将x变成单独的黑色。处理的方式是“:进行颜色修改,然后对x的父节点进行左旋。下面,我们来分析是如何实现的。为了便于说明,我们设置“当前节点”为S(Original Son),“兄弟节点”为B(Brother),“兄弟节点的左孩子”为BLS(Brother's Left Son),“兄弟节点的右孩子”为BRS(Brother's Right Son),“父节点”为F(Father)。我们要对F进行左旋。但在左旋前,我们需要调换F和B的颜色,并设置BRS为黑色。为什么需要这里处理呢?因为左旋后,F和BLS是父子关系,而我们已知BL是红色,如果F是红色,则违背了“特性(4)”;为了解决这一问题,我们将“F设置为黑色”。 但是,F设置为黑色之后,为了保证满足“特性(5)”,即为了保证左旋之后:第一,“同时经过根节点和S的分支的黑色节点个数不变”。若满足“第一”,只需要S丢弃它多余的颜色即可。因为S的颜色是“黑+黑”,而左旋后“同时经过根节点和S的分支的黑色节点个数”增加了1;现在,只需将S由“黑+黑”变成单独的“黑”节点,即可满足“第一”。第二,“同时经过根节点和BLS的分支的黑色节点数不变”。若满足“第二”,只需要将“F的原始颜色”赋值给B即可。之前,我们已经将“F设置为黑色”(即,将B的颜色"黑色",赋值给了F)。至此,我们算是调换了F和B的颜色。第三,“同时经过根节点和BRS的分支的黑色节点数不变”。在“第二”已经满足的情况下,若要满足“第三”,只需要将BRS设置为“黑色”即可。经过,上面的处理之后。红黑树的特性全部得到的满足!接着,我们将x设为根节点,就可以跳出while循环(参考伪代码);即完成了全部处理。至此,我们就完成了Case 6的处理。理解Case 4的核心,是了解如何“去掉当前节点额外的黑色”。
-
void delete_case6(node *n){
-
w->color=n->parent->color;
-
n->parent->color=BLACK;
-
w->right->color=BLACK;
-
rotate_left(n->parent);
-
}
红黑树的插入、删除情况时间复杂度的分析
因为每一个红黑树也是一个特化的二叉查找树,因此红黑树上的只读操作与普通二叉查找树上的只读操作相同。然而,在红黑树上进行插入操作和删除操作会导致不再符合红黑树的性质。恢复红黑树的属性需要少量(O(log n))的颜色变更(实际是非常快速的)和不超过三次树旋转(对于插入操作是两次)。虽然插入和删除很复杂,但操作时间仍可以保持为 O(log n) 次。
四 B-/B+树
由于篇幅有限,再加上B树独有特征,B树相关知识在下一篇介绍。
具体参考:
http://www.cnblogs.com/skywang12345/p/3245399.html#a34