红黑树

一、定义

为了解决BST树在最坏情况会退化成链表，有了AVL树，但是AVL树为了维护节点平衡，在插入和删除时做了大量的旋转操作，当数据量过大时，AVL树的旋转操作就拖慢了插入删除的时间。

为了解决这个问题，就有了红黑树。

红黑树的特点：

• 红黑树是不是一棵平衡树
• 红黑树节点左右子树高度差不超过2倍（长的不能超过短的2倍）， 牺牲了一些平衡，使得插入删除操作更快
• 红黑树插入最多旋转两次，删除最多旋转三次

红黑树的五个性质：

• 每个节点都有颜色，不是黑色就是红色
• 根节点root必须是黑色
• 叶子节点都是黑色（指叶子节点的地址域null为黑色，一般null节点默认颜色是黑色）
• 不能出现连续的红色节点，也就是说红色节点的孩子节点必须是黑色的
• 从根节点root到达每一个叶子节点的路径上，黑色节点的数量都是相同的

这是一个简单的红黑树：

/**
 * 红黑树节点颜色定义
 */
enum Color{
    BLACK,RED
}

/**
 * 红黑树节点类型定义
 * @param <T>
 */
class RBNode<T extends Comparable<T>>{
    private T data;
    private RBNode<T> left;
    private RBNode<T> right;
    private RBNode<T> parent;
    private Color color;

    public RBNode(T data, RBNode<T> left, RBNode<T> right, RBNode<T> parent, Color color) {
        this.data = data;
        this.left = left;
        this.right = right;
        this.parent = parent;
        this.color = color;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public RBNode<T> getLeft() {
        return left;
    }

    public void setLeft(RBNode<T> left) {
        this.left = left;
    }

    public RBNode<T> getRight() {
        return right;
    }

    public void setRight(RBNode<T> right) {
        this.right = right;
    }

    public RBNode<T> getParent() {
        return parent;
    }

    public void setParent(RBNode<T> parent) {
        this.parent = parent;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

/**
 * RB树定义
 * @param <T>
 */
class RBTree<T extends Comparable<T>> {
    private RBNode<T> root;

    public RBTree() {
        this.root = null;
    }

    /**
     * 获取红黑树节点颜色
     * @param node
     * @return
     */
    private Color color(RBNode<T> node){
        return node == null ? Color.BLACK : node.getColor();
    }

    /**
     * 设置节点颜色
     * @param node
     * @param color
     */
    public void setColor(RBNode<T> node, Color color){
        node.setColor(color);
    }

    /**
     * 获取node节点的左孩子节点
     * @param node
     * @return
     */
    public RBNode<T> left(RBNode<T> node){
        return node.getLeft();
    }

    /**
     * 获取当前节点的右孩子节点
     * @param node
     * @return
     */
    public RBNode<T> right(RBNode<T> node){
        return node.getRight();
    }

    /**
     * 获取 当前节点的父节点
     * @param node
     * @return
     */
    public RBNode<T> parent(RBNode<T> node){
        return node.getParent();
    }
}

二、红黑树的旋转

红黑树的左旋和右旋操作同AVL树的左旋右旋原理一样，如果不明白可以参考博客AVL树看详细的图解左旋和右旋操作

左旋操作

private void leftRotate(RBNode<T> node) {
    RBNode<T> child = node.getRight();
    child.setParent(node.getParent());
    if (node.getParent() == null) {
        this.root = child;
    } else {
        if (node.getParent().getLeft() == node) {
            node.getParent().setLeft(child);
        } else {
            node.getParent().setRight(child);
        }
    }

    node.setRight(child.getLeft());
    if (child.getLeft() != null) {
        child.getLeft().setParent(node);
    }

    child.setLeft(node);
    node.setParent(child);
}

右旋操作

private void rightRotate(RBNode<T> node){
    RBNode<T> child = node.getLeft();
    child.setParent(node.getParent());
    if(node.getParent() == null)
        this.root = child;
    else if(node.getParent().getLeft() == node)
        node.getParent().setLeft(child);
    else
        node.getParent().setRight(child);
    node.setParent(child);
    node.setLeft(child.getRight());
    if(child.getRight() != null)
        child.getRight().setParent(node);
    child.setRight(node);
}

红黑树的查找操作和AVL树的查找操作相同，所以参考AVL树的查找代码即可
主要介绍插入和删除

三、红黑树的插入

红黑树插入时，插入节点是应该是红色。因为如果插入节点是黑色，那么插入位置所在的子树黑色节点总是多1。
红黑树的插入主要有以下三种情况：

1.红黑树为空树

当是空树时，直接把插入节点作为根节点，并且它设为黑色。因为红黑树规定根节点root必须是黑色。

2.插入节点的父节点是黑色

由于插入的节点是红色的，当插入节点的父节点是黑色时，不会影响红黑树的平衡，直接插入 即可。

同AVL树一样，查找合适的地方直接插入

3.插入节点的父节点是红色

这种情况又分为下面三种情况：

• 叔叔节点是红色：
  把当前插入节点的父节点和叔叔节点都设置成黑色，把祖父节点设置成红色，然后从祖父节点开始继续向上回溯

• 叔叔节点为空或者是黑色，且当前节点、父节点、祖父节点在一条线上：
  先把父节点设置成黑色，祖父节点都设置成红色，相当于把父节点和祖父节点的颜色进行交换，再进行一次旋转操作
  
• 叔叔节点为空或者是黑色，且当前节点、父节点、祖父节点不在一条线上：
  先进行一次旋转操作，将当前节点、父节点、祖父节点调整到同一侧，变成上述情况，再进行上述操作
  

/**
 * 红黑树插入
 * @param val
 */
public void insert(T val){
    if(root == null){ //空树
        //直接插入到根节点，且置为黑色
        root = new RBNode<>(val, null,null,null,Color.BLACK);
        return;
    }

    RBNode<T> parent = null;
    RBNode<T> cur = root;
    //查找合适的插入位置
    while(cur != null){
        if(cur.getData().compareTo(val) > 0){
            parent = cur;
            cur = cur.getLeft();
        } else if(cur.getData().compareTo(val) < 0){
            parent = cur;
            cur = cur.getRight();
        } else {
            return;
        }
    }
    //待插入的节点
    RBNode<T> node = new RBNode<T>(val, null, null,parent,Color.RED);
    //直接插入
    if(parent.getData().compareTo(node.getData()) > 0){
        parent.setLeft(node);
    } else{
        parent.setRight(node);
    }

    // 如果新插入节点的父节点是红色，则进行红黑树的插入调整
    if(color(parent) == Color.RED){
        fixAfterInsert(node);
    }
}

/**
 * 红黑树的插入调整操作
 * @param node
 */
private void fixAfterInsert(RBNode<T> node) {
    //node节点的父节点是红色，出现连续的红色节点，需要调整颜色
    while(color(parent(node)) == Color.RED){
        //插入节点再祖父节点的左子树上
        if(left(parent(parent(node))) == parent(node)){
            //叔叔节点
            RBNode<T> uncle = right(parent(parent(node)));
            //叔叔节点是红色
            if(color(uncle) == Color.RED){ // 插入情况3.1
                setColor(parent(node), Color.BLACK); //父亲节点置为黑色
                setColor(uncle, Color.BLACK); //叔叔节点置为黑色
                setColor(parent(parent(node)), Color.RED); //祖父节点置为红色
                node = parent(parent(node)); //node指向祖父节点，继续向上回溯调整
            } else {
                //叔叔节点为黑色，且祖父、父亲、插入节点不在一条线上
                if(node == right(parent(node))){ // 插入情况3.3前半段
                    node = parent(node);
                    leftRotate(node); //左旋
                }
                // 插入情况3.3后半段和情况3.2合并
                //祖父、父亲、当前节点在一条直线上，直接做右旋转操作
                setColor(parent(node), Color.BLACK); //将父节点置成黑色，旋转以后就成为根节点了
                setColor(parent(parent(node)), Color.RED);//祖父节点置成红色
                //以祖父节点为根节点做右旋操作
                rightRotate(parent(parent(node)));
                break; //调整完成，跳出循环
            }
        } else {
            // 插入节点在祖父节点的右子树上，和上面的所有情况相反
            RBNode<T> uncle = left(parent(parent(node)));
            if(color(uncle) == Color.RED){ // 插入情况3.1
                setColor(parent(node), Color.BLACK);
                setColor(uncle, Color.BLACK);
                setColor(parent(parent(node)), Color.RED);
                node = parent(parent(node));
            } else {
                if(node == left(parent(node))){ // 插入情况3.3前半段
                    node = parent(node);
                    rightRotate(node);
                }

                setColor(parent(node), Color.BLACK); // 插入情况3.33后半段和情况3.22合并
                setColor(parent(parent(node)), Color.RED);
                leftRotate(parent(parent(node)));
                break;
            }
        }
    }
    // 有可能向上回溯时把根节点置成红色，直接把根节点设置成黑色
    setColor(this.root, Color.BLACK);
}

四、红黑树的删除

红黑树的删除操作和插入操作一样，都需要在不同的情况下进行相应的调整，并且删除操作还稍微要复杂一点

如果删除的是红色节点 ，直接删除就可以，因为黑色节点的数量不会变化

但是如果删除的是黑色节点 ，删除完节点就需要进行调整，因为破坏了红黑树的性质，某一个分支路径上的黑色节点少了一个。
这种情况主要分为四种小的情况：

情况1

兄弟节点是红色

兄弟节点是红色的，所以删除一个黑色节点后无法借调一个黑色节点过来，但是兄弟节点的孩子肯定都是黑色的，所以以该节点的父节点为根节点进行一次旋转操作，把黑色的兄弟节点提上来，就可以借调黑色节点了。

情况2

兄弟节点是黑色的，而且兄弟节点的两个孩子也都是黑色的
直接把兄弟节点设置成红色，然后从父节点开始继续回溯调整。

情况3

兄弟是黑色，和父亲，兄弟在同一侧的兄弟的孩子为红色

将兄弟节点颜色置为父亲节点的颜色，再将父亲节点颜色涂成黑色，将兄弟节点的红色孩子涂成黑色，再以父节点为根节点进行旋转
ps：当前节点在为左孩子，左旋，右孩子，右旋

情况4

兄弟是黑色，和父亲，兄弟不在同一侧的兄弟的孩子为红色
将兄弟节点的颜色和其红色孩子颜色交换，再将兄弟节点作为根节点进行旋转，就变成了情况3。
ps：兄弟为左子树，左旋，右子树，右旋

    /**
     * 红黑树的删除
     */
    public void remove(T data){
        if(this.root == null)  //空树
            return;

        RBNode<T> cur = this.root;
        //搜索要删除的节点
        while(cur != null){
            if(cur.getData().compareTo(data) > 0){
                cur = cur.getLeft();
            } else if(cur.getData().compareTo(data) < 0){
                cur = cur.getRight();
            } else {
                break;
            }
        }

        if(cur == null){
            return;
        }
        //待删除的节点有两格孩子 转换成有一个孩子的节点，或者叶子节点的删除
        if(cur.getLeft() != null && cur.getRight() != null){
            //用前驱节点代替
            RBNode<T> old = cur;
            cur = cur.getLeft();
            while(cur.getRight() != null){
                cur = cur.getRight();
            }
            old.setData(cur.getData());
        }

        // 删除cur指向的节点
        RBNode<T> child = cur.getLeft();
        if(child == null){
            child = cur.getRight();
        }

        if(child != null){
            child.setParent(cur.getParent());
            if(cur.getParent() == null){
                this.root = child;
            } else {
                if(cur.getParent().getLeft() == cur){
                    cur.getParent().setLeft(child);
                } else {
                    cur.getParent().setRight(child);
                }
            }
            //如果删除的是黑色节点，需要进行调整
            if(color(cur) == Color.BLACK){
                fixAfterRemove(child);
            }
        } else {
            if(cur.getParent() == null){
                this.root = null;
            } else {
                if(color(cur) == Color.BLACK){
                    fixAfterRemove(cur);
                }

                if(cur.getParent().getLeft() == cur){
                    cur.getParent().setLeft(null);
                } else {
                    cur.getParent().setRight(null);
                }
            }
        }
    }

    /**
     * 删除时对红黑树的调整
     * @param node
     */
    private void fixAfterRemove(RBNode<T> node) {
        //回溯过程中遇到根节点或者红色节结束循环
        while(node != this.root && color(node) == Color.BLACK){
            if(node == left(parent(node))){
                RBNode<T> brother = right(parent(node));
                //兄弟节点是红色，无法借一个黑色节点，需要左旋，把黑色节点的子节点往上提
                if(color(brother) == Color.RED){
                    setColor(brother, Color.BLACK);
                    setColor(parent(node), Color.RED);
                    leftRotate(parent(node));
                    brother = right(parent(node));
                }
                // 兄弟节点是黑色，而且兄弟节点的两个孩子也是黑色节点，把兄弟节点改成红色，继续回溯父节点
                if(color(left(brother)) == Color.BLACK
                        && color(right(brother)) == Color.BLACK){
                    setColor(brother, Color.RED);
                    node = parent(node);
                } else {
                    // 兄弟节点是黑色，但是右孩子没有红色节点（借给左子树后，右子树设法给自己添加一个黑色节点保证黑色节点数量不变）
                    if(color(right(brother)) != Color.RED){
                        setColor(brother, Color.RED);
                        setColor(left(brother), Color.BLACK);
                        rightRotate(brother);
                        brother = right(parent(node));
                    }

                    // 兄弟节点是黑色，而且右孩子是红色，直接左旋，并把右孩子直接调成黑色
                    setColor(brother, color(parent(node)));
                    setColor(parent(node), Color.BLACK);
                    setColor(right(brother), Color.BLACK);
                    leftRotate(parent(node));
                    break;
                }
            } else {
                // 兄弟节点是红色，无法借一个黑色节点，需要右旋转，把兄弟节点的子节点黑色节点往上提
                RBNode<T> brother = left(parent(node));
                if(color(brother) == Color.RED){
                    setColor(brother, Color.BLACK);
                    setColor(parent(node), Color.RED);
                    rightRotate(parent(node));
                    brother = left(parent(node));
                }

                //兄弟节点是黑色，而且兄弟节点的两个孩子也是黑色节点
                if(color(left(brother)) == Color.BLACK
                        && color(right(brother)) == Color.BLACK){
                    setColor(brother, Color.RED);
                    node = parent(node);
                } else {
                    // 兄弟节点是黑色，但是左孩子没有红色节点
                    if(color(left(brother)) != Color.RED){
                        setColor(brother, Color.RED);
                        setColor(right(brother), Color.BLACK);
                        leftRotate(brother);
                        brother = left(parent(node));
                    }

                    // 兄弟节点是黑色，而且左孩子是红色，直接左旋，并把右孩子直接调成黑色
                    setColor(brother, color(parent(node)));
                    setColor(parent(node), Color.BLACK);
                    setColor(left(brother), Color.BLACK);
                    rightRotate(parent(node));
                    break;
                }
            }
        }
        /**
         * 删除黑色节点后，其孩子节点是红色，直接调成黑色，结束上面循环，保持黑色节点数量不变；
         * 删除黑色节点后，其孩子节点是黑色，但是向上回溯的时候，遇到红色节点，直接改成黑色节点，结束上面循环，保持黑色节点数量不变
         */
        // 在当前这一路遇见红色节点，直接补一个黑色节点
        setColor(node, Color.BLACK);
    }