红黑树的插入与删除 基于JDK15 源码

这里是做了一个简单封装 没有设置键值对 只设置了一个整形的值 方便比较

**具体情况都在注解里面分析了 **

为了描述方便 注解里面的黑高 指的是左右子树最大的黑高

插入最终只会有两种解决情况 叔叔是红 ， 或者叔叔是黑。虽然叔叔是黑可以分为两种，但其中一种可以通过旋转变成另外一种，进行处理也是转化为一种情况处理。

删除最终只会有一种解决情况，如果兄弟是红，直接旋转父亲 父亲的一个孩子会变成兄弟的孩子之一 ， 但都是黑色。所以说更新之后，新兄弟也就成了黑色。所以说最终只会有一种情况 兄弟是黑。

兄弟是黑：

• 1.如果孩子都是黑 直接把兄弟变红 因为你删除节点 节点是确定为黑色 那么一边的黑色节点就少了1个 恰巧兄弟是黑 兄弟的孩子也都是黑 直接把兄弟变红 那么兄弟这棵树的黑色节点也刚刚少了1个， 同时因为把兄弟变红 父亲必要变黑即可
• 2如果(假设删除节点在左子树)兄弟其中一个是红 不能再对其进行单纯的染色操作了(因为兄弟无法染成红色的)，想到如果旋转父亲，让兄弟不再构成右树的黑高，那么右树黑高减一，但是删除节点之后左树黑高是0，依然不平衡。这时我们进行了旋转，父亲变成了左子树的节点，只要把父亲染黑就达成了想到的目的。
  但是下一个问题是 如果红色节点跟着父亲一起跑到左子树去，现在右子树是损失了一个黑高，那么为了平衡，需要把右子树中红色的节点变黑才能弥补损失。那就意味着红色节点不能跟着父亲跑过去，如果确定了红色节点会跑过去，那么就对兄弟进行旋转，把红色节点移到另一边去，对应的原来节点的位置就为空了。那么就没有节点跟着跑过去。就不会影响右子树黑高变化。

弄清楚了最终状态，其他状态可以直接通过旋转变成最终状态。
有些文章光是图就是十几个 直接给我看麻了。仔细梳理一遍Java TreeMap 对红黑树的实现其实可以发现情况也就那么几种。

具体实现细节可以看代码，对源码提取出来简化了一部分 方便理解和阅读

public class RBTree {

    private TreeNode root;
    
    private enum Color{
        RED,
        BLACK
    }

    private static class TreeNode {
        TreeNode parent;
        TreeNode left;
        TreeNode right;
        int val;
        Color color;

        @SuppressWarnings("unused")
        public TreeNode(){}

        public TreeNode(int val, TreeNode parent, TreeNode left, TreeNode right){
            this.val = val;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }

        @Override
        public String toString() {
            return "TreeNode{" +
                    "val=" + val +
                    ", color=" + color +
                    '}' + "\t";
        }
    }

    public RBTree(){

    }

    private Color colorOf(TreeNode p){
        return (p == null) ? Color.BLACK : p.color;
    }

    private void rotateLeft(TreeNode p){
        TreeNode r = p.right;
        p.right = r.left;
        if(r.left != null){
            r.left.parent = p;
        }
        r.parent = p.parent;
        if(p.parent == null){
            root = r;
        }else if(p.parent.left == p){
            p.parent.left = r;
        }else{
            p.parent.right = r;
        }
        r.left = p;
        p.parent = r;
    }

    private void rotateRight(TreeNode p){
        TreeNode l = p.left;
        p.left = l.right;
        if(l.right != null){
            l.right.parent = p;
        }
        l.parent = p.parent;
        if(p.parent == null){
            root = l;
        }else if(p.parent.left == p){
            p.parent.left = l;
        }else{
            p.parent.right = l;
        }
        l.right = p;
        p.parent = l;
    }

    private void fixAfterInsertion(TreeNode p){
        p.color = Color.RED; // 插入节点设置为红
        while(p != null && p != root && p.parent.color == Color.RED){
            if(p.parent.parent.left == p.parent){
                TreeNode uncle = p.parent.parent.right; // 获取到叔叔节点
                if(colorOf(uncle) == Color.RED){ // 叔叔节点是红色 父亲也是红色 插入节点也是红色
                    uncle.color = Color.BLACK; // 左右黑高已经平衡 但父亲和插入节点连续红色 只需要把父亲叔叔染黑
                    p.parent.color = Color.BLACK; // 父亲叔父染黑之后 祖父必须也要染红 然后检查祖父是否需要修复
                    p.parent.parent.color = Color.RED;
                    p = p.parent.parent;
                }else{ // 叔叔是黑色 意味着叔叔构成了右树的黑高 要想解决父亲和插入节点连续红色 任然只有尝试把父亲染黑
                    // 父亲染黑之后 右边黑高变大 只有把祖父节点右旋下沉 才可以平衡 因为祖父右旋 父亲不再构成左树黑高
                    // 但是如果插入节点在父亲的右边 祖父节点右旋会带走插入节点 只有把父亲先左旋 插入节点为根父亲为左孩子
                    if(p.parent.right == p){
                        p = p.parent;
                        rotateLeft(p);
                    }
                    // 处理完之后 现在可以右旋祖父
                    // 祖父右子树是叔叔为黑色 左子树来自父亲的右子树 父亲原本是红 意味着
                    // 祖父右旋之后 祖父左右都是黑 所以说需要把祖父染红
                    p.parent.color = Color.BLACK;
                    p.parent.parent.color = Color.RED;
                    rotateRight(p.parent.parent);
                }
            }else{
                TreeNode uncle = p.parent.parent.left;
                if(colorOf(uncle) == Color.RED){
                    uncle.color = Color.BLACK;
                    p.parent.color = Color.BLACK;
                    p.parent.parent.color = Color.RED;
                    p = p.parent.parent;
                }else{
                    if(p.parent.left == p){
                        p = p.parent;
                        rotateRight(p);
                    }
                    p.parent.color = Color.BLACK;
                    p.parent.parent.color = Color.RED;
                    rotateLeft(p.parent.parent);
                }
            }
        }
        root.color = Color.BLACK;
    }

    public void insert(int val){
        if(root == null){
            root = new TreeNode(val, null, null, null);
        }else{
            TreeNode node = root;
            TreeNode recordOfParent = node;
            while(node != null){
                recordOfParent = node;
                node = (node.val > val) ? node.left : node.right;
            }
            TreeNode point = new TreeNode(val, null, null, null);
            if (recordOfParent.val < val) {
                recordOfParent.right = point;
            } else {
                recordOfParent.left = point;
            }
            point.parent = recordOfParent;
            fixAfterInsertion(point);
        }
    }

    private TreeNode successor(TreeNode x){
        while(x.left != null){
            x = x.left;
        }
        return x;
    }

    private void deleteNode(TreeNode node){
        if(node.left != null && node.right != null){ // 左右不为空 寻找右树最小节点代替
            TreeNode s = successor(node.right);
            node.val = s.val;
            node = s;
        }
        // 上面处理之后 保证了节点变成 叶子节点 或是只有一个孩子
        // 找到代替的节点
        TreeNode replacement = (node.left == null) ? node.right : node.left;
        if(replacement != null){ // 右子树也可能为空 再次判断
            replacement.parent = node.parent;
            if(node.parent == null){
                root = replacement;
            }else if(node.parent.left == node){
                node.parent.left = replacement;
            }else{
                node.parent.right = replacement;
            }
            node.left = node.right = node.parent = null; // out of link
            if(colorOf(node) == Color.BLACK){
                fixAfterDeletion(replacement);
            }
        }else if(node.parent == null){ // only one node
            root = null;
        }else{ // node has not child
            if(colorOf(node) == Color.BLACK){ // before delete must be fixed
                fixAfterDeletion(node);
            }
            if(node.parent.left == node){
                node.parent.left = null;
            }else{
                node.parent.right = null;
            }
            node.parent = null; // node.left & node.right is already null
        }
    }
    private void fixAfterDeletion(TreeNode p){
        while(p != root && colorOf(p) == Color.BLACK){ // 遇到红色终止
            if(p.parent.left == p){
                TreeNode brother = p.parent.right;
                if(colorOf(brother) == Color.RED){ // 如果兄弟是红 左旋父亲父亲变红 兄弟变黑 更新兄弟
                    // 父亲必须置为红 因为父亲可以推测出来是黑 左旋下沉会导致右树黑高变高
                    brother.color = Color.BLACK;
                    p.parent.color = Color.RED;
                    rotateLeft(p.parent); // 主要是为了变成删除节点的兄弟必须为黑色
                    brother = p.parent.right; // 因为兄弟是红会有两个黑孩子 左旋父亲之后左黑孩子变成父亲的右孩子
                    // 刚好符合需要的兄弟节点为黑孩子
                } // 兄弟左右都是黑 如果删除节点 那么左边黑高会比右边少1 只需要把兄弟染红就可以
                // 因为上一步已经得到黑兄弟的结构
                if(colorOf(brother.left) == Color.BLACK &&
                colorOf(brother.right) == Color.BLACK){
                    brother.color = Color.RED;
                    p = p.parent; // 指向父亲 是为了把父亲染黑 现在父亲是红 指向父亲之后不满足循环条件
                }else{
                    // 现在我们需要右旋父亲 把父亲下沉且变为黑才能平衡
                    // 左孩子是红 右旋父亲之后 会导致左孩子跑到左子树去
                    if(colorOf(brother.left) == Color.RED){
                        brother.left.color = Color.BLACK;
                        brother.color = Color.RED;
                        rotateRight(brother);
                        brother = p.parent.right;
                    } 
                    // 兄弟要上浮为根 变成原本根的颜色
                    // 右孩子变黑 弥补损失
                    // 父亲变黑 弥补删除节点带来的损失
                    brother.color = p.parent.color;
                    p.parent.color = Color.BLACK;
                    brother.right.color = Color.BLACK;
                    rotateLeft(p.parent);
                    p = root;
                }
            }else{
                TreeNode brother = p.parent.left;
                if(colorOf(brother) == Color.RED){
                    p.parent.color = Color.RED;
                    brother.color = Color.BLACK;
                    rotateRight(p.parent);
                    brother = p.parent.left;
                }
                if(colorOf(brother.left) == Color.BLACK &&
                colorOf(brother.right) == Color.BLACK){
                    brother.color = Color.RED;
                    p = p.parent;
                }else{
                    if(colorOf(brother.right) == Color.RED){
                        brother.right.color = Color.BLACK;
                        brother.color = Color.RED;
                        rotateLeft(brother);
                        brother = p.parent.left;
                    }
                    brother.color = p.color;
                    p.color = Color.BLACK;
                    brother.left.color = Color.BLACK;
                    rotateRight(p.parent);
                    p = root;
                }
            }
        }
        p.color = Color.BLACK;
    }

    private TreeNode search(int val){
        TreeNode node = root;
        while(node != null && node.val != val){
            node = (node.val > val) ? node.left : node.right;
        }
        return node;
    }

    public boolean remove(int val){
        TreeNode p = search(val);
        if(p == null){
            return false;
        }
        deleteNode(p);
        return true;
    }

    public void displayTree(){
        if(root != null){
            Queue<TreeNode> queue = new LinkedList<>();
            List<TreeNode> buffer = new ArrayList<>();
            TreeNode nodes = root;
            queue.offer(nodes);
            int size;
            while(!queue.isEmpty()){
                size = queue.size();
                buffer.clear();
                for(int i = 0; i < size; i++){
                    TreeNode node = queue.poll();
                    assert node != null;
                    if(node.left != null){
                        queue.offer(node.left);
                    }
                    if(node.right != null){
                        queue.offer(node.right);
                    }
                    buffer.add(node);
                }
                for(TreeNode i : buffer){
                    System.out.print(i);
                }
                System.out.println();
            }
        }
    }

    public List<Integer> inOrder(){
        TreeNode node = root;
        Stack<TreeNode> stack = new Stack<>();
        ArrayList<Integer> records = new ArrayList<>();
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            records.add(node.val);
            node = node.right;
        }
        return records;
    }
}