【2020-MOOC-浙江大学-陈越、何钦铭-数据结构】树（第三周的笔记和编程作业）

深藏阁楼爱情的钟 2023-07-17 06:08 2阅读 0赞

### 文章目录 ###

*  〇、前言
 *  一、树的定义
 *  二、树的基本术语
 *  三、二叉树
 *  四、性质
 *  五、二叉树基本操作
 *  六、二叉树遍历
 *   *   *  1、先序遍历
         *  2、中序遍历
         *  3、后序遍历
         *  4、层序遍历
 *  七、树的同构
 *  八、课后题
 *   *   *  1、03-树1 树的同构 (25分)
         *  2、03-树2 List Leaves (25分)
         *  3、03-树3 Tree Traversals Again (25分)
 *  总结

# 〇、前言 #

这两周开始跟着【MOOC-浙江大学-陈越、何钦铭-数据结构】进行数据结构与算法的学习，特此记录复习一下，虽然记不住，但是一直记一直记一直记，成为复读机就好了。  
![在这里插入图片描述][20200314162146148.png_pic_center]

# 一、树的定义 #

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

# 二、树的基本术语 #

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

# 三、二叉树 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 4]

# 四、性质 #

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

# 五、二叉树基本操作 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 6]

# 六、二叉树遍历 #

### 1、先序遍历 ###

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

### 2、中序遍历 ###

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

### 3、后序遍历 ###

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

### 4、层序遍历 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 11]

# 七、树的同构 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 14]  
实现在后面的第一题！

# 八、课后题 #

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

--------------------

### 1、03-树1 树的同构 (25分) ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 16]  
**输入样例1（对应图1）：**

8  
A 1 2  
B 3 4  
C 5 -  
D - -  
E 6 -  
G 7 -  
F - -  
H - -  
8  
G - 4  
B 7 6  
F - -  
A 5 1  
H - -  
C 0 -  
D - -  
E 2 -

**输出样例1:**

Yes

**输入样例2（对应图2）：**

8  
B 5 7  
F - -  
A 0 3  
C 6 -  
H - -  
D - -  
G 4 -  
E 1 -  
8  
D 6 -  
B 5 -  
E - -  
H - -  
C 0 2  
G - 3  
F - -  
A 1 4

**输出样例2:**

--------------------

#include <stdio.h>
    #define MaxTree 10
    #define ElementType char
    #define Tree int
    #define Null -1
    
    struct TreeNode{ 
    	ElementType Element;
    	Tree Left;
    	Tree Right;
    }T1[MaxTree],T2[MaxTree];
    
    Tree BuildTree(struct TreeNode T[]){ 
    	int N,i,check[MaxTree],Root=Null;
    	ElementType cl,cr;
    	scanf("%d\n",&N);
    	if(N){ 
    		for(i=0;i<N;i++)
    			check[i]=0;
    		for(i=0;i<N;i++){ 
    			scanf("%c %c %c\n",&T[i].Element,&cl,&cr);
    			if(cl!='-'){ 
    				T[i].Left=cl-'0';
    				check[T[i].Left]=1;
    			}
    			else{ 
    				T[i].Left=Null;
    			}
    			if(cr!='-'){ 
    				T[i].Right=cr-'0';
    				check[T[i].Right]=1;
    			}
    			else{ 
    				T[i].Right=Null;
    			}
    		}
    		for(i=0;i<N;i++){ 
    			if(!check[i]){ 
    				Root=i;
    				break;
    			}
    		}
    	}
    	return Root;
    }
    
    int Isomorphic(Tree R1,Tree R2){ 
        //两树为空树，则为同构
    	if((R1==Null)&&(R2==Null))
    		return 1;
        //一个树为空，另一个不为空，则不同构
    	if(((R1==Null)&&(R2!=Null))||((R1!=Null)&&(R2==Null)))
    		return 0;
        //两树根结点存在但数据不同，则不同构
    	if(T1[R1].Element!=T2[R2].Element)
    		return 0;
        //两树左子树均为空树，则判断两树右子树是否同构
    	if((T1[R1].Left==Null)&&(T2[R2].Left==Null))
    		return Isomorphic(T1[R1].Right,T2[R2].Right);
    	//两树左子树不为空，且两树左子树数据相等，则判断两树左子树和右子树是否同时同构
    	if((T1[T1[R1].Left].Element==T2[T2[R2].Left].Element)&&(T1[R1].Left!=Null)&&(T2[R2].Left!=Null))
    		return (Isomorphic(T1[R1].Left,T2[R2].Left)&&Isomorphic(T1[R1].Right,T2[R2].Right));
    	//否则交换判断子树是否同构
        else
    		return (Isomorphic(T1[R1].Left,T2[R2].Right)&&Isomorphic(T1[R1].Right,T2[R2].Left));
    	
    }
    
    int main(){ 
    	Tree R1,R2;
    	R1=BuildTree(T1);
    	R2=BuildTree(T2);
    	if(Isomorphic(R1,R2))
    		printf("Yes\n");
    	else
    		printf("No\n");
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 17]

--------------------

### 2、03-树2 List Leaves (25分) ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 18]  
**Sample Input:**

8  
1 -  
\- -  
0 -  
2 7  
\- -  
\- -  
5 -  
4 6

**Sample Output:**

4 1 5

--------------------

#include <stdio.h>
    #include <stdlib.h>
    
    #define MaxTree 10
    #define Tree int
    #define Null -1
    
    struct TreeNode { 
        Tree Left;
        Tree Right;
    } T1[MaxTree];
    
    #define QueueSize 100
    typedef int Position;
    typedef int ElementType;
    struct QNode { 
        ElementType *Data;     /* 存储元素的数组 */
        Position Front, Rear;  /* 队列的头、尾指针 */
        int MaxSize;           /* 队列最大容量 */
    };
    typedef struct QNode *Queue;
     
    Queue CreateQueue( int MaxSize )
    { 
        Queue Q = (Queue)malloc(sizeof(struct QNode));
        Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
        Q->Front = Q->Rear = 0;
        Q->MaxSize = MaxSize;
        return Q;
    }
     
    int IsFull( Queue Q )
    { 
        return ((Q->Rear+1)%Q->MaxSize == Q->Front);
    }
     
    int AddQ( Queue Q, ElementType X )
    { 
        if ( IsFull(Q) ) { 
            printf("队列满");
            return;
        }
        else { 
            Q->Rear = (Q->Rear+1)%Q->MaxSize;
            Q->Data[Q->Rear] = X;
            return;
        }
    }
     
    int IsEmpty( Queue Q )
    { 
        return (Q->Front == Q->Rear);
    }
     
    ElementType DeleteQ( Queue Q )
    { 
        if ( IsEmpty(Q) ) {  
            printf("队列空");
            return Null;
        }
        else  { 
            Q->Front =(Q->Front+1)%Q->MaxSize;
            return  Q->Data[Q->Front];
        }
    }
    
    Tree BuildTree(struct TreeNode T[])
    { 
        char cl, cr;
        int N, i, check[MaxTree];
        Tree Root = Null;
        scanf("%d\n", &N);
        if(N) { 
            for(i=0;i<N;i++)
                check[i] = 0;
            for(i=0;i<N;i++) { 
                scanf("%c %c\n", &cl, &cr);
                if(cl!='-') { 
                    T1[i].Left = cl - '0';
                    check[T1[i].Left] = 1;
                } else
                    T1[i].Left = Null; 
    
                if(cr!='-') { 
                    T1[i].Right = cr - '0';
                    check[T1[i].Right] = 1;
                } else
                    T1[i].Right = Null;
            }
            for(i=0;i<N;i++)
                if(check[i] != 1) break;
            Root = i;
        }
        return Root;
    }
    
    void PrintLeaves(Tree R)    //层序遍历
    { 
        Queue Q;
        Tree cur;
        int count = 0;
        if(R==Null) return;
        Q=CreateQueue(QueueSize);
        AddQ(Q, R);
        while(!IsEmpty(Q)) { 
            cur = DeleteQ(Q);
            if((T1[cur].Left == Null) && (T1[cur].Right == Null)) { 
                if(!count) { 
                    printf("%d", cur);
                    count++;
                } 
    			else{ 
                	printf(" %d", cur);
                	continue;
    			}
            }
            if(T1[cur].Left!=Null) AddQ(Q, T1[cur].Left);
            if(T1[cur].Right!=Null) AddQ(Q, T1[cur].Right);
        }
    }
    
    int main()
    { 
        Tree R;
        R = BuildTree(T1);
        PrintLeaves(R);
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 19]

--------------------

### 3、03-树3 Tree Traversals Again (25分) ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 20]  
**Sample Input:**

6  
Push 1  
Push 2  
Push 3  
Pop  
Pop  
Push 4  
Pop  
Pop  
Push 5  
Push 6  
Pop  
Pop

**Sample Output:**

3 4 2 6 5 1

--------------------

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    
    int count = 0;
    
    typedef struct TreeNode *BinTree;
    struct TreeNode { 
        int Data;
        BinTree Left;
        BinTree Right;
    };
    
    typedef struct SNode *Stack;
    struct SNode { 
        BinTree Data;
        Stack Next;
    };
    
    BinTree CreateBinTree(int data)
    { 
        BinTree head;
        head = (BinTree)malloc(sizeof(struct TreeNode));
        head->Data = data;
        head->Left = NULL;
        head->Right = NULL;
        return head;
    }
    
    int IsEmptyBinTree(BinTree BST)
    { 
        return (BST == NULL);
    }
    
    void InsertLeftLeafe(BinTree BST, int leftData)
    { 
        BinTree left;
        left = (BinTree)malloc(sizeof(struct TreeNode));
        left->Data = leftData;
        left->Left = NULL;
        left->Right = NULL;
        BST->Left =  left;
    }
    
    void InsertRightLeafe(BinTree BST, int rightData)
    { 
        BinTree right;
        right = (BinTree)malloc(sizeof(struct TreeNode));
        right->Data = rightData;
        right->Left = NULL;
        right->Right = NULL;
        BST->Right =  right;
    }
    
    Stack CreateStack()
    { 
        Stack S = (Stack)malloc(sizeof(struct SNode));
        S->Data = NULL;
        S->Next = NULL;
        return S;
    }
    
    int IsEmptyStack(Stack S)
    { 
        return (S->Next == NULL);
    }
    
    void StackPush(Stack S, BinTree pos)
    { 
        Stack TmpCell = (Stack)malloc(sizeof(struct SNode));
        TmpCell->Data = pos;
        TmpCell->Next = S->Next;
        S->Next = TmpCell;
    }
    
    BinTree StackPop(Stack S)
    { 
        Stack FirstCell;
        BinTree pos;
        if(S->Next == NULL) { 
            printf("Stack Empty");
            return NULL;
        } 
    	else { 
            FirstCell = S->Next;
            S->Next = FirstCell->Next;
            pos = FirstCell->Data;
            free(FirstCell);
            return pos;
        }
    }
    
    void PrintStack(Stack S)
    { 
        Stack head = S;
        while(head) { 
            printf("%p ", head->Next);
            head = head->Next;
        }
        printf("\n");
    }
    
    BinTree Read()
    { 
        int N, data, count=0;
        char str[10];
        Stack S = CreateStack();
        BinTree head;
        BinTree BT = CreateBinTree(0);
        head = BT;
        scanf("%d\n", &N);
        scanf("Push %d\n", &BT->Data);
        StackPush(S, BT);
        count++;
        if(N) { 
            while(!IsEmptyStack(S)||count<N) {       //是否堆栈为空，输入足够的结点
                scanf("%s", str);
                if(strcmp("Push", str) == 0) {       //区分Push和Pop
                    scanf("%d", &data);
                    if(BT->Left == NULL) { 
                        InsertLeftLeafe(BT, data);
                        BT = BT->Left;
                        StackPush(S, BT);
                        count++;
                    } 
    				else if(BT->Right==NULL) { 
                        InsertRightLeafe(BT, data);
                        BT = BT->Right;
                        StackPush(S, BT);
                        count++;
                    } 
    				else { 
                        printf("can't go here\n");
                    }
                }
    			else { 
                    BT = StackPop(S);
                }
            }
            return head;
        }
        return NULL;
    }
    
    void PostOrderTraversal(BinTree BT){ 
    
    	if(BT){ 
    		PostOrderTraversal(BT->Left); 
    		PostOrderTraversal(BT->Right); 
    		if(!count) { 
                printf("%d", BT->Data);
                count++;
            } 
    		else { 
                printf(" %d", BT->Data);
            }
    	}
    }
    
    int main()
    { 
        int N;
        BinTree BT;
        BT = Read();
        PostOrderTraversal(BT);
    
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 21]

# 总结 #

简单总结下这周的学习内容，二叉树应该是数据结构的一大难点了，日常自闭，写了博客是为了能找着平板写一写代码，只能背一背了！！！

***如果想要更多的资源，欢迎关注 @我是管小亮，文字强迫症MAX~***

***回复【数据结构】即可获取我为你准备的大礼***

***想看更多文（段）章（子），欢迎关注微信公众号「程序员管小亮」~***

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

[20200314162146148.png_pic_center]: /images/20230528/13ffd9f4fb284490a05b31d1c0359a64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70]: /images/20230528/4423bc44b3df40d9bd11fab090d174f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 1]: /images/20230528/0d9396033c754b418f00dd6c13f16118.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 2]: /images/20230528/5bfb7762b68e4760b5bde031d07fa0d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 3]: /images/20230528/f44c59a99f1f46d99b3a888af5133d4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 4]: /images/20230528/167dc43252db49e18321417cc9d6f595.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 5]: /images/20230528/f1a621ae8c2e498788a881648b15945a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 6]: /images/20230528/22037a47a97b4040ad5edffec291f665.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 7]: /images/20230528/61c04990197f449a8bfdf1ddae801688.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 8]: /images/20230528/a47683141f144dd1a77bc2b8fde8d270.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 9]: /images/20230528/10a24775c1bb499a868adfa3bef78168.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 10]: /images/20230528/ee8b1f03116149bdb43f3477c1ed4e93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 11]: /images/20230528/4cceeee676244a5dacbcf069450d3e12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 12]: /images/20230528/bb6c7eadca7c431ca205af823deee856.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 13]: /images/20230528/2662aa5c75984a30a59f83e52bb3fc78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 14]: /images/20230528/cf757829483e43c68e01023a04f44f5f.png
[20200319212942205.png]: /images/20230528/aab39a9081f44c5181fb27c94d2c77b2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 15]: /images/20230528/a47e26b078c045b0b6d22d853a161059.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 16]: /images/20230528/6adbcb6f680b43649d15dd1d0a2c46d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 17]: /images/20230528/ed72d508a2ae43d0be715f96c081c022.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 18]: /images/20230528/fa733069651a44d9b2a6276c5dfb3494.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 19]: /images/20230528/24584308104c4a2790ffb73bb589d808.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 20]: /images/20230528/53d9207be22b4fe098f42e3a156170b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70 21]: /images/20230528/22088e9cf5454d9fb3e183ec9d15515d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RlRnVpcm5ldmVy_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/9a5bd9518ffb41b8b1b5fac635b28ebe.png