红黑树

最新推荐文章于 2023-01-17 14:54:08 发布

又肥又壮的韭菜

最新推荐文章于 2023-01-17 14:54:08 发布

阅读量152

点赞数

分类专栏：数据结构算法源码

本文链接：https://blog.csdn.net/u013043103/article/details/86716526

版权

算法源码同时被 2 个专栏收录

5 篇文章 1 订阅

订阅专栏

数据结构

2 篇文章 0 订阅

订阅专栏

作为一种数据结构，红黑树可谓不算朴素，因为各种宣传让它过于神秘，网上搜罗了一大堆的关于红黑树的文章，不外乎千篇一律，介绍概念，分析性能，贴上代码，然后给上罪恶的一句话，它最坏情况怎么怎么地...

我们想，一棵二叉树怎么就是最坏情况，那就是它退化为一个链表，这样查找就成了遍历。问题是，平衡二叉树怎么会退回链表！它是怎么保持平衡的？能不能简单地阐述？当然可以！一般的讲述红黑树的资料都是直接给出黑节点相同，红节点不连续等来作为一个足够硬但是又不是太硬的约束来保证树的平衡，但事实上，它还有更加简单的理解方式。

1.查找-在高度不在宽度

对于查找而言，如果一棵二叉树的高度是N，那么最多可以在N步内完成查找，这个不用解释，解释这个有点喧宾夺主了。这就是说，树的高度要尽可能矮。考虑到查找的平均情况，叶子节点到根节点的距离不能差别太大。

2.二叉树的不平衡根源

一棵树在查找看来变得不平衡是因为子树的高度相差很大。
二叉树为什么会这么容易变得不平衡，很简单，因为它只有二叉，左右均有50%的概率，那么插入N个节点全部都是左节点或者右节点的概率就是50%的N次方，如果是8叉树，那么这个概率就是12.5%的N次方，哪个概率大，自己算。

3.多叉树-宽度换高度

在第1节以及第2节，我们已经知道，树的宽度越大，高度越小，这样查询起来越快，Cisco路由器里不是有256叉乃至1024叉树吗？但是这样真的很好吗？对于稀疏节点，这样会严重消耗内存。
如果我们考虑CPU的MMU系统，就会知道，二级页表和三级页表的区别就在于对付稀疏地址空间的效果不同。

4.权衡-2，3树

我们发现，道生一，一生二，二叉树是一个完美的开始，但是我们发现它特别容易倾斜，倾斜的时候别触摸。我们也不能一下子就上256叉树，即使那样在海量节点情况下也抗不住，因此这种盲目宽度换高度的方案没有可扩展性。我们需要找出一种动态的机制，让一棵树动态调整保持平衡。
       为了更加容易找出这个机制，让它更加容易现形，暂时不断增加树的宽度，如果增加到3叉树还找不到方案，就增加到4叉树...我们说的N叉树并不是说一个节点一定有N个子节点，而是说它最多有N个子节点。
       迄今为止，以前都是我自己形而上的观点，几年前我的想法就到此为止，原因在于那段时间特别郁闷，就想找出些技术上的形而上思想，可是突然自己变好了，就没有继续下去。幸运的是，我现在发现确实有这么一个方案，而红黑树就是从3叉树回退过去的。
       让我高兴的是，我的思路并没有跑偏。

5.2-3树的平衡变换

如果是二叉树，那么你插入一个节点，你只有最多1次机会保持子树的高度不变，如果是一个三叉树，那么就有2次机会。现在开始，我们为二叉树添了一叉，变成了三叉树。

二叉树的时候，一个节点有两个分支，三叉树的时候，有三个分支。一个点可以将区间分为两个部分区域，要想将一个区间分为三个部分区域，就需要两个点，因此三叉的情形下，节点存储的是两个点而不是一个，如下图所示：

现在考虑插入一个新节点，这个2-3树怎么保持平衡。非常简单，我们知道，插入的位置一定是叶子，假设当前的树是平衡的，现在分两种情况：

1).插入的新叶子节点的父节点是一个二叉节点

这种情况最简单，二叉节点变三叉节点即可，如下图所示：

2).插入的新叶子节点的父节点是一个三叉节点

这种情况比较复杂。树总是要长高的，保持平衡的方式就是同时长高，而这是不可能的，插入一个节点只能让该节点所在的子树长高。然而，如果能将这个信息上升到根部，在根部长高，就实现了“同时长高”！
还是循着上面的那个思路，我们继续增加树叉的数量，我们把它增加到4！新节点的插入如下图所示：

很遗憾，没有完成任务，但是最终我们提出了两个问题，只要解决了这两个问题，所有问题就解决了。

解决这两个问题，无疑都要牵扯到节点P的父节点以及再往上的节点，有两种可能：
可能性1：P的父节点PP是一个二叉节点
这个太爽，我们直接把P以及它的子树全部提到PP节点即可，类似B插入的情景，如下图所示：

问题2解决。

可能性2：P的父节点PP是一个三叉节点
这就有点不好办了，不过有最后一击！不管怎样先把P节点以及其子节点全部上提到PP，保持最底部的平衡性，这样就可以递归解决了，此时我们又一次遇到了往一个三叉节点里面插入子节点的问题了，为了不增加树高，唯一的方式就是膨胀成一个四叉节点-宽度换高度。如下图所示：

最后，我们发现，在递归的过程中，要么碰到了P..P是个二叉节点，此时按照问题2的解决方式将当前节点的值直接提到P...P中，其子树降低一个高度，抵消增加的高度，平衡保持，递归结束，要么递归到了根节点，此时只需要一个分裂操作即可完美结束！

6.演进到红黑树

很显然，通过上面的描述，我们似乎找到了一个使树保持平衡的方案，而且是相当完美的平衡！核心就是宽度和高度之间的博弈。我们总是可以用一个宽度抵消一层高度，整个过程就是一次或者多次的一加一减，最终的结果还是0！
然而，这也不再是二叉树了，有的节点变成了三叉，并且保存了两个值，该两个值将区间分割成了三部分，是为三叉！因此在使用上就不如二叉树方便，比较操作复杂化了。事实上，将三叉节点处理成二叉节点，这棵树就成了红黑树！怎么处理呢？很简单！如下图所示：

看到了吧，红色节点就是从2-3树中分出来的，为了维持一棵二叉树而不是2-3树，必须将三叉节点变成二叉节点，这是一个宽度换高度得回退，即高度换宽度，当然代价就是不再完美平衡。

       按照以上的这个变换，你自己试试看，可以变出两个连续的红节点吗？NO！还在纠结红黑树的性质概念吗？看了它的演进，你会发现，很多红黑树的复杂概念和让人没有头绪的性能都是自然而然的。下面我们来看一下它的最坏情况是什么。
       还是以2-3树分析，如果在一棵2-3树中，最左边路径上的节点全部是三叉节点，而最右边路径上的节点都是二叉节点，那么把它变换成二叉红黑树之后，就会发现最左边的路径上是红黑间隔的节点，而最右边的路径上全部是黑节点，它们的高度差接近2倍。出现这样的情况是令人悲哀的，但是也是极低概率的。
       红黑树的所有包括旋转等操作，都可以映射到2-3树中，而我们对2-3树以及高度和宽度之间的博弈已经足够理解了。请再次去理解红黑树吧，再看看它的性质和概念，together with左旋和右旋，是不是有一种新的体会呢？

红黑树C语言实现：

#include<iostream>
#include<time.h>
using namespace std;
typedef int KEY;
#define N 15
enum NODECOLOR
{
BLACK = 0,
RED = 1
};
typedef struct RBTree
{
struct RBTree *parent;
struct RBTree *leftChild, *rightChild;
KEY key;
NODECOLOR color;
}RBTree, *PRBTree;
PRBTree ROOT;//根节点是ROOT
void Mid_Visit(PRBTree &T);
void LeftRotate(PRBTree &subroot)
{
//cout<<" left rotate "<<endl;
PRBTree grandParent,parent,leftChild;//,rightChild;
grandParent=NULL;parent=NULL;leftChild=NULL;
if(subroot!=ROOT&&subroot!=NULL)parent=subroot->parent;//根节点是ROOT,
if(parent!=ROOT&&parent!=NULL)grandParent=parent->parent;
if(subroot->leftChild!=NULL)leftChild=subroot->leftChild;//如果subroot不为空，两个孩子都不为空，至多有虚拟节点，同样参与装换
//if(subroot->rightChild!=NULL)rightChild=subroot->rightChild;
if(grandParent!=NULL)
{
if(grandParent->leftChild->key==parent->key)grandParent->leftChild=subroot;//1
else grandParent->rightChild=subroot;//grandparent不空，一定有左孩子，或右孩子并且至少有一个不是虚拟节点
/*if(grandParent->leftChild!=NULL&&grandParent->leftChild->key==parent->key)grandParent->leftChild=subroot;//1
else if(grandParent->rightChild->key==parent->key)grandParent->rightChild=subroot;//有问题 if语句不成立条件*/
}
else//if grandparent is null, then quadain parent is ROOT ,after left rotate, subroot becomes ROOT
{ // if quadain parent is root then change cannot happened for its color is balck.so this sentence will never be executed
//此判断不对，当进行一次有旋转后，在进行的左旋转就针对当前节点没有grandparent，而只有parent，而此时grandparent初始化为空了
ROOT=subroot;subroot->parent=NULL;subroot->color=BLACK;//cout<<" try judgement "<<endl;
}
//if(grandParent->leftChild!=NULL&&grandParent->leftChild->key==parent->key)grandParent->leftChild=subroot;//1
//else if(grandParent->rightChild->key==parent->key)grandParent->rightChild=subroot;//有问题 if语句不成立条件
subroot->parent=grandParent;//2 grandparent可为空
parent->rightChild=leftChild;//1
if(leftChild!=NULL)leftChild->parent=parent;//2
parent->parent=subroot;//1
subroot->leftChild=parent;//2
//变颜色
//parent->color=RED;
//subroot->color=BLACK;
}
void RightRotate(PRBTree &subroot)
{
//cout<<" right rotate "<<endl;
PRBTree grandParent,parent,rightChild;//leftChild;,
grandParent=NULL;parent=NULL;rightChild=NULL;
if(subroot!=ROOT&&subroot!=NULL)parent=subroot->parent;//根节点是ROOT,
if(parent!=ROOT&&parent!=NULL)grandParent=parent->parent;
if(subroot->rightChild!=NULL)rightChild=subroot->rightChild;
//if(subroot->rightChild!=NULL)rightChild=subroot->rightChild;
if(grandParent!=NULL)
{
if(grandParent->leftChild!=NULL&&grandParent->leftChild->key==parent->key)grandParent->leftChild=subroot;//1
else if(grandParent->rightChild->key==parent->key)grandParent->rightChild=subroot;//有问题 if语句不成立条件
}
else//if grandparent is null, then quadain parent is ROOT ,after right rotate, subroot baecomes ROOT
{
ROOT=subroot;subroot->parent=NULL;subroot->color=BLACK;
}
subroot->parent=grandParent;//2
parent->leftChild=rightChild;//1
if(rightChild!=NULL)rightChild->parent=parent;//2
parent->parent=subroot;//1
subroot->rightChild=parent;//2
//变颜色
//parent->color=RED;
//subroot->color=BLACK;
}
int check(PRBTree subroot)//subroot is new added node三个节点相连有四种情况.1.2.3.4，四个节点也有四种情况5，每种和三个节点有对应关系
{
PRBTree parent,grandparent;
parent=NULL;grandparent=NULL;//指针都要初始化
if(subroot!=NULL&&subroot->parent!=NULL)parent=subroot->parent;
//cout<<" in test 12 "<<endl;
if(parent!=NULL&&parent->parent!=NULL)grandparent=parent->parent;
//cout<<" in test 13 "<<endl;
if(parent!=NULL&&parent->color==BLACK)return 0;//不用变换
else
{
//cout<<" in test 14 "<<endl;
if(grandparent!=NULL)//grandparent不为空，则两个孩子也不为空
{
if(grandparent->leftChild->key!=0&&grandparent->leftChild->key==parent->key)
{
//cout<<" in test 15 "<<endl;
if(grandparent->rightChild->key!=0&&grandparent->rightChild->color==RED)//属于四个节点情况，四种情况一样处理，返回5
{
//只有右节点不是虚拟节点时上面判断才有意义
return 5;
//cout<<" in test 16 "<<endl;
}
else//属于三个节点情况
{
//cout<<" in test 17 "<<endl;
if(parent->leftChild==subroot)//parent肯定不是虚拟节点，
return 1;
else return 2;
}
}
else
{
//cout<<" in test 18 "<<endl;
if(grandparent->leftChild->key!=0&&grandparent->leftChild->color==RED)//属于四个节点情况，四种情况一样处理，返回5
{
return 5;
}
else//属于三个节点情况
{
//cout<<" in test 19 "<<endl;
if(parent->leftChild==subroot)
return 4;
else return 3;
}
}
}
else return 0;//当前只有两个节点
}
}
PRBTree find_insertPos(PRBTree &root,KEY key)//寻找插入位置，二分查找
{
PRBTree p,q;
p=root;q=p;
while(q->key!=0)//判断是否虚拟节点
{
if(p->key>key)
{
q=p->leftChild;
if(q->key!=0)p=q;
}
else
{
q=p->rightChild;
if(q->key!=0)p=q;
}
}
return p;
}
void rotate(PRBTree &subroot)//针对新插入的节点
{
//cout<<" in rotate "<<endl;
PRBTree parent,grandparent;
parent=NULL;grandparent=NULL;
if(subroot!=NULL&&subroot->parent!=NULL)parent=subroot->parent;
//cout<<" in test 10 "<<endl;
if(parent!=NULL&&parent->parent!=NULL)grandparent=parent->parent;
//cout<<" in test 11 "<<endl;
switch(check(subroot))
{
//cout<<" in check "<<endl;
case 5://有四种情况
//cout<<" test check 5 "<<endl;
if(grandparent!=ROOT)grandparent->color=RED;
else grandparent->color=BLACK;
grandparent->leftChild->color=BLACK;
grandparent->rightChild->color=BLACK;
//check(grandparent);
//if(grandparent-parent!=NULL)
rotate(grandparent);//如果返回0，什么也不做
break;
case 1:
//cout<<" test check 1 "<<endl;
RightRotate(parent);
parent->color=BLACK;
//grandparent->color=RED;
if(grandparent!=ROOT)grandparent->color=RED;
else grandparent->color=BLACK;
//subroot->color=BLACK;
break;
case 2:
//cout<<" test check 2 "<<endl;
LeftRotate(subroot);
//cout<<"after leftrotate "<<endl;
//Mid_Visit(ROOT);//ROOT为根节点
RightRotate(subroot);
//cout<<"test whether rightrotate "<<endl;
subroot->color=BLACK;
//if(grandparent!=ROOT)grandparent->color=RED;
if(grandparent!=ROOT)grandparent->color=RED;
else grandparent->color=BLACK;
break;
case 3:
//cout<<" test check 3 "<<endl;
LeftRotate(parent);
parent->color=BLACK;
//grandparent->color=RED;
if(grandparent!=ROOT)grandparent->color=RED;
else grandparent->color=BLACK;
break;
case 4:
//cout<<" test check 4 "<<endl;
RightRotate(subroot);
//LeftRotate(parent);//此时parent是subroot的右孩子
LeftRotate(subroot);
subroot->color=BLACK;
if(grandparent!=ROOT)grandparent->color=RED;
break;
case 0:
//cout<<" test check 0 "<<endl;
;
}
}
void insert(PRBTree &root,KEY key)
{
PRBTree p,q,news,vir1,vir2;
p=NULL;q=NULL;news=NULL;
if(root==NULL)
{
news=(PRBTree)new RBTree;//1，新建当前节点
news->leftChild=NULL;
news->rightChild=NULL;
news->parent=NULL;//根节点无父节点
news->color=BLACK;//根节点为黑色节点
news->key=key;
root=news;//root返回的也是根
ROOT=news;
// 新建2个虚拟节点vir1,vir2，颜色为黑，值为0；
vir1=(PRBTree)new RBTree;
vir1->leftChild=NULL;
vir1->rightChild=NULL;
vir1->parent=news;
vir1->color=BLACK;
vir1->key=0;
vir2=(PRBTree)new RBTree;
vir2->leftChild=NULL;
vir2->rightChild=NULL;
vir2->parent=news;
vir2->color=BLACK;
vir2->key=0;
news->leftChild=vir1;
news->rightChild=vir2;
}
else
{
p=find_insertPos(root,key);
//if(p!=NULL)cout<<" insert position "<<p->key<<endl;
if(p->key>key)//在p左边插入，不用新开辟节点，用虚拟节点即可
{
news=p->leftChild;
news->color=RED;
news->key=key;
//cout<<" test left insert "<<endl;
}
else
{
news=p->rightChild;
news->color=RED;
news->key=key;
//cout<<" test right insert "<<endl;
}
// 在news下面新建2个虚拟节点vir1,vir2，颜色为黑，值为0；
vir1=(PRBTree)new RBTree;
vir1->leftChild=NULL;
vir1->rightChild=NULL;
vir1->parent=news;
vir1->color=BLACK;
vir1->key=0;
vir2=(PRBTree)new RBTree;
vir2->leftChild=NULL;
vir2->rightChild=NULL;
vir2->parent=news;
vir2->color=BLACK;
vir2->key=0;
news->leftChild=vir1;
news->rightChild=vir2;
rotate(news);
}
}
PRBTree find_succesor(PRBTree &subroot)//首先应调用find_insertpos()找删除位置，没找到返回错误
//即subroot是找到的当前删除点，找subroot的后继,不是所有删除点都要找后继，找后继应从当前节点右子树开始，如果有的话,后继是其右子树的最左的节点
{//肯定有后继，
PRBTree p,q;
p=q=NULL;
q=subroot->rightChild;
while(q->key!=0){p=q;q=q->leftChild;}
return p;
}
void adjust(PRBTree &root,PRBTree &subroot)
{
PRBTree adjx,parent,grandparent,brother,brother_left,brother_right;
//int bicolor=1;//bicolor 用于记录调整节点是否双色，刚开始为双色
adjx=parent=grandparent=brother=brother_left=brother_right=NULL;
adjx=subroot;//adjx标记当前双重色节点，当其为红时，推出循环
//当前节点不是根节点，肯定有双亲
//if(parent->parent!=NULL)grandparent=parent->parent;//?不用考虑grandparent，做旋转的时候自动处理
//else ROOT=parent;//双寝室根节点
while(adjx!=ROOT&&adjx!=NULL&&adjx->color==BLACK)//红色节点直接变黑
{
parent=adjx->parent;
if(parent->leftChild==adjx)//调整节点位于双亲左边
{
if(parent->rightChild->key!=0)brother=parent->rightChild;
brother_left=brother->leftChild;//brother—left可以是虚拟节点
brother_right=brother->rightChild;
if(brother->color==RED)//第一种情况 before brother is red, so parent is black
{
parent->color=RED;//1-parent->color;
brother->color=BLACK;//1-brother->color;
LeftRotate(brother);
}
else
{
if(brother_right->color==BLACK)
{
if(brother_left->color==BLACK)//第二种情况
{
brother->color=RED;//brother原来是黑色，去掉一层色后应该变红
adjx->color=BLACK;
adjx=parent;//父节点可红或黑，若红则退出，若黑则继续循环，直至根节点
//adjust(parent);不用递归
}
else //情况三变情况四
{
brother->color=RED;//1-brother->color;//brother原来是黑，左孩子原来是红
brother_left->color=BLACK;//1-brother_left->color;
RightRotate(brother_left);
}
}
else //if(brother_right->color==RED) //情况四可结束
{
brother->color=parent->color;
parent->color=BLACK;
brother_right->color=BLACK;
LeftRotate(brother);//对应算法导论以parent为支点
adjx=NULL;
}
}
}
else//调整节点位于双亲右边
{
if(parent->leftChild->key!=0)brother=parent->leftChild;
brother_left=brother->leftChild;//brother—left可以是虚拟节点
brother_right=brother->rightChild;
if(brother->color==RED)//第一种情况
{
parent->color=RED;//1-parent->color;
brother->color=BLACK;//1-brother->color
RightRotate(brother);
}
else
{
if(brother_left->color==BLACK)
{
if(brother_right->color==BLACK)//第二种情况
{
brother->color=RED;
adjx->color=BLACK;
adjx=parent;//父节点可红或黑，若红则退出，若黑则继续循环，直至根节点
//adjust(parent);不用递归
}
else //情况三变情况四
{
brother->color=RED;//;//brother原来是黑，右孩子原来是红
brother_right->color=BLACK;//
LeftRotate(brother_right);
}
}
else //if(brother_right->color==RED) //情况四可结束
{
brother->color=parent->color;
parent->color=BLACK;
brother_left->color=BLACK;
RightRotate(brother);
adjx=NULL;
}
}
}
}//while
if(adjx!=NULL)adjx->color=BLACK;//根或颜色是红都执行
}
PRBTree find_deletePos(PRBTree &root,KEY key)
{
PRBTree p;
p=root;//q=p;
while(p->key!=0)//判断是否虚拟节点
{
if(p->key==key) return p;
else
{
if(p->key>key)p=p->leftChild;
else p=p->rightChild;
}
}
if(p->key==0) return NULL;//未找到删除节点
}
void delete_rbt(PRBTree &root,KEY key)
{
PRBTree pos,suc,adj,suc_child,suc_del_child,suc_parent;
pos=suc=adj=suc_child=suc_del_child=suc_parent=NULL;
pos=find_deletePos(root,key);//pos 是要删除的节点位置,不能用寻找插入的函数
if(pos==NULL)cout<<" no such element "<<endl;
else
{
if(pos->leftChild->key==0||pos->rightChild->key==0)
suc=pos;//此时不用找后继,pos就是直接删除的节点,为方便都用suc表示
else {
suc=find_succesor(pos);
pos->key=suc->key;//后继是要删除的节点，用后继值覆盖pos
}
//接下来要删除suc，adj是用来调整的，suc最多只有一个孩子，且只能右孩子为虚拟节点，不对，因为suc可以等于pos，pos可以有左节点，不管怎样最多只有一个节点
if(suc->leftChild->key!=0){suc_child=suc->leftChild;suc_del_child=suc->rightChild;}//左孩子为保留节点，有孩子为删除节点
else{
suc_del_child=suc->leftChild;//让左孩子为要删除的虚拟节点
//if(suc->rightChild->key!=0)
suc_child=suc->rightChild;//不管空不空，右孩子都为保留节点，注意右孩子可以是虚拟节点
//else {suc_child=suc->rightChild;}
}
if(suc->parent!=NULL)
{
suc_parent=suc->parent;
if(suc->color==RED)//如果suc是红色节点不需要调整
{
if(suc_parent->leftChild==suc)suc_parent->leftChild=suc_child;
else suc_parent->rightChild=suc_child;
suc_child->parent=suc_parent;
delete suc_del_child;
delete suc;
}
else
{
if(suc_parent->leftChild==suc)suc_parent->leftChild=suc_child;
else suc_parent->rightChild=suc_child;
suc_child->parent=suc_parent;
delete suc_del_child;
delete suc;
adjust(root,suc_child);//对保留的节点进行调整
}
}
else //suc是当前根节点，其双亲为空，删除后保留节点为新的根节点
{
ROOT=suc_child;
suc_child->parent=NULL;
if(suc->color==RED)//如果suc是红色节点不需要调整
{
delete suc_del_child;
delete suc;
}
else
{
delete suc_del_child;
delete suc;
adjust(root,suc_child);//对保留的节点进行调整
}
}
}
}
void Mid_Visit(PRBTree &T)
{
if(T->key==0)cout<<" tree is empty "<<endl;//都删除之后 T应是一个虚拟节点
if (0 != T->key)
{
if (0 != T->leftChild->key)
{
if (T->leftChild->key > T->key)
{
printf("wrong!\n");
exit(-1);
}
Mid_Visit(T->leftChild);
}
cout<<T->key<<" ";
cout<<" color is "<<T->color;
if(T->leftChild)cout<<" T->leftChild is "<<T->leftChild->key;
if(T->rightChild)cout<<" T->rightChild is "<<T->rightChild->key;
if(T->parent)cout<<" T->parent is "<<T->parent->key;
if(T==ROOT)cout<<endl<<" current root is "<<T->key<<endl;
cout<<endl;
if (0 != T->rightChild->key)
{
if (T->rightChild->key < T->key)
{
printf("wrong\n");
exit(-1);
}
Mid_Visit(T->rightChild);
}
}
cout<<endl;
}
//要通过遍历树来找所有的虚拟节点，递归遍历无法记录虚拟节点的黑色高度（除了用全局静态数组），故要用树的非递归遍历
int judge_rbt(PRBTree b){
PRBTree stack[100], p,q;
int top=0,height1,height2=0;
p=b;
do{
while (p!=NULL)
{ //扫描所有左结点
top++;
stack[top]=p;
p=p->leftChild;
}
if (top>0)
{
p=stack[top];
top--;
//printf("%c",p->data); //访问结点,有虚拟节点，情况不一样
if(p->key==0)//计算虚拟节点黑色高度
{
height1=0;
q=p->parent;
while(q!=NULL)
{
if(q->color==BLACK)height1++;
q=q->parent;
}
}
if(height2==0)height2=height1;//初始情况，只执行一次
if(height2!=height1)return 0;//当有节点高度和先前的不一样，证明不是红黑树
p=p->rightChild; //扫描右子树
}
} while(p!=NULL || top!=0);
return 1;//
}
int main(int argc, char *argv[])
{
srand(time(NULL));
//PRBTree root = NULL;
int i,arr[N],brr[N],flag,k;
for (i = 0; i < N; i++)
{
arr[i]=rand() % 100;//arr中可能有重复元素
if(arr[i]==0)i=0;//如果产生0元素，重新产生，只有虚拟节点放0元素
}
for (i = 0,k=0;i < N; i++)//除去重复元素
{
flag=0;
for(int j=0;j<k;j++)
if(brr[j]==arr[i])flag=1;//表示当前brr[]有重复元
if(flag==0){brr[k]=arr[i];k++;}//
}
cout<<"insert order as follow: "<<endl;
for(int j=0;j<k;j++)
cout<<brr[j]<<" ";
cout<<endl;
for(j=0;j<k;j++)
{
insert(ROOT, brr[j]);
cout<<"after insert judge whether is brt 1 means yes, 0 means no : "<<judge_rbt(ROOT)<<endl;
}
Mid_Visit(ROOT);
for(j=0;j<k;j++)
{
cout<<"after delete "<<brr[j]<<endl;
delete_rbt(ROOT,arr[j]);
cout<<"after delete judge whether is brt 1 means yes, 0 means no : "<<judge_rbt(ROOT)<<endl;
Mid_Visit(ROOT);
}
/*//insert(ROOT,15);
insert(ROOT,23);
insert(ROOT,10);
//insert(ROOT,18);
Mid_Visit(ROOT);
delete_rbt(ROOT,10);
cout<<"after delete 1 "<<endl;
Mid_Visit(ROOT);
cout<<" test "<<endl;
delete_rbt(ROOT,23);
cout<<"after delete 2 "<<endl;
Mid_Visit(ROOT);*/
return 0;
}

又肥又壮的韭菜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
红黑树

作为一种数据结构，红黑树可谓不算朴素，因为各种宣传让它过于神秘，网上搜罗了一大堆的关于红黑树的文章，不外乎千篇一律，介绍概念，分析性能，贴上代码，然后给上罪恶的一句话，它最坏情况怎么怎么地... 我们想，一棵二叉树怎么就是最坏情况，那就是它退化为一个链表，这样查找就成了遍历。问题是，平衡二叉树怎么会退回链表！它是怎么保持平衡的？能不能简单地阐述？当然可以！一般的讲述...
复制链接

扫一扫

专栏目录