十、红黑树

package rbtree;

public class RBTree<K extends Comparable<K>, V> {
    private static final boolean RED = true;
    private static final boolean BLACK = false;
    private RBNode root;//根节点


    //寻找当前节点的父节点parentOf()
    private RBNode parentOf(RBNode node) {
        if (node != null) {
            return node.parent;
        }
        return null;
    }

    //判断当前节点是否为红色
    private boolean isRed(RBNode node) {
        if (node != null) {
            return node.color == RED;
        }
        return false;
    }

    //判断当前节点是否为黑色
    private boolean isBlack(RBNode node) {
        if (node != null) {
            return node.color == BLACK;
        }
        return false;
    }

    //设置节点成红色
    private void setRed(RBNode node) {
        if (node != null) {
            node.color = RED;
        }
    }

    //设置节点成黑色
    private void setBlack(RBNode node) {
        if (node != null) {
            node.color = BLACK;
        }
    }

    //中序遍历
    public void inOrderPrint() {
        inOrderPrint(this.root);
    }

    //内部中序遍历
    private void inOrderPrint(RBNode node) {
        if (node != null) {
            inOrderPrint(node.left);
            System.out.println("key:" + node.key + ",value:" + node.value);
            inOrderPrint(node.right);
        }
    }

    //左旋

    /**
     * p                           p
     * |                           |
     * x                           y
     * / \       -->               / \
     * lx   y                       x   ry
     * / \                     / \
     * ly   ry                 lx   ly
     * <p>
     * 1.将ly设置成x的右子节点
     * 2.将x的父节点设置成y的父节点
     * 3.将y的左子节点设置成x
     */
    private void leftRotate(RBNode x) {
        if (x != null) {
            RBNode y = x.right;
            //1.
            if (y != null) {
                x.right = y.left;
                RBNode ly = y.left;
                if (ly != null) {
                    ly.parent = x;
                }
                //2.
                if (x.parent != null) {
                    y.parent = x.parent;
                    if (x.parent.left == x) {
                        x.parent.left = y;
                    } else {
                        x.parent.right = y;
                    }
                } else {
                    this.root = y;
                }
                //3.
                y.left = x;
                x.parent = y;
            } else {
                return;
            }
        } else {
            return;
        }
    }

    //右旋

    /**
     * p                           p
     * |                           |
     * x                           y
     * / \       -->               / \
     * y   lx                     ly   x
     * / \                             / \
     * ly   ry                         ry   lx
     * <p>
     * 1.将ry设置成x的右子节点
     * 2.将x的父节点设置成y的父节点
     * 3.将y的右子节点设置成x
     */
    private void rightRotate(RBNode x) {
        if (x == null) {
            return;
        } else {
            RBNode y = x.left;
            if (y == null) {
                return;
            } else {
                //1.
                RBNode ry = y.right;
                x.left = ry;
                if (ry != null) {
                    ry.parent = x;
                }
                //2.
                if (x.parent != null) {
                    y.parent = x.parent;
                    if (x.parent.left == x) {
                        x.parent.left = y;
                    } else {
                        x.parent.right = y;
                    }
                } else {
                    this.root = y;
                }
                //3.
                y.right = x;
                x.parent = y;
            }
        }
    }

    //外部插入方法
    public void insert(K key, V value) {
        //将key和value封装成一个node对象
        RBNode node = new RBNode();
        node.setKey(key);
        node.setValue(value);
        node.setColor(RED);
        insert(node);
    }

    //内部插入方法
    private void insert(RBNode node) {
        RBNode parent = null;
        RBNode temp = this.root;//临时变量，为找到当前node的父节点
        while (temp != null) {
            parent = temp;
            int cmp = node.key.compareTo(temp.key);
            if (cmp > 0) {//当前node.key比parent大
                temp = temp.right;
            } else if (cmp == 0) {//当前node.key等于parent，直接更新parent的value值
                temp.setValue(node.getValue());
                return;
            } else {//当前node.key比parent小
                temp = temp.left;
            }
        }
        node.parent = parent;
        if (parent != null) {
            int cmp = node.key.compareTo(parent.key);
            if (cmp > 0) {
                parent.right = node;//node插入到右面
            } else {
                parent.left = node;//node插入到左面
            }
        } else {
            this.root = node;
        }

        //插入后会破坏红黑树的平衡，需要调用修复平衡的方法insertFixup()
        insertFixUp(node);

    }


    /**
     * 插入后修复红黑树的方法
     * |--情景1：红黑树为空树，将根节点染色为黑色
     * |--情景2：插入节点的key已经存在，不需要处理
     * |--情景3：插入节点的父节点为黑色，因为所插入的路径上的黑色节点没有变化，所以不用处理
     * |--情景4：插入节点的父节点为红色，需要我们处理：
     * |--4.1：叔叔节点存在，并且为红色（父-叔 双红），将爸爸和叔叔染色为黑色，再将爷爷染色为红色，并且再以
     * 爷爷为当前节点，进行下一轮的处理
     * |--4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
     * |--4.2.1：插入节点为其父节点的左子节点（LL情况），将爸爸染色为黑色，将爷爷染色为红色，然后以爷爷节点右旋，就完成了
     * |--4.2.2：插入节点为其父节点的右子节点（LR情况），以爸爸节点进行一次左旋，得到4.2.1的情况
     * 然后以爸爸节点为当前节点，进行下一轮操作
     * |--4.3：叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
     * |--4.3.1：插入节点为其父节点的右子节点（RR情况），将爸爸染色为黑色，将爷爷染色为红色，然后以爷爷节点左旋，就完成了
     * |--4.3.2：插入节点为其父节点的左子节点（Rl情况），以爸爸节点进行一次右旋，得到4.2.1的情况
     * *                  然后以爸爸节点为当前节点，进行下一轮操作
     */
    private void insertFixUp(RBNode node) {
        RBNode parent = parentOf(node);
        RBNode gparent = parentOf(parent);
        if (parent != null && isRed(parent)) {
            //如果父节点为红色，那么一定有根节点，因为根节点不可能为红色
            RBNode uncle = null;
            //
            if (parent == gparent.left) {//父节点为爷爷节点的左子树
                uncle = gparent.right;
                if (uncle != null && isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                if (uncle == null || isBlack(uncle)) {
                    if (node == parent.left) {
                        setBlack(parent);
                        setRed(gparent);
                        rightRotate(gparent);
                        return;
                    }
                    if (node == parent.right) {
                        leftRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            } else {//父节点为爷爷节点的右子树
                uncle = gparent.left;
                if (uncle != null && isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                if (uncle == null || isBlack(uncle)) {
                    if (node == parent.right) {
                        setBlack(parent);
                        setRed(gparent);
                        leftRotate(gparent);
                        return;
                    }
                    if (node == parent.left) {
                        rightRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            }
        }

    }

    static class RBNode<K extends Comparable<K>, V> {
        private RBNode parent;
        private RBNode left;
        private RBNode right;
        private boolean color;
        private K key;
        private V value;

        public RBNode() {
        }

        public RBNode(RBNode parent, RBNode left, RBNode right, boolean color, K key, V value) {
            this.parent = parent;
            this.left = left;
            this.right = right;
            this.color = color;
            this.key = key;
            this.value = value;
        }

        public RBNode getParent() {
            return parent;
        }

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

        public RBNode getLeft() {
            return left;
        }

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

        public RBNode getRight() {
            return right;
        }

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

        public boolean isColor() {
            return color;
        }

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

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }

}