2-3查找树和左偏红黑树

2-3查找树

对于二叉查找树，发现它的查询效率比单纯的链表和数组的查询效率要高很多，大部分情况下，确实是这样的，但不幸的是，在最坏情况下，二叉查找树的性能还是很糟糕。

例如我们依次往二叉查找树中插入9,8,7,6,5,4,3,2,1这9个数据，那么最终构造出来的树是长得下面这个样子：极端情况下，变成类似与链表的数据结构。

我们会发现，如果我们要查找1这个元素，查找的效率依旧会很低。效率低的原因在于这个树并不平衡，全部是向左边分支，如果我们有一种方法，能够不受插入数据的影响，让生成的树都像完全二叉树那样，那么即使在最坏情况下，查找的效率依旧会很好。

2-3查找树的定义

为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键。确切的说，我们将一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点，它含有两个键和三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。

一棵2-3查找树要么为空，要么满足满足下面两个要求：

• 2-结点： 含有一个键(及其对应的值)和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3树中的键都大于该结点。
• 3-结点：含有两个键(及其对应的值)和三条链，左链接指向的2-3树中的键都小于该结点，中链接指向的2-3树中的键都位于该结点的两个键之间，右链接指向的2-3树中的键都大于该结点。

2-3查找树的插入

向2-结点中插入新键

往2-3树中插入元素和往二叉查找树中插入元素一样，首先要进行查找，然后将节点挂到未找到的节点上。2-3树之所以能够保证在最差的情况下的效率的原因在于其插入之后仍然能够保持平衡状态。如果查找后未找到的节点是一个2-结点，那么很容易，我们只需要将新的元素放到这个2-结点里面使其变成一个3-结点即可。但是如果查找的节 点结束于一个3-结点，那么可能有点麻烦。

向一棵只含有一个3-结点的树中插入新键

假设2-3树只包含一个3-结点，这个结点有两个键，没有空间来插入第三个键了，最自然的方式是我们假设这个结点能存放三个元素，暂时使其变成一个4-结点，同时他包含四条链接。然后，我们将这个4-结点的中间元素提升， 左边的键作为其左子结点，右边的键作为其右子结点。插入完成，变为平衡2-3查找树，树的高度从0变为1。

向一个父结点为2-结点的3-结点中插入新

和上面的情况一样一样，我们也可以将新的元素插入到3-结点中，使其成为一个临时的4-结点，然后，将该结点中 的中间元素提升到父结点即2-结点中，使其父结点成为一个3-结点，然后将左右结点分别挂在这个3-结点的恰当位置。

向一个父结点为3-结点的3-结点中插入新键

当我们插入的结点是3-结点的时候，我们将该结点拆分，中间元素提升至父结点，但是此时父结点是一个3-结点， 插入之后，父结点变成了4-结点，然后继续将中间元素提升至其父结点，直至遇到一个父结点是2-结点，然后将其变为3-结点，不需要继续进行拆分。

分解根结点

当插入结点到根结点的路径上全部是3-结点的时候，最终我们的根结点会变成一个临时的4-结点，此时，就需要将根结点拆分为两个2-结点，树的高度加1。

2-3查找树的性质

1. 任意空链接到根结点的路径长度都是相等的。

2. 4-结点变换为3-结点时，树的高度不会发生变化，只有当根结点是临时的4-结点，分解根结点时，树高+1。

3. 2-3树与普通二叉查找树最大的区别在于，普通的二叉查找树是自顶向下生长，而2-3树是自底向上生长。

左偏红黑树(LLRB)

关于左偏红黑树的详细算法和定义可见：https://www.cs.princeton.edu/~rs/talks/LLRB/RedBlack.pdf

下面左偏红黑树简称为红黑树。

我们前面介绍了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-3树的对应关系：

红黑树节点API设计

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

    private class Node {
        private Key key;           
        private Value val;         
        private Node left, right;  
        private boolean color;     //由其父结点指向它的链接的颜色
        private int size;          

        public Node(Key key, Value val, boolean color, int size) {
            this.key = key;
            this.val = val;
            this.color = color;
            this.size = size;
        }
    }

平衡化

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

左旋

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

左旋过程：

右旋

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

右旋过程：

颜色转换

当一个结点的左子结点和右子结点的color都为RED时，也就是出现了临时的4-结点，此时只需要把左子结点和右子 结点的颜色变为BLACK，同时让当前结点的颜色变为RED即可。但是注意：根节点链接的颜色总是黑色，我们会在每次插入后将根节点设置为黑色。每当根节点由红变黑后，树的黑链接高度会加1。

颜色转换过程：

插入

向单个2-结点中插入新键

一棵只含有一个键的红黑树只含有一个2-结点。插入另一个键后，我们马上就需要将他们旋转。 如果新键小于当前结点的键，我们只需要新增一个红色结点即可，新的红黑树和单个3-结点完全等价。

• 如果新键小于当前结点的键，我们只需要新增一个红色结点即可，新的红黑树和单个3-结点完全等价。

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

向底部的2-结点插入新键

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

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

这种情况有可以分为三种子情况：

1. 新键大于原树中的两个键

2. 新键小于原树中的两个键

3. 新键介于原数中两个键之间

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

假设在树的底部的一个3-结点下加入一个新的结点。前面我们所讲的3种情况都会出现。指向新结点的链接可能是3-结点的右链接（此时我们只需要转换颜色即可），或是左链接(此时我们需要进行右旋转然后再转换)，或是中链接(此时需要先左旋转然后再右旋转，最后转换颜色)。颜色转换会使中间结点的颜色变红，相当于将它送入了父结点。这意味着父结点中继续插入一个新键，我们只需要使用相同的方法解决即可，直到遇到一个2-结点或者根结点为止。

代码实现

public class RedBlackBST<Key extends Comparable<Key>, Value> {

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

    //红黑树的根节点
    private Node root;

    private class Node {
        private Key key;
        private Value val;
        private Node left, right;  // 左子树和右子树
        private boolean color;     // 链接颜色
        private int size;          // 子树的大小

        public Node(Key key, Value val, boolean color, int size) {
            this.key = key;
            this.val = val;
            this.color = color;
            this.size = size;
        }
    }

    private boolean isRed(Node x) {
        if (x == null) return false;
        return x.color == RED;
    }

    private int size(Node x) {
        if (x == null) return 0;
        return x.size;
    }

    public int size() {
        return size(root);
    }

    public boolean isEmpty() {
        return root == null;
    }

    /**
     * @author wen.jie
     * @date 2021/8/25 14:16
     * 根据指定key查询value
     */
    public Value get(Key key) {
        if (key == null) throw new IllegalArgumentException("argument to get() is null");
        return get(root, key);
    }

    /**
     * @author wen.jie
     * @date 2021/8/25 14:16
     * 该树中是否包含指定的key
     */
    public boolean contains(Key key) {
        return get(key) != null;
    }

    private Value get(Node x, Key key) {
        while (x != null) {
            int cmp = key.compareTo(x.key);
            if      (cmp < 0) x = x.left;
            else if (cmp > 0) x = x.right;
            else              return x.val;
        }
        return null;
    }

    public void put(Key key, Value val) {
        if (key == null) throw new IllegalArgumentException("first argument to put() is null");
        root = put(root, key, val);
        //树的根节点总是黑色
        root.color = BLACK;
    }

    private Node put(Node h, Key key, Value val) {
        if (h == null) return new Node(key, val, RED, 1);

        //这里与二叉查找树代码一样
        int cmp = key.compareTo(h.key);
        if      (cmp < 0) h.left  = put(h.left,  key, val);
        else if (cmp > 0) h.right = put(h.right, key, val);
        else              h.val   = val;
        //红黑树平衡化
        return balance(h);
    }

    // 树的平衡化
    private Node balance(Node h) {
        //左旋:右链接为红,左连接为黑
        if (isRed(h.right) && !isRed(h.left))    h = rotateLeft(h);
        //右旋:两条连续的左链接
        if (isRed(h.left) && isRed(h.left.left)) h = rotateRight(h);
        //节点的左链接和右链接都是红链接,发生颜色变换
        if (isRed(h.left) && isRed(h.right))     flipColors(h);
        h.size = size(h.left) + size(h.right) + 1;
        return h;
    }

    //右旋
    private Node rotateRight(Node h) {
        assert (h != null) && isRed(h.left);
        Node x = h.left;
        h.left = x.right;
        x.right = h;
        x.color = x.right.color;
        x.right.color = RED;
        x.size = h.size;
        h.size = size(h.left) + size(h.right) + 1;
        return x;
    }

    //左旋
    private Node rotateLeft(Node h) {
        assert (h != null) && isRed(h.right);
        Node x = h.right;
        h.right = x.left;
        x.left = h;
        x.color = x.left.color;
        x.left.color = RED;
        x.size = h.size;
        h.size = size(h.left) + size(h.right) + 1;
        return x;
    }

    // 颜色变换
    private void flipColors(Node h) {
        h.color = !h.color;
        h.left.color = !h.left.color;
        h.right.color = !h.right.color;
    }

}

测试：

    @Test
    public void test() {
        RedBlackBST<Integer, String> redBlackBST = new RedBlackBST<>();
        for (int i = 0; i < 10; i++) {
            char v = (char)(97+i);
            redBlackBST.put(i, new String(new char[]{v}));
        }
        System.out.println(redBlackBST.get(3));
    }

测试出来的树结构如下：

红黑树删除节点

以下内容均来自《算法(第4版)》,原文链接：https://blog.csdn.net/weixin_43696529/article/details/104707495

删除最小值

如果待删除的节点是一个3-节点，那么直接删除就好了，但是如果是一个2-节点，删除后便后影响树的结构，因此删除最小值的思路如下：
从根节点开始向下寻找最小值，路径上的每一个节点都需要满足以下条件之一：

1. 当前节点的左孩子是3-节点，过
2. 当前节点的左孩子是2-节点，但是兄弟节点是3-节点，此时可以向兄弟节点借一个过来，保证自己不是2-节点；
3. 当前节点左孩子右孩子都是2-节点，则向父节点借一个，并将借的节点和左孩子右孩子合并。

按如上操作遍历到最小值处，此时最小值就在一个3-节点或者4-节点中，删除接即可。然后就可以自底向上修复临时的4-节点（同前面的步骤）。

public void  delMin(){
        if (isEmpty()){
            throw new NoSuchElementException("树为空");
        }
        if(!isRed(root.left) && !isRed(root.right)){
            root.color = RED;   // 如果根节点的左右子节点是2-节点，我们要先根设为红的，这样才能进行后面的moveRedLeft操作，因为左孩子要从根节点借一个
        }
        root = delMin(root);
        root.color = BLACK;  // 借完以后，我们将根节点的颜色复原
    }
     private Node delMin(Node node) {
        if (node.left==null){
            return null;
        }
        if (!isRed(node.left) && !isRed(node.left.left)){
        // node的左节点如果是2-节点，则按上面的方法编程3-节点或是临时4-节点
            node=moveRedLeft(node);
        }
        node.left=delMin(node.left);
        return balance(node); //   平衡临时组成的4-节点
    }

以下是2-节点变3-节点或4-节点的方法：

private Node moveRedLeft(Node node) {
        /**
         * 因为我们规定红链接只能在左，
         * 因此当前节点的左右子节点都是2-节点，这时候我们就需要通过颜色转换，将这三个节点合并在一起
         */
        flipColors(node);
        //如果兄弟节点为2-节点的话，那么到上一步就结束了

        if(isRed(node.right.left)){     // 而如果兄弟节点不是2-节点的话，我们就需要通过旋转从兄弟节点借一个过来
            node.right = rotateRight(node.right);
            node = rotateLeft(node);
            //  因为条件2要求我们只向兄弟节点借一个，
            //  而一开始从父节点那里借了一个，因此需要还一个给父节点
            flipColors(node);
        }
        return node;

    }

删除最大值

逻辑同删除最小值相同，方向相反

 public void delMax(){
        if (isEmpty()){
            throw new NoSuchElementException("树为空");
        }
        if (!isRed(root.left) && !isRed(root.right)){
            root.color=RED;
        }
        root=delMax(root);
        root.color=BLACK;
    }

在删除中需要添加一个左孩子是否为红链接的判断，
因为最大值要么不存在子孩子，要么最多存在一个左链接（从以上几个平衡旋转可以发现，最大值节点一定是这两个情况）
如果有左红链接，则应该将此节点右旋转，让最大值没有一个孩子，这样就可以直接删除，否则会破坏树的结构，丢失该左孩子

private Node delMax(Node node) {
        if(isRed(node.left)){
         
            node = rotateRight(node);
        }
        if (node.right==null){
            return null;
        }
        if (!isRed(node.right) && !isRed(node.right.left)){
            node=moveRedRight(node);
        }
        node.right=delMax(node.right);
        return balance(node);
    }

    private Node moveRedRight(Node h) {
        // assert (h != null);
        // assert isRed(h) && !isRed(h.right) && !isRed(h.right.left);
        flipColors(h);
        if (isRed(h.left.left)) { 
            h = rotateRight(h);
            flipColors(h);
        }
        return h;
    }

删除任意key

删除操作则就是将删除最小值和删除最大值组合在一起，但需要考虑key不在树底的情况，此时按二叉查找树的删除逻辑删除即可，具体如下：

public void delete(Key key) {
        if (key == null) throw new IllegalArgumentException("argument to delete() is null");
        if (!contains(key)) return;

        if (!isRed(root.left) && !isRed(root.right))
            root.color = RED;

        root = delete(root, key);
        if (!isEmpty()) root.color = BLACK;
    }
    private Node delete(Node node, Key key) {

        if (key.compareTo(node.key) < 0)  {
            //key在左子树，按删除最小值一样删除
            if (!isRed(node.left) && !isRed(node.left.left))
                node = moveRedLeft(node);
            node.left = delete(node.left, key);
        }
        else {//key在右子树，按删除最大值一样删除
            if (isRed(node.left))
                node = rotateRight(node);
            //需首先判断待删除的节点是否在树底，否则下一步的node.right.left会出现空指针
            if (key.compareTo(node.key) == 0 && (node.right == null))
                return null;
            //递归在右子树中删除
            if (!isRed(node.right) && !isRed(node.right.left))
                node = moveRedRight(node);
            //如果待删除的节点不在树底
            if (key.compareTo(node.key) == 0) {
                //像二叉查找树一样删除，从node右子树找到最小的节点放在当前位置，然后再将该最小节点从右子树删除
                Node x = min(node.right);
                node.key = x.key;
                node.value = x.value;
              
                node.right = delMin(node.right);
            }
            else {
                //key仍然大于该node，继续在右子树递归
                node.right = delete(node.right, key);
            }
        }
        return balance(node);
    }

上面所有代码已提交至：https://gitee.com/wj204811/algorithm