[数据结构与算法] 树结构之二叉排序树、平衡二叉树、多路查找树

àì夳堔傛蜴生んèń 2023-07-07 05:44 28阅读 0赞

### BST、AVL树与多路查找树 ###

*  BST
 *   *  介绍
     *  创建和遍历
     *   删除 
 *  AVL树
 *   *  介绍
     *   *  AVL树的左旋转
         *  AVL树的右旋转
         *  AVL树的双旋转
 *  多路查找树
 *   *  多叉树
     *  B树
     *  2-3树
     *  B+树
     *  B\* 树

# BST #

## 介绍 ##

>  需求: 给你一个数列 (7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加

**解决方案——使用数组**

*  **数组未排序**， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢.
 *  **数组排序**，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序，在添加新数据时，找到插入位置后，后面的数据需整体移动，速度慢。
 *  **使用链式存储-链表**. 不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。

> 在此基础上,我们引入了二叉排序树, 它能够高效的实现数组的添加和删除

**二叉排序树介绍**

二叉排序树：BST: (Binary Sort(Search) Tree), 对于**二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。**

*  特别说明：**如果有相同的值，可以将该节点放在左子节点或右子节点**
 *  比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树以及添加一个元素2后二叉排序树为：

![在这里插入图片描述][20200221110729516.png]

## 创建和遍历 ##

*  创建节点类, 定义相关属性构造方法以及ToSting()方法
 *  编写BST的创建方法, 判断传入的节点是否为空  
    传入的节点的值小于当前节点, 插入到左子树(判断非空), 左子树递归调用创建节点的方法  
    传入的节点的值大于当前节点, 插入到右子树(判断非空), 右子树递归调用创建节点的方法
 *  编写中序遍历方法
 *  创建二叉排序树类,定义根节点. 根据根节点是否为空的情况, 编写二叉排序树的创建和遍历方法
 *  测试代码

public class BinarySortTreeDemo { 
        public static void main(String[] args) { 
            int[] arr = { 7, 3, 10, 12, 13, 5, 1, 9};
            BinarySortTree binarySortTree = new BinarySortTree();
            //循环将节点添加到二叉树
            for (int i = 0; i < arr.length; i++) { 
                binarySortTree.add(new Node(arr[i]));
            }
    
            //中序遍历二叉树
            System.out.println("中序遍历二叉树");
            binarySortTree.midOrder();
        }
    }
    
    /** * 创建二叉排序树 */
    class BinarySortTree{ 
        //创建根节点
        private Node root;
    
        //创建二叉排序树的添加方法
        public void add(Node node){ 
            if (root==null){ 
                root = node;
            }else { 
                root.add(node);
            }
    
        }
    
    
        //创建二叉排序树的中序遍历方法
        public void midOrder(){ 
            if (root==null){ 
                System.out.println("该树为空,无法进行中序遍历");
            }else { 
                root.midOder();
            }
    
        }
    
    }
    
    /** * 1.创建节点 */
    class Node{ 
        int value;
        Node left;
        Node right;
    
        public Node(int value){ 
            this.value = value;
        }
    
        @Override
        public String toString() { 
            return "Node{" +
                    "value=" + value +
                    '}';
        }
    
        //二叉排序树的生成
        public void add(Node node){ 
            if (node==null){ //如果为空,直接返回
                return;
            }
            //传入的节点的值小于当前节点
            if (node.value<this.value){ //插入到左子树
                if (this.left==null){ 
                    this.left = node;
                }else { 
                    //递归调用添加的方法
                    this.left.add(node);
                }
            }else { 
                //传入节点的值大于当前节点
                if (this.right==null){ 
                    this.right = node;
                }else { 
                    //右子树递归调用添加的方法
                    this.right.add(node);
                }
            }
        }
    
        public void midOder(){ 
            if (this.left!=null){ 
                this.left.midOder();
            }
            System.out.println(this);
            if (this.right!=null){ 
                this.right.midOder();
            }
        }
    
    
    }

**测试结果**  
![结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70]

##  删除  ##

**二叉排序树的删除情况比较复杂，有下面三种情况需要考虑**

*  删除叶子节点 (比如：2, 5, 9, 12)
 *  删除只有一颗子树的节点 (比如：1)=>删除的节点的值=子树节点
 *  删除有两颗子树的节点. (比如：7, 3，10 )=>删除的节点的值=任意一边的最小值

![在这里插入图片描述][2020022111215729.png]

**实现思路**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 1]

public class BinarySortTreeDemo { 
        public static void main(String[] args) { 
            int[] arr = { 7, 3, 10, 12, 5, 1, 9, 2};
            BinarySortTree binarySortTree = new BinarySortTree();
            //循环将节点添加到二叉树
            for (int i = 0; i < arr.length; i++) { 
                binarySortTree.add(new Node(arr[i]));
            }
    
            //中序遍历二叉树
            System.out.println("中序遍历二叉树");
            binarySortTree.midOrder();
    
            //测试删除叶子节点
            binarySortTree.delNode(2);
            binarySortTree.delNode(5);
            binarySortTree.delNode(9);
            binarySortTree.delNode(12);
            //测试删除含有两个叶子节点的节点
            binarySortTree.delNode(7);
            binarySortTree.delNode(3);//原来3的位置放的是2
            binarySortTree.delNode(10);//原来10的位置放的是9
            binarySortTree.delNode(1);//原来10的位置放的是9
            System.out.println("执行删除操作完毕");
            binarySortTree.midOrder();
        }
    }
    
    /** * 创建二叉排序树 */
    class BinarySortTree{ 
        //创建根节点
        private Node root;
    
        //创建二叉排序树的添加方法
        public void add(Node node){ 
            if (root==null){ 
                root = node;
            }else { 
                root.add(node);
            }
    
        }
    
    
        //创建二叉排序树的中序遍历方法
        public void midOrder(){ 
            if (root==null){ 
                System.out.println("该树为空,无法进行中序遍历");
            }else { 
                root.midOder();
            }
    
        }
    
        /** * 查找要删除的节点 * @param value * @return 如果有返回该节点,,如果没有返回null */
        public Node search(int value){ 
            if (root==null){ 
                return null;
            }else { 
                return root.search(value);
            }
        }
    
        /** * 查找要删除的父节点 * @param value * @return 如果有返回该节点,如果没有返回null */
        public Node searchParent(int value){ 
            if (root==null){ 
                return null;
            }else { 
                return root.searchParent(value);
            }
        }
    
        /** * 删除对应的节点 * @param value */
        public void delNode(int value){ 
            if (root==null){ 
                return;
            }else { 
                //如果根节点不会空则进行节点的删除操作
                //1. 查找要删除的节点targetNode
                Node targetNode = search(value);
                //如果没有找到要删除的节点
                if (targetNode==null){ 
                    return;
                }
                //如果要查找的二叉树只有一个节点
                if (root.left==null && root.right==null){ 
                    root = null;
                    return;
                }
                //2.去找到targetNode的父节点
                Node parent = searchParent(value);
                //a.如果要删除的节点都是叶子节点
                if (targetNode.left==null && targetNode.right==null){ 
                    if (parent.left!=null && parent.left.value==value){ //是左子节点
                        parent.left = null;
                    }else if(parent.right!=null && parent.right.value==value){ //是右子节点
                        parent.right = null;
                    }
                }else if(targetNode.left!=null && targetNode.right!=null){ //b.删除有两个子树的节点
                    //在右树中找最小的
                    int minVal = delRightTreeMin(targetNode.right);
                    targetNode.value = minVal;
                    System.out.println("minVal = " + minVal);
                }else { //c.删除只有一个子树的节点
                    //x如果要删除的节点有左子节点
                    if (targetNode.left!=null){ 
                       if (parent!=null){ //***防止出现在删除最后两个节点时,首先删除根节点的情况
                           if (parent.left.value==value){ //如果targetNode是parent的左子节点
                               parent.left = targetNode.left;
                           }else { //如果targetNode是parent的右子节点
                               parent.right = targetNode.left;
                           }
                       }else { 
                           root = targetNode.left;
                       }
                    }else { //x如果要删除的节点有右子节点
                        if (parent!=null){ //***防止出现在删除最后两个节点时,首先删除根节点的情况
                            if (parent.left.value==value){ //如果targetNode是parent的左子节点
                                parent.left = targetNode.right;
                            }else { //如果targetNode是parent的右子节点
                                parent.right = targetNode.right;
                            }
                        }else { 
                            root = targetNode.right;
                        }
    
                    }
    
                }
    
            }
    
        }
    
    
    
        /**
         * 编写方法:
         * 1.返回以node为根节点的二叉树的最小节点的值
         * 2.删除以node为根节点的二叉树的最小节点
         * @param node
         * @return
         */
        public int delRightTreeMin(Node node){ 
            Node target = node;
            // 循环的查找左子节点,就会找到最小值
            while (target.left!=null){ 
                target = target.left;
            }
            // 如果左子节点为空,说明找到了最小节点
            // 删除最小节点
            delNode(target.value);
            return target.value;
        }
    }
    
    /** * 1.创建节点 */
    class Node{ 
        int value;
        Node left;
        Node right;
    
        public Node(int value){ 
            this.value = value;
        }
    
        @Override
        public String toString() { 
            return "Node{" +
                    "value=" + value +
                    '}';
        }
    
        //二叉排序树的生成
        public void add(Node node){ 
            if (node==null){ //如果为空,直接返回
                return;
            }
            //传入的节点的值小于当前节点
            if (node.value<this.value){ //插入到左子树
                if (this.left==null){ 
                    this.left = node;
                }else { 
                    //递归调用添加的方法
                    this.left.add(node);
                }
            }else { 
                //传入节点的值大于当前节点
                if (this.right==null){ 
                    this.right = node;
                }else { 
                    //右子树递归调用添加的方法
                    this.right.add(node);
                }
            }
        }
    
        public void midOder(){ 
            if (this.left!=null){ 
                this.left.midOder();
            }
            System.out.println(this);
            if (this.right!=null){ 
                this.right.midOder();
            }
        }
    
        /** * 查找要删除的节点 * @param value 要删除的节点的值 * @return 如果找到返回该节点,否则返回null */
        public Node search(int value){ 
            if (value<this.value){ //如果小于父节点,则进入左子树
                if (this.left==null){ 
                    return null;
                }
                return this.left.search(value);//左子树递归调用查找的方法
            }else if(value>this.value){ //如果大于父节点,则进行入右子树
                if (this.right==null){ 
                    return null;
                }
                return this.right.search(value);//右子树递归调用查找方法
            }else { //如果查找的值等于父节点,则直接返回该节点
                return this;
            }
        }
    
        /** * 查找要删除的父节点 * @param value 要删除的节点的值 * @return 要删除的父节点, 否则返回null */
        public Node searchParent(int value){ 
            //如果当前节点就是要删除的父节点, 则直接返回
            if ( (this.left!=null && this.left.value==value) || (this.right!=null && this.right.value==value) ){ 
                return this;
            }else { 
                // 如果需要找的值小于当前节点则递归调用左子树(判空)
                if (this.left!=null && value<this.value){ 
                    return this.left.searchParent(value);
                    // 如果需要找到值大于当前节点则递归调用右子树(判空)
                }else if (this.right!=null && value>this.value){ 
                    return this.right.searchParent(value);
                }else { 
                    return null;//没有找到父节点
                }
            }
    
        }
    
    }

**测试结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 2]

# AVL树 #

>  看一个案例(说明二叉排序树可能的问题)  
> 给你一个数列\{1,2,3,4,5,6\}，要求创建一个二叉排序树(BST), 并分析问题所在

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 3]

## 介绍 ##

平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。  
**具有以下特点：**

*  它是一 棵空树或它的**左右两个子树的高度差的绝对值不超过1**，并且**左右两个子树都是一棵平衡二叉树。**
 *  平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

举例: 下图1,2是AVL树,3不是. 因为左右两个子树高度差为2

![在这里插入图片描述][20200221222858695.png]

### AVL树的左旋转 ###

**AVL左旋转思路图解**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 4]

// 返回左子树的高度
        public int leftHeight() { 
            if (left == null) { 
                return 0;
            }
            return left.height();
        }
    
        // 返回右子树的高度
        public int rightHeight() { 
            if (right == null) { 
                return 0;
            }
            return right.height();
        }
    
        // 返回以该结点为根结点的树的高度
        public int height() { 
            return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
        }
    
        /** * 相当于上面使用三目运算符实现的返回根节点的树的高度的方法 * @return */
      /* public int height(){ int leftVal = 0; int rightVal = 0; //如果左树不为空,则递归调用该方法 if (left!=null){ leftVal=left.height(); } //如果右树不为空,则递归调用该方法 if (right!=null){ rightVal = right.height(); } // 返回时,需要将本层的高度加上 return Math.max(leftVal, rightVal)+1; }*/
    
       //左旋转方法
        private void leftRotate() { 
    
            //创建新的结点，以当前根结点的值
            Node newNode = new Node(value);
            //把新的结点的左子树设置成当前结点的左子树
            newNode.left = left;
            //把新的结点的右子树设置成当前结点的右子树的左子树
            newNode.right = right.left;
            //把当前结点的值替换成右子结点的值
            value = right.value;
            //把当前结点的右子树设置成当前结点右子树的右子树
            right = right.right;
            //把当前结点的左子树(左子结点)设置成新的结点
            left = newNode;
    
    
        }

### AVL树的右旋转 ###

**AVl右旋转思路图解**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 5]

//右旋转方法
        private void rightRotate() { 
            Node newNode = new Node(value);
            newNode.right = right;
            newNode.left = left.right;
            value = left.value;
            left = left.left;
            right = newNode;
        }

### AVL树的双旋转 ###

**AVL树的双旋转的图解**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 6]

# 多路查找树 #

> 二叉树的操作效率较高，但是也存在问题, 请看下面的二叉树

**二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)， 就存在如下问题:**

*  问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响
 *  问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 7]

**如果对二叉查找树/二叉排序树和平衡二叉树等概念理解不清楚, 建议看看下面**  
[理解完全二叉树、平衡二叉树、二叉查找树][Link 1]

## 多叉树 ##

>  在二叉树中，每个节点有数据项，最多有两个子节点。如果允许**每个节点可以有更多的数据项和更多的子节点，就是多叉树**（multiway tree）

*后面我们讲解的2-3树，2-3-4树就是多叉树，多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。*

**举例说明(下面2-3树就是一颗多叉树)**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 8]

## B树 ##

>  B树通过重新组织节点，降低树的高度，并且减少i/o读写次数来提升效率。

**如下图B树通过重新组织节点， 降低了树的高度.**

*  文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为4k)，这样每个节点只需要一次I/O就可以完全载入
 *  将树的度M设置为1024，在600亿个元素中最多只需要4次I/O操作就可以读取到想要的元素, **B树(B+)广泛应用于文件存储系统以及数据库系统中**

![在这里插入图片描述][20200224104026754.png]

## 2-3树 ##

> **2-3树是最简单的B树结构, 具有如下特点:**

*  2-3树的**所有叶子节点都在同一层.(只要是B树都满足这个条件)**
 *  有两个子节点的节点叫二节点，**二节点要么没有子节点，要么有两个子节点.**
 *  有三个子节点的节点叫三节点，**三节点要么没有子节点，要么有三个子节点.**
 *  **2-3树是由二节点和三节点构成的树**

**插入规则:**

*  **2-3树的所有叶子节点都在同一层.(只要是B树都满足这个条件)**
 *  有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.
 *  有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点
 *   当按照规则插入一个数到某个节点时，不能满足上面三个要求，就需要拆，先向上拆，如果上层满，则拆本层，拆后仍然需要满- 足上面3个条件。 
 *  **对于三节点的子树的值大小仍然遵守(BST 二叉排序树)的规则**

**下图是模拟2-3树创建的结构图**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 10]

除了23树，**还有234树等，概念和23树类似，也是一种B树。它除了每个节点所容纳的元素个数不同外, 创建方式和23树一样** 如图  
  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 11]

**B树的介绍**

>  前面已经介绍了2-3树和2-3-4树，他们就是B树(英语：B-tree 也写成B-树)，这里我们再做一个说明，我们**在学习Mysql时，经常听到说某种类型的索引是基于B树或者B+树的**，如下图:

![p1,p2,p3仅仅是代表子节点数据所存放的位置位于父节点的哪些元素之间][p1_p2_p3]

**树的说明:**

*  B树的阶：**节点的最多子节点个数**。比如2-3树的阶是3，2-3-4树的阶是4
 *  B-树的搜索，**从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束**，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点
 *  关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据.
 *  搜索有可能在非叶子结点结束
 *  其**搜索性能等价于在关键字全集内做一次二分查找**

## B+树 ##

> B+树是B树的变体，也是一种多路搜索树。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 12]  
**B+树的说明:**

*  B+树的搜索与B树也基本相同，区别是**B+树只有达到叶子结点才命中（B树可以在非叶子结点命中）**，其**性能也等价于在关键字全集做一次二分查找**
 *  所有关键字都出现在叶子结点的链表中（即数据只能在**叶子节点【也叫稠密索引】**），且链表中的关键字(数据)恰好是有序的。
 *  不可能在非叶子结点命中  
    **非叶子结点**相当于是叶子结点的索引（**稀疏索引**），叶子结点相当于是存储（关键字）数据的数据层
 *  更适合文件索引系统
 *  B树和B+树各有自己的应用场景，不能说B+树完全比B树好，反之亦然.

## B\* 树 ##

> B\* 树是B+树的变体，**在B+树的非根和非叶子结点再增加指向兄弟的指针。(和B树,B+树区别在此)**  
>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 13]  
**B\*树的说明:**

*  B\* 树定义了非叶子结点关键字个数至少为(2/3)\*M(**M为树的度**)，即块的最低使用率为2/3，而B+树的块的最低使用率为B+树的1/2。
 *  从第1个特点我们可以看出，B\*树分配新结点的概率比B+树要低，空间使用率更高

[20200221110729516.png]: https://img-blog.csdnimg.cn/20200221110729516.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200221111847144.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[2020022111215729.png]: https://img-blog.csdnimg.cn/2020022111215729.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020022111251373.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200221220433350.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200221222357712.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[20200221222858695.png]: https://img-blog.csdnimg.cn/20200221222858695.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200221223403121.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200222171345192.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200222232729696.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200224103610431.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[Link 1]: https://mp.weixin.qq.com/s?src=11&timestamp=1583934791&ver=2210&signature=Daya4oFlOSfS2jgUp4CUf6EMZjRuF*OLvKL5k0-dJ5NhoFnFJX9NyROl1uxvuxmRe--PIesRmAURXs493iU283D-70w-6pZI0MQHnFOQNG49x528eEwrez27mH-JzlNo&new=1
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200224103717897.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[20200224104026754.png]: https://img-blog.csdnimg.cn/20200224104026754.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200224111143333.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/2020022411120749.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/2020022415333836.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[p1_p2_p3]: https://img-blog.csdnimg.cn/20200224154204478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200224155007638.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200224155645111.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2,size_16,color_FFFFFF,t_70