数据结构——平衡树之红黑树

ゞ浴缸里的玫瑰 2022-05-15 16:35 200阅读 0赞

## 一、2-3树 ##

在了解什么是红黑树之前，首先需要补充一下什么是2-3树，因为它有助于我们对红黑树的理解，包括对B类树的理解。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70][]

2-3树可以有两个孩子或三个孩子，所以也就被称为2-3树，且2-3满足二分搜索树的基本性质。如左图中，**a的左孩子值 < a**，**a右孩子的值 > a**，在右图中可以存放两个元素b、c，该树有三个孩子，**左孩子的值 < b**，**b < 中间孩子的值 < c**，**右孩子的值 > c**。通常称左图含有两个孩子的节点为2节点，称右图中含有三个孩子的节点为3节点。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 1][]

当我们需要对2-3进行搜索的时候，实际上也是和二分搜索树思路一致的，当我们搜索的过程来到一个3节点的话，搜索数x如果小于3节点的左值，则在3节点的左子树中继续寻找，如果搜索的这个树大于3节点的右值，到三节点的右子树中继续查找，如果搜索数x的值介于3节点的左值与右值之间，则在3节点的中间子树继续寻找。

**对于2-3树来说，它是一个绝对平衡的树**。即从根节点到任意一个叶子节点，所经过的节点数量一定是相同的。

理解在2-3树中添加节点时，是如何维护绝对平衡的，对我们理解红黑树的机制很有帮助。

**2-3树在添加节点时，如果子树为空，则进行融合，如果融合之后是四节点，则分裂。**

**如图：**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 2][]**     在添加元素6时，元素12不存在左子树，则元素12与元素6融合形成3节点

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 3][]     融合形成4节点则分裂

**插入后形成3节点，且父亲节点为2节点时**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 4][]**

**插入后形成3节点，且父亲节点为3节点时**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 5][]

## 二、2-3树与红黑树的等价性 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 6][]

黑色为普通节点，红色为特殊节点，红黑组合相当于2-3树中的3节点，我们把3节点中的左节点b作为右节点c的 左子节点 ，因为左节点 < 右节点 ，之所以b为红色是因为在2-3树中，元素b元素c是作为3节点相融在一起的，但在红黑树中只有2节点，红色表示【红色的b】与其父节点【黑色的c】在2-3树是以3节点相融的，**在红黑树中，所有的红色节点都是向左倾斜的**。

转化为对应的红黑树：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 7][]

## 三、红黑树的五大特性 ##

1、每个节点或者是红色的或者是黑色的。

2、根节点是黑色的。

3、每一个叶子节点(最后的空节点NIL)是黑色的。

4、如果一个节点是红色的，那么他的孩子节点一定是黑色的。

5、从任意一个节点到叶子节点，所经过的黑色节点数量相同。

性质2证明： 根节点是黑色的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 8][]

性质3是一种性质：每一个叶子节点(最后的空节点NIL)是黑色的

对于一棵空树本身，其根节点一定是黑色的，在极端的环境下，空树即是叶节点又是根节点，都是黑色的

性质4证明：如果一个节点是红色的，那么他的孩子节点一定是黑色的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 9][]

在红黑树中，红黑节点组合代表的是2-3树中的3节点，3节点中左侧元素b对应红黑树中的红色节点，该红色节点的孩子为对应2-3树中的左孩子和中间孩子，若该孩子节点为2节点，如左边图所示，则一定为黑色；若孩子节点为3节点，则连接的形状如右图所示，先连接黑色节点，黑色节点的左孩子才为空色节点，所以如果一个节点它是红色的，它的孩子节点一定是黑色的。

**拓展**：对于一个黑色节点，他的左孩子可能为红色【对应2-3树的融合】，也可能为黑色。 总的来说：**它的左孩子右可能为红色，有可能为黑色，但右节点一定是黑色节点**。

性质5【红黑树核心特性】证明：从任意一个节点到叶子节点，所经过的黑色节点数量相同

因为红黑树和2-3树是等价的，2-3树是一棵绝对平衡的树。对于2-3树的任意一个节点出发，到叶子节点所经过的节点数一样多，由于2-3树是绝对平衡的树，所有的叶子节点都在同一层中。

在2-3树转化为红黑树时，对应2节点/3节点分别转化为黑色节点/红色和黑色节点2个节点，不管如何转化一定会存在一个黑色节点，所以从任意一个节点到叶子节点，对于2-3树来说经过的节点数相同，对红黑树来说经过的黑色节点数量相同。

**红黑树是保持"黑平衡"的二叉树**，严格意义上讲**红黑树并不是平衡二叉树**，左右子树的黑色节点保持着绝对的平衡，对红黑树来说，如果存在节点个数n，那么最大高度为2logn，时间复杂度为O(logn)。

**AVL  vs  红黑树**

查找效率： AVL树 > 红黑树

增删改效率：  AVL树 < 红黑树

## 四、向红黑树中添加新元素 ##

由于2-3树和红黑树具有等价性，先回忆在2-3树中添加新节点时，永远不会添加到一个空节点【要么融合，要么产生临时4节点分裂】，所以添加进2节点时，会形成一个3节点，当添加进3节点时，会暂时形成一个4节点后分裂。

**在红黑树中添加新元素时，设置为永远是红色节点**，在递归结束后，我们需要手动设置根节点为黑色BLACK(boolean)。

**新增元素时，有几种情况：**

添加到对应2-3树中的2节点下：

### 1、新增元素添加到左右子树都为空的黑色节点\[2-node\] ###

①**新插入节点比其根节点小**，则作为根节点的左子节点，这种情况比较简单【相当于2-3树融合】

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 10][]

②**新插入节点比根节点大**，则作为根节点的右子节点，我们知道红色节点不可能在右侧，所以需要做调整

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 11][]                            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 12][]

**执行左旋转**

**步骤1：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 13][]

**步骤2：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 14][]

为了表示37、42是一个3节点，则原来的元素37需要变为红色节点

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 15][]

其中第三句x.color = node.color，如果原来node颜色为红色节点，则打破了红黑树的基本性质，在这里左旋转只是一个子过程，左旋转后形成子树新的根节点x将会被返回做后续处理，在左旋转时并不维持红黑树的基本性质，只需要保证37、42两个元素对应2-3树中的三节点即可。

左旋转代码：

//   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-node\] ###

**①向原3节点的红黑树中添加一个大于其根节点42的值**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 16][]

**步骤1**：根据二分搜索树的添加规则，66添加到37的右节点上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 17][]

对应的是一个临时的4节点【融合】 处理方式为：

**步骤2：**拆分成3个2节点

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 18][]

对应红黑树为3个黑色节点，让42的左右子节点都改变为黑色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 19][]

**步骤3：**

此时其根节点42应该与42的父节点进行融合，所以42需要变为红色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 20][]

我们发现42由黑色变为了红色，而37和66都由红色变为了黑色，该动作称为**颜色翻转**【flipColors】

//颜色翻转
        private void flipColors(Node node){
            node.color = RED;
            node.left.color = BLACK;
            node.right.color = BLACK;
        }

②**向原3节点的红黑树中添加一个小于其父节点的值**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 21][]**

添加后：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 22][]

此时产生了一个临时的4节点，处理方式仍然为分裂，即变为由3个2节点的子树，如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 23][]

此时应该执行**右旋转**，**步骤1**：

旋转之前：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 24][]

旋转之后：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 25][]

**步骤2：**此时需要变换颜色，x的颜色需要改变为node的颜色，node的颜色需要设置为红色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 26][]

最后执行我们编写过的颜色翻转即可，变为:  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 27][]

右旋转代码：

//     node                   x
        //    /   \     右旋转       /  \
        //   x    T2   ------->   y   node
        //  / \                       /  \
        // y  T1                     T1  T2
        public Node rightNode(Node node){
            Node x = node.left;
            node.left = x.right;
            x.right = node;
            //切换颜色
            x.color = node.color;
            node.color = RED;
            return x;
        }

③**向原3节点的红黑树中添加一个大于根节点且大于其父节点的值**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 28][]

添加后形成的红黑树情况：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 29][]

**步骤1：**对节点37进行**左旋转**，如图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 30][]

**步骤2：**对节点42进行**右旋转**，如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 31][]

**步骤3：变色操作**，对节点40变为42的颜色，将节点42变为红色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 32][]

**步骤4：**执行**颜色翻转**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 33][]

### 添加元素总结 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 34][]

这种过程即为我上述的向红黑树3节点中添加元素【添加的元素**小于根节点**但**大于添加位置的父节点**】的全过程

向红黑树3节点中添加元素【添加的**元素小于根节点**且**小****于添加位置的父节点**】的全过程，即直接跳到了第三步

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 35][]

向红黑树3节点中添加元素【添加的**元素大于根节点**】的全过程，即直接跳到了第四步

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 36][]

左右旋转条件总体逻辑代码编写：

左旋转 右节点为红色且左节点不为红色
    
    右旋转 左节点为红色且左节点的左节点也为红色
    
    颜色翻转

在add方法中：【使用3个if 每次都顺序判断】

// 向以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 // key.compareTo(node.key) == 0
                node.value = value;
    
            //左旋转 右节点为红色且左节点不为红色
            if(isRed(node.right) && !isRed(node.left))
                node = leftRotate(node);
            //右旋转 左节点为红色且左节点的左节点也为红色
            if(isRed(node.left) && isRed(node.left.left))
                node = rightNode(node);
            //颜色翻转
            if(isRed(node.left) && isRed(node.right))
                flipColors(node);
            return node;
        }

红黑树的性能总结：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 37][]

红黑树完整代码：

import java.util.ArrayList;
    
    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 RBTree(){
            root = null;
            size = 0;
        }
    
        public int getSize(){
            return size;
        }
    
        public boolean isEmpty(){
            return size == 0;
        }
    
        // 判断节点node的颜色
        private 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;
        }
    
        //     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;
        }
    
        // 颜色翻转
        private void flipColors(Node node){
    
            node.color = RED;
            node.left.color = BLACK;
            node.right.color = BLACK;
        }
    
        // 向红黑树中添加新的元素(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 // key.compareTo(node.key) == 0
                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.equals(node.key))
                return node;
            else if(key.compareTo(node.key) < 0)
                return getNode(node.left, key);
            else // if(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 newValue){
            Node node = getNode(root, key);
            if(node == null)
                throw new IllegalArgumentException(key + " doesn't exist!");
    
            node.value = newValue;
        }
    
        // 返回以node为根的二分搜索树的最小值所在的节点
        private Node minimum(Node node){
            if(node.left == null)
                return node;
            return minimum(node.left);
        }
    
        // 删除掉以node为根的二分搜索树中的最小节点
        // 返回删除节点后新的二分搜索树的根
        private Node removeMin(Node node){
    
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }
    
            node.left = removeMin(node.left);
            return node;
        }
    
        // 从二分搜索树中删除键为key的节点
        public V remove(K key){
    
            Node node = getNode(root, key);
            if(node != null){
                root = remove(root, key);
                return node.value;
            }
            return null;
        }
    
        private Node remove(Node node, K key){
    
            if( node == null )
                return null;
    
            if( key.compareTo(node.key) < 0 ){
                node.left = remove(node.left , key);
                return node;
            }
            else if(key.compareTo(node.key) > 0 ){
                node.right = remove(node.right, key);
                return node;
            }
            else{   // key.compareTo(node.key) == 0
    
                // 待删除节点左子树为空的情况
                if(node.left == null){
                    Node rightNode = node.right;
                    node.right = null;
                    size --;
                    return rightNode;
                }
    
                // 待删除节点右子树为空的情况
                if(node.right == null){
                    Node leftNode = node.left;
                    node.left = null;
                    size --;
                    return leftNode;
                }
    
                // 待删除节点左右子树均不为空的情况
    
                // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
                // 用这个节点顶替待删除节点的位置
                Node successor = minimum(node.right);
                successor.right = removeMin(node.right);
                successor.left = node.left;
    
                node.left = node.right = null;
    
                return successor;
            }
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70]: /images/20220503/03fddb385f5f440085e6d7b76b72c3df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 1]: /images/20220503/02d71b9227594e64a87a070cb44a7de3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 2]: /images/20220503/eb0c534a99f54ecc815567db3193512b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 3]: /images/20220503/89b18c1641cd450190a2d33bf21807fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 4]: /images/20220503/0d05e7a647b04241b3c944f679a9541f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 5]: /images/20220503/d34dc39747b545b88df57a0076db31f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 6]: /images/20220503/0b27945f1ea74739b123333a232b5357.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 7]: /images/20220503/486c514e32b24b7cb9d39b9a8d23a101.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 8]: /images/20220503/16501d2ad0e540cea15e94ba800d2b51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 9]: /images/20220503/e5161fff59774f02bbe4e3ceab75d3cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 10]: /images/20220503/7376e367e39b4b38b95a66cfe6d00468.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20181031135107370.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 12]: /images/20220503/929db787997048459ca9f9d9f21ff14c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 13]: /images/20220503/4f5bcf26314c478a8bfabee52da3859d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 14]: /images/20220503/af2aac7616cb46af881c0fd92c8e72dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 15]: /images/20220503/f24886e4b65b4f9898365de1543d9ed6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 16]: /images/20220503/844892dd3b6946f9a2f901a88d34d3db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 17]: /images/20220503/1d7a5f02645649a3a0649d394bd84b8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 18]: /images/20220503/f2c707a5416e4302863083a0f9338661.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 19]: /images/20220503/201a992899d440a6ba965783c571d08f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 20]: /images/20220503/73706366b5094288b5013ef7a0837a14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 21]: /images/20220503/07ec71cebb154794b454ee7c35dcd940.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 22]: /images/20220503/8a1c8fdb76e44c04a4a95e2c249c0fc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 23]: /images/20220503/1b9005b22db94391b21417e4c1ad9c9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 24]: /images/20220503/66c93972baf1429ab6f0f4c9be5d2c3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 25]: /images/20220503/777c77d45c0d44c498451f38e6711e8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 26]: /images/20220503/ad57d6566876422bbcefd6f6647a0e86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 27]: /images/20220503/6a0494d21f6e4bfbb5d5d0dcfd431dff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 28]: /images/20220503/e7f7b1c42fe545bf85039c778f9c0e75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 29]: /images/20220503/a310863765c047f587e68048738b054f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 30]: /images/20220503/dde9f7699850440a8ac4bd3a00641b84.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 31]: /images/20220503/4365e85ba09a46ca9b6e046ce59d59cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 32]: /images/20220503/468419c824cd40adbe6ff58c6f480f98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 33]: /images/20220503/8028fa1a97fb47df89319f6d7db3388a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 34]: /images/20220503/ad0e332516414ba094fc8c838a4ec1d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 35]: /images/20220503/b5608d8354164a7e9877f3b8884bfad7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 36]: /images/20220503/ac0bf88827e04b8880e9e62c8005cf1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0Y2F0c19jbg_size_16_color_FFFFFF_t_70 37]: /images/20220503/50945aac8de1449cb7c1070a8829077d.png