BST二叉搜索树、BBST :AVL树、伸展树、红黑树、b树、kd-树

4.1 二叉搜索树

BinNode* search (const T &e , BinNode* _hot, BinNode* x){
    while(true){
        if(!x) {return x;}
        else if(edata){
            _hot=x;
            x=x->lc;
        }
        else if(e>x->data){
            _hot=x;
            x=x->rc;
        }
        else if(e==x->data){
            return x;
        }
    }
}
BinNode* search(const T &e){
    return search(e, _root,_hot);
}

BinNode * insert(const T &e){
    BinNode* x=search(e);
    if(x) return x;//duplicated
    x= new BinNode*(e,_hot);
    _size++;
    updateHeightAbove(x);
    return x;
}

BinNode * remove(const T &e){
    BinNode * x=search(e);
    BinNode* succ;
    if(!x) return false;
    if(!x->rc){
        succ=x=x->lc
    }
    else if((!x->lc)){
        succ=x=x->rc;
    }
    else{
        BinNode w=x;
        w=w.succ();
        swap(x->data,w->data);
        BinNode *u =w->parent;
        ((u==x)?u->rc:u->lc)=succ=w->rc;//w only has rc
    }
    _hot=w->parent;//father of deleted elem;
    if(succ) succ->parent =_hot;
    delete w->data;
    delete ->w;
    _size--;
    updateHeightAbove(_hot);
    return succ;
}

4.2 控制树高 ,制造平衡二叉搜索树

zig右旋
zag左旋
不改变中序遍历顺序,
通过增加局部限制,保证平衡性,红黑树通过根节点到叶子节点黑节点数相同来保证。AVL树通过兄弟节点高度差不大于1来保证。
保证了单次动态修改后最多只有logn 出失去平衡,在logn时间内改回来。

4.2 AVL树

控制平衡因子<2保证(左右子树高度差)

Balanced (x){return stature(x->lc)==stature(x->rc);}//ideal
BalFac(x){ return stature(x->lc)-stature(x->rc);}
AVLBal(x){return (-2

remove(x)后仅单个节点失衡,insert后多个节点失衡
失衡节点集中UT(x),高度不低于x的祖父,从x向上搜索,首个失衡节点即为

既然g(x)由于x引入而失衡,所以g(x)的孩子p, p的孩子v都没有失衡,可由g(x)找到p和v

tallerChild(x) {stature(x->lc)>stature(x->rc)?(x->lc):(
    stature(x->lc)rc)?x->rc:(
        IsLChild(*(x))?x->lc:x->rc;//与父亲同侧者 zig/zag
    )
)
}

p、v在一侧,采取单旋手段
单旋 g(x)插入右子树边高,zag(g(x))
g(x)插入左边子树高, zig(g(x)) 可调整平衡

双旋g(x)p v
左右,zag(p),zig(g)
右左,zig(p),zag(g)

insert(const T& e){
    BinNode* x=search(e);
    if(x) return x;
    BinNode* xx= x =new BinNode(e, _hot); _size++;
    //_hot增高,_hot的父亲有可能失衡
    for (BinNode *g=_hot;g;g=g->parent){//从x之父向上搜索
       if(!AVLBalanced(g)){//即找到g(x)//第一个失衡的祖先
           //从g往下找两次较高孩子,若同样高,取与父亲同侧(单旋)
           //g->parent->self
           FromParentTo(*g)=rotateAt(tallerChild(tallerChild(g)));//采用3+4算法,使其恢复平衡
           break;
       }
       else{
           updateHeight(g);//g不失衡,高度也可能增加//插入调整局部,更新高度避免每次全局调整
       }
    }
    return xx;//返回新节点
}

与插入操作不同,删除后,失衡节点仅一个g(x),其高度与失衡前相同,g(x)有可能是x父亲
沿着parent指针上行,可找到g(x),g(x)另一侧必有非空孩子p,-取p较高孩子为v(相同取同侧)//同侧调一次,不同侧调两次

  • 单旋
    设g(x)平衡因子为2(左侧高(-2对称)) fac(p)非负时,即同侧,调整g即可使得g恢复平衡


    image.png
  • 双旋
    fac(p)为负时,即不同侧,需要先调整p,再调整g(双旋)
    g调整完成后,g的高度有可能降低,导致祖先失衡(当g为高祖先的短分枝时)称为失衡传播,可沿着parent继续向前,重复调整


    image.png

    在此过程中的任一时刻, 至多只有一个失衡的节点;高层的某一节点由平衡转为失衡,只可能发生在下层失衡节点恢复平 衡之后。因此,可沿parent指针逐层遍历所有祖先,每找到一个失衡的祖先节点,即可套用以 上方法使之恢复平衡

remove(const T& e){
    BinNode* x=search(e); if(!e) return false;
    removeAt(x,_hot); _size--;//依然是二叉搜索树
    for(BinNode* g=_hot;g;g=g->parent){
        if(!AVLBalanced(*g)){
            g=FromParentTo(g)=rotateAt(tallerChild(tallerChild(g)));
        }
        updateHeight(g);
    }
    return true;
}

统一平衡算法:
根据失衡节点调整其左右孩子位置关系,分别做单选和双旋操作,代码量大而复杂。将导致调试困难。
可将失衡节点子树统一划分为四个子树T0、T1、T2、T3
重新排列后中序遍历结果应该是T0 a T1 b T2 c T3,四颗子树彼此高度差不超过一层//实际上覆盖了单旋和双旋大所有情况。
重构过程仅涉及3个节点和4颗树。故称为3+4重构connnect34


image.png
connnect34(BinNode* a, BinNode *b, BinNode *c, BinNode *T1, BinNode * T2, BinNode* T3, BinNode* T4){
    a->lc=T0;
    if(T0) T0->parent=a;
    a->rc=T1;
    if(T1) T1->parent=a;
    updateHeight(a);
    c->lc=T2;
    if(T2) T2->parent=c;
    c->rc=T3;
    if(T3) T3->parent=c;
    updateHeight(c);
    b->lc=a;
    a->parent=b;
    b->rc=c;
    c->parent=b;
    update(b);
    return b;
}

旋转变换统一算法

rotateAt(BinNode *v){
BinNode* p=v->parent; BinNode *g=p->parent;
if(IsLChild(*p)){//zig (zig(g))
    if(IsLChild(*v)){//zig-zig
        p->parent=g->parent;
        return connect34(v,p,g,v->lc,v->rc,p->rc,g->rc);
    }
    else{//zig-zag   (zag(p))
    v->parent=g->parent;
    return connect(p,v,g,p->lc,v->lc,v->rc,g->rc);
    }
}
else{//zag
    if(IsRChild(*v)){//zag-zag
        p->parent=g->parent;
        connect34(g,p,v,g->lc,p->lc,v->lc,v->rc);
    }
    else{//zag-zig
        v->parent=g->parent;
        connect34(g,v,p,g->lc,v->lc,v->rc,p->rc);
    }
}

}

4.2伸展树 Splay

无需维护树高、平衡因子,不需要严格保证平衡状态。分摊效率高
按照最常用优先,引入伸展树
根据数据局部性1.被访问过的节点更容易被访问 2.下一个被访问节点在上一个周围
只需将访问完成节点调整到根附近,保证前后等价即可。加快访问速度

一种直接的方法:访问一个节点后,以他的父亲节点为中心旋转,直到成为树根
无论查找或插 入,甚至“删除”都可通过3次旋转,将该树等价变换为以E为根的另一棵二叉搜索树。


image.png
  • 最坏情况
    不难验证,若从空树开始依次插入关键码{ 1, 2, 3, 4, 5 },且其间采用如上调整策略,
    则可得到如图8.2(a)所示的二叉搜索树。接下来,若通过search()接口,再由小到大地依次访 问各节点一次,则该树在各次访问之后的结构形态将如图(b~f)所示。


    image.png

    随着节点E的逐层上升,两侧子树的结构也不断地调整,故这一过程也称作伸展(splaying), 而采用这一调整策略的二叉搜索树也因此得名。不过,为实现真正意义上的伸展树,还须对以上 策略做点微妙而本质的改进。之所以必须改进,是因为目前的策略仍存在致命的缺陷--对于很多访问序列,单次访问的分摊时间复杂度在极端情况下可能高达o(n)。

一般地,若节点总数为n,则旋转操作的总次数应为:

如此分摊下来,每次访问平均需要O(n)时间。很遗憾,这一效率不仅远远低于AVL树,而且甚至 与原始的二叉搜索树的最坏情况相当。而事实上,问题还远不止于此。

对于规模为任意n的伸展树, 只要按关键码单调的次序,周期性地反复进行查找,则无论总的访问次数m >> n有多大,就分 摊意义而言,每次访问都将需要O(n)时间!
那么,这类最坏的访问序列能否回避?具体地,又应该如何回避?

双层伸展:

为克服上述伸展调整策略的缺陷,一种简便且有效的方法就是:将逐层伸展改为双层伸展。 具体地,每次都从当前节点v向上追溯两层(而不是仅一层),并根据其父亲p以及祖父g的相对 位置,进行相应的旋转。以下分三类情况,分别介绍具体的处理方法。

  • zig-zig(zag-zag)
    针对这种情况,首先以节点g为轴做顺时针旋转zig(g),其效果如图(b)所示。然后,再以p
    为轴做顺时针旋转zig(p),其效果如图(c)所示。如此连续的两次zig旋转,合称zig-zig调整


    image.png
  • zig-zag(zag-zig)
    针对这种情况,首先以节点p为轴做顺时针旋转zig(p),其效果如(b)所示。然后,再以g
    为轴做逆时针旋转zag(g),其效果如图(c)所示。如此zig旋转再加zag旋转,合称zig-zag调整。同样地,另一完全对称的情形--v是p的右孩子,而p是g的左孩子则可通过zag旋转再
    加zig旋转实现调整,合称zag-zig操作


    image.png

    -zig/zag
    若v最初的深度为奇数,则经 过若干次双层调整至最后一次调整时,v的父亲p即是 树根r。将v的左、右子树记作X和Y,节点p = r的另 一子树记作Z。


    image.png
  • 效果与效率
    综合以上各种情况,每经过一次双层调整操作,节点v都会上升两层。若v的初始深度depth(v)为偶数,则最终v将上升至树根。若depth(v)为奇数,则当v上升至深度为1时,不妨最后再相应 地做一次zig或zag单旋操作。无论如何,经过depth(v)次旋转后,v最终总能成为树根。

重新审视图8.2的最坏实例不难发现,这一访问序列导致(n)平均单次访问时间的原因, 可以解释为:在这一可持续重复的过程中,二叉搜索树的高度始终不小于n/2;而且,至少有 一半的节点在接受访问时,不仅没有如最初设想的那样靠近树根,而且反过来恰恰处于最底层。 从树高的角度看,问题根源也可再进一步地解释为:在持续访问的过程中,树高依算术级数逐步 从n - 1递减至n/2,然后再逐步递增回到n - 1

  • 效果
    稍作对比不难看出,就调整之后的局部结构而言,zig-zag和zag-zig调整与此前的逐层伸 展完全一致(亦等效于AVL树的双旋调整),而zig-zig和zag-zag调整则有所不同。事实上, 后者才是双层伸展策略优于逐层伸展策略的关键所在。以如图8.6(b)所示的二叉搜索树为例, 在find(1)操作之后采用逐层调整策略与双层调整策略的效果,分别如图(a)和图(c)所示。


    image.png

    可见,最深节点(1)被访问之后再经过双层调整,不仅同样可将该节点伸展至树根,而且 同时可使树的高度接近于减半。就树的形态而言,双层伸展策略可“智能”地“折叠”被访问的 子树分支,从而有效地避免对长分支的连续访问

这就意味着,即便节点v的深度为O(n),双层 伸展策略既可将v推至树根,亦可令对应分支的长度以几何级数(大致折半)的速度收缩。

image.png

一旦这类“坏”节点 被“碰触”到,经过随后的双层伸展,其对应的分支都会收缩至长度大致折半。于是,即便每次 都“恶意地”试图访问最底层节点,最坏情况也不会持续发生

在改用“双 层伸展”策略之后,伸展树的单次操作均可在分摊的O(logn)时间内完成

#include "../BST/BST.h" //基亍BST实现Splay
template  class Splay : public BST { //由BST派生癿Splay树模板类 protected:
BinNodePosi(T) splay(BinNodePosi(T) v); //将节点v伸展至根 public:
BinNodePosi(T) & search(const T& e); //查找(重写) BinNodePosi(T) insert(const T& e); //插入(重写) bool remove(const T& e); //初除(重写)
};

需强调的是,与一般的二叉搜索树不同,伸展
树的查找也会引起整树的结构调整,故search()操作也需重写

template  inline //在节点*p不*lc(可能为空)间建立父(左)子关系
void attachAsLChild(NodePosi p, NodePosi lc) { p->lChild = lc; if (lc) lc->parent = p; }

template  inline //在节点*p不*rc(可能为空)间建立父(右)子关系
void attachAsRChild(NodePosi p, NodePosi rc) { p->rChild = rc; if (rc) rc->parent = p; }

template  //Splay树伸展算法:从节点v出収逐局伸展
BinNodePosi(T) Splay::splay(BinNodePosi(T) v) { //v为因最近访问而需伸展的节点位置
 if ( !v ) return NULL; BinNodePosi(T) p; BinNodePosi(T) g; //*v的父亲与祖父
    while ( ( p = v->parent ) && ( g = p->parent ) ) { //自下而上,反复对*v做双层伸展
       BinNodePosi(T) gg = g->parent; //每轮之后*v都以原曾祖父(great-grand parent)为父
       if ( IsLChild ( *v ) )
          if ( IsLChild ( *p ) ) { //zig-zig
             attachAsLChild ( g, p->rc ); attachAsLChild ( p, v->rc );
             attachAsRChild ( p, g ); attachAsRChild ( v, p );
          } else { //zig-zag
             attachAsLChild ( p, v->rc ); attachAsRChild ( g, v->lc );
             attachAsLChild ( v, g ); attachAsRChild ( v, p );
          }
       else if ( IsRChild ( *p ) ) { //zag-zag
          attachAsRChild ( g, p->lc ); attachAsRChild ( p, v->lc );
          attachAsLChild ( p, g ); attachAsLChild ( v, p );
       } else { //zag-zig
          attachAsRChild ( p, v->lc ); attachAsLChild ( g, v->rc );
          attachAsRChild ( v, g ); attachAsLChild ( v, p );
       }
       if ( !gg ) v->parent = NULL; //若*v原先的曾祖父*gg不存在,则*v现在应为树根
       else //否则,*gg此后应该以*v作为左或右孩子
          ( g == gg->lc ) ? attachAsLChild ( gg, v ) : attachAsRChild ( gg, v );
       updateHeight ( g ); updateHeight ( p ); updateHeight ( v );
    } //双层伸展结束时,必有g == NULL,但p可能非空
    if ( p = v->parent ) { //若p果真非空,则额外再做一次单旋
       if ( IsLChild ( *v ) ) { attachAsLChild ( p, v->rc ); attachAsRChild ( v, p ); }
       else                   { attachAsRChild ( p, v->lc ); attachAsLChild ( v, p ); }
       updateHeight ( p ); updateHeight ( v );
    }
    v->parent = NULL; return v;
 } //调整之后新树根应为被伸展的节点,故返回该节点的位置以便上层函数更新树根
  • 查找算法的实现 在伸展树中查找任一关键码e的过程
template  BinNodePosi(T) & Splay::search(const T& e) { //在伸展树中查找兲键码e BinNodePosi(T) p = searchIn(_root, e, _hot = NULL);
_root = splay((p ? p : _hot)); //将最后一个被讵问癿节点伸展至根
return _root;
} //不其它BST不同,无讳查找成功不否,_root都指向最后被讵问癿节点

首先,调用二叉搜索树的通用算法searchIn()(代码7.3)尝试查找具有关键码e的节点。 无论查找是否成功,都继而调用splay()算法,将查找终止位置处的节点伸展到树根。

  • 插入
    为将节点插至伸展树中,固然可以调用二叉搜索树的标准插入算法BST::insert(),再通过双层伸展,将新插入的节点提升至树根。
    然而,以上接口Splay::search()已集成了splay()伸展功能,故查找返回后,树根节点 要么等于查找目标(查找成功),要么就是_hot,而且恰为拟插入节点的直接前驱或直接后继 (查找失败)。因此,不妨改用如下方法实现Splay::insert()接口。


    image.png
  • 删除
    为从伸展树中删除节点,固然也可以调用二叉搜索树标准的节点删除算法BST::remove() (190页代码7.6),再通过双层伸展,将该节点此前的父节点提升至树根。
    然而,同样鉴于Splay::search()已集成了splay()伸展功能,且在成功返回后,树根节 点恰好就是待删除节点。因此,亦不妨改用如下方法实现Splay::remove()接口。


    image.png

4.4 B-树

实践证明,分级存储才是行之有效的方法。在由内存与外存(磁盘)组成的二级存储系统中, 数据全集往往存放于外存中,计算过程中则可将内存作为外存的高速缓存,存放最常用数据项的 复本。借助高效的调度算法,如此便可将内存的“高速度”与外存的“大容量”结合起来。

  • 多路搜索树
    当数据规模大到内存已不足以容纳时,常规平衡二叉搜索树的效率将大打折扣。其原因在于,
    查找过程对外存的访问次数过多。

比如可以两层为间隔,将各节点与其左、右孩子合并为“大节点”: 原节点及其孩子的共三个关键码予以保留;孩子节点原有的四个分支也予以保留并按中序遍历次 序排列;节点到左、右孩子的分支转化为“大节点”内部的搜索,在图中表示为水平分支。如此 改造之后,每个“大节点”拥有四个分支,故称作四路搜索树。
这一策略还可进一步推广,比如以三层为间隔,将各节点及其两个孩子、四个孙子合并为含 有七个关键码、八个分支的“大节点”,进而得到八路搜索树。一般地,以k层为间隔如此重组, 可将二叉搜索树转化为等价的2^k路搜索树,统称多路搜索树(multi-way search tree)。


image.png

实际上,在此时的搜索每下降一层,都以“大节点” 为单位从外存读取一组(而不再是单个)关键码。更为重要的是,这组关键码在逻辑上与物理上 都彼此相邻,故可以批量方式从外存一次性读出,且所需时间与读取单个关键码几乎一样。

  • 多路平衡搜索树
    m阶B -tree,所谓m阶B-树4(B-tree),即m路平衡搜索树(m >2)


    image.png
#include "../vector/vector.h"
#define BTNodePosi(T) BTNode* //B-树节点位置
template  struct BTNode { //B-树节点模板类 // 成员(为简化描述起见统一开放,读者可根据需要迕一步封装)
BTNodePosi(T) parent; //父节点
Vector key; //兲键码向量
Vector child; //孩子向量(其长度总比key夗一)
// 极造函数(注意:BTNode叧能作为根节点创建,而且刜始时有0个兲键码和1个空孩子指针) BTNode() { parent = NULL; child.insert(0, NULL); }
BTNode(T e, BTNodePosi(T) lc = NULL, BTNodePosi(T) rc = NULL) {
parent = NULL; //作为根节点,而且刜始时
key.insert(0, e); //叧有一个关键码,以及 
child.insert(0, lc); child.insert(1, rc); //两个孩子
 if (lc) lc->parent = this; if (rc) rc->parent = this;
}
};
#include "BTNode.h" //引入B-树节点类 2
3 template  class BTree { //B-树模板类
4 protected:
5 int _size; //存放癿兲键码总数
6 int _order; //B-树癿阶次,至少为3——创建时指定,一般丌能修改
7 BTNodePosi(T) _root; //根节点
8 BTNodePosi(T) _hot; //BTree::search()最后讵问癿非空(除非树空)癿节点位置
9 void solveOverflow(BTNodePosi(T)); //因揑入而上溢乀后癿分裂处理
10 void solveUnderflow(BTNodePosi(T)); //因初除而下溢乀后癿合幵处理
11 public:
12 BTree(int order = 3) : _order(order), _size(0) //极造函数:默讣为最低癿3阶
13 { _root = new BTNode(); }
14 ~BTree() { if (_root) release(_root); } //枂极函数:释放所有节点
15 int const order() { return _order; } //阶次
16 int const size() { return _size; } //觃模
17 BTNodePosi(T) & root() { return _root; } //树根
18 bool empty() const { return !_root; } //刞空
19 BTNodePosi(T) search(const T& e); //查找
20 bool insert(const T& e); //揑入
21 bool remove(const T& e); //初除
22 }; //BTree

  • 关键码查找
template  BTNodePosi(T) BTree::search(const T& e) { //在B-树中查找兲键码e BTNodePosi(T) v = _root; _hot = NULL; //从根节点出収
while (v) { //逐局查找
Rank r = v->key.search(e); //在弼前节点中,找刡丌大亍e癿最大兲键码
if ((0 <= r) && (e == v->key[r])) return v; //成功:在弼前节点中命中目标兲键码
_hot = v; v = v->child[r + 1]; //否则,转入对应子树(_hot指向其父)——需做I/O,最费时间
} //返里在向量内是二分查找,但对通常癿_order可直接顸序查找 return NULL; //失败:最终抵达外部节点
}

与二叉搜索树类似,B-树的每一次查找过程中,在每一高度上至多访问 一个节点。这就意味着,对于高度为h的B-树,外存访问不超过O(h - 1)次。

存有N个关键码的m阶B-树的高度h = O(logmN)

  • 上溢与分裂
    一般地,刚发生上溢的节点,应恰好含有m个关键码。若取s = m/2,则它们依次为:
    { k0, ..., ks-1; ks; ks+1, ..., km-1 } 可见,以ks为界,可将该节点分前、后两个子节点,且二者大致等长。于是,可令关键码ks
    上升一层,归入其父节点(若存在)中的适当位置,并分别以这两个子节点作为其左、右孩子。 这一过程,称作节点的分裂(split)。


    image.png
template  //兲键码揑入后若节点上溢,则做节点分裂处理 void BTree::solveOverflow(BTNodePosi(T) v) {
if (_order >= v->child.size()) return; //逑弻基:弼前节点幵未上溢
Rank s = _order / 2; //轴点(此时应有_order = key.size() = child.size() - 1) BTNodePosi(T) u = new BTNode(); //注意:新节点已有一个空孩子
for (Rank j = 0; j < _order - s - 1; j++) { //v右侧癿_order-s-1个孩子及兲键码分裂为右侧节点u
u->child.insert(j, v->child.remove(s + 1)); //逐个秱劢效率低 u->key.insert(j, v->key.remove(s + 1)); //此策略可改迕
 9}
10 u->child[_order - s - 1] = v->child.remove(s + 1); //秱劢v最靠右癿孩子
  • 删除
    为从B-树中删除关键码e,也首先需要调用search(e)查找e所属的节点。倘若查找失败, 则说明关键码e尚不存在,删除操作即告完成
 template  bool BTree::remove(const T& e) { //从BTree树中初除关键码e 
BTNodePosi(T) v = search(e); if (!v) return false; //确讣目标兲键码存在
Rank r = v->key.search(e); //确定目标兲键码在节点v中的秩(由上,肯定合法)
if (v->child[0]) { //若v非叶子,则e的后继必然为叶子节点
BTNodePosi(T) u = v->child[r+1]; //在右子树中一直向左,即可 
while (u->child[0]) u = u->child[0]; //找出e的后继 
v->key[r] = u->key[0]; v = u; r = 0; //并与之交换位置
} //至此,v必然位于最底局,且其中第r个兲键码就是待初除者
v->key.remove(r); v->child.remove(r + 1); _size--; //初除e,以及其下两个外部节点solveUnderflow(v); //如有必要,需做旋转戒合幵
return true;
  • 下溢与合并
    由上,在m阶B-树中,刚发生下溢的节点V必恰好包含m/2 - 2个关键码和m/2 - 1个分 支。以下将根据其左、右兄弟所含关键码的数目,分三种情况做相应的处置。


    image.png

    image.png

    image.png

在经如此合并而得新节点中,关键码总数应为:
(m/2 -1)+1+(m/2 -2) = 2*(m/2) -2<= m-1 故原节点V的下溢缺陷得以修复,而且同时也不致于反过来引发上溢。

接下来,还须检查父节点P关键码y的删除可能致使该节点出现下溢。好在,即便如此, 也尽可套用上述三种方法继续修复节点P。当然,修复之后仍可能导致祖父节点以及更高层节点 的下溢这种现象称作下溢的传递。特别地,当下溢传递至根节点且其中不再含有任何关键码 时,即可将其删除并代之以其唯一的孩子节点,全树高度也随之下降一层。

与上溢传递类似地,每经过一次下溢修复,新下溢节点的高度都必然上升一层


image.png

如前所述,若下溢现象持续传播至树根,且树根当时仅含一个关键码。于是,在其仅有的两 个孩子被合并、仅有的一个关键码被借出之后,原树根将退化为单分支节点。对这一特殊情况, 需删除该树根,并以刚合并而成的节点作为新的树根整树高度也随之降低一层。

image.png

4.5红黑树

伸展树实现简便、无需修改节点 结构、分摊复杂度低,但可惜最坏情况下的单次操作需要O(n)时间,故难以适用于核电站、医 院等对可靠性和稳定性要求极高的场合。反之,7.4节的AVL树尽管可以保证最坏情况下的单次 操作速度,但需在节点中嵌入平衡因子等标识;更重要的是,删除操作之后的重平衡可能需做多 达O(logn)次旋转,从而频繁地导致全树整体拓扑结构的大幅度变化。

红黑树即是针对后一不足的改进。通过为节点指定颜色,并巧妙地动态调整,红黑树可保证: 在每次插入或删除操作之后的重平衡过程中,全树拓扑结构的更新仅涉及常数个节点。尽管最坏 情况下需对多达O(logn)个节点重染色,但就分摊意义而言仅为O(1)个

当然,为此首先需在AVL树“适度平衡”标准的基础上,进一步放宽条件。实际上,红黑树 所采用的“适度平衡”标准,可大致表述为:任一节点左、右子树的高度,相差不得超过两倍。

由红、黑两色节点组成的二叉搜索树若满足以下条件,即为红黑树5(red-black tree):


image.png

其中,条件(1)和(2)意味着红节点均为内部节点,且其父节点及左、右孩子必然存在。另 外,条件(3)意味着红节点之父必为黑色,因此树中任一通路都不含相邻的红节点。

由此可知,在从根节点通往任一节点的沿途,黑节点都不少于红节点。除去根节点本身,沿 途所经黑节点的总数称作该节点的黑深度(black depth)--根节点的黑深度为0,其余依此 类推。故条件(4)亦可等效地理解和描述为“所有外部节点的黑深度统一”。
由条件(4)可进一步推知,在从任一节点通往其任一后代外部节点的沿途,黑节点的总数亦 必相等。除去(黑色)外部节点,沿途所经黑节点的总数称作该节点的黑高度(black height)。 如此,所有外部节点的黑高度均为0,其余依此类推。

  • (2,4)-树
    红黑树与四阶B-经适当转换之后,二者相互等价
    此时,若将原红黑树的节点视作关键码,沿水平方向相 邻的每一组(父子至多三个)节点即恰好构成4阶B-树的一个节点。
image.png

关键码也被赋予了对应的颜色。对照红黑 树的条件,(2,4)-树中的每个节点应包含且仅包含一个黑关键码,同时红关键码不得超过两个。 而且,若某个节点果真包含两个红关键码,则黑关键码的位置必然居中。


image.png

包含n个内部节点的红黑树T的高度h也不致超 过O(logn)。更严格地有:
log2(n+1) <=h <=2∙log2(n+1)

#include "../BST/BST.h" //基亍BST实现RedBlack
template  class RedBlack : public BST { //RedBlack树模板类 protected:
void solveDoubleRed(BinNodePosi(T) x); //双红修正
void solveDoubleBlack(BinNodePosi(T) x); //双黑修正 int updateHeight(BinNodePosi(T) x); //更新节点x癿高度
public:
BinNodePosi(T) insert(const T& e); //揑入(重写) bool remove(const T& e); //初除(重写)
}

可见,这里直接沿用了二叉搜索树标准的查找算法search(),并根据红黑树的重平衡规则 与算法,重写了insert()和remove()接口;新加的两个内部功能接口solveDoubleRed()和 solveDoubleBlack(),分别用于在节点插入或删除之后恢复全树平衡。其具体实现稍后介绍。
预留的两个成员 变量height和color
可借助辅助宏来检查节点的颜 色以及判定是否需要更新(黑)高度记录,如此可大大简化相关算法的描述。

#define IsBlack(p) (!(p) || (RB_BLACK == (p)->color)) //外部节点也规作黑节点 #define IsRed(p) (!IsBlack(p)) //非黑即红
#define BlackHeightUpdated(x) ( \
(stature((x).lChild) == stature((x).rChild)) && \
((x).height == (IsRed(&x) ? stature((x).lChild) : stature((x).lChild) + 1)) \ ) //RedBlack高度更新条件
1 template  int RedBlack::updateHeight(BinNodePosi(T) x) { //更新红黑树节点高度 
2 x->height = max(stature(x->lChild), stature(x->rChild)); //孩子一般黑高度相等,除非出现双黑 
3 return IsBlack(x) ? x->height++ : x->height; //若弼前节点为黑,则计入黑深度
4 } //因统一定stature(NULL) = -1,故height比黑高度少一,好在丌致影响刡各种算法中癿比较刞断

此处的height已不再是指常规的树高,而是红黑树的黑高度。故如代码8.15所示,节点黑 高度需要更新的情况共分三种:或者左、右孩子的黑高度不等;或者作为红节点,黑高度与其孩 子不相等;或者作为黑节点,黑高度不等于孩子的黑高度加一。

因新节点的引入,而导致父子节点同为红色的此类情况,称作“双红”(double red)。 为修正双红缺陷,可调用solveDoubleRed(x)接口。每引入一个关键码,该接口都可能迭代地 调用多次。在此过程中,当前节点x的兄弟及两个孩子(初始时都是外部节点),始终均为黑色。

  • 双红修正RR1
    首先,考查u为黑色的情况。此时,x的兄弟、两个孩子的黑高度,均与u相等。图8.25(a) 和(b)即为此类情况的两种可能(另两种对称情况,请读者独立补充)。


    image.png

    此时红黑树条件(3)的违反,从B-树角度等效地看,即同一节点不应包含紧邻的红色关键码。 故如图8.25(c')所示,只需令黑色关键码与紧邻的红色关键码互换颜色。从图(c)红黑树的角度 看,这等效于按中序遍历次序,对节点x、p和g及其四棵子树,做一次局部“3 + 4”重构。

不难验证,如此调整之后,局部子树的黑高度将复原,这意味着全树的平衡也必然得以恢复。 同时,新子树的根节点b为黑色,也不致引发新的双红现象。至此,整个插入操作遂告完成。

  • 双红修正(RR-2)
    再考查节点u为红色的情况。此时,u的左、右孩子非空且均为黑色,其黑高度必与x的兄弟
    以及两个孩子相等。图8.26(a)和(b)给出了两种可能的此类情况(另两种对称情况,请读者独 立补充)。此时红黑树条件(3)的违反,从B-树角度等效地看,即该节点因超过4度而发生上溢。


    image.png

不难验证,如此调整之后局部子树的黑高度复原。然而,子树根节点g转为红色之后,有可 能在更高层再次引发双红现象。从图8.26(c')B-树的角度来看,对应于在关键码g被移出并归入 上层节点之后,进而导致上层节点的上溢即上溢的向上传播。
若果真如此,可以等效地将g视作新插入的节点,同样地分以上两类情况如法处置。请注意, 每经过一次这样的迭代,节点g都将在B-树中(作为关键码)上升一层,而在红黑树中存在双红 缺陷的位置也将相应地上升两层,故累计至多迭代O(logn)次。

image.png
/****************************************************************************************** *RedBlack双红调整算法:解决节点x不其父均为红色癿问题。分为两大类情冴:
* RR-1:2次颜色翻转,2次黑高度更新,1~2次旋转,丌再逑弻
* RR-2:3次颜色翻转,3次黑高度更新,0次旋转,需要逑弻 ******************************************************************************************/
template  void RedBlack::solveDoubleRed(BinNodePosi(T) x) { //x弼前必为红 if (IsRoot(*x)) //若已(逑弻)转至树根,则将其转黑,整树黑高度也随乀逑增
{ _root->color = RB_BLACK; _root->height++; return; } //否则,x的父亲p必存在 BinNodePosi(T) p = x->parent; if (IsBlack(p)) return; //若p为黑,则可终止调整。否则 BinNodePosi(T) g = p->parent; //既然p为红,则x癿祖父必存在,且必为黑色 BinNodePosi(T) u = uncle(x); //以下,规x叔父u癿颜色分删处理
if (IsBlack(u)) { //u为黑色(含NULL)时
if (IsLChild(*x) == IsLChild(*p)) //若x不p同侧(即zIg-zIg戒zAg-zAg),则
///// /////
p->color = RB_BLACK; //p由红转黑,x保持红 else //若x不p异侧(即zIg-zAg戒zAg-zIg),则
x->color = RB_BLACK; //x由红转黑,p保持红
g->color = RB_RED; //g必定由黑转红 以上虽保证总共两次染色,但因增加了刞断而得丌偿失 在旋转后将根置黑、孩子置红,虽需三次染色但效率更高
BinNodePosi(T) gg = g->parent; //曾祖父(great-grand parent)
BinNodePosi(T) r = FromParentTo(*g) = rotateAt(x); //调整后癿子树根节点 r->parent = gg; //不原曾祖父联接
 } }
} else { //若u为红色
p->color = RB_BLACK; p->height++; //p由红转黑
u->color = RB_BLACK; u->height++; //u由红转黑
if (!IsRoot(*g)) g->color = RB_RED; //g若非根,则转红
solveDoubleRed(g); //继续调整g(类似亍尾逑弻,可优化为迭代形式)
  • 节点删除算法
    节点删除与双黑现象
template  bool RedBlack::remove(const T& e) { //从红黑树中初除关键码e 
BinNodePosi(T) & x = search(e); if (!x) return false; //确定目标节点存在(留意对_hot的位置) 
BinNodePosi(T) r = removeAt(x, _hot); if (0 >= --_size) return true; //实施删除
// assert: _hot某一孩子刚被初除,且被r所指节点(可能是NULL)接替。以下检查是否失衡,幵做必要调整 
if (!_hot) //若刚被初除癿是根节点,则将其置黑,并更新黑高度
{ _root->color = RB_BLACK; updateHeight(_root); return true; } // assert: 以下,原x(现r)必非根,_hot必非空
if (BlackHeightUpdated(*(_hot))) //若所有祖先癿黑深度依然平衡,则无需调整 
  return true;
if (IsRed(r)) //否则,若r为红,则叧需令其转黑
{ r->color = RB_BLACK; r->height++; return true; }
// assert: 以下,原x(现r)均为黑色
solveDoubleBlack(r); return true; //经双黑调整后迒回
} //若目标节点存在且被初除,返回true;否则迒回false

不难验证,此时红黑树的前两个条件继续满足,但后两个条件却未必依然满足。

如图8.28所示,除了其接替者r,x 还应有另一个孩子w。既然x是实际被删除 者,故w必为(黑色的)外部节点NULL。
如图(a)和(a')所示,若x为红色, 则在删除x并代之以r后,条件(3~4)依然 满足;反之,若x为黑色,则要看其替代 者r的颜色。
如图(b)和(b')所示,若r为红色, 则只需将其翻转为黑色,即可使条件 (3~4)重新满足。
然而如图(c)和(c')所示,若x和r均 为黑色,则为使条件(3~4)重新成立,还 需要做略微复杂一些的处理。


image.png

因某一无红色孩子的黑节点被删除,而导致的此类复杂情况,称作“双黑”(double black) 现象。此时,需从r出发调用solveDoubleBlack(r)算法予以修正。

自然,原黑节点x的兄弟必然非空,将其记作s;x的父亲记作p,其颜色不确定(故在图中 以八角形示意)。以下视s和p颜色的不同组合,按四种情况分别处置。

  • 双黑修正(BB-1)
    既然节点x的另一孩子w=NULL,故从B-树角度(图8.29(a'))看节点x被删除之后的情况,
    可以等效地理解为:关键码x原所属的节点发生下溢;此时,t和s必然属于B-树的同一节点,且 该节点就是下溢节点的兄弟。故可参照B-树的调整方法,下溢节点从父节点借出一个关键码(p), 然后父节点从向下溢节点的兄弟节点借出一个关键码(s),调整后的效果如图(b')。

从红黑树的角度(图(b))来看, 上述调整过程等效于,对节点t、s和p 实施“3 + 4”重构。

此外,根据红黑树与B-树的对应 关系不难理解,若这三个节点按中序遍 历次序重命名为a、b和c,则还需将a 和c染成黑色,b则继承p此前的颜色。 就图8.29的具体实例而言,也就是将t 和p染成黑色,s继承p此前的颜色。注 意,整个过程中节点r保持黑色不变。
由图8.29(b)(及其对称情况)不 难验证,经以上处理之后,红黑树的所 有条件,都在这一局部以及全局得到恢 复,故删除操作遂告完成。


image.png
  • 双黑修正(BB-2-R)
    节点s及其两个孩子均为黑色时,视节点p颜色的不同,又可进一步分为两种情况。

先考虑p为红色的情况。如图8.30(a)所示,即为一种典型的此类情况


image.png

与BB-1类似,在对应的B-树中,关键码x的删除导 致其所属的节点下溢。但因此时关键码s所在节点只有两 个分支,故下溢节点无法从父节点借出关键码(p)。
按照8.2.8节的B-树平衡算法,此时应如图(b')所 示,将关键码p取出并下降一层,然后以之为“粘合剂”, 将原左、右孩子合并为一个节点。从红黑树角度看,这 一过程可如图(b)所示等效地理解为:s和p颜色互换。
由图8.30(b)(及其对称情况)可知,经过以上处 理,红黑树的所有条件都在此局部得以恢复。另外,由 于关键码p原为红色,故如图8.30(a')所示,在关键码p 所属节点中,其左或右必然还有一个黑色关键码(当然, 不可能左、右兼有)--这意味着,在关键码p从其中取 出之后,不致引发新的下溢。至此,红黑树条件亦必在 全局得以恢复,删除操作即告完成。

  • 双黑修正(BB-2-B)
    接下来,再考虑节点s、s的两个孩子以及节点p均为黑色的情况。 如图8.31(a)所示,即为一种典型的此类情况(与之对称的情况,请读者独立补充)。此时
    与BB-2-R类似,在对应的B-树中,因关键码x的删除,导致其所属节点发生下溢。

因此可如图(b')所示,将下溢 节点与其兄弟合并。从红黑树的角 度来看,这一过程可如图(b)所示等 效地理解为:节点s由黑转红。
由图8.31(b)(及其对称情况) 可知,经以上处理,红黑树所有条 件都在此局部得到恢复。
然而,因s和x在此之前均为黑 色,故如图8.31(a')所示,p原所 属的B-树节点必然仅含p这一个关 键码。于是在p被借出之后,该节点 必将继而发生下溢,故有待于后续 进一步修正。


image.png

从红黑树的角度来看,此时的状态可等效地理解为:节点p的父节点刚被删除。当然,可以 按照本节所介绍的算法,视具体的情况继续调整。
实际上稍后总结时将会看出,这也是双黑修正过程中,需要再次迭代的唯一可能。幸运的是, 尽管此类情况可能持续发生,下溢的位置也必然不断上升,故至多迭代O(logn)次后必然终止。

  • 双黑修正(BB-3)
    最后,考虑节点s为红色的情
    况。如图8.32(a)所示,即为一种典 型的此类情况(与之对称的情况, 请读者独立补充)。此时,作为红 节点s的父亲,节点p必为黑色;同 时,s的两个孩子也应均为黑色。

于是从B-树的角度来看,只需 如图(b')所示,令关键码s与p互换 颜色,即可得到一棵与之完全等价 的B-树。而从红黑树的角度来看, 这一转换对应于以节点p为轴做一 次旋转,并交换节点s与p的颜色。


image.png

读者可能会发现,经过如此处理之后,双黑缺陷依然存在,而且缺陷位置的高度也并未上升。 既然如此,这一步调整的意义又何在呢?

实际上,经过这一转换之后,情况已经发生了微妙而本质的变化。仔细观察图(b)不难发现, 在转换之后的红黑树中,被删除节点x(及其替代者节点r)有了一个新的兄弟s'--与此前的 兄弟s不同,s'必然是黑的!这就意味着,接下来可以套用此前所介绍其它情况的处置方法,继 续并最终完成双黑修正。

还有一处本质的变化,同样需要注意:现在的节点p,也已经黑色转为红色。因此接下来即 便需要继续调整,必然既不可能转换回此前的情况BB-3,也不可能转入可能需要反复迭代的情 况BB-2-B。实际上反过来,此后只可能转入更早讨论过的两类情况BB-1或BB-2-R。这就意 味着,接下来至多再做一步迭代调整,整个双黑修正的任务即可大功告成。

image.png

image.png

一旦在某步迭代中做过节点的旋转调整,整个修复过程便会随即 完成。因此与双红修正一样,双黑修正的整个过程,也仅涉及常数次的拓扑结构调整操作。
这一有趣的特性同时也意味着,在每此插入操作之后,拓扑联接关系有所变化的节点绝不会 超过常数个这一点与AVL树(的删除操作)完全不同,也是二者之间最本质的一项差异。

/****************************************************************************************** *RedBlack双黑调整算法:解决节点x不被其替代癿节点均为黑色癿问题
分为三大类共四种情冴:
BB-1 :2次颜色翻转,2次黑高度更新,1~2次旋转,不再迭代 
BB-2R:2次颜色翻转,2次黑高度更新,0次旋转,不再更新 
BB-2B:1次颜色翻转,1次黑高度更新,0次旋转,需要迭代
BB-3 :2次颜色翻转,2次黑高度更新,1次旋转,转为BB-1或者BB-2-R
template  void RedBlack::solveDoubleBlack(BinNodePosi(T) r) { BinNodePosi(T) p = r ? r->parent : _hot; if (!p) return; //r父亲 
BinNodePosi(T) s = (r == p->lChild) ? p->rChild : p->lChild; //r的兄弟
if(IsBlack(s)) { //兄弟s为黑
BinNodePosi(T) t = NULL; //s的红孩子(若左、右孩子都是红,左者优先;皆黑时为NULL) 
if (HasLChild(*s) && IsRed(s->lChild)) t = s->lChild;
else if (HasRChild(*s) && IsRed(s->rChild)) t = s->rChild;
if(t) { //黑s有红孩子:BB-1
RBColor oldColor = p->color; //备份原子树根节点p颜色,并对t及其父亲、祖父 
BinNodePosi(T) b = FromParentTo(*p) = rotateAt(t); //重平衡,并将新子树的左、右孩子染黑 
if (HasLChild(*b)) b->lChild->color = RB_BLACK; updateHeight(b->lChild); //左孩子
if (HasRChild(*b)) b->rChild->color = RB_BLACK; updateHeight(b->rChild); //右孩子 
b->color = oldColor; updateHeight(b); //新子树根节点继承原根节点的颜色
} else { //黑s无红孩子
s->color = RB_RED; s->height--; //s转红 
if (IsRed(p)) { //BB-2R
p->color = RB_BLACK; //p转黑,但黑高度不变 } 
else { //BB-2B
p->height--; //p保持黑,但黑高度下降
solveDoubleBlack(p); }
 }
} else { //兄弟s为红:BB-3
s->color = RB_BLACK; p->color = RB_RED; //s转黑,p转红
BinNodePosi(T) t = IsLChild(*s) ? s->lChild : s->rChild; //取t不其父s同侧 
_hot = p; FromParentTo(*p) = rotateAt(t); //对t及其父亲、祖父做平衡调整 
solveDoubleBlack(r); //继续修正r处双黑——此时的p已转红,故后续叧能是BB-1或者BB-2R
 } }

你可能感兴趣的:(BST二叉搜索树、BBST :AVL树、伸展树、红黑树、b树、kd-树)