红黑树及Java代码实现

1 特征描述

1.1 性质

1. 含有红黑链接的二叉查找树；
2. 红链接均为左链接；
3. 没有任何一个结点同时和两条红链接相连；
4. 完美黑色平衡，即任意空链接到根结点的路径上的黑链接数量相同;

1.2 与2-3树的对应关系

1. 红黑树是一种2-3树思想的简单实现，主要是对2-3树进行编码；

2. 基本思想是用标准的二叉查找树（完全由2-结点构成）+ 一些额外的信息（表示3-结点）来表示2-3树；

3. 树中有两种链接：

   红链接：将两个2-结点链接起来构成一个3-结点；

   黑链接：普通链接。

4. 可以将3-结点看作由一条左斜的红链接相连的两个2-结点。

与2-3树的对应关系：

1.3 结点

1. 在二叉搜索树结点中添加一个boolean类型的变量color表示链接的颜色，链接由父节点指向该结点；
2. 如果链接是红色，color等于true；如果是黑色，color等于false。
   

2 平衡化

在对红黑树进行一些增删改查的操作后，很可能会出现红色的右链接或两条连续红色的链接，而这些都不满足红黑树的定义。因此我们需要对这些情况进行旋转修复。

2.1 左旋

当某个结点的左子结点为黑色，右子节点为红色，需要左旋。

1. 当前结点为h，其右子节点为x;
2. 让x的左子结点变为h的右子节点：h.right = x.left;
3. 让h成为x的左子结点：x.left = h;
4. 让x的color变为h的color：x.color = h.color;
5. 让h的color变为红：h.color = true;
   

2.2 右旋

当某个结点的左子结点是红色，其左子结点的左子结点也是红色，需要右旋。

1. 当前结点为h，其左子结点为x；
2. 让 x的右子节点成为h的左子结点：h.left = x.right;
3. 让h成为x的右子结点：x.right = h;
4. 让x的color变为h的color：x.color = h.color;
5. 让h的color变为红：h.color = true;

3 插入操作

3.1 向2-结点插入新键（可能旋转3-结点）

两种情况：

1. 新键小于当前结点的键，不用旋转：
   

2. 如果新键大于当前结点的键，需要左旋：
   

3.2 向3-结点插入新键（必然拆分4-结点）

三种情况：

1. 新键大于结点中的两个键，颜色反转：
   

2. 新键小于结点中的两个键，先右旋再颜色反转：

3. 新键介于结点中两个键之间，先左旋，再右旋，再颜色反转：

4 两个重要的颜色变换

4.1 向3-结点插入新键时颜色反转

1. 当一个结点的左子结点和右子结点的color都为RED时，也就是出现了临时的4-结点，需要进行颜色反转；
2. 颜色反转相当于将中间结点（当前结点）送入父结点，意味着父结点中插入了一个新键；
3. 因此把左子结点和右子结点的颜色变为Black，同时让当前结点的颜色变为RED；
4. 父结点可能还要继续各种变换操作，直到满足条件。

4.2 每次插入操作后根节点重设为黑

由于根结点不存在父结点，所以根节点的颜色为黑，而插入过程中可能导致根结点颜色变红，因此每次插入操作后，我们都需要将根结点的颜色重新设置为黑色。

5 Java代码实现

public class RedBlackTree<Key extends Comparable<Key>, Value> {
    //根节点
    private Node root;
    //记录树中元素的个数
    private int N;
    //红色链接
    private final boolean RED = true;
    //黑色链接
    private final boolean BLACK = false;

    //结点类
    private class Node {
        //存储键
        private Key key;
        //存储值
        private Value value;
        //记录左子结点
        private Node left;
        //记录右子结点
        private Node right;
        //由其父结点指向它的链接的颜色
        private boolean color;

        public Node(Key key, Value value, Node left, Node right, boolean color) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
            this.color = color;
        }
    }

    //获取树中元素的个数
    public int size() {
        return N;
    }

    /**
     * 判断当前节点的父指向链接是否为红色
     *
     * @param x
     * @return
     */
    private boolean isRed(Node x) {
        if (x==null){
            return false;
        }
        return x.color==RED;
    }

    /**
     * 左旋转
     *
     * @param h
     * @return
     */
    private Node rotateLeft(Node h) {
        //找到h结点的右子结点x
        Node x = h.right;
        //找到x结点的左子结点，让x结点的左子结点成为h结点的右子结点
        h.right = x.left;
        //让h结点成为x结点的左子结点
        x.left = h;
        //让x结点的color属性变为h结点的color属性
        x.color = h.color;
        //让h结点的color属性变为RED
        h.color = RED;

        return x;
    }

    /**
     * 右旋
     *
     * @param h
     * @return
     */
    private Node rotateRight(Node h) {
        //找到h结点的左子结点 x
        Node x = h.left;
        //让x结点的右子结点成为h结点的左子结点
        h.left = x.right;
        //让h结点成为x结点的右子结点
        x.right = h;
        //让x结点的color属性变为h结点的color属性
        x.color = h.color;
        //让h结点的color属性为RED
        h.color = RED;

        return x;
    }

    /**
     * 颜色反转,相当于拆分4-节点
     *
     * @param h
     */
    private void flipColors(Node h) {
        //当前结点变为红色
        h.color = RED;
        //左子结点和右子结点变为黑色
        h.left.color = BLACK;
        h.right.color = BLACK;
    }

    /**
     * 在整个树上完成插入操作
     *
     * @param key
     * @param val
     */
    public void put(Key key, Value value) {
        root = put(root,key,value);
        //根结点的颜色总是黑色
        root.color = BLACK;
    }

    /**
     * 在指定树中，完成插入操作,并返回添加元素后新的树
     *
     * @param h
     * @param key
     * @param val
     */
    private Node put(Node h, Key key, Value value) {
        //判断h是否为空，如果为空则直接返回一个红色的结点就可以了
        if (h == null){
            //数量+1
            N++;
            return new Node(key,value,null,null,RED);
        }

        //比较h结点的键和key的大小
        int cmp = key.compareTo(h.key);
        if (cmp<0){
            //继续往左
            h.left = put(h.left,key,value);

        }else if (cmp>0){
            //继续往右
            h.right = put(h.right,key,value);

        }else{
            //发生值的替换
            h.value = value;
        }

        //进行左旋:如果当前结点h的左子结点为黑色，右子结点为红色，需要左旋
        if (isRed(h.right) && !isRed(h.left)){
            h = rotateLeft(h);
        }

        //进行右旋：如果当前结点h的左子结点和左子结点的左子结点都为红色，需要右旋
        if (isRed(h.left) && isRed(h.left.left)){
            h = rotateRight(h);
        }

        //颜色反转：当前结点的左子结点和右子结点都为红色时，需要颜色反转
        if (isRed(h.left) && isRed(h.right)){
            flipColors(h);
        }

        return h;
    }

    //根据key，从树中找出对应的值
    public Value get(Key key) {
        return get(root,key);
    }

    //从指定的树x中，查找key对应的值
    private Value get(Node x, Key key) {
        if (x == null){
            return null;
        }

        //比较x结点的键和key的大小
        int cmp = key.compareTo(x.key);
        if (cmp<0){
            return get(x.left,key);
        }else if (cmp>0){
            return get(x.right,key);
        }else {
           return x.value;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        RedBlackTree<Integer, String> bt = new RedBlackTree<>();
        bt.put(4, "刘备");
        bt.put(2, "关羽");
        bt.put(3, "张飞");
        bt.put(5, "赵云");
        System.out.println(bt.size());
        bt.put(5,"马超");
        System.out.println(bt.get(3));
        System.out.println(bt.size());
    }
}

4
张飞
4