红黑树学习总结

一、红黑树特性

1、所有节点不是黑色就是红色。

2、根节点为黑色。

3、null节点为黑色，区别于叶子节点。

4、如果当前节点为红色节点，孩子则全为黑色节点（反之不然）。

5、任意节点到叶子节点的所有路径都包含相同的黑色节点（保持平衡的重要原因）。

三、红黑树修正方式

1、染色：为了符合红黑树的规则特性而改变当前节点的颜色。

2、旋转 :平衡二叉树的操作共性

（1）左旋

　　演示：

 

　　代码：

 public void leftRotate(RBNode<T> x){
        if(x==null) return;

        RBNode<T> y = x.right;
        x.right = y.left;
        if(y.right!=null){
            y.right.parent = x;
        }

        y.parent = x.parent;
        if(x.parent==null){
            mRoot = y;
        }else{
            if(x==x.parent.left){
                x.parent.left = y;
            }else{
                x.parent.right = y;
            }
        }
        //设置x与y之间的关系
        x.parent = y;
        y.left = x;

    }

（2）右旋

　　演示：

　　代码：

 public void rightRotate(RBNode<T> x){
        if(x==null) return;

        RBNode<T> y = x.left;
        x.left = y.right;
        if(y.right!=null){
            y.right.parent = x;
        }
        y.parent = x.parent;
        if(x.parent==null){
            mRoot = y;
        }else{
            if(x==x.parent.left){
                x.parent.left = y;
            }else{
                x.parent.right = y;
            }
        }
        x.parent = y;
        y.right = x;
    }

 四、红黑树插入节点

步骤：1、按照二叉树的插入规则插入节点（节点为红色）。2、修正红黑树。

插入节点为红色：插入黑色节点，一定破坏红黑树结构（特性5）。插入红色节点，可能破坏特性（2,4）

情况分析

分析插入节点的父节点为祖父节点的左孩子，如果插入节点的父节点为祖父节点的右孩子则为镜像操作。

核心步骤：看父亲节点，看叔叔节点，看插入位置。

　　*如果插入红色节点的父节点为黑色，树不需要调整。

　　*如果插入红色节点的父节点为红色，树需要调整。

　　　　（1）叔叔节点为红色。

　　　　（2）叔叔节点为黑色，添加节点为父亲节点的左孩子。

　　　　（3）叔叔节点为黑色，添加节点为父亲节点的右孩子。

case1：父亲节点为红色，叔叔节点也为红色：

上边的目标节点为左孩子，下边的目标节点为右孩子。

解释：

　　*将父节点和叔叔节点全部染成黑色（节点T满足了特性四），但是这样父亲和叔叔节点的分支都多了一个黑色；

　　*将祖父节点染成红色，这样祖父节点的两个分支满足了所有特性，但是我们需要检验祖父节点是否符合红黑树的特性；

　　*将祖父节点当做插入节点，向根节点进行回溯修改。

停止条件：一直向上回溯，直到父节点变为黑色，或者达到树根为止。

case2：父亲节点为红色，叔叔节点为黑色，插入节点为父亲节点的左孩子。

修正过程：

 解释：

　　（1）将父亲节点染成黑色。

　　（2）将祖父节点染成红色。

　　（3）对祖父节点进行右旋。

case3：父亲节点为红色，叔叔节点为黑色，插入节点为父亲节点的右孩子。

修正过程：

解释：

　　（1）对父节点进行左旋操作、

　　（2）将父节点当做插入节点，执行case2情况的红黑树修正。

五、红黑树删除节点

1、平衡二叉树操作方式删除节点

删除case：

　　（1）待删节点为叶子节点，直接删除。

　　（2）待删节点只存在一个孩子，使用孩子替换待删节点。

　　（3）待删节点存在左右孩子，使用中序遍历结果中的后继节点替换待删节点（实际回到了case2）。

删除节点时重点：

　　case1：直接解除待删节点与父节点之间的关系。

　　case2：建立待删节点的父节点与替换节点的关系。

　　case3：1、建立待删节点的父节点与替换节点的关系；2、建立替换节点的父节点与替换节点子节点之间的关系；3、建立替换节点与待删节点的子节点之间的关系。

2、红黑树修正：分析父节点为祖父节点的左孩子，右孩子则为镜像操作。

当删除节点为黑色，需要修正红黑树。

删除节点判断：删除情况的case1和case，删除节点为实际被删节点。删除情况的case3，删除节点为替换节点（因为替换节点被移动到被删节点的位置，并染成与实际被删节点相同的颜色）。

核心思想：从兄弟节点借调黑色节点。

case1：被删节点为黑色节点，兄弟节点为红色

修正过程：

 解释：

　　*将父节点涂红，将兄弟节点涂黑，然后将当前节点的父节点进行支点左旋。这样就转换为兄弟节点为黑色的情况

case2：当前节点为黑色，兄弟节点为黑色，兄弟节点的左右孩子都为黑色

修成过程：

解释：

　　*将兄弟节点涂红，将当前节点指向其父节点，将其父节点指向当前节点的祖父节点，继续往树根递归判断以及调整；

case3：当前节点为黑色，兄弟节点为红色，近侄子为红色（兄弟节点的左孩子），远侄子为黑色（兄弟节点的右孩子）

修正过程：

 解释：

　　*把当前节点的兄弟节点涂红，把兄弟节点的左子节点涂黑，然后以兄弟节点作为支点做右旋操作。

 case4：当前节点为黑色节点，兄弟节点为黑色，近侄子为任意色（兄弟节点的左孩子），远侄子为红色（兄弟节点的右孩子）

修正过程：

 解释：

　　*把兄弟节点涂成父节点的颜色，再把父节点涂黑，把兄弟节点的右子节点涂黑，然后以当前节点的父节点为支点做左旋操作。

六、红黑树完整代码（java实现）

package RBTree;

/**
 * 红黑树演示
 * @param <T>
 */
public class RBTree<T extends Comparable<T>> {

    public RBNode<T> mRoot = null;
    public static boolean RED = true;
    public static boolean BLACK = false;
    //节点结构
    class RBNode<T extends Comparable<T>>{
       boolean color;
       T key;
       RBNode<T> right;
       RBNode<T> left;
       RBNode<T> parent;

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

        public boolean getColor(){
            return this.color;
        }
        @Override
        public String toString() {
            return "RBNode{" +
                    "color=" + color +
                    ", key=" + key +
                    ", right=" + right +
                    ", left=" + left +
                    ", parent=" + parent +
                    '}';
        }
    }

    /**
     * 左旋：设父节点x,x的左子节点y
     * 1、
     * @param x
     */
    public void leftRotate(RBNode<T> x){
        if(x==null) return;

        RBNode<T> y = x.right;
        x.right = y.left;
        if(y.right!=null){
            y.right.parent = x;
        }

        y.parent = x.parent;
        if(x.parent==null){
            mRoot = y;
        }else{
            if(x==x.parent.left){
                x.parent.left = y;
            }else{
                x.parent.right = y;
            }
        }
        //设置x与y之间的关系
        x.parent = y;
        y.left = x;

    }

    /**
     * 右旋：左旋的镜像
     * @param x
     */
    public void rightRotate(RBNode<T> x){
        if(x==null) return;

        RBNode<T> y = x.left;
        x.left = y.right;
        if(y.right!=null){
            y.right.parent = x;
        }
        y.parent = x.parent;
        if(x.parent==null){
            mRoot = y;
        }else{
            if(x==x.parent.left){
                x.parent.left = y;
            }else{
                x.parent.right = y;
            }
        }
        x.parent = y;
        y.right = x;
    }

    public boolean isRED(RBNode<T> node){
       return node!=null&&node.getColor();
    }
    /**
     * 插入节点接口
     * @param key
     */
    public void insert(T key){
        RBNode node = new RBNode<T>(RED,key,null,null,null);
        insert(node);
    }

    /**
     * 在红黑树中插入节点，
     * 同二叉搜索树的方法相同
     * @param node
     */
    public void insert(RBNode<T> node){
        RBNode<T> k = mRoot;
        RBNode<T> current = null;
        //定位
        while(k!=null){
            current = k;
            int res = node.getKey().compareTo(k.getKey());
            if(res<0){
                k = k.left;
            }else{
                k = k.right;
            }
        }
        node.parent = current;
        //插入节点
        if(current!=null){
            int res = node.getKey().compareTo(current.getKey());
            if(res<0){
                current.left = node;
            }else{
                current.right = node;
            }
            insertFixUp(node);
        }else{
            mRoot = node;
        }
    }

    /**
     * 修正插入节点后的红黑树
     * 如果插入节点的父节点为红色，违背红黑树特性（1、红节点的孩子全为黑节点；2、路径中的黑节点个数）。
     * case：考虑父节点为祖父节点的左孩子，如果是右孩子则为镜像
     * 1、父节点的兄弟节点为红色
     * 2、父节点的兄弟节点为黑色，插入节点左为父节点的左孩子
     * 3、父节点的兄弟节点为黑色，插入位置作为父节点的右孩子
     * @param node
     */
    public void insertFixUp(RBNode<T> node){
            RBNode<T> parent,gparent;
            while((parent=node.parent)!=null && isRED(parent)){
                gparent = parent.parent;
                //父节点为祖父节点的左孩子
                if(parent==gparent.left){
                    RBNode<T> uncle = gparent.right;
                    //case1:叔叔节点为红色
                    if(uncle!=null && isRED(uncle)){
                        parent.color = BLACK;
                        uncle.color = BLACK;
                        gparent.color = RED;
                        node = gparent;
                        continue;
                    }
                    //case3:叔叔节点为黑色，插入节点为父节点的右孩子
                    if(node==parent.right){
                        /*
                        对父节点进行左旋，变成第case2
                         */
                        leftRotate(parent);
                        //调整父节点与子节点的关系
                        RBNode<T> tmp = parent;
                        parent = node;
                        node = tmp;
                    }
                    //case2:叔叔节点为黑色，插入节点为父节点的左孩子
                    parent.color = BLACK;
                    gparent.color = RED;
                    rightRotate(gparent);
                }else{  //父节点为祖父节点的右孩子,基本为镜像操作
                    RBNode<T> uncle = gparent.left;

                    if(uncle!=null && isRED(uncle)){
                        uncle.color = BLACK;
                        parent.color = BLACK;
                        gparent.color = RED;
                        node = gparent;
                        continue;
                    }
                    if(node==parent.left){
                        rightRotate(parent);
                        RBNode<T> tmp = parent;
                        parent = node;
                        node = tmp;
                    }
                    parent.color = BLACK;
                    gparent.color = RED;
                    leftRotate(gparent);
                }
            }
            this.mRoot.color = BLACK;
    }

    /**
     * 删除节点
     * 1、删除节点：保证二叉树规则
     * 2、调整结构：保证红黑树规则。
     *      (1)删除节点为红色，不需要进行调整
     *      (2)删除节点为黑色，需要进行调整
     * @param key
     */
    public void remove(T key){
        RBNode<T> node;
        if((node = search(mRoot,key))!=null){
            remove(node);
        }
    }
    public void remove(RBNode<T> node){
        RBNode<T> child,parent;
        boolean color;
        /*
        待删除节点同时存在左右孩子
        找到后继节点：中序遍历的下一个节点
         */
        if(node.left!=null && (node.right!=null)){
            RBNode<T> replace = node.right;
            while(replace.left!=null){
                replace = replace.left;
            }
            //处理待删节点的父节点与后继节点的关系
            if(node.parent!=null){
                if(node==node.parent.left){
                    node.parent.left = replace;
                }else{
                    node.parent.right= replace;
                }
            }else{
                mRoot = replace;
            }
            //建立后继节点的子节点与父节点的关系
            //后继节点一定不存在左孩子。
            child = replace.right;
            parent = replace.parent;
            color = replace.color;
            //后继节点的父节点为待删节点
            if(parent==node){
                parent = replace;
            }else{
                if(child!=null){
                    child.parent = parent;
                }
                parent.left = child;
                //处理后继节点与待删节点的子节点的关系
                replace.right = node.right;
                node.right.parent = replace;
            }
            replace.parent = node.parent;
            replace.color = node.color;
            replace.left = node.left;
            node.right.parent = replace;
            if(color == BLACK){
                removeFixUp(child,parent);
            }
            //删除节点
            node = null;
        }else{
            //被删除的节点为叶子节点或只有一个孩子
            if(node.left!=null){
                child = node.left;
            }else{
                child = node.right;
            }
            parent = node.parent;
            color = node.color;
            if(child!=null){
                child.parent = parent;
            }
            if(parent!=null){
                if(node == node.parent.left){
                    node.parent.left = child;
                }else{
                    node.parent.right = child;
                }
            }else{
                mRoot = child;
            }
            if(color == BLACK){
                removeFixUp(child,parent);
            }
            node = null;
        }
    }

    /**
     * 为了保证删除节点的父节点左右两边黑色节点数一致，需要重点关注父节点没删除的那一边节点是不是黑色。
     *  * 如果删除后父亲节点另一边比删除的一边黑色多，就要想办法搞到平衡。
     *  * 1、把父亲节点另一边（即删除节点的兄弟树）其中一个节点弄成红色，也少了一个黑色。
     *  * 2、或者把另一边多的节点（染成黑色）转过来一个
     *  *
     *  * 1）、当前节点是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）；
     *  * 2）、当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的两个子节点均为黑色的；
     *  * 3）、当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的左子节点是红色，右子节点时黑色的；
     *  * 4）、当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的右子节点是红色，左子节点任意颜色。
     * @param node
     * @param parent
     */
    public void removeFixUp(RBNode<T> node,RBNode<T> parent){
            RBNode<T> other;
            RBNode<T> root = mRoot;
            while((node==null || node.color == BLACK) && node!=root){
                if(node == parent.left){
                    other = parent.right;
                    //case1：兄弟节点为红色
                    if(other!=null && isRED(other)){
                        other.color = BLACK;
                        parent.color = RED;
                        leftRotate(parent);
                        other = parent.right;
                    }
                    //case2:兄弟节点为黑色，其左右孩子也为黑色。
                    if((other.left == null || other.left.color==BLACK) &&
                            (other.right==null || other.right.color==BLACK)){
                        other.color = RED;
                        node = parent;
                        parent = node.parent;
                    }else{
                        //case3:兄弟节点为黑色，兄弟节点的左孩子为红色色，右孩子为黑色。
                        if(other.right == null || other.right.color==BLACK){
                            other.left.color = BLACK;
                            other.color = RED;
                            rightRotate(other);
                            other = parent.right;
                        }
                        //case4:兄弟节点为黑色，且兄弟节点的右孩子红色，左孩子任意颜色
                        other.color = parent.color;
                        parent.color = BLACK;
                        other.right.color = BLACK;
                        leftRotate(parent);
                        node = root;
                        break;
                    }
                }else{
                    other = parent.left;
                    if(other!=null && isRED(other)){
                        other.color = BLACK;
                        parent.color = RED;
                        rightRotate(parent);
                        other = parent.left;
                    }
                    if((other.left==null || other.left.color==BLACK) &&
                            (other.right==null || other.right.color==BLACK)){
                       other.color = RED;
                       node = parent;
                       parent = node.parent;
                    }else{
                        if(other.left==null || other.left.color==BLACK){
                            other.right.color = BLACK;
                            other.color = RED;
                            leftRotate(other);
                            other = parent.left;
                        }
                        other.color = parent.color;
                        parent.color = BLACK;
                        other.left.color = BLACK;
                        rightRotate(parent);
                        node = root;
                        break;
                    }
                }
            }
            if(node != null){
                node.color = BLACK;
            }
    }

    /**
     * 搜索key
     * 返回key所在节点
     * @param key
     * @return
     */
    public RBNode<T> search(RBNode<T> mRoot,T key){
        if(mRoot==null){
            return null;
        }
        RBNode<T> current = mRoot;
        while(current!=null){
            int res = key.compareTo(current.getKey());
            if(res<0){
                current = current.left;
            }else if(res>0){
                current = current.right;
            }else{
                //找到节点
                return current;
            }
        }
        return null;

    }
    
}

 

博客参考：

http://dandanlove.com/2018/03/18/red-black-tree/（基本参考了此博客）

https://zhuanlan.zhihu.com/p/24367771

http://blog.csdn.net/eson_15/article/details/51144079

将将当前节点指向其父节点，将其父节点指向当前节点的祖父节点，继续往树根递归判断以及调整；