二叉树遍历算法详解（递归法+非递归法）

青旅半醒 2023-01-09 12:37 136阅读 0赞

# 二叉树遍历算法详解 #

在上一篇[C语言实现二叉树][C]中有提到对于二叉树的遍历，包括前序，中序和后续遍历，以及层次遍历

大家已经熟悉了二叉树的前中后序遍历过程，大部分都采用了递归的思想来实现

在leetcode算法练习题中，有这样三道题：

*  前序遍历

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2][]

在leetcode中，最终将输出结果输出到数组中保存，上一篇博客提到的二叉树前中后遍历均打印输出，为了直观比较，先通过递归的形式实现

*  ### 前序遍历的递归实现： ###

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
    
    void BinaryTreePrevOrder(struct TreeNode* root,int* ret,int* index) 
    {
    	if (root == NULL)
    	{
    		return;
    	}
    	ret[(*index)++]=root->val;//索引创建为指针，递归回溯过程中可以及时更新
    	BinaryTreePrevOrder(root->left,ret,index);
    	BinaryTreePrevOrder(root->right,ret,index);
    }
    /**
     * Note: The returned array must be malloced, assume caller calls free().
     */
    int* preorderTraversal(struct TreeNode* root, int* returnSize){
        int index=0;
        int* arr=(int*)malloc(sizeof(int)*100);
        memset(arr,0,sizeof(int)*100);
        BinaryTreePrevOrder(root,arr,&index);
        *returnSize=index;
        return arr;
    }

通过代码分析发现：首先开辟存放节点数据的数组，数组大小此处给了固定大小100，可以根据二叉树节点个数进行设置

比如获取二叉树节点个数代码如下：

//获取节点个数
    int getsize(struct TreeNode* root)
    {
        if(root)
        {
            return getsize(root->left)+getsize(root->right)+1;
        }
        return 0;
    }

同时，还需要注意一点，在遍历过程中，为了将访问的节点保存在数组中，必须创建索引来顺序存放

但由于采用了递归进行遍历，对此在回溯的过程中，为了索引能够及时更新，对此，需要将索引设置为全局变量或指针变量

*  ### 中序遍历的递归实现 ###

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
    void BinaryInOrder(struct TreeNode* root,int* arr,int* index)
    {
        if(root==NULL)
            return;
        BinaryInOrder(root->left,arr,index);
        arr[(*index)++]=root->val;
        BinaryInOrder(root->right,arr,index);
    }
    /**
     * Note: The returned array must be malloced, assume caller calls free().
     */
    int* inorderTraversal(struct TreeNode* root, int* returnSize){
        int indexsum=0;
        int* arr=(int*)malloc(sizeof(int)*100);
        memset(arr,0,sizeof(int)*100);
        BinaryInOrder(root,arr,&indexsum);
        *returnSize=indexsum;
        return arr;
    }

中序遍历与前序遍历类似，不同之处在于，先遍历左子树，再访问根节点，保存数组中，再遍历右子树

*  ### 后序遍历的递归实现 ###

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
    void BinaryAfterOrder(struct TreeNode* root,int* arr,int* index)
    {
        if(root==NULL)
            return;
        BinaryAfterOrder(root->left,arr,index);
        BinaryAfterOrder(root->right,arr,index);
        arr[(*index)++]=root->val;
    }
    /**
     * Note: The returned array must be malloced, assume caller calls free().
     */
    int* postorderTraversal(struct TreeNode* root, int* returnSize){
        int index=0;
        int* ret=(int*)malloc(sizeof(int)*100);
        memset(ret,0,sizeof(int)*100);
        BinaryAfterOrder(root,ret,&index);
        *returnSize=index;
        return ret;
    }

后序遍历的不同之处在于，先遍历左子树，再遍历右子树，最后访问根节点，保存在数组中返回

以上三种方法均基于递归思想实现，代码简洁，但递归回溯的过程有一定的理解难度

对此，本博客基于一种先进后出的数据结构“栈”实现遍历的非递归算法

其中，所用到的有关“栈”的接口定义以及接口具体实现可以参照[C语言实现栈和队列][C 1]这篇博客

*  ### 前序遍历的非递归实现 ###

**算法思想：**

前序遍历中，对于每一个节点，最先访问的是以此节点开始的最左路径

前序遍历中，对于每一个树，最先访问的右子树是在访问左路径时最后遇到的右子树

左边的节点访问：自上向下

右边的节点访问：自下向上

**算法步骤：**

1.访问每一个节点开始的最左路径，访问到的每一个节点入栈  
2.最左路径访问完成之后，获取栈顶元素，继续访问以栈顶元素的右子树为根的子结构，继续执行第1步  
3.结束条件：栈为空&&右子树为空

**算法图解：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 10][]

**代码实现：**

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
     //非递归
    #include<stdio.h>
    #include<stdlib.h>
    // 支持动态增长的栈
    typedef struct TreeNode* STDataType;
    typedef struct Stack
    {
    	STDataType* _data;
    	int _size;
    	int _capacity; // 容量
    }Stack;
    //检查容量
    void checkCapcity(Stack* ps)
    {
    	if (ps->_size == ps->_capacity)
    	{
    		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
    		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
    		ps->_capacity = newCap;
    	}
    }
    // 初始化栈
    void StackInit(Stack* ps)
    {
    	if (ps == NULL)
    		return;
    	ps->_data = NULL;
    	ps->_size = ps->_capacity = 0;
    }
    // 入栈
    void StackPush(Stack* ps, STDataType data)
    {
    	if (ps == NULL)
    		return;
    	checkCapcity(ps);
    	ps->_data[ps->_size++] = data;
    }
    // 出栈
    void StackPop(Stack* ps)
    {
    	if (ps == NULL || ps->_size == 0)
    		return;
    	ps->_size--;
    
    }
    // 获取栈顶元素
    STDataType StackTop(Stack* ps)
    {
    	return ps->_data[ps->_size - 1];
    }
    // 获取栈中有效元素个数
    int StackSize(Stack* ps)
    {
    	if (ps == NULL)
    		return 0;
    	return ps->_size;
    }
    // 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
    int StackEmpty(Stack* ps)
    {
    	if (ps == NULL||ps->_size==0)
    		return 1;
    	else
    		return 0;
    }
    // 销毁栈
    void StackDestroy(Stack* ps)
    {
    	free(ps->_data);
    	ps->_size = 0;
    	ps->_capacity = 0;
    }
    
    //获取节点个数
    int getsize(struct TreeNode* root)
    {
        if(root)
        {
            return getsize(root->left)+getsize(root->right)+1;
        }
        return 0;
    }
    
    int* preorderTraversal(struct TreeNode* root, int* returnSize)
    {
        Stack st;
        StackInit(&st);
        int sz=getsize(root);
        int* arr=(int*)malloc(sizeof(int)*sz);
        int idx=0;
        while(root||!StackEmpty(&st))
        {
            //1访问最左路径
            while(root)
            {
                arr[idx++]=root->val;
                StackPush(&st,root);
                root=root->left;
            }
            //2获取栈顶元素，访问右子树
            root=StackTop(&st);
            StackPop(&st);
            root=root->right;
        }
        *returnSize=idx;
        return arr;
    }

*  ### 中序遍历的非递归实现 ###

**算法步骤：**

1，以节点开始，走最左路径，此路径上遇到的每一个节点首先入栈，但不能访问  
2，获取栈顶元素，访问栈顶元素  
3，获取栈顶元素的右子树，继续执行第一步  
4，结束：栈为空&&右子树为空

**算法图解：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 15][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 17][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 18][]

**代码实现：**

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
     //非递归
    #include<stdio.h>
    #include<stdlib.h>
    // 支持动态增长的栈
    typedef struct TreeNode* STDataType;
    typedef struct Stack
    {
    	STDataType* _data;
    	int _size;
    	int _capacity; // 容量
    }Stack;
    //检查容量
    void checkCapcity(Stack* ps)
    {
    	if (ps->_size == ps->_capacity)
    	{
    		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
    		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
    		ps->_capacity = newCap;
    	}
    }
    // 初始化栈
    void StackInit(Stack* ps)
    {
    	if (ps == NULL)
    		return;
    	ps->_data = NULL;
    	ps->_size = ps->_capacity = 0;
    }
    // 入栈
    void StackPush(Stack* ps, STDataType data)
    {
    	if (ps == NULL)
    		return;
    	checkCapcity(ps);
    	ps->_data[ps->_size++] = data;
    }
    // 出栈
    void StackPop(Stack* ps)
    {
    	if (ps == NULL || ps->_size == 0)
    		return;
    	ps->_size--;
    
    }
    // 获取栈顶元素
    STDataType StackTop(Stack* ps)
    {
    	return ps->_data[ps->_size - 1];
    }
    // 获取栈中有效元素个数
    int StackSize(Stack* ps)
    {
    	if (ps == NULL)
    		return 0;
    	return ps->_size;
    }
    // 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
    int StackEmpty(Stack* ps)
    {
    	if (ps == NULL||ps->_size==0)
    		return 1;
    	else
    		return 0;
    }
    // 销毁栈
    void StackDestroy(Stack* ps)
    {
    	free(ps->_data);
    	ps->_size = 0;
    	ps->_capacity = 0;
    }
    
    //获取节点个数
    int getsize(struct TreeNode* root)
    {
        if(root)
        {
            return getsize(root->left)+getsize(root->right)+1;
        }
        return 0;
    }
    
    
    int* inorderTraversal(struct TreeNode* root, int* returnSize)
    {
        Stack st;
        StackInit(&st);
        int sz=getsize(root);
        int* arr=(int*)malloc(sizeof(int)*sz);
        int idx=0;
        while(root||!StackEmpty(&st))
        {
            //1最左路径
            while(root)
            {
                //arr[idx++]=root->val;
                StackPush(&st,root);
                root=root->left;
            }
            //2获取栈顶元素，访问栈顶元素 访问右子树
            root=StackTop(&st);
            arr[idx++]=root->val;
            StackPop(&st);
            root=root->right;
        }
        *returnSize=idx;
        return arr;
    }

*  ### **后序遍历的非递归实现** ###

**算法步骤：**

1，以节点开始，走最左路径，遇到每一个节点入栈，但不访问  
2，获取栈顶元素：  
当前栈顶元素是否可以访问：  
a,没有右子树:可以访问 -->执行第一步  
b,右子树访问完成：可以访问 -->执行第一步  
c,有右子树，但没有访问：不能访问当前元素-->首先访问右子树-->执行第一步

**算法图解：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 19][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 20][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 21][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 22][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 23][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 24][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 25][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 26][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 27][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 28][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 29][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 30][]

**代码实现：**

/**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
    
    //非递归
    #include<stdio.h>
    #include<stdlib.h>
    // 支持动态增长的栈
    typedef struct TreeNode* STDataType;
    typedef struct Stack
    {
    	STDataType* _data;
    	int _size;
    	int _capacity; // 容量
    }Stack;
    //检查容量
    void checkCapcity(Stack* ps)
    {
    	if (ps->_size == ps->_capacity)
    	{
    		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
    		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
    		ps->_capacity = newCap;
    	}
    }
    // 初始化栈
    void StackInit(Stack* ps)
    {
    	if (ps == NULL)
    		return;
    	ps->_data = NULL;
    	ps->_size = ps->_capacity = 0;
    }
    // 入栈
    void StackPush(Stack* ps, STDataType data)
    {
    	if (ps == NULL)
    		return;
    	checkCapcity(ps);
    	ps->_data[ps->_size++] = data;
    }
    // 出栈
    void StackPop(Stack* ps)
    {
    	if (ps == NULL || ps->_size == 0)
    		return;
    	ps->_size--;
    
    }
    // 获取栈顶元素
    STDataType StackTop(Stack* ps)
    {
    	return ps->_data[ps->_size - 1];
    }
    // 获取栈中有效元素个数
    int StackSize(Stack* ps)
    {
    	if (ps == NULL)
    		return 0;
    	return ps->_size;
    }
    // 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
    int StackEmpty(Stack* ps)
    {
    	if (ps == NULL||ps->_size==0)
    		return 1;
    	else
    		return 0;
    }
    // 销毁栈
    void StackDestroy(Stack* ps)
    {
    	free(ps->_data);
    	ps->_size = 0;
    	ps->_capacity = 0;
    }
    
    //获取节点个数
    int getsize(struct TreeNode* root)
    {
        if(root)
        {
            return getsize(root->left)+getsize(root->right)+1;
        }
        return 0;
    }
    
    
    int* postorderTraversal(struct TreeNode* root, int* returnSize)
    {
        Stack st;
        StackInit(&st);
        int sz=getsize(root);
        int* arr=(int*)malloc(sizeof(int)*sz);
        int idx=0;
        
        struct TreeNode* prev=NULL;//指向上一次访问节点
        while(root||!StackEmpty(&st))
        {
            //1最左路径,不访问
            while(root)
            {
                //arr[idx++]=root->val;
                StackPush(&st,root);
                root=root->left;
            }
            //2通过指针获取栈顶元素
            struct TreeNode* top=StackTop(&st);//指向栈顶的指针
            //判断栈顶元素是否可以访问
            //可以访问，没有右子树，或右子树访问完成（上一次访问节点指向右子树根结点）
            if(top->right==NULL||top->right==prev)
            {
                //可以访问当前栈顶元素
                arr[idx++]=top->val;
                //出栈
                StackPop(&st);
                //更新prev
                prev=top;
            }
            else{
                //右子树存在，且没有访问完成
                root=top->right;
            }
        }
        *returnSize=idx;
        return arr;
    }

*  ### **执行结果：** ###

![2021012118360215.png][]

[C]: https://blog.csdn.net/qq_36131611/article/details/112465006
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70]: /images/20221119/37e2a41f30c7484b94bcc7a9f89336de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1]: /images/20221119/b93f6fcb58dc4cd09e193f9be0f86012.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210121143103215.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[C 1]: https://blog.csdn.net/qq_36131611/article/details/111573696
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210121162023582.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210121162050984.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/202101211624515.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210121162519342.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210121162548496.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210121162619295.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210121162637378.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210121162657889.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20210121163932967.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20210121164109369.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20210121164128165.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20210121164145232.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20210121164204464.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/2021012116422577.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20210121164244387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20210121164304163.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20210121182953995.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20210121183018918.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20210121183038581.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20210121183059301.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/20210121183118955.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20210121183144574.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 25]: https://img-blog.csdnimg.cn/20210121183206148.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 26]: https://img-blog.csdnimg.cn/20210121183255588.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 27]: https://img-blog.csdnimg.cn/20210121183315942.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 28]: https://img-blog.csdnimg.cn/20210121183334717.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/2021012118335519.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 30]: https://img-blog.csdnimg.cn/20210121183410743.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx,size_16,color_FFFFFF,t_70
[2021012118360215.png]: https://img-blog.csdnimg.cn/2021012118360215.png