红黑树的理解与代码实现

红黑树

        我们知道对于二叉搜索树而言,无法保证树的平衡性,从而使得进行操作的时候时间复杂度在O(logn)与O(n)之间。这样是不稳定的。而2-3树则借助于3-结点和临时的4-结点,通过分解,解决了平衡问题。例如对于插入,在最终是3-结点的情况下,临时构成4-结点,然后再分解成3个2-结点,这样令树高度+1,但是整体平衡性不变。而红黑树就是为了实现自平衡这个功能而对2-3树进行了扩展。而红黑树仍然属于一棵二叉查找树,只是多了红结点与黑结点,来模仿2-结点和3-结点。所以对于二叉搜索树的方法,很多都能在红黑树上使用。而红黑树的关于自平衡的很多理论,来源于2-3树。下面是一棵简单的红黑树:

《红黑树的理解与代码实现》

其实按照标准定义,叶子节点仍然有左右两个引用,也就是说,任何一个结点都一定有2个子树,就算这个子树是空的。而这些结点分为红色与黑色。注意看上面的箭头,也有红黑之分。或者说,我们虽然在定义Node结点的时候,认为某个节点的颜色有红黑之分,但是实际上,这个红黑是指链接是红色还是黑色。

        也就是说,如果某结点的颜色是红色,是说连接到该结点的链接是红色,而根的颜色永远为黑色。

        这里提一嘴,红黑树非常依赖图像演示,推荐找视频或者找各种动图来学习红黑树,能够非常快理解旋转之类的操作。

红黑树与2-3树

        为什么一定要对链接区分红黑?如果就上面的图进行变换,我们不管黑色,将红色的连接平着画,可以得到这个图:

《红黑树的理解与代码实现》

可以看到,这样来表示,树的高度是一致的,如果我们仔细看,是不是可以认为,红色链接连接的2个结点可以组合起来作为一个2-3树中的3-结点。这样,就把一棵红黑树转换成了2-3树。而我们认为2-3树是完美平衡的,那么是否说明了,红黑树也是完美平衡。

        红链接将2个2-结点连接起来构成一个3-结点,黑链接则是2-3树中的普通链接。那么对于红黑树而言,仍然可以使用二叉查找树中的搜索之类的,与颜色无关的方法。而例如插入和删除,我们可以认为在处理过程中,使用2-结点、3-结点、4-结点之间的组合与删除,来完成自平衡。

        《算法》书中认为:这样用红黑链接表示的2-3树,是红黑二叉查找树。

红黑树的性质

        对红黑树有这样的定义:

1.红链接均为左链接。

2.两个红链接不能相连在一起。

3.红黑树是完美黑色平衡,即任意空结点到根节点所经过的黑链接完全一致。

4.空结点的链接颜色是黑色。

第一条有点疑问,因为有的资料说可以将红链接作为右链接,这个文章统一认为是只能为左。因为上面的性质,我们需要额外确定一些性质:

1.根节点的链接颜色必定为黑。这里其实无所谓,因为根没有父链接,但是结点中有color,所以就默认为黑了。

2.我们认为红黑树“有数据”的结点都不是叶子结点。叶子结点只能为null或者NIL。

        既然我们认为红黑树就是2-3树的一种,那么就可以理解为什么不能两个红链接连在一起了,这就像一个临时的4-结点,我们允许其存在,但是为了保证平衡,需要分解。

红黑树的颜色

        其实上面写了一点,虽然我们将颜色定义到结点中,但是只是因为我们无法对链接声明数据结构罢了,应该认为是指向该结点的链接的颜色。

        在实际的代码中,可以用常量来表示红黑,调用一个方法可以判定是黑是红即可。例如:

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

写一个就行了,没必要写个isBlack。具体的实现可以看下面对红黑树的定义以及结点的定义。这里并不是写进Node类,而是RBT类中的方法,因为这样会使得后面的算法更加灵活。

红黑树的声明以及Node结点的实现

        我们可以像容器一样,声明一个“红黑树”,而将Node结点作为其内部类。这样可以保证比较广泛地应用。当然也需要使用泛型,因为不可能固定数据类型。红黑树在Java中是TreeMap和TreeSet的底层,对于Map这种数据结构,我们需要使用Key-Value的结构,那么在结点中,声明两种元素就可以了,为了保证顺序,可以令Key实现comparator接口,从而保证按照Key顺序排序,同时完成Map映射关系。这样,我们可以得到这样的数据结构:

class RBT<Key extends Comparable<Key>, Value>{
    private static final boolean BLACK = false;
    private static final boolean RED = true;

    private Node root;

    private class Node{
        private Key key;
        private Value value;
        private Node left;
        private Node right;
        private boolean color;

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

在Node结点中,我是定义了boolean作为红黑判定,这个可以任意改变,例如int,都可以。而这两个常量是在RBT类里面而不是Node,因为我们需要在其他算法里也使用这些常量。

红黑树自平衡的操作-旋转

        会AVL树的话,可能就非常简单能够理解旋转操作。旋转的作用是在进行例如插入、删除操作的时候,根据不同的情况(主要是因为平衡被破坏了),从而进行不同的旋转操作使得以及破坏平衡的树重新回归平衡。这也是我们说“自平衡”的原因。

        红黑树的话,旋转其实有点类似2-3树中的结点分解与临时合并。这个等后面再分析。旋转其实就是左旋和右旋。接收一个结点,转就完事了。而不同情况下如何调用旋转来保持平衡,这是插入、删除等方法中的算法,与单纯的左右旋无关。所以下面先分析对一个结点进行左旋和右旋,怎么调用,调用几次,等到用了再分析。

        可能会担心,父结点怎么办,或者旋转操作是在根上怎么办。其实无所谓,我们只用在旋转操作后返回一个旋转后的根就行了,具体怎么链接怎么操作,都与单纯的旋转算法无关。

左旋

        对于一个结点左旋,其实就像是将这个结点“降级”了,让这个结点在树上变得更低,而将另一个原来比较低的结点给提上去。不管样得看图,看懂图就能理解这个算法。

《红黑树的理解与代码实现》

这个是对结点h进行了左旋。所以左旋是必须要求有右子树,不一定有左子树。这里注意,画的是红色链接,h和x的链接是一定是红色的,因为红黑树的旋转一定是因为颜色。而连接h的链接,可能是左链接也可能是右链接,这个不是旋转的算法,我们只需要返回“拉上去”的结点x,让上层来处理。这个链接也可能为红或者为黑,那么令x.color = h.color就完美解决问题了,算法如下:

    public Node rotateLeft(Node h){
        Node x = h.right;
        h.right = x.left;
        x.left = h;
        x.color = h.color;
        h.color = RED;
        return x;
    }

右旋

        与左旋类似,还是看图:

《红黑树的理解与代码实现》

右旋是下降,其他基本和左旋一致,那么右旋的代码呼之欲出:

    public Node rotateRight(Node h){
        Node x = h.left;
        h.left = x.right;
        x.right = h;
        x.color = h.color;
        h.color = RED;
        return x;
    }

旋转后对父结点进行重置

        上面的旋转,最后是返回一个结点的。主要就是因为无法确定父结点到该结点的具体链接是左是右,以及是否需要重置根。并且可能造成两条连续的红色结点——这里可以理解为2-3树的临时4-结点。需要将其分解。但是这样可以通过对旋转的多次调用解决这个问题。

        旋转可以保持红黑树的有序性和完美平衡。

红黑树的插入

        红黑树的插入分为多种情况,需要逐条分析,但是需要确定红黑树在插入的时候需要遵循怎样的条件。更新这个就不说了,如果在插入过程中,发现key已存在,那就更新value,这个可以忽略,主要讨论插入的问题。我们认为红黑树是黑色完美平衡,并且在看一棵红黑树的时候,将红链接放平,看成2-3树。那么假设我们在最底部插入元素,肯定是想要插入一个红色结点,这样,树的高度实际上没有任何变化,而插入黑结点使得高度+1。所以插入的链接必定是红色。

        插入之前仍然是需要搜索到具体的插入位置。如果不存在树,则new出来根。最终需要找到插入点。所以先写一部分插入代码,跟正常的二叉查找树很类似,就是搜索:

    public void put(Key key,Value value){
        root = put(root,key,value);
        root.color = BLACK;
    }
    private Node put(Node root,Key key,Value value){
        if(root == null) return new Node(key,value);
        int cmp = key.compareTo(root.key);
        if(cmp == 0){
            root.value = value;
        }else{
            if(cmp > 0){
                root.right = put(root.right,key,value);
            }else{
                root.left = put(root.left,key,value);
            }
        }

    }

        为什么一定要令root的颜色为黑?这是为了符合性质。根节点一定是黑色(主要是后面算法,可能会导致根变红)。

        插入的过程其实是类比2-3树的,可能会导致出现临时4-结点等情况,所以需要通过旋转来保持平衡,整体上的插入分为以下几种情况。

红黑树的插入-向单个黑结点插入

        单个黑结点之所以单独拿出来说,是因为比较特殊——只存在根的情况。空树不考虑,这个算是特殊情况了。如上面所描述,我们认为新增结点一定是红结点,这样树高度暂时保持不变。那么对于只存在根结点的情况下,只有2种情况:

1.新结点小于根结点。

2.新结点大于根结点。

忽略相等,这样是更新。而小于根结点,那么左链接是红色完全符合红黑树性质,也就是不需要任何处理。而如果是大于,则是右链接为红色。这样其实是不符合红黑树性质的——只存在左链接为红链接。那么我们可以看一下上面两种旋转的图片:左旋会导致右红链接变成左红链接。

        那么对于这种情况下,解决方法就确定了:相等,则更新根结点value。小于则new出来左子树根结点。大于则new出来右子树根结点,然后再对根结点进行左旋。

红黑树的插入-向一个黑结点插入

        这个包含了上面的情况,即只存在一个根节点。但是先不考虑这个,也就是有很多结点的时候插入。如果是向一个黑结点,或者说2-结点插入,最终插入的时候仍然是必定插入红链接,但是有可能引发一系列问题。这里分析一下:

1.新结点小于父结点。

2.新结点大于父结点。

仍然忽略相等的情况。那么如果是小于,则是左链接,因为父结点是黑色,所以不会引发红黑树的不平衡。如果是右链接,那么就是出现了红色右链接,左旋即可解决。实际上跟在仅仅一个根上插入是一样的,只是多了很多其他结点。但是实际上,跟其他结点是无关的,旋转的操作仅仅影响2个结点而已,其他的全部没有变化。

        但是可以认为,对一个黑结点进行插入,必定形成一个红链接。

红黑树的插入-向一个红结点插入

        这个其实可以分解为3种情况,看图理解会更好:

《红黑树的理解与代码实现》

如果将红链接想象成3-结点,那么1情况就是,插入数据小于两个值,2就是在两个值中间,3就是大于两个值。仍然是考虑新加的链接是红色的,那么3种插入情况都有会出现问题——2-3树此时产生了一个4-结点。

        而2-3树解决方案是分解4-结点,红黑树也一样。允许出现临时的4-结点,但是会根据情况来进行旋转,使其变成正常的红黑树。同时向上传递红色链接直到碰见黑链接或者是根。这个过程在2-3树中是分解4-结点并向上传递。先看图,展示一下3种情况下的旋转方法,再文字解析:

《红黑树的理解与代码实现》

这3种情况,看图也基本能理解了:

1.左右连接均为红色。两链接变为黑色,而父结点颜色变红。

2.连续两个左链接均为红色。父结点右旋,然后变成1的情况。

3.出现红色右链接。父结点左旋。然后变成2的情况。

实际上,这是一个向上传递的过程——所以代码写成了递归,改成非递归算法很难理解,而递归就能直接理解。最简单的,如果发生了1,那么有可能出现这样的情况:

《红黑树的理解与代码实现》

等于说,我们需要回溯,因为上面的结点可能出现其他需要旋转的情况。这个就是在回溯的时候解决的。

        既然有3种情况,考虑到回溯,我们需要对3种情况的出现排个顺序,就能方便写出代码:3之后可能出现2或者1,2之后可能出现1,1之后可能出现2、3。但是有一点,2和3都是正常的旋转,但是1却使得父结点之上出现红色结点。1是向上传递的,这就引发了树的向上分解的过程。很多其他的写法,会单独将这个过程和顺序写进一个方法或者函数,认为这个是维持红黑树平衡的核心:

        if(isRed(root.right) && !isRed(root.left)) root = rotateLeft(root);
        if(isRed(root.left) && isRed(root.left.left)) root = rotateRight(root);
        if(isRed(root.left) && isRed(root.right)) flipColors(root);
        return root;

3种情况,1情况必须放在最后。这样的顺序可以保证解决当前结点下所有不平衡的行为,最终通过情况1向上传递红结点。那么完善的put方法为:

    public void put(Key key,Value value){
        root = put(root,key,value);
        root.color = BLACK;
    }
    private Node put(Node root,Key key,Value value){
        if(root == null) return new Node(key,value);
        int cmp = key.compareTo(root.key);
        if(cmp == 0){
            root.value = value;
        }else{
            if(cmp > 0){
                root.right = put(root.right,key,value);
            }else{
                root.left = put(root.left,key,value);
            }
        }
        if(isRed(root.right) && !isRed(root.left)) root = rotateLeft(root);
        if(isRed(root.left) && isRed(root.left.left)) root = rotateRight(root);
        if(isRed(root.left) && isRed(root.right)) flipColors(root);
        return root;
    }

那么树在增高的时候,就是红结点一直传递到根的时候。而根颜色是什么无所谓的,只需要知道:如果根结点为红,就是树增高了一层。

删除

        有点难了,最难的就是这个= =。书上直接简单说一下思路就不管了,代码也不给,认为这个是扩展内容。确实,删除并维持平衡要比插入考虑的多得多,主要在于删除后如何保持平衡。

        网上关于红黑树的删除有很多不同的描述方法,例如分析可能出现的情况,比较经典的有X图详解删除操作等等。先解释删除最小值和最大值,然后再解释常规的删除。

删除最小值

        《算法》书中认为,最小值如果是3-结点,那么删除后无所谓,但是不能够直接删除2-结点。扩展到红黑树的话,就是说不能删除黑结点,但是可以删除红结点。这是为了满足红黑树黑树完美平衡的情况,或者就跟上面写的一样,将红链接平画——那么删除红色结点,树的高度是不变的,但是删除黑结点,就无法满足黑色完美平衡性质:任何叶子结点到根节点所经过的黑链接数量相同。认为红黑树的平衡被破坏了。

        以此出发,书中认为,我们需要从根节点开始,跟正常的二叉树找最小值一样,一直左子树遍历,但在遍历过程中,通过算法,保证最终找到的最小值一定是红结点。这个看起来似乎是有点扯了,大体思路如此。在遍历的时候,不关心是否满足红黑树的具体情况,就是通过一定的算法,保证最终是红结点,而最后在回溯的时候,再将其不合理的结点通过一定的算法给变合理。这样,保证最终树是平衡的,又删除了最小值。

        首先分析搜索阶段的“特殊算法”。根节点比较特殊,如果根节点左右子树全是黑结点,在2-3树中就是一棵3个2-结点组成的树。此时我们需要操作——在2-3树中是将3个2-结点合成1个临时的4-结点,然后删除最小值,保存这个3-结点。而扩展称为红黑树的画,看下面的图:

《红黑树的理解与代码实现》

这个是比较特殊的,仅限有3个结点的情况,而其他情况下实际上是这样:

        左子树是黑结点,右子树一定是黑结点,但是左子树的左子树可能我们要删除的——我们需要保证,X结点的左子树的左子树是一个3-结点。也就是说,每次我们向下遍历一次,都需要保证出现这样的情况:

《红黑树的理解与代码实现》

H结点一定是3-结点。而实际上,我们只用保证1的情况出现就可以了,在此基础上,2情况不可能出现。但是在分析的时候,只要我们能够满足每一步都实现上述两种情况,那么最终删除的时候,一定是在删除一个红结点。

        那么,为了保证这样的情况出现,我们需要向兄弟结点“借结点”。这个过程是这样的:假设左子结点的兄弟结点是红结点,那么将兄弟结点的一个给移动过来,如果不是,则选择最上面的情况,即父结点+左结点+右结点,合并成4-结点。由此出现了一个辅助方法:

    private Node moveRedLeft(Node root){
        flipColors(root);
        if(isRed(root.right.left)){
            root.right = rotateRight(root.right);
            root = rotateLeft(root);
            flipColors(root);
        }
        return root;
    }

假设我们发现需要将2-结点给转换了,首先进行反转flipColors。这也是当出现特殊情况——只有3个2-结点的时候的操作,合成一个临时的4-结点。而如果发现兄弟结点由红色结点,最后再调用一次flipColors,那么临时的4-结点就取消了。if语句里面的内容,就是将右边兄弟结点的一个给移动过来。为什么是两次旋转?先右转后左转,给个图理解一下:

《红黑树的理解与代码实现》

这就是转换过程,认为此时给了一个结点。这里可能有疑问,但是注意:我们开始就对根结点调用了flipColors,那么我们代入红色结点再来看这个图:

《红黑树的理解与代码实现》

为什么最后一张图少了2个红链接?因为最后又调用了一次flipColors,给恢复了。那么跟最开始的图比起来,是不是左子树多了一个结点。

        那么,整体代码可以看这样:

    public void deleteMin(){
        if(!isRed(root.left) && !isRed(root.right)) root.color = RED;
        root = deleteMin(root);
        if(root != null) root.color = BLACK;
    }
    private Node deleteMin(Node root){
        if(root.left == null) return null;
        if(!isRed(root.left) && !isRed(root.left.left)) root = moveRedLeft(root);
        root.left = deleteMin(root.left);
        return balance(root);
    }

根结点置红,但是最后又给变黑,这个是为了满足中间条件,根操作的时候不会出错。而第二个重载方法就是核心了。而当左结点是null的时候,直接return null,因为这个就是要删除的结点。但是可能存在的右子树怎么办?我们之前的转换就解决这个情况了。最终,如果该结点满足上面讨论的——连续两个左结点是黑,那么进行递归过程中的转换,从兄弟中拿过来结点,或者生成临时的4-结点。而没有问题,就递归继续向右前进。

        最终,递归的结局就是删除最小值。此时因为可能也生成了临时的4-结点,或者其他不满足的条件,应该向上回溯,分解4-结点并解决其他平衡问题,这个balance方法其实就是put方法最后几行的代码:

    private Node balance(Node root){
        if(isRed(root.right)) root = rotateLeft(root);
        if(isRed(root.left) && isRed(root.left.left)) root = rotateRight(root);
        if(isRed(root.left) && isRed(root.right)) flipColors(root);
        return root;
    }

不解释了,在put中就已经解释了。

删除最大值

        删除最大值跟删除最小值有不同,虽然说是直接右子树递归,但是按照书中给的红黑树定义:不存在红色右链接。(这个其实网上有的写法是允许红色右链接的)。所以算法有不同,但是整体思路一样——生成临时4-结点或者从兄弟节点中借过来。

    private Node moveRedRight(Node root){
        flipColors(root);
        if(isRed(root.left.left)){
            root = rotateRight(root);
            flipColors(root);
        }
        return root;
    }
    public void deleteMax(){
        if(!isRed(root.left) && !isRed(root.right)) root.color = RED;
        root = deleteMax(root);
        if(root != null) root.color = BLACK;
    }
    private Node deleteMax(Node root){
        if(isRed(root.left)) root = rotateRight(root);
        if(root.right == null) return null;
        if(!isRed(root.right) && !isRed(root.right.left)) root = moveRedRight(root);
        root.right = deleteMax(root.right);
        return balance(root);
    }

基本跟删除最小值一样,从上到下,慢慢分析不同点。

        首先是moveRedRight,if判断是判断的左子树的左子树,满足条件的话只用一次右旋即可,此时已经送过来一个右子节点了。因为必定会送过来红链接,所以只用旋转一次。而在deleteMax的重载方法中,并不是先判定是否找到最大值,而是先进行一次旋转。因为红黑树的性质,下面图中左边的树一定不存在,右边的树可能存在,这个是红黑树性质问题:

《红黑树的理解与代码实现》

那么,找最大值的时候,可能直接就找到根了,但是此时没有处理直接return null的话,左子树就丢失了。所以要先进行一次旋转,再进行删除。后面的就一样了。

完整的删除

        删除,其实就是删除最大值和删除最小值的代码的结合。因为我们肯定是在不断利用compareTo方法进行比较,确定递归进入左子树还是右子树。可以简单理解为,进入左子树,就用删除最小值的特殊方法moveRedLeft来处理结点,反之则是删除最大值的情况。这样分别调用moveRedLeft和moveRedRright,最后还是调用balance回溯的时候保证平衡。

        因为解释比较碎,代码还长,所以写进注释了:

    public void delete(Key key){
        if(!isRed(root.left) && !isRed(root.right)) root.color = RED;
        root = delete(root,key);
        if(root != null) root.color = BLACK;
    }
    private Node delete(Node root,Key key){
        int cmp = key.compareTo(root.key);
        if(cmp < 0){
        	// 左递归,跟删除最小值的一样
            if(!isRed(root.left) && !isRed(root.left.left)) root = moveRedLeft(root);
            root.left = delete(root.left,key);
        }else{
        	// 右递归,先判定了是否需要删除最小值的第一次旋转保证不会丢失左子树
            if(isRed(root.left)) root = rotateRight(root);
            // 找到了,该删了,但是需要确保不会丢失右子树
            if(cmp == 0 && (root.right == null)) return null;
            // 这个是删除最大值中的算法
            if(!isRed(root.right) && !isRed(root.right.left)) root = moveRedRight(root);
            // 此时,完美解决所有丢失情况,可以正常删除了,这个过程实际上就是二叉搜索树树的删除
            if(cmp == 0){
                Node x = min(root.right);
                root.key = x.key;
                root.value = x.value;
                root.right = deleteMin(root.right);
            }else{
                root.right = delete(root.right,key);
            }
        }
        return balance(root);
    }

而真正删除一个结点的时候,其实就是二叉搜索树的删除算法——找到右子树的最小值来补充删除位。这里不多说了,不理解这个的可以先看一下二叉搜索树的删除。

关于和红黑链接无关的算法

        例如搜索。在遍历的时候,我们是不需要考虑红色链接或者黑色链接,它们的作用就是保证红黑树的平衡,而查找等不改变红黑树结构的算法根本用不到考虑红黑链接。所以这些算法,其实跟二叉搜索树中的算法完全一致,直接拿过来用就行了,例如get方法或者search方法,都跟二叉搜索树一样。所以说推荐先学会二叉搜索树再考虑学习红黑树。

总结

        我觉得还是不太会= =。好鸡儿难啊,但是红黑树是真的厉害,解决了自平衡的问题,当然因为AVL树差不多也没啥印象了,应该是比AVL树好的吧,具体怎么好了不知道了,印象中AVL树在一定情况下不是完美平衡,会有一定的高度差,在数据非常大的时候还是不算特别好,但是红黑树是非常完美的黑色平衡。保证了树高一定是小于2logN。等于说非常的稳定和高效。所以在Java中Map的底层之一就是红黑树。

        还是好难啊,说真的删除这一部分其实现在也是勉强理解,不过插入倒是感觉还行。然而自己写肯定gg。并且红黑树的算法是递归了,应该是改成非递归会好一点,但是也懒得再思考了= =,菜鸡还是别花太大时间搞这个了。

        给一个完整的连接,附带一棵写好的红黑树:

https://github.com/iwts/data-structure/blob/master/red-black-tree.java

    原文作者:算法小白
    原文地址: https://blog.csdn.net/iwts_24/article/details/86754155
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞