数据结构学习之红黑树篇(Java)

红黑树也首先是一颗二分搜索树，然后还要满足一下定义（算法导论中的定义）：

1. 每个节点或者是红色的，或者是黑色的
2. 根节点是黑色的
3. 每一个叶子节点（最后的空节点）是黑色的
4. 如果一个节点是红色的，那么他的孩子节点都是黑色的
5. 从任意一个节点到叶子节点，经过的黑色节点是一样的

利用红黑树与2-3树的等价性，有利于理解红黑树的实现。
使用java实现简单的左倾红黑树的增加功能（不满足红黑树任何不平衡都会在三次旋转内解决):

/**
 * @author ymn
 * @version 1.0
 * @date 2020\6\3 0003 14:17
 */
public class RBTree<K extends Comparable<K>,V> {

    private static final boolean RED = true;
    private static final boolean BLACK = false;

    private class Node{
        public K key;
        public V value;
        public Node left,right;
        public boolean color;

        public Node(K key,V value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            color = RED;
        }
    }

    private Node root;
    private int size;

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public boolean isRed(Node node){
        if (node == null)
            return BLACK;
        return node.color;
    }

    //     node                     x
    //     /  \      左旋转        /   \
    //    T1   x     ------>   node    T3
    //        / \              /  \
    //       T2 T3            T1  T2
    private Node leftRotate(Node node){
        Node x = node.right;
        node.right = x.left;
        x.left = node;
        x.color = node.color;
        node.color = RED;
        return x;
    }

    //颜色翻转（对应2-3树中分裂与向上兼容的过程)
    private void flipColors(Node node){
        node.color = RED;
        node.left.color = BLACK;
        node.right.color = BLACK;
    }

    //     node                     x
    //     /  \      右旋转        /   \
    //    x   T2     ------>     y    node
    //   / \                          /  \
    //  y  T1                        T1  T2
    private Node rightRotate(Node node){
         Node x = node.left;
         node.left = x.right;
         x.right = node;
         x.color = node.color;
         node.color = RED;
         return x;
    }

    //向红黑树中添加新的元素(key,value)
    public void add(K key,V value){
        root = add(root,key,value);
        //保持根节点为黑色
        root.color = BLACK;
    }

    //向以node为根的红黑树树中插入元素(key,value),递归算法
    //返回插入新节点后红黑树树的根
    private Node add(Node node,K key,V value){
        if(node == null){
            size ++;
            return new Node(key, value);//默认插入红色节点
        }
        if (key.compareTo(node.key) < 0){
            node.left = add(node.left,key, value);
        }else if(key.compareTo(node.key) > 0){ //插入重复元素说明什么也不做
            node.right = add(node.right,key, value);
        }else {
            node.value = value;
        }
        //节点插入完后进行红黑树性质的维护
        /*先判断一下当前节点需不需要左旋转,即当前节点的右孩子是红节点而左孩子不是红节点，因为如果左孩子是红节点的话，
        我们需要做的是颜色翻转，而不是左旋转*/
        if (isRed(node.right) && !isRed(node.left))
            node = leftRotate(node);
        //当前节点的左孩子与左孩子的左孩子都为红节点，进行一次右旋转
        if (isRed(node.left) && isRed(node.left.left))
            node = rightRotate(node);
        //最后判断一下当前节点需不需要进行颜色翻转
        if (isRed(node.left) && isRed(node.right))
            flipColors(node);
        return node;
    }

    //返回以node为根节点的红黑树中，key所在的节点
    private Node getNode(Node node,K key){
        if (node == null){
            return null;
        }
        if (key.compareTo(node.key) == 0){
            return node;
        }else if (key.compareTo(node.key) < 0){
            return getNode(node.left,key);
        }else {   //key.compareTo(node.key) > 0
            return getNode(node.right,key);
        }
    }

    public boolean contains(K key){
        return getNode(root,key) != null;
    }

    public V get(K key){
        Node node = getNode(root,key);
        return node == null ? null : node.value;
    }

    public void set(K key, V value) {
        Node node = getNode(root,key);
        if (node == null){
            throw new IllegalArgumentException(key + "dose't exist!");
        }
        node.value = value;
    }
}

java中,TreeMap和TreeSet底层都是用红黑树实现的。

红黑树的性能总结：
对于完全随机的数据，普通的二分搜索树就很好用；
普通的二分搜索树的缺点：极端情况下退化成链表（或高度不平衡树）；
当你的应用场景查询操作很多的时候,AVL树很好用 ;
红黑树牺牲了平衡性(2logn的高度)
红黑树的统计性能更优（平均来看，综合增删改查所有的操作更优)