二叉树之红黑树的插入方法（JAVA代码实现）

之前写过AVL树的插入与删除，今天给大家分享下用JAVA代码实现红黑树的插入。
首先回忆下红黑树的五个特性：
性质1：节点是红色或黑色。
性质2：根节点是黑色。
性质3：每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质4：从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
规定：空节点为黑节点

1、RedBlackTree基本属性

	private static final int BLACK = 1;
    private static final int RED = 0;

    public RedBlackNode root;

    private RedBlackNode current;
    private RedBlackNode parent;
    private RedBlackNode grand;
    private RedBlackNode uncle;
    private RedBlackNode brother;

    public RedBlackTree() {}

    private static class RedBlackNode {
        public RedBlackNode left;
        public RedBlackNode right;
        public RedBlackNode parent;
        public int element;
        public int color;
        public RedBlackNode(int element) {
            this(element, null, null, null);
        }
        public RedBlackNode(int element, RedBlackNode left, RedBlackNode right, RedBlackNode parent) {
            this.element = element;
            this.left = left;
            this.right = right;
            this.parent = parent;
            this.color = RED;
        }

        @Override
        public String toString() {
            if (color == RED) {
                return element + "R";
            } else {
                return element + "B";
            }
        }
    }

2、红黑树的基本操作（旋转）

旋转方式比AVL少两种，只有左单旋和右单旋。但是在旋转的过程中需要改变父节点和子节点的角色。代码如下：

/**
     * 右单旋
     * @param redBlackNode
     * @return
     */
    private RedBlackNode rightRotate(RedBlackNode redBlackNode) {
        RedBlackNode left = redBlackNode.left;
        redBlackNode.left = left.right;
        left.right = redBlackNode;
        //交换父子节点关系
        left.parent = redBlackNode.parent;
        redBlackNode.parent = left;
        if (redBlackNode.left != null) {
            redBlackNode.left.parent = redBlackNode;
        }
        return left;
    }

    /**
     * 左单旋
     * @param redBlackNode
     * @return
     */
    private RedBlackNode leftRotate(RedBlackNode redBlackNode) {
        RedBlackNode right = redBlackNode.right;
        redBlackNode.right = right.left;
        right.left = redBlackNode;
        //交换父子节点关系
        right.parent = redBlackNode.parent;
        redBlackNode.parent = right;
        if (redBlackNode.right != null) {
            redBlackNode.right.parent = redBlackNode;
        }
        return right;
    }

3、红黑树节点的插入

首先列出来每种情况，以及每种情况的操作，其中第三种到第五种情况和第六种到第九种情况属于镜面对称。

下面看具体插入代码

/**
     * 获取节点颜色
     * @param redBlackNode
     * @return
     */
    private int getColor(RedBlackNode redBlackNode) {
        if (redBlackNode == null) {
            return BLACK;
        }
        return redBlackNode.color;
    }

    /**
     * 红黑树的插入，isBalance=true则构建红黑树，否则构建普通二叉树
     * @param redBlackNode
     * @param element
     * @param isBalance
     * @return
     */
    public RedBlackNode insert(RedBlackNode redBlackNode, int element, boolean isBalance) {
        root = insertElement(redBlackNode, element);
        if (isBalance == true) {
            balance(current);
        }
        return root;
    }

    /**
     * 插入方法
     * @param redBlackNode
     * @param element
     * @return
     */
    public RedBlackNode insertElement(RedBlackNode redBlackNode, int element) {
        if (redBlackNode == null) {
            current = new RedBlackNode(element);
            return current;
        }
        int compareResult = redBlackNode.element - element;
        if (compareResult > 0) {
            redBlackNode.left = insertElement(redBlackNode.left, element);
            redBlackNode.left.parent = redBlackNode;
        } else if (compareResult < 0) {
            redBlackNode.right = insertElement(redBlackNode.right, element);
            redBlackNode.right.parent = redBlackNode;
        } else { //元素相等，do nothing
            ;
        }
        return redBlackNode;
    }

    /**
     * 平衡方法
     * @param redBlackNode
     */
    private void balance(RedBlackNode redBlackNode) {
        if (redBlackNode.parent == null) {
            //第一种情况，当前节点是根节点，直接将颜色翻转成黑色
            redBlackNode.color = BLACK;
        } else if (getColor(redBlackNode.parent) == BLACK) {
            //第二种情况，当前节点的父节点是黑色
        } else if (getColor(redBlackNode.parent) == RED) {
            //首先将当前节点、父节点、祖父节点、叔叔节点构建出来
            current = redBlackNode;
            parent = redBlackNode.parent;
            grand = parent.parent;
            if (parent == grand.left) {
                //第三种到第五种情况是父节点在左侧，第六种到第八种是父节点在右侧，属于镜面对称
                uncle = grand.right;
                if (getColor(uncle) == RED) {
                    //第三种情况，当前节点的父节点是红色，叔叔节点也是红色
                    //(01) 将父节点设为黑色。
                    //(02) 将叔叔节点设为黑色。
                    //(03) 将祖父节点设为红色。
                    //(04) 将祖父节点设为当前节点(红色节点)；之后继续对当前节点进行操作。
                    parent.color = BLACK;
                    uncle.color = BLACK;
                    grand.color = RED;
                    current = grand;
                    balance(current);
                } else {
                    if (current == parent.right) {
                        //第四种情况，当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的右孩子
                        //(01) 将父节点作为新的当前节点。
                        //(02) 以新的当前节点为支点进行左旋。
                        //(03) 将祖父节点的左节点指向旋转后的节点
                        current = parent;
                        grand.left = leftRotate(current);
                        //左旋后，变成第五种情况，此时祖父节点不变，子节点变为父节点，父节点变为子节点
                        balance(current);
                    } else {
                        //第五种情况，当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的左孩子
                        //(01) 将父节点设为黑色。
                        //(02) 将祖父节点设为红色。
                        //(03) 以祖父节点为支点进行右旋。
                        //(04) 需要将祖父节点指向旋转之后的节点，若祖父点没有父节点，则新节点为root。
                        parent.color = BLACK;
                        grand.color = RED;
                        current = grand;
                        if (grand.parent != null) {
                            if (grand.parent.left == grand) {
                                grand.parent.left = rightRotate(current);
                            } else {
                                grand.parent.right = rightRotate(current);
                            }
                        } else {
                            root = rightRotate(current);
                        }
                    }
                }
            } else {
                //第三种到第五种情况是父节点在左侧，第六种到第八种是父节点在右侧，属于镜面对称
                uncle = grand.left;
                if (getColor(uncle) == RED) {
                    //第六种情况（等同于第三种情况），当前节点的父节点是红色，叔叔节点也是红色
                    //(01) 将父节点设为黑色。
                    //(02) 将叔叔节点设为黑色。
                    //(03) 将祖父节点设为红色。
                    //(04) 将祖父节点设为当前节点(红色节点)；之后继续对当前节点进行操作。
                    parent.color = BLACK;
                    uncle.color = BLACK;
                    grand.color = RED;
                    current = grand;
                    balance(current);
                } else {
                    if (current == parent.right) {
                        //第七种情况（和第五种情况对称，区别是LL进行右旋，RR进行左旋），当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的右孩子
                        //(01) 将父节点设为黑色。
                        //(02) 将祖父节点设为红色。
                        //(03) 以祖父节点为支点进行左旋。
                        //(04) 需要将祖父节点指向旋转之后的节点，若祖父点没有父节点，则新节点为root。
                        parent.color = BLACK;
                        grand.color = RED;
                        current = grand;
                        if (grand.parent != null) {
                            if (grand.parent.left == grand) {
                                grand.parent.left = leftRotate(current);
                            } else {
                                grand.parent.right = leftRotate(current);
                            }
                        } else {
                            root = leftRotate(current);
                        }
                    } else {
                        //第八种情况，当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的左孩子
                        //(01) 将父节点作为新的当前节点。
                        //(02) 以新的当前节点为支点进行右旋。
                        //(03) 将祖父节点的右节点指向旋转后的节点
                        current = parent;
                        grand.right = rightRotate(current);
                        //右旋后，变成第七种情况，此时祖父节点不变，子节点变为父节点，父节点变为子节点
                        balance(current);
                    }
                }
            }
        }
    }

4、红黑树打印

红黑树本质上还是二叉树，之前写的打印方法可用，但是表现不出红黑，这里为红黑树优化下打印方法

/**
     * 直接调用打印方法，用长度为100的数组来存放二叉树
     * @param root
     */
    public void printRedBlackTree(RedBlackNode root) {
        printRedBlackTreeWithLength(root, 150);
    }

    /**
     * 指定数组长度来存放二叉树
     * @param root
     * @param length
     */
    public void printRedBlackTreeWithLength(RedBlackNode root, int length) {
        List<RedBlackNode> list1 = new LinkedList<>();
        List<RedBlackNode> list2 = new LinkedList<>();
        list1.add(root);
        RedBlackNode[] rbs = generateRbs(new RedBlackNode[length], root, 0, length);
        Map<String, String> flagMap = new HashMap<>();
        flagMap.put("flag", "N");
        printRedBlackByRecurion(rbs, list1, list2, flagMap);
    }

    /**
     * 递归打印方法
     * @param rbs
     * @param list1
     * @param list2
     * @param flagMap
     */
    private void printRedBlackByRecurion(RedBlackNode[] rbs, List<RedBlackNode> list1, List<RedBlackNode> list2, Map<String, String> flagMap) {
        if (list1.isEmpty() && list2.isEmpty()) {
            return;
        }
        if (!list1.isEmpty()) {
            String[] printRbs = new String[rbs.length];
            while (!list1.isEmpty()) {
                RedBlackNode redBlackNode = list1.remove(0);
                //将父节点放入到打印数组中
                int parentIndex = getIndex(redBlackNode, rbs);
                printRbs[parentIndex] = redBlackNode.toString();
                if (redBlackNode.left != null) {
                    list2.add(redBlackNode.left);
                    int leftIndex = getIndex(redBlackNode.left, rbs);
                    generatePrivateRbs(leftIndex, parentIndex - 1, printRbs);
                }
                if (redBlackNode.right != null) {
                    list2.add(redBlackNode.right);
                    int rightIndex = getIndex(redBlackNode.right, rbs);
                    generatePrivateRbs(parentIndex + 1, rightIndex, printRbs);
                }
            }
            printRbsByString(printRbs, flagMap);
            printRedBlackByRecurion(rbs, list1, list2, flagMap);
        }
        if (!list2.isEmpty()) {
            String[] printRbs = new String[rbs.length];
            while (!list2.isEmpty()) {
                RedBlackNode redBlackNode = list2.remove(0);
                //将父节点放入到打印数组中
                int parentIndex = getIndex(redBlackNode, rbs);
                printRbs[parentIndex] = redBlackNode.toString();
                if (redBlackNode.left != null) {
                    list1.add(redBlackNode.left);
                    int leftIndex = getIndex(redBlackNode.left, rbs);
                    generatePrivateRbs(leftIndex, parentIndex - 1, printRbs);
                }
                if (redBlackNode.right != null) {
                    list1.add(redBlackNode.right);
                    int rightIndex = getIndex(redBlackNode.right, rbs);
                    generatePrivateRbs(parentIndex + 1, rightIndex, printRbs);
                }
            }
            printRbsByString(printRbs, flagMap);
            printRedBlackByRecurion(rbs, list1, list2, flagMap);
        }
    }

    /**
     * 将构建好的数组打印
     * @param rbs
     * @param flagMap
     */
    private void printRbsByString(String[] rbs, Map<String, String> flagMap) {
        for (int i = 0; i < rbs.length; i++) {
            if (rbs[i] != null && !rbs[i].equals("-")) {
                if ("Y".equals(flagMap.get("flag"))) {
                    System.out.print("|");
                }
            } else {
                System.out.print(" ");
            }
        }
        flagMap.put("flag", "Y");
        System.out.println();
        for (int i = 0; i < rbs.length; i++) {
            if (rbs[i] != null) {
                System.out.print(rbs[i]);
            } else {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    /**
     * 用于构建左右子树的连接
     * @param startIndex
     * @param endIndex
     * @param rbs
     */
    private void generatePrivateRbs(int startIndex, int endIndex, String[] rbs) {
        for (int i = startIndex; i <= endIndex; i++) {
            rbs[i] = "-";
        }
    }

    /**
     * 获取当前元素在数组里的索引
     * @param redBlackNode
     * @param rbs
     * @return
     */
    private int getIndex(RedBlackNode redBlackNode, RedBlackNode[] rbs) {
        for (int i = 0; i < rbs.length; i++) {
            if(rbs[i] != null && redBlackNode.element == rbs[i].element) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 将二叉树放在一维数组
     * @param rbs
     * @param redBlackNode
     * @param startLocation
     * @param endLocation
     * @return
     */
    public RedBlackNode[] generateRbs(RedBlackNode[] rbs, RedBlackNode redBlackNode, int startLocation,int endLocation) {
        if (redBlackNode == null) {
            return rbs;
        }
        if (endLocation - startLocation < 2) {
            System.out.println("区间不够，请扩容");
        }
        int flag = (endLocation - startLocation)%2;
        int rootLocation = (endLocation - startLocation)/2 + startLocation;
        if (flag > 0) {
            rootLocation = rootLocation + 1;
        }
        rbs[rootLocation] = redBlackNode;
        if (redBlackNode.left != null) {
            generateRbs(rbs, redBlackNode.left, startLocation, rootLocation - 1);
        }
        if (redBlackNode.right != null) {
            generateRbs(rbs, redBlackNode.right, rootLocation + 1, endLocation);
        }
        return rbs;
    }

5、测试效果

都这里红黑树的插入已经结束，有时间更新下红黑树的删除，删除情况稍微多些。

项目源码：
github：https://github.com/licy-IT/Tree.git
码云：https://gitee.com/rising-dragon/Tree.git