十五、数据结构---红黑树

 二叉查找树
    二叉查找树,也称有序二叉树(ordered binary tree),或已排序二叉树(sorted binary tree),是指一棵空树或者具有下列性质的二叉树:
    若任意结点的左子树不空,则左子树上的所有结点的值均小于它的根结点的值;
    若任意结点的右子树不空,则右子树上的所有结点的值均大于它的根结点的值;
    任意结点的左,右子树也分别为二叉查找树。
    没有键值相等的节点。
 注意:具有n个结点的二叉树的深度至少是log2(N)+1,至多是n,所以二叉查找树的查找性能(时间复杂度)在O(log2(N))和O(n)之间。
 一、红黑树的介绍
   红黑树(Red-Black Tree,简称R-B Tree),它是一种特殊的二叉查找树。
   意味着它满足二叉查找树的特征:任意一个结点所包含的键值,大于等于左孩子的键值,小于等于右孩子的键值。
   红黑树的每个结点上都有存储位表示结点的颜色,颜色是红(Red)或黑(Black)。
   红黑树的特性:
   (1)每个结点或者是黑色,或者是红色。
   (2)根结点是黑色。
   (3)每个叶子结点是黑色。[注意:这里的叶子结点,是指为空的叶子结点!]
   (4)如果一个结点是红色的,则它的子节点必须是黑色的。
   (5)从根结点到所有叶子结点上的黑色结点数量是相同的。
   上述的性质约束了红黑树的关键:从根到叶子的最长可能路径不多于最短可能路径的两倍长。
   得到这个结论的理由是:
    1.红黑树中最短的可能路径是全部为黑色结点的路径
    2.红黑树中最长的可能路径是红黑相同的路径


    可以看到根结点到所有NULL LEAF节点(即叶子结点)所经过的黑色节点都是2个。
    另外从这张图上我们还能得到一个结论:红黑树并不是高度的平衡树。所谓平衡树指的是一棵空树或它的左右两个子树的高度差的绝对值不超过1,但是我们看:
    .最左边的路径0026-->0017-->0012-->0010-->0003-->NULL LEAF，它的高度为5
    .最后边的路径0026-->0041-->0047-->NULL LEAF，它的高度为3
    左右子树的高度差为2,因此红黑树并不是高度平衡的,它放弃了高度平衡的特性而只追求部分平衡,这种特性降低了插入,删除时对树旋转的要求,从而提升了树的整体性能。


 二、红黑树的Java实现(代码说明)
    红黑树的基本操作是添加,删除和旋转。在对红黑树进行添加或删除后,会用到旋转方法。为什么呢?道理很简单,添加或删除红黑树中的结点之后,红黑树就发生了变化,可能不满足红黑树的5条性质,也就不再是一棵红黑树了,而是一棵普通的树。而通过旋转,可以使这课树重新成为红黑树。简单点说,旋转的目的是让树保持红黑树的特性。
    旋转包括两种:左旋 和 右旋。
    下面分别对红黑树的基本操作进行介绍。


 (1)基本定义


    public class RBTree<T extends Comparable<T>> {


    private RBTNode<T> mRoot;    // 根结点


    private static final boolean RED   = false;
    private static final boolean BLACK = true;


    public class RBTNode<T extends Comparable<T>> {
        boolean color;        // 颜色
        T key;                // 关键字(键值)
        RBTNode<T> left;    // 左孩子
        RBTNode<T> right;    // 右孩子
        RBTNode<T> parent;    // 父结点


        public RBTNode(T key, boolean color, RBTNode<T> parent, RBTNode<T> left, RBTNode<T> right) {
            this.key = key;
            this.color = color;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }


    }


    ...
}


    RBTree是红黑树对应的类,RBTNode是红黑树的节点类。在RBTree中包含了根结点mRoot和红黑树的相关API。


 (2)左旋
    对X进行左旋,意味着"将x变成一个左结点"。

    左旋的过程是将X的右子树绕X逆时针旋转,使得X的右子树成为X的父亲,同时修改相关节点的引用。旋转之后,二叉查找树的属性任然满足。

    左旋的实现代码(Java)
    /* 
     * 对红黑树的节点(x)进行左旋转
     *
     * 左旋示意图(对节点x进行左旋)：
     *      px                              px
     *     /                               /
     *    x                               y                
     *   /  \      --(左旋)-.           / \                #
     *  lx   y                          x  ry     
     *     /   \                       /  \
     *    ly   ry                     lx  ly  
     *
     *
     */
    private void leftRotate(RBTNode<T> x) {
        // 设置x的右孩子为y
        RBTNode<T> y = x.right;


        // 将 “y的左孩子” 设为 “x的右孩子”；
        // 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”
        x.right = y.left;
        if (y.left != null)
            y.left.parent = x;


        // 将 “x的父亲” 设为 “y的父亲”
        y.parent = x.parent;


        if (x.parent == null) {
            this.mRoot = y;            // 如果 “x的父亲” 是空节点，则将y设为根节点
        } else {
            if (x.parent.left == x)
                x.parent.left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
            else
                x.parent.right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
        }
        
        // 将 “x” 设为 “y的左孩子”
        y.left = x;
        // 将 “x的父节点” 设为 “y”
        x.parent = y;
    }


 (3)右旋
    对y进行右旋意味着"将y变成一个右节点"。

    右旋的过程是将y的左子树绕y顺时针旋转,使得y的左子树成为y的父亲,同时修改相关结点的引用。

    代码:
    /* 
 * 对红黑树的节点(y)进行右旋转
 *
 * 右旋示意图(对节点y进行左旋)：
 *            py                               py
 *           /                                /
 *          y                                x                  
 *         /  \      --(右旋)-.            /  \                     #
 *        x   ry                           lx   y  
 *       / \                                   / \                   #
 *      lx  rx                                rx  ry
 * 
 */
private void rightRotate(RBTNode<T> y) {
    // 设置x是当前节点的左孩子。
    RBTNode<T> x = y.left;


    // 将 “x的右孩子” 设为 “y的左孩子”；
    // 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”
    y.left = x.right;
    if (x.right != null)
        x.right.parent = y;


    // 将 “y的父亲” 设为 “x的父亲”
    x.parent = y.parent;


    if (y.parent == null) {
        this.mRoot = x;            // 如果 “y的父亲” 是空节点，则将x设为根节点
    } else {
        if (y == y.parent.right)
            y.parent.right = x;    // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”
        else
            y.parent.left = x;    // (y是它父节点的左孩子) 将x设为“y的父节点的左孩子”
    }


    // 将 “y” 设为 “x的右孩子”
    x.right = y;


    // 将 “y的父节点” 设为 “x”
    y.parent = x;
}
 (4)插入


/*********************** 向红黑树中插入节点 **********************/
public void insert(T key) {
    RBNode<T> node = new RBNode<T>(key, RED, null, null, null);
    if(node != null) 
        insert(node);
}


//将节点插入到红黑树中，这个过程与二叉搜索树是一样的
private void insert(RBNode<T> node) {
    RBNode<T> current = null; //表示最后node的父节点
    RBNode<T> x = this.root; //用来向下搜索用的
    
    //1. 找到插入的位置
    while(x != null) {
        current = x;
        int cmp = node.key.compareTo(x.key);
        if(cmp < 0) 
            x = x.left;
        else
            x = x.right;
    }
    node.parent = current; //找到了位置，将当前current作为node的父节点
    
    //2. 接下来判断node是插在左子节点还是右子节点
    if(current != null) {
        int cmp = node.key.compareTo(current.key);
        if(cmp < 0)
            current.left = node;
        else
            current.right = node;
    } else {
        this.root = node;
    }
    
    //3. 将它重新修整为一颗红黑树
    insertFixUp(node);
}
    这与二叉搜索树中实现的思路一模一样,这里不再赘述,主要看看方法里面最后一步insertFixUp操作。
    因为插入后可能会导致树的不平衡,insertFixUp方法里主要是分情况讨论,分析何时变色,何时左旋,何时右旋。
    我们先从理论上分析具体的情况,然后再看insertFixUp方法的具体实现。
    如果是第一次插入,由于原树为空,所以只会违反红-黑树的规则2,所以只要把根结点涂黑即可;如果插入节点的父节点是黑色的,那不会违背红-黑树的规则,什么也不需要做;但是遇到如下三种情况时,我们就要开始变色和旋转了:
        1.插入结点的父节点和其叔叔结点(祖父结点的另一个子结点)均为红色的;
        2.插入结点的父结点是红色,叔叔结点是黑色,且插入结点是其父结点的右子结点;
        3.插入结点的父结点是红色,叔叔结点是黑色,且插入结点是其父结点的左子结点。
    对于情况1:插入结点的父结点和其叔叔结点(祖父结点的另一个子结点)均为红色的。此时,肯定存在祖父结点,但是不知道父结点是其左子结点还是右子结点,但是由于对称性,我们只要讨论出一边的情况,另一边情况自然也与之对应。这里考虑父结点是祖父结点的左子结点的情况。
    如下图1所示:

图1

图2

    对于这种情况,我们要做的操作有:将当前结点(4)的父结点(5)和叔叔结点(8)涂黑,将祖父结点(7)涂红,变成如图2所示的情况。再将当前结点指向其祖父结点,再次从新的当前结点开始算法(具体看下面程序)。这样图2就变成了情况2了。


    对于情况2:插入结点的父结点是红色,叔叔结点是黑色,且插入结点是其父结点的右子结点。我们要做的操作有:将当前结点(7)的父结点(2)作为新的结点,以新的当前结点为支点做左旋操作。完成后如图3所示,这样图3就变成情况3了。

图3

    对于情况3:插入结点的父结点是红色,叔叔结点是黑色,且插入结点是其父结点的左子结点。我们要做的操作有:将当前结点的父结点(7)涂黑,将祖父结点(11)涂红在祖父结点为支点做右旋操作。最后把根结点涂黑,整个红-黑树重新恢复了平衡,如图4所示。

图4

    至此,插入操作完成!
    我们可以看出,如果是从情况1开始发生的,必然会走完情况2和3,也就是说这是一整个流程,当然了,实际中不一定会从情况1发生,如果从情况2开始发生,那再走个情况3即可完成调整,如果直接只要调整情况3,那么前两种情况均不需要调整了。
    故变色和旋转之间先后关系可以表示为 变色->左旋->右旋。


    至此,我们完成了全部的插入操作。下面我们看看insertFixUp方法中的具体实现:


private void insertFixUp(RBNode<T> node) {
    RBNode<T> parent, gparent; //定义父节点和祖父节点
    
    //需要修整的条件：父节点存在，且父节点的颜色是红色
    while(((parent = parentOf(node)) != null) && isRed(parent)) {
        gparent = parentOf(parent);//获得祖父节点
        
        //若父节点是祖父节点的左子节点，下面else与其相反
        if(parent == gparent.left) {                
            RBNode<T> uncle = gparent.right; //获得叔叔节点
            
            //case1: 叔叔节点也是红色
            if(uncle != null && isRed(uncle)) {
                setBlack(parent); //把父节点和叔叔节点涂黑
                setBlack(uncle);
                setRed(gparent); //把祖父节点涂红
                node = gparent; //将位置放到祖父节点处
                continue; //继续while，重新判断
            }
            
            //case2: 叔叔节点是黑色，且当前节点是右子节点
            if(node == parent.right) {
                leftRotate(parent); //从父节点处左旋
                RBNode<T> tmp = parent; //然后将父节点和自己调换一下，为下面右旋做准备
                parent = node;
                node = tmp;
            }
            
            //case3: 叔叔节点是黑色，且当前节点是左子节点
            setBlack(parent);
            setRed(gparent);
            rightRotate(gparent);
        } else { //若父节点是祖父节点的右子节点,与上面的完全相反，本质一样的
            RBNode<T> uncle = gparent.left;
            
            //case1: 叔叔节点也是红色
            if(uncle != null & isRed(uncle)) {
                setBlack(parent);
                setBlack(uncle);
                setRed(gparent);
                node = gparent;
                continue;
            }
            
            //case2: 叔叔节点是黑色的，且当前节点是左子节点
            if(node == parent.left) {
                rightRotate(parent);
                RBNode<T> tmp = parent;
                parent = node;
                node = tmp;
            }
            
            //case3: 叔叔节点是黑色的，且当前节点是右子节点
            setBlack(parent);
            setRed(gparent);
            leftRotate(gparent);
        }
    }
    
    //将根节点设置为黑色
    setBlack(this.root);
}
 (5)删除
    上面探讨完了红-黑树的插入操作,接下来讨论删除,红黑树的删除和二叉查找树的删除是一样的,只不过删除后多了个平衡的修复而已。
    我们先来回忆一下二叉搜索树的删除:
        1.如果待删除结点没有子结点,那么直接删除掉即可;
        2.如果待删除结点只有一个子结点,那么直接删掉,并用其子结点去顶替它;
        3.如果待删除结点有两个子结点,这种情况比较复杂:
        首先找出它的"后继结点" 和 "被删除结点的父结点" 之间的关系,最后处理 "后继结点的子结点" 和 "被删除结点的子结点" 之间的关系。每一步中也会有不同的情况。


        我们来看一下删除操作的代码及注释:


/*********************** 删除红黑树中的节点 **********************/
public void remove(T key) {
    RBNode<T> node;
    if((node = search(root, key)) != null)
        remove(node);
}


private void remove(RBNode<T> node) {
    RBNode<T> child, parent;
    boolean color;
    
    //1. 被删除的节点“左右子节点都不为空”的情况
    if((node.left != null) && (node.right != null)) {
        //先找到被删除节点的后继节点，用它来取代被删除节点的位置
        RBNode<T> replace = node;
        //  1). 获取后继节点
        replace = replace.right;
        while(replace.left != null) 
            replace = replace.left;
        
        //  2). 处理“后继节点”和“被删除节点的父节点”之间的关系
        if(parentOf(node) != null) { //要删除的节点不是根节点
            if(node == parentOf(node).left) 
                parentOf(node).left = replace;
            else
                parentOf(node).right = replace;
        } else { //否则
            this.root = replace;
        }
        
        //  3). 处理“后继节点的子节点”和“被删除节点的子节点”之间的关系
        child = replace.right; //后继节点肯定不存在左子节点！
        parent = parentOf(replace);
        color = colorOf(replace);//保存后继节点的颜色
        if(parent == node) { //后继节点是被删除节点的子节点
            parent = replace;
        } else { //否则
            if(child != null) 
                setParent(child, parent);
            parent.left = child;
            replace.right = node.right;
            setParent(node.right, replace);
        }
        replace.parent = node.parent;
        replace.color = node.color; //保持原来位置的颜色
        replace.left = node.left;
        node.left.parent = replace;
        
        if(color == BLACK) { //4. 如果移走的后继节点颜色是黑色，重新修整红黑树
            removeFixUp(child, parent);//将后继节点的child和parent传进去
        }
        node = null;
        return;
    }
}
    下面我们主要看看方法里面最后的removerFixUp操作。
    因为remove后可能会导致树的不平衡,removeFixUp方法里主要是分情况讨论,分析何时变色,何时左旋,何时右旋。我们同样先从理论上分析具体的情况,然后在看removeFixUp方法的具体实现。
    从上面的代码中可以看出,删除某个结点后,会用它的后继结点来填上,并且后继结点会设置为和删除结点同样的颜色,所以删除结点的那个位置是不会破坏平衡的，可能破坏平衡的是后继结点原来的位置,因为后继结点拿走了,原来的位置结构改变了,这就会导致不平衡的出现。所以removeFixUp方法中传入的参数也是后继结点的子结点和父结点。
    为了方便下文的叙述,我们现在约定:后继结点的子结点称为"当前结点"。
    删除操作后,如果当前结点是黑色的根结点,那么不用任何操作,因为并没有破坏树的平衡性,既没有违背红-黑树的规则,这很好理解。如果当前结点是红色的,说明刚刚移走的后继结点是黑色的,那么不管后继结点的父节点是啥颜色,我们只要将当前结点涂黑就可以了,红-黑树的平衡性就可以恢复。但是遇到以下四种情况,我们就需要通过变色或旋转来恢复红-黑树的平衡了。
        1.当前结点是黑色的,且兄弟结点是红色的(那么父结点和兄弟结点的子结点肯定是黑色的)；
        2.当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点的两个子结点均为黑色的;
        3.当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点左子结点是红色,右子结点是黑色的;
        4.当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点的右子结点是红色,左子结点任意颜色。
     以上四种情况中,我们可以看出2,3,4其实是 "当前结点是黑色的,且兄弟结点是黑色的" 三种子集,等会在程序中可以体现出来。现在我们假设当前结点是左结点(当然也有可能是右结点,跟左结点相反即可,我们讨论一边就可以了),分别解决上面四种情况:
     对于情况1:当前结点是黑色的,且兄弟结点是红色的(那么父结点和兄弟结点的子结点肯定是黑色的)。
     如图5所示:A结点表示当前结点。针对这种情况,我们要做的操作有:将父结点(B)涂红,将兄弟结点(D)涂黑,然后将当前结点(A)的父结点(B)作为支点左旋,然后当前结点的兄弟结点就变成黑色的情况(自然就转换成情况2,3,4的公有特征了),如图6所示:

图5

图6

     对于情况2:当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点的两个子结点均为黑色的。如图7所示,A表示当前结点。针对这种情况,我们要做的操作有:将兄弟结点(D)涂红,将当前结点指向其父结点(B),将其父结点指向当前结点的祖父结点,继续新的算法(具体见下面的程序),不需要旋转。这样变成了图8所示的情况:

图7

图8

     对于情况3:当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点的左结点是红色的,右结点是黑色的。如图9所示,A是当前结点。针对这种情况,我们要做的操作有:把当前结点的兄弟结点(D)涂红,把兄弟结点的左子节点(C)涂黑,然后以兄弟结点作为支点做右旋操作。然后兄弟结点就会变成黑色的,且兄弟结点的右子结点变成红色的情况(情况4)了。如图10:

图9

图10

     对于情况4:当前结点是黑色的,且兄弟结点是黑色的,且兄弟结点的右子结点是红色,左子结点任意颜色。如图11所示:A为当前结点,针对这种情况,我们要做的操作有:把兄弟结点(D)涂成父结点的颜色,再把父结点(B)涂黑,把兄弟结点的右子结点(E)涂黑,然后以当前结点的父结点为支点做左旋操作,如图12所示。至此,删除修复算法就结束了,最后将根结点涂黑即可。

图11图12
     我们可以看出,如果是从情况1开始发生的,可能情况2,3,4中的一种:如果是情况2,就不可能在出现3和4;如果是情况3,必然会导致情况4的出现;如果2和3都不是,那必然是4.当然了,实际中可能不一定会从情况1发生,这要看具体情况了。
     至此，我们完成了全部的删除操作。下面我们看看removeFixUp方法中的具体实现(可以结合上面的分析图，更加利与理解):
     
//node表示待修正的节点，即后继节点的子节点（因为后继节点被挪到删除节点的位置去了）
private void removeFixUp(RBNode<T> node, RBNode<T> parent) {
    RBNode<T> other;
    
    while((node == null || isBlack(node)) && (node != this.root)) {
        if(parent.left == node) { //node是左子节点，下面else与这里的刚好相反
            other = parent.right; //node的兄弟节点
            if(isRed(other)) { //case1: node的兄弟节点other是红色的
                setBlack(other);
                setRed(parent);
                leftRotate(parent);
                other = parent.right;
            }
            
            //case2: node的兄弟节点other是黑色的，且other的两个子节点也都是黑色的
            if((other.left == null || isBlack(other.left)) && 
                    (other.right == null || isBlack(other.right))) {
                setRed(other);
                node = parent;
                parent = parentOf(node);
            } else {
                //case3: node的兄弟节点other是黑色的，且other的左子节点是红色，右子节点是黑色
                if(other.right == null || isBlack(other.right)) {
                    setBlack(other.left);
                    setRed(other);
                    rightRotate(other);
                    other = parent.right;
                }
                
                //case4: node的兄弟节点other是黑色的，且other的右子节点是红色，左子节点任意颜色
                setColor(other, colorOf(parent));
                setBlack(parent);
                setBlack(other.right);
                leftRotate(parent);
                node = this.root;
                break;
            }
        } else { //与上面的对称
            other = parent.left;
            
            if (isRed(other)) {
                // Case 1: node的兄弟other是红色的  
                setBlack(other);
                setRed(parent);
                rightRotate(parent);
                other = parent.left;
            }


            if ((other.left==null || isBlack(other.left)) &&
                (other.right==null || isBlack(other.right))) {
                // Case 2: node的兄弟other是黑色，且other的俩个子节点都是黑色的  
                setRed(other);
                node = parent;
                parent = parentOf(node);
            } else {


                if (other.left==null || isBlack(other.left)) {
                    // Case 3: node的兄弟other是黑色的，并且other的左子节点是红色，右子节点为黑色。  
                    setBlack(other.right);
                    setRed(other);
                    leftRotate(other);
                    other = parent.left;
                }


                // Case 4: node的兄弟other是黑色的；并且other的左子节点是红色的，右子节点任意颜色
                setColor(other, colorOf(parent));
                setBlack(parent);
                setBlack(other.left);
                rightRotate(parent);
                node = this.root;
                break;
            }
        }
    }
    if (node!=null)
        setBlack(node);
}