DataStructure——红黑树学习笔记

1.前言

• 本文伪码和解释参考：

http://blog.csdn.net/v_JULY_v/article/details/6105630

• C实现的源码本文未贴出，请见：

http://blog.csdn.net/v_july_v/article/details/6114226

• July的博客对红黑树的分析很精彩，请见：

http://blog.csdn.net/v_JULY_v/article/category/774945

本文对参考资料有所修订和补完（侵删）。

2.正文

伪码中使用的符号：

 N：node，当前节点
 S：sibling，当前节点的兄弟节点
 P：praent，当前节点的父节点
 U：uncle，当前节点的叔节点，即父节点的兄弟节点
 G：graparent，当前节点的祖辈节点，即父节点的父节点
 ←：赋值
 ==或=：是否相等
 ≠：不等
 x.p：x的父节点
 N:L或N:R：节点N是父节点的左孩子（大写L，Left），或，节点N是父节点的右孩子（大写R，Right）
 N:r或N:b：节点N是红色的（小写r，red），或，节点N是黑色的（小写b，black）
 <N:r>：条件判断，判断N:r是否成立
 #n：相当于#Case n，即情况n（n=,,.....）
 L_rt(N)或R_rt(N)：以节点N为轴心，进行左旋转操作（L_rt），或，右旋操作（R_rt）

伪码：

 //-------------RBTree:Insesrt-----------//
 RB-INSERT(T, z)
 y ← nil
 x ← T.root
 while x ≠ nil
     do y ← x
     if z.key < x.key
         then x ← x.left
     else x ← x.right
 z.p ← y
 if y == nil
     then T.root ← z
 else if z.key < y.key
     then y.left ← z
 else y.right ← z
 z.left ← nil
 z.right ← nil
 z.color ← RED
 RB-INSERT-FIXUP(T, z)

 //-------------RBTree:Insert-FIXUP-----------//
 RB-INSERT-FIXUP(T, z)
 while z.p.color == RED                            //fixup only in case P:r
     do if z.p == z.p.p.left                     //P:L
         then y ← z.p.p.right
         if y.color == RED                        //U:r , # Case
             then z.p.color ← BLACK              //P ← b,U ← b,G ← r #
             y.color ← BLACK
             z.p.p.color ← RED
             z ← z.p.p                           //N ← G
         else                                     //U:b , # Case  -> # Case
             if z == z.p.right                     //N:R ,
                 then z ← z.p                    //    N ← P,L_rt(T,N)
                 LEFT-ROTATE(T, z)
             z.p.color ← BLACK                    //<U:b> , P ← b,G ← r,R_rt(T,G) # Case
             z.p.p.color ← RED
             RIGHT-ROTATE(T, z.p.p)
     else if z.p == z.p.p.right                     //<P:R>
         y ← z.p.p.left
         if y.color == RED                        //<U:r> , # Case
             then z.p.color ← BLACK              //P ← b,U ← b,G ← r #
             y.color ← BLACK
             z.p.p.color ← RED
             z ← z.p.p                           //N ← G
         else                                     //<U:b> , # Case  -> # Case
             if z == z.p.left                     //<U:b,N:L> , N ← P,R_rt(T,N)
                 then z ← z.p
                 RIGHT-ROTATE(T, z)
             z.p.color ← BLACK                    //<U:b> , P ← b,G ← r,L_rt(T,G) # Case
             z.p.p.color ← RED
             LEFT-ROTATE(T, z.p.p)
 T.root.color ← BLACK

 //-------------RBTree:Delete-----------//
 RB-DELETE(T, z)                                                    //y was deleted , x
 if z.left = NIL or z.right = NIL                                  //N doesnot have child node
    then y ← z
    else y ← TREE-SUCCESSOR(z)                                      //TREE-SUCCESSOR(z):find the Lmax in subtree:z
 if y.left ≠ NIL
    then x ← y.left
 else x ← y.right
 if x ≠ NIL
     x.p ← y.p
 if y.p = NIL                                                    //in case N is root
    then T.root ← x
 else if y = y.p.left                                            //in case single child
     then y.p.left ← x
 else y.p.rght ← x
 if y ≠ z                                                          //in case double child
    then z.key ← y.key                                            //cover but not remove
         copy y's satellite data into z
 if y.color = BLACK                                              //fixup only when <N:b>=true
    then RB-DELETE-FIXUP(T, x)
 return y

 //-------------RBTree:Delete-Fixup-----------//
 RB-DELETE-FIXUP(T, x)
 while x ≠ T.root and x.color = BLACK
     do
         if x = x.p.left                                          //<N:L>
             then w ← x.p.right                                  //w ← S:R
             if w.color = RED                                      //<w:r>    #1
                 then w.color ← BLACK                               //S:b , P:r , L_rt(P) ,w ← S:R
                     x.p.color ← RED
                     LEFT-ROTATE(T, x.p)
                     w ← x.p.right
             if w.left.color = BLACK and w.right.color = BLACK   //<S.left:b & S.right:b> #2
                 then w.color ← RED                              //S:r , N ← P
                     x ← x.p
             else if w.right.color = BLACK                         //<S.right:b> #3
                 then w.left.color ← BLACK                          //S.left:b , S:r , R_rt(S) ,
                     w.color ← RED
                     RIGHT-ROTATE(T, w)
                     w ← x.p.right                                 //new N's S cos of the R_rt()
                 w.color ← x.p.color                             //S.color ← P.color，P:b，S.right:b，L_rt(P), #4
                 x.p.color ← BLACK
                 w.right.color ← BLACK
                 LEFT-ROTATE(T, x.p)
                 x ← T.root                                        //break,exit while{}
         else
             w ← x.p.left
             if w.color = RED
                 then w.color ← BLACK
                     x.p.color ← RED
                     RIGHT-ROTATE(T, x.p)
                     w ← x.p.left
             if w.left.color = BLACK and w.right.color = BLACK
                 then w.color ← RED
                     x ← x.p
             else if w.left.color = BLACK
                 then w.right.color ← BLACK
                     w.color ← RED
                     LEFT-ROTATE(T, w)
                     w ← x.p.left
                 w.color ← x.p.color
                 x.p.color ← BLACK
                 w.left.color ← BLACK
                 RIGHT-ROTATE(T, x.p)
                 x ← T.root
 x.color ← BLACK