C++ 轻松搞定实现尾插入创建以及单链表，循环单链表，循环双链表进阶转换

谁践踏了优雅 2022-12-19 11:39 89阅读 0赞

## **单向转循环，链表转换** ##

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

> **一、单链表**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70][]

#include <iostream>//引入输入输出流 
    using namespace std; //将单链表的结点结构定义,单链表类定义和各个成员函数定义写到这里
    typedef int DataType;
    typedef struct Node
    {
    	DataType data;//数据域 
    	struct Node * next;//指针域 
    }Node; 
    
    //单链表的实现
    class LinkList{
    	public:
    		LinkList();//建立只有头结点的空链表
    		LinkList(DataType a[],int n);//建立n个元素的单链表
    		~LinkList();//析构函数 
    		int Length();//求单链表的长度 
    		DataType Get(int i);// 按位查找,查找第i个结点的元素值
    		int Locate(DataType x);///按值查找，查找值为x的元素序号
    		void Insert(int i,DataType x);//插入操作，第i个元素插入值为x的结点
    		DataType Delete(int i);//删除操作，删除第i个结点
    		int Empty();//判断线性表是否为空
    		void PrintList();//遍历操作，按序号依次输出各元素
    	private:
    		Node* first;//单链表的头指针 
    };
    //判断是否为空 
    int LinkList::Empty()
    {
    	if(first->next == nullptr)
    	{
    		return true;
    	}
    	else{
    		return false;
    	}
    } 
    //析构函数--销毁单链表
    LinkList::~LinkList()
    {
    	Node*p=first;
    	while(first!=nullptr)//释放每一个结点的存储空间
    	{
    		first = first->next;//first指向被释放结点的下一个结点
    		delete p;
    		p = first;//工作指针p后移 
    	} 
    }
    /*
    //建立单链表 头插法 
    LinkList::LinkList(DataType a[],int n)
    {
    	first = new Node<DataType>;
    	first->next = nullptr;//初始化一个空表	
    	for(int i=0;i<n;i++)
    	{
    		Node<DataType>*s=nullptr;
    		s=new Node<DataType>;s->data=a[i];
    		s->next=first->next;first->next=s;//将结点s插入头结点后 
    	} 
    } 
    */
    
    //建立单链表 尾插法 
    LinkList::LinkList(DataType a[],int n)
    {
    	first = new Node();
    	Node *r=first,*s = nullptr;//尾指针初始化	
    	for(int i=0;i<n;i++)
    	{
    		s=new Node();
    		s->data=a[i]; 
    		r->next=s;
    		r=s;
    	} 
    	r->next=nullptr;//单链表建立完毕，将终端结点的指针域置空 
    }
    
    //遍历操作
    void LinkList::PrintList()//遍历操作，按序号依次输出各元素
    {
    	Node *p = first->next;//工作指针p初始化
    	while(p!=nullptr)
    	{
    		cout<<p->data<"\t";
    		p=p->next;//工作指针p后移,注意不能写作p++ 
    	} 
    }
    //求单链表的长度 
    int LinkList::Length(){
    	Node *p = first->next;//工作指针初始化
    	int count = 0;//累加器初始化
    	while(p!=nullptr)
    	{
    		p=p->next;
    		count++;	
    	}
    	return count;//注意count的初始化和返回值之间的关系 
    } 
    //按位查找 
    DataType LinkList::Get(int i)
    {
    	Node *p = first->next; //工作指针p初始化
    	int count = 1;//累加器count初始化
    	while(p!=nullptr && count<i)
    	{
    		p = p->next;//工作指针p后移
    		count++; 
    	} 
    	if(p==nullptr) throw "查找位置错误";
    	else return p->data;
    }
    //按值查找
    int LinkList::Locate(DataType x)
    {
    	Node *p=first->next;//工作指针p初始化
    	int count=1;
    	while(p!=nullptr)
    	{
    		if(p->data==x) return count;//查找成功返回序号 
    		p=p->next; 
    	} 
    	return 0;//退出循环表明查找失败 
    }
    //插入操作 
    void LinkList::Insert(int i,DataType x)
    {
    	Node *p=first,*s=nullptr;
    	int count=0;
    	while(p!=nullptr&&count<i-1)
    	{
    		p = p->next; //工作指针后移 
    		count++;
    	}
    	if(p==nullptr) throw "插入位置错误";//没有找到第i-1个结点
    	else{
    		s = new Node();s->data=x;//申请结点x，数据域为xx
    		s->next = p->next;p->next=s;//将结点s插入到结点p之后 
    	} 
    }
    //删除操作
    DataType LinkList::Delete(int i)
    {
    	DataType x;
    	Node *p = first,*q=nullptr;
    	int count=0;
    	while(p!=nullptr && count<i-1)//查找第i-1个结点 
    	{
    		p = p->next;
    		count++;	
    	} 
    	if(p==nullptr || p->next == nullptr)//结点p不存在或p的后继结点不存在
    		throw "删除位置错误";
    	else{
    		q=p->next;x=q->data;//暂存被删除的结点
    		p->next=q->next;//摘链
    		delete q;
    		return x; 
    	} 
    }
    
    int main()
    {
    	int r[5]={1,2,3,4,5},i,x,element_data;
    	LinkList L{r,5};
    	cout<<"当前线性表的数据为:"<<endl;
    	L.PrintList();//输出 
    	cout<<endl;
     
    	cout<<"请输入当前需要查找第几个元素:";
    	cin>>i;
    	cout<<endl;
    	cout<<i<<"的位置的值为："<<L.Get(i); 
    	cout<<endl;
    	cout<<"请输入当前需要删除第几个元素:";
    	cin>>i;
    	cout<<endl;
    	L.Delete(i); 
    	L.PrintList();//输出
    	
    	cout<<"请输入当前需添加第几个元素:";
    	cin>>i;
    	cout<<"请输入当前需要添加元素值";
    	cin>>element_data;
    	L.Insert(i,element_data); 
    	L.PrintList();//输出
    }

*  **1.核心代码：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 2][]

**2.单链表的作用**

**单链表是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续，甚至可以零散分布在内存中的任意位置。**

> **二、循环单链表实现**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 3][]

### **改造单链表为循环单链表：单链表最后一个结点next不指向nullptr，指向头结点first即可。** ###

#include <iostream>//引入输入输出流 
    #include <stdio.h>
    #include <stdlib.h>
    using namespace std; //将循环单链表的结点结构定义,循环单链表类定义和各个成员函数定义写到这里
    
    typedef int DataType;
    typedef struct CirNode
    {
    	DataType data;//数据域 
    	struct CirNode * next;//指针域 
    }CirNode; 
    
    //循环单链表的实现
    class CirLinkList{
    	public:
    		CirLinkList();//建立只有头结点的空链表
    		CirLinkList(DataType a[],int n);//建立n个元素的循环单链表
    		~CirLinkList();//析构函数 
    		bool Empty();//判断线性表是否为空
    		int Length(); 
    		void PrintList();//遍历操作，按序号依次输出各元素
    		void GetNode(int i);//通过数据得到结点
    		void PrintCirNode(CirNode *node);
    		void RunPrintCirCirNode();
    		void Insert(int i,DataType x); 
    		DataType Delete(int i);
    	private:
    		CirNode *first;//循环单链表的头指针 
    };
    
    //判断是否为空 
    bool CirLinkList::Empty()
    {
    	if(first->next == first)
    	{
    		return true;
    	}
    	else{
    		return false;
    	}
    } 
    
    //求循环单链表的长度 
    int CirLinkList::Length(){
    	CirNode *p = first->next;//工作指针初始化
    	int count = 0;//累加器初始化
    	while(p!=first)
    	{
    		p=p->next;
    		count++;	
    	}
    	return count;//注意count的初始化和返回值之间的关系 
    } 
    
    //建立循环单链表 尾插法 
    CirLinkList::CirLinkList(DataType a[],int n)
    {
    	first = new CirNode();
    	CirNode *r=first,*s = nullptr;//尾指针初始化
    	for(int i=0;i<n;i++)
    	{
    		s=new CirNode();
    		s->data=a[i]; 
    		r->next=s;
    		r=s;
    	}
    	r->next=first;//循环链表建立完毕，将终端结点的指针域指向自身 
    }
    
    //析构函数--销毁循环单链表
    CirLinkList::~CirLinkList()
    {
    	/*
    	CirNode *p=first->next;
    	while(p!=first)//释放每一个结点的存储空间
    	{
    		first = first->next;//first指向被释放结点的下一个结点
    		delete p;
    		p = first;//工作指针p后移 
    	} 
    	first->next=first;
    	*/
    	
    	first = first->next;
    	CirNode *p = first->next;
    	CirNode *q;
    	while(p!=first)
    	{
    		q=p->next;
    		delete p;
    		p=q;
    	}
    	first->next=first;
    }
    
    //遍历操作
    void CirLinkList::PrintList()//遍历操作，按序号依次输出各元素
    {
    	CirNode *p = first->next;//工作指针p初始化
    	
    	while(p!=first)
    	{
    		if(p==first){
    			p=p->next;
    			continue;
    		} 
    		cout<<p->data<"\t";
    		p=p->next;//工作指针p后移,注意不能写作p++ 
    	}
    }
    
    //从任意结点处遍历整个链表 
    void CirLinkList::PrintCirNode(CirNode *node)
    {
    	CirNode *p = node;
    	cout<<p->data<<"\t";
    	p=p->next;
    	while(p!=node)
    	{
    		if(p==first){
    			p=p->next;
    			continue;
    		}
    		cout<<p->data<<"\t";
    		p=p->next;
    	}
    }
    
    //查找任意位置
    void CirLinkList::GetNode(int i)
    {
    	CirNode *p = first->next; //工作指针p初始化
    	int count = 1;//累加器count初始化
    	while(count<i)
    	{
    		p = p->next;//工作指针p后移
    		count++; 
    	} 
    	PrintCirNode(p);
    	cout<<endl;
    	/*
    	CirNode *p = first->next; 
        while(1)
        {
            p = p->next;
            if(p->data == i){
            	PrintCirNode(p);
            	break;
            }
        }*/
    }
    
    //从任意位置遍历 
    void CirLinkList::RunPrintCirCirNode()
    {
    	int locate;
    	cout<<"请输入从第几个开始遍历整个链表:";
    	cin>>locate;
    	GetNode(locate);
    }
    
    //插入操作 
    void CirLinkList::Insert(int i,DataType x)
    {
    	CirNode *p=first,*s=nullptr;
    	int count=0;
    	while(count<i-1)
    	{
    		p = p->next; //工作指针后移 
    		count++;
    	}
    	s = new CirNode;s->data=x;//申请结点x，数据域为xx
    	s->next = p->next;p->next=s;//将结点s插入到结点p之后 
    }
    
    //删除操作 
    DataType CirLinkList::Delete(int i)
    {
    	DataType x;
    	CirNode*p = first,*q=nullptr;
    	int count=0;
    	while(count<i-1)//查找第i-1个结点 
    	{
    		p = p->next;
    		count++;	
    	} 
    	q=p->next;x=q->data;//暂存被删除的结点
    	p->next=q->next;//摘链
    	delete q;
    	return x; 
    }
    
    
    int main()
    {
    	int r[5]={1,2,3,4,5},i,x;
    	DataType element_data;
    	CirLinkList L{r,5};
    	cout<<"当前链表的数据为:";
    	L.PrintList();//输出 
    	cout<<"当前链表的长度为"<<L.Length()<<endl;
    	L.RunPrintCirCirNode();
    
    	cout<<"请输入当前需添加第几个元素:";
    	cin>>i;
    	cout<<"请输入当前需要添加元素值";
    	cin>>element_data;
    	cout<<endl;
    	try 
    	{
    		L.Insert(i,element_data);  
    	}
    	catch(const char* e){
    		cout << "插入错误！" << endl;
    	} 
    	L.PrintList();//输出
    	cout<<endl;
    	L.RunPrintCirCirNode();
    	
    	cout<<endl;
    	L.PrintList();//输出
    	cout<<endl;
    	cout<<"请输入当前需删除第几个元素:";
    	cin>>i;
    	try 
    	{
    		L.Delete(i);  
    	}
    	catch(const char* e){
    		cout << "删除错误！" << endl;
    	} 
    	L.PrintList();//输出
    	cout<<endl;
    	L.RunPrintCirCirNode();
    }

*  ### **1.实验截图** ###
 *  ### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 4][] ###
 *  ### **2.核心代码：** ###
 *  ### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 5][] ###
 *  ## **3.循环单链表的作用** ##

###     **从表中任一结点出发都能遍历整个链表** ###

> ### **三、循环双链表实现** ###

### ** 循环单链表改造为循环双链表：双向链表每一个结点需要初始化数据域和两个指针域，一个指向直接前趋结点，另一个指向直接后继结点。** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 6][]

#include <iostream>//引入输入输出流 
    #include <stdio.h>
    #include <stdlib.h>
    using namespace std; //将循环双链表的结点结构定义,循环双链表类定义和各个成员函数定义写到这里
    
    typedef int DataType;
    typedef struct CirNode
    {
    	DataType data;//数据域 
    	struct CirNode * next;//前驱指针域 
    	struct CirNode * prior; //后继指针域 
    }CirNode; 
    
    //循环双链表的实现
    class CirLinkList{
    	public:
    		CirLinkList();//建立只有头结点的空链表
    		CirLinkList(DataType a[],int n);//建立n个元素的循环双链表
    		bool Empty();//判断线性表是否为空
    		int Length(); 
    		void PrintList();//遍历操作，按序号依次输出各元素
    		void GetNode(int i);//通过数据得到结点
    		void PrintCirNode(CirNode *node);//遍历操作 
    		void RunPrintCirCirNode();//从任意位置遍历链表 
            void Print_NearBothNode(int i);//从任意位置查询结点的前驱和后继 
            void Insert(int i,DataType x); 
            DataType Delete(int i);
    	private:
    		CirNode *first;//循环双链表的头指针 
    };
    
    //判断是否为空 
    bool CirLinkList::Empty()
    {
    	if(first->next == first)
    	{
    		return true;
    	}
    	else{
    		return false;
    	}
    } 
    
    //求循环双链表的长度 
    int CirLinkList::Length(){
    	CirNode *p = first->next;//工作指针初始化
    	int count = 0;//累加器初始化
    	while(p!=first)
    	{
    		p=p->next;
    		count++;	
    	}
    	return count;//注意count的初始化和返回值之间的关系 
    } 
    
    //建立循环双链表 尾插法 
    CirLinkList::CirLinkList(DataType a[],int n)
    {
    	first = new CirNode();
    	CirNode *r=first,*s = nullptr;//尾指针初始化
    	for(int i=0;i<n;i++)
    	{
    		s=new CirNode();
    		s->data=a[i]; 
    		r->next=s;
    		s->prior=r;
    		r=s;
    	}
    	r->next=first;//循环链表建立完毕，将终端结点的指针域指向自身 
    	first->prior=r;
    }
    
    //遍历操作
    void CirLinkList::PrintList()//遍历操作，按序号依次输出各元素
    {
    	CirNode *p = first->next;//工作指针p初始化
    	
    	while(p!=first)
    	{
    		if(p==first){
    			p=p->next;
    			continue;
    		} 
    		cout<<p->data<"\t";
    		p=p->next;//工作指针p后移,注意不能写作p++ 
    	}
    }
    
    //从任意结点处遍历整个链表 
    void CirLinkList::PrintCirNode(CirNode *node)
    {
    	CirNode *p = node;
    	cout<<p->data<<"\t";
    	p=p->next;
    	while(p!=node)
    	{
    		if(p==first){
    			p=p->next;
    			continue;
    		}
    		cout<<p->data<<"\t";
    		p=p->next;
    	}
    }
    
    //查找任意位置
    void CirLinkList::GetNode(int i)
    {
    	CirNode *p = first->next; //工作指针p初始化
    	int count = 1;//累加器count初始化
    	while(count<i)
    	{
    		p = p->next;//工作指针p后移
    		count++; 
    	} 
    	PrintCirNode(p);
    	cout<<endl;
    	/*
    	CirNode *p = first->next; 
        while(1)
        {
            p = p->next;
            if(p->data == i){
            	PrintCirNode(p);
            	break;
            }
        }*/
    }
    
    //从任意位置遍历链表 
    void CirLinkList::RunPrintCirCirNode()
    {
    	int locate;
    	cout<<"请输入从第几个开始遍历整个链表:";
    	cin>>locate;
    	GetNode(locate);
    }
    
    //从任意位置查询结点的前驱和后继 
    void CirLinkList::Print_NearBothNode(int i)
    {
    	CirNode *p = first->next; //工作指针p初始化
    	int count = 1;//累加器count初始化
    	while(count<i)
    	{
    		p = p->next;//工作指针p后移
    		count++; 
    	} 
    	cout<<"当前位置的前驱:"<<p->prior->data<<"当前位置:"<<p->data<<"当前位置的后继:"<<p->next->data<<endl;
    }
    
    //插入操作 
    void CirLinkList::Insert(int i,DataType x)
    {
    	CirNode *p=first,*s=nullptr;
    	int count=0;
    	while(count<i-1)
    	{
    		p = p->next; //工作指针后移 
    		count++;
    	}
    	s = new CirNode;s->data=x;//申请结点x，数据域为xx
    	//s->next = p->next;p->next=s;//将结点s插入到结点p之后 
    	s->prior=p;
    	s->next=p->next;
    	p->next->prior=s;
    	p->next=s;
    }
    
    //删除操作 
    DataType CirLinkList::Delete(int i)
    {
    	DataType x;
    	CirNode*p = first->next;
    	int count=0;
    	while(p!=first && count<i-1)//查找第i-1个结点 
    	{
    		p = p->next;
    		count++;	
    	} 
    	if(!p)//结点p不存在或p的后继结点不存在
    		throw "删除位置错误";
    	else{
    		p->prior->next=p->next;
    		p->next->prior=p->prior; 
    		delete p;
    		return x; 
    	} 
    }
    
    int main()
    {
    	int r[5]={1,2,3,4,5},i,x;
    	DataType element_data;
    	CirLinkList L{r,5};
    	cout<<"当前链表的数据为:";
    	L.PrintList();//输出 
    	cout<<"当前链表的长度为"<<L.Length()<<endl;
    	L.RunPrintCirCirNode();
    	cout<<endl;
    	cout<<"请输入当前想要搜索的位置，为您查找它和它的前驱和后继"<<endl;
    	cin>>i;
    	L.Print_NearBothNode(i);
    	cout<<endl;
    	
    	cout<<"请输入当前想删除第几个元素:";
    	cin>>i;
    	cout<<endl;
    	try 
    	{
    		L.Delete(i);  
    	}
    	catch(const char* e){
    		cout << "删除错误！" << endl;
    	} 
    	L.PrintList();//输出
    	cout<<endl;
    	
    	cout<<"请输入当前需添加第几个元素:";
    	cin>>i;
    	cout<<"请输入当前需要添加元素值";
    	cin>>element_data;
    	cout<<endl;
    	try 
    	{
    		L.Insert(i,element_data);  
    	}
    	catch(const char* e){
    		cout << "插入错误！" << endl;
    	} 
    	L.PrintList();//输出
    	cout<<endl;
    	
    	L.RunPrintCirCirNode();
    	cout<<endl;
    	cout<<"请输入当前想要搜索的位置，为您查找它和它的前驱和后继"<<endl;
    	cin>>i;
    	L.Print_NearBothNode(i);
    	cout<<endl;
    }

*  ### **1.实验结果截图：** ###
 *  ### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 7][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 8][] ###
 *  ### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 9][] ###
 *  ### **2.核心代码：** ###
 *  ### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 10][] ###
 *  ### 3.循环双链表的作用 ###

**   从表中任一结点出发都能遍历整个链表且能够很容易地找到它的直接前驱结点和后继结点**

### 我是热爱学习的呵呵哒~如果你觉得文章很棒，对你有帮助的话，可以点赞收藏加关注喔~ ###

如果文章有不正确的地方，欢迎交流指正，我将虚心请教~o(>ω<)o

**我会定期更新文章，继续为您提供优质文章~o(>ω<)o**

## ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70]: /images/20221120/efd99b765de34cfd812e37e36e29952e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 1]: /images/20221120/24530d3a08dc4294bff974f6abc7c3ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 2]: /images/20221120/98c01cf7be414d6f98b6abfcddc77fa2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 3]: /images/20221120/a36c4c2301ae4e4c96c65d54d029c3dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 4]: /images/20221120/87aef7db65f247e3a91439a9a44dfd89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 5]: /images/20221120/8428b71b08b64c57a37ca0fd38240c72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 6]: /images/20221120/1ce0ca7a620d41e4b442478661f0b391.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020110701161830.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20201107011600127.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20201107012454983.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20201107012756907.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTk4NzAxNg==,size_16,color_FFFFFF,t_70