Java 学习+面试指南：https://javaxiaobear.cn

我们前面介绍了2-3树，可以看到2-3树能保证在插入元素之后，树依然保持平衡状态，它的最坏情况下所有子结点都是2-结点，树的高度为lgN,相比于我们普通的二叉查找树，最坏情况下树的高度为N，确实保证了最坏情况下的时间复杂度，但是2-3树实现起来过于复杂，所以我们介绍一种2-3树思想的简单实现：红黑树。

红黑树主要是对2-3树进行编码，红黑树背后的基本思想是用标准的二叉查找树(完全由2-结点构成)和一些额外的信
息(替换3-结点)来表示2-3树。我们将树中的链接分为两种类型：

  • 红链接：将两个2-结点连接起来构成一个3-结点
  • 黑链接：2-3树中的普通链接

我们将3-结点表示为由由一条左斜的红色链接(两个2-结点其中之一是另一个的左子结点)相连的两个2-结点。这种表示法的一个优点是，我们无需修改就可以直接使用标准的二叉查找树的get方法。

1、红黑树的定义

红黑树是含有红黑链接并满足下列条件的二叉查找树：

  • 红链接均为左连接
  • 没有任何一个节点同时和两条红链接相连
  • 该树是完美黑色平衡的，即是任意空链接到根节点的路径上的黑链接数量相同

红黑树与2-3树的对应关系：

2、红黑树的API

因为每个结点都只会有一条指向自己的链接（从它的父结点指向它），我们可以在之前的Node结点中添加一个布尔类型的变量color来表示链接的颜色。如果指向它的链接是红色的，那么该变量的值为true，如果链接是黑色的，那么该变量的值为false。

API设计

类名

Node<Key,Value>

构造方法

Node(Key key, Value value, Node left, Node right，boolean color)：创建Node对象

成员变量

public Node left:记录左子结点

public Node right:记录右子结点

public Key key:存储键

public Value value:存储值

public boolean color:由其父结点指向它的链接的颜色

3、平衡化

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

1、左旋

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

前提：当前结点为h，它的右子结点为x；

左旋过程：

  1. 让x的左子结点变为h的右子结点：
h.right=x.left;
  • 1.
  1. 让h成为x的左子结点：
x.left=h;
  • 1.
  1. 让h的color属性变为x的color属性值：
x.color=h.color;
  • 1.
  1. 让h的color属性变为RED：
h.color=true;
  • 1.
2、右旋

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

前提：当前结点为h，它的左子结点为x；

右旋过程：

  1. 让x的右子结点成为h的左子结点：
h.left = x.right;
  • 1.
  1. 让h成为x的右子结点：
x.right=h;
  • 1.
  1. 让x的color变为h的color属性值：
x.color = h.color;
  • 1.
  1. 让h的color为RED；
4、操作
1、向单个2-结点中插入新键

一棵只含有一个键的红黑树只含有一个2-结点。插入另一个键后，我们马上就需要将他们旋转。

  • 如果新键小于当前结点的键，我们只需要新增一个红色结点即可，新的红黑树和单个3-结点完全等价。
  • 如果新键大于当前结点的键，那么新增的红色结点将会产生一条红色的右链接，此时我们需要通过左旋，把红色右链接变成左链接，插入操作才算完成。形成的新的红黑树依然和3-结点等价，其中含有两个键，一条红色链接。
2、向底部的2-结点插入新键

用和二叉查找树相同的方式向一棵红黑树中插入一个新键，会在树的底部新增一个结点（可以保证有序性），唯一区别的地方是我们会用红链接将新结点和它的父结点相连。如果它的父结点是一个2-结点，那么刚才讨论的两种方式仍然适用。

3、颜色反转

当一个结点的左子结点和右子结点的color都为RED时，也就是出现了临时的4-结点，此时只需要把左子结点和右子结点的颜色变为BLACK，同时让当前结点的颜色变为RED即可。

4、向一棵双键树(即一个3-结点)中插入新键

这种情况分为三种情况：

  1. 新键大于原树中的两个键
  2. 新键小于原树中的两个键
  3. 新键介于原树中两个键之间
5、根节点的颜色总是黑色

由于根结点不存在父结点，所以每次插入操作后，我们都需要把根结点的颜色设置为黑色。

6、向树底部的3-结点插入新键

假设在树的底部的一个3-结点下加入一个新的结点。前面我们所讲的3种情况都会出现。指向新结点的链接可能是：

  • 3-结点的右链接（此时我们只需要转换颜色即可）
  • 或是左链接(此时我们需要进行右旋转然后再转换)
  • 或是中链接(此时需要先左旋转然后再右旋转，最后转换颜色)。

颜色转换会使中间结点的颜色变红，相当于将它送入了父结点。这意味着父结点中继续插入一个新键，我们只需要使用相同的方法解决即可，直到遇到一个2-结点或者根结点为止。

5、API的设计

类名

RedBlackTree<Key,Value>

构造方法

RedBlackTree()：创建RedBlackTree对象

成员方法

1.private boolean isRed(Node x)：判断当前结点的父指向链接是否为红色

2.private Node rotateLeft(Node h):左旋调整

3.private Node rotateRight(Node h):右旋调整

4.private void flipColors(Node h)：颜色反转,相当于完成拆分4-结点

5.public void put(Key key, Value val):在整个树上完成插入操作

6.private Node put(Node h, Key key, Value val):在指定树中，完成插入操作,并返回添加元素后

新的树

7.public Value get(Key key):根据key，从树中找出对应的值

8.private Value get(Node x, Key key):从指定的树x中，找出key对应的值

9.public int size():获取树中元素的个数

成员变量

1.private Node root : 记录根结点

2.private int N:记录树中元素的个数

3.private static final boolean RED：红色链接标识

4.private static final boolean BLACK:黑色链接标识

6、代码实现
public class RedBlackTree<Key extends Comparable<Key>,Value> {

    /**
     * 根结点
     */
    private Node root;

    /**
     * 元素个数
     */
    private int size;

    /**
     * 红链接
     */
    private static final boolean RED = true;

    /**
     * 黑链接
     */
    private static final boolean BLACK = false;

    /**
     * 判断当前结点的父指向链接是否为红色
     * @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){
        //找到当前节点的右子结点
        Node rightNode = h.right;
        //找到右子结点的左子结点
        Node left = rightNode.left;
        //让当前结点h的右子结点的左子结点成为当前结点的右子结点
        h.right = left;
        //让当前节点h变为rightNode的左子节点
        rightNode.left = h;
        //让当前结点h的color变成右子结点的color
        rightNode.color = h.color;
        //让当前结点的color变成RED
        h.color = RED;
        return rightNode;
    }

    /**
     * 右旋调整
     * @param h
     * @return
     */
    private Node rotateRight(Node h){
        //找到当前结点的左子结点
        Node leftNode = h.left;
        //找到leftNode的右子结点
        Node right = leftNode.right;
        //让right变成当前结点的左子结点
        h.left = right;
        //让当前节点变为leftNode的右子结点
        leftNode.right = h;
        //让当前结点h的color值变为左子结点的color值
        leftNode.color = h.color;
        //让当前结点的color变为RED
        h.color = RED;
        return leftNode;
    }

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

    /**
     * 在整个树上完成插入操作
     * @param key
     * @param val
     */
    public void put(Key key, Value val){
        root = put(root,key,val);
        //让根节点颜色变为BLACK
        root.color = BLACK;
    }

    /**
     * 在指定树中，完成插入操作,并返回添加元素后新的树
     * @param h
     * @param key
     * @param val
     * @return
     */
    private Node put(Node h, Key key, Value val){
        //根结点
        if (h == null) {
            size++;
            return new Node(null,null,key,val,RED);
        }
        //比较当前节点的键与key
        int compare = key.compareTo(h.key);
        if(compare < 0){
            //往左子结点插入
            h.left = put(h.left,key,val);
        }else if(compare > 0){
            //往右子结点插入
            h.right = put(h.right,key,val);
        }else {
            //更新值
            h.value = val;
        }
        //如果当前结点的右链接是红色，左链接为黑色，需要左旋
        if(isRed(h.right) && !isRed(h.left)){
            h = rotateLeft(h);
        }
        //如果当前节点的左子结点以及左子结点的左子结点都是红链接，需要右旋
        if(isRed(h.right) && isRed(h.right.right)){
            h = rotateRight(h);
        }
        //颜色变换：当前节点的左右子结点都是红链接
        if(isRed(h.right) && isRed(h.left)){
            flipColors(h);
        }
        return h;
    }

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

    /**
     * 从指定的树x中，找出key对应的值
     * @param x
     * @param key
     * @return
     */
    private Value get(Node x, Key key){
        if (x == null) {
            return null;
        }
        int compare = key.compareTo(x.key);
        if(0 > compare){
            return get(x.left,key);
        }else if(0 < compare){
            return get(x.right,key);
        }else {
            return x.value;
        }
    }

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


    /**
     * 结点类
     */
    private class Node{
        public Node left;
        public Node right;
        public Key key;
        public Value value;
        public boolean color;

        public Node(Node left, Node right, Key key, Value value, boolean color) {
            this.left = left;
            this.right = right;
            this.key = key;
            this.value = value;
            this.color = color;
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.
  • 111.
  • 112.
  • 113.
  • 114.
  • 115.
  • 116.
  • 117.
  • 118.
  • 119.
  • 120.
  • 121.
  • 122.
  • 123.
  • 124.
  • 125.
  • 126.
  • 127.
  • 128.
  • 129.
  • 130.
  • 131.
  • 132.
  • 133.
  • 134.
  • 135.
  • 136.
  • 137.
  • 138.
  • 139.
  • 140.
  • 141.
  • 142.
  • 143.
  • 144.
  • 145.
  • 146.
  • 147.
  • 148.
  • 149.
  • 150.
  • 151.
  • 152.
  • 153.
  • 154.
  • 155.
  • 156.
  • 157.
  • 158.
  • 159.
  • 160.
  • 161.
  • 162.
  • 163.
  • 164.
  • 165.
  • 166.
  • 167.
  • 168.
  • 169.
  • 170.
  • 171.
  • 172.
  • 173.
  • 174.
  • 175.
  • 176.
  • 177.
  • 178.
  • 179.
  • 180.
  • 181.
  • 182.
  • 183.
  • 184.
  • 185.
  • 186.
  • 187.
  • 188.
  • 189.
  • 190.
  • 191.
  • 192.
  • 193.
  • 194.
  • 195.
  • 196.
  • 测试类
public class RedBlackTreeTest {

    public static void main(String[] args) {
        RedBlackTree<Integer, String> tree = new RedBlackTree<>();
        tree.put(1,"1111");
        tree.put(2,"2222");
        tree.put(3,"3333");
        tree.put(4,"4444");
        System.out.println(tree.size());
        tree.put(2,"666666");
        System.out.println(tree.get(2));
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

Java平衡树--红黑树，如何平衡化以及操作实现_平衡树