【数据结构】红黑树-新增节点

红黑树

 

特性总结：

定义：

 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。
 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。
 除了具备该特性之外，红黑树还包括许多额外的信息。
 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。

五大特性:
 (1) 每个节点或者是黑色，或者是红色。
 (2) 根节点是黑色。
 (3) 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
 (4) 如果一个节点是红色的，则它的子节点必须是黑色的。
 (5) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

 关于它的特性，需要注意的是：
 第一，特性(3)中的叶子节点，是只为空(NIL或null)的节点。
 第二，特性(5)，确保没有一条路径会比其他路径长出俩倍。因而，红黑树是相对是接近平衡的二叉树。

 

定义红黑树对象：

public class RbTree<T extends Comparable<T>> {
    /**根结点*/
    private RbNode<T> mRoot;
 
    private static final boolean RED   = false;
    private static final boolean BLACK = true;
 
    public class RbNode<T extends Comparable<T>> {
        /**颜色*/
        boolean color;
        /**关键字(键值)*/
        T key;
        /**左孩子*/
        RbNode<T> left;
        /**右孩子*/
        RbNode<T> right;
        /**父结点*/
        RbNode<T> parent;
 
        public RbNode(T key, boolean color, RbNode<T> parent, RbNode<T> left, RbNode<T> right) {
            this.key = key;
            this.color = color;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }
    }
}

插入操作（左旋平衡）：

插入逻辑（摘抄）：

    /**
     * 将结点插入到红黑树中
     * 参数说明：
     * newNode 新插入的结点        // 对应《算法导论》中的node
     */
    private void insert(RBTNode<T> newNode) {
        int cmp;
        RBTNode<T> temp = null;
        RBTNode<T> currentNode = this.mRoot;
        // 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。
        while (currentNode != null) {
            temp = currentNode;
            cmp = newNode.key.compareTo(currentNode.key);
            //node的值小于当前节点，指针左下移动
            if (cmp < 0){
                currentNode = currentNode.left;
            }else{
                currentNode = currentNode.right;
            }
        }
        //2、获取到父节点temp
        newNode.parent = temp;
        if (temp!=null) {
            cmp = newNode.key.compareTo(temp.key);
            if (cmp < 0){
                temp.left = newNode;
            }else{
                temp.right = newNode;
            }
        } else {
            this.mRoot = newNode;
        }
 
        // 2. 设置节点的颜色为红色
        newNode.color = RED;
 
        // 3. 将它重新修正为一颗二叉查找树
        insertFixUp(newNode);
    }
    /**
     * 红黑树插入修正函数
     * 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
     * 目的是将它重新塑造成一颗红黑树。
     *
     * 参数说明：
     *     node 插入的结点        // 对应《算法导论》中的z
     */
    private void insertFixUp(RBTNode<T> node) {
        RBTNode<T> parent, gparent;
 
        // 若“父节点存在，并且父节点的颜色是红色”
        while (((parent = parentOf(node))!=null) && isRed(parent)) {
            gparent = parentOf(parent);
 
            //若“父节点”是“祖父节点的左孩子”
            if (parent == gparent.left) {
                // Case 1条件：叔叔节点是红色
                RBTNode<T> uncle = gparent.right;
                if ((uncle!=null) && isRed(uncle)) {
                    setBlack(uncle);
                    setBlack(parent);
                    setRed(gparent);
                    node = gparent;
                    continue;
                }
                // Case 2条件：叔叔是黑色，且当前节点是右孩子
                if (parent.right == node) {
                    RBTNode<T> tmp;
                    leftRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }
                // Case 3条件：叔叔是黑色，且当前节点是左孩子。
                setBlack(parent);
                setRed(gparent);
                rightRotate(gparent);
            } else {    //若“z的父节点”是“z的祖父节点的右孩子”
                // Case 1条件：叔叔节点是红色
                RBTNode<T> uncle = gparent.left;
                if ((uncle!=null) && isRed(uncle)) {
                    setBlack(uncle);
                    setBlack(parent);
                    setRed(gparent);
                    node = gparent;
                    continue;
                }
 
                // Case 2条件：叔叔是黑色，且当前节点是左孩子
                if (parent.left == node) {
                    RBTNode<T> tmp;
                    rightRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }
 
                // Case 3条件：叔叔是黑色，且当前节点是右孩子。
                setBlack(parent);
                setRed(gparent);
                leftRotate(gparent);
            }
        }
        // 将根节点设为黑色
        setBlack(this.mRoot);
    }