【数据结构基础_有[*pHead]和[*pEnd]的单向链表_(C++实现)】

已于 2022-01-28 18:46:07 修改
阅读量586 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 开发语言
于 2021-11-18 21:25:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sugar_wolf/article/details/121410512
版权

此文为上一篇文章改为C++格式实现（多文件形式）

头文件

#pragma once
#include<iostream>
using namespace std;

struct Node
{
	int iData;
	Node* pNext;
};

class List
{
private:
	Node* pHead;
	Node* pEnd;	//pEnd指针是为了增加尾添加的效率，否则就要循环找尾
	int iCount = 0;
public:
	List();
	~List();
private:
	void FreeList();
	void FreeListNULL();
public:
	void AddToEnd(int iData);
	void AddToEndNopEnd(int iData);
	void Look();
	void AddToHead(int iData);
	Node* FindNodeByIndex(int iIndex);
	Node* FindNodeByData(int iData);
	void InsertNodeByIndex(int iIndex, int iData);
	void AddSomeNode(unsigned int iCount, unsigned int iData);
	void ChengeData(int iResData, int iDecData);
	void ChengeSomeData(int iResData, int iDecData);
	void ChengeSomeDataText(int iResData, int iDecData);
	void DeleteHead();
	void DeleteEnd();
	Node* DeleteOneDataByData(int iData);
	void DeleteAllDataByData(int iData);
	void DeleteDataByIndex(int iIndex);
	void SwapByData(int iData1, int iData2);
	void SwapByIndex(int iIndex1, int iIndex2);
	void SwapByChangePoint(int iIndex1, int iIndex2);
	void ReverseByData();
	void ReverseByPoint();
	int GetListNodeCount();
};

函数实现

#include"dl.h"

List::List()
{
	pHead = NULL;
	pEnd = NULL;
	iCount = 0;
}
List::~List()
{
	FreeListNULL();
}

void List::ReverseByPoint()
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead || NULL == pHead->pNext)
	{
		return;
	}
	int iCount = GetListNodeCount();
	int i = 0, j = iCount - 1;
	for (; i < j; i++, j--)
	{
		SwapByChangePoint(i, j);
	}
}
void List::ReverseByData()
{
	//参数合法性检测
	if (NULL == pHead || NULL == pHead->pNext)
	{
		return;
	}
	int iCount = GetListNodeCount();
	int i = 0, j = iCount - 1;
	for (; i < j; i++, j--)
	{
		SwapByIndex(i, j);
	}
}
int List::GetListNodeCount()
{
	Node* pHead = this->pHead;
	int iCount = 0;
	while (NULL != pHead)
	{
		iCount++;
		pHead = pHead->pNext;
	}
	return iCount;
}
void List::SwapByChangePoint(int iIndex1, int iIndex2)
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead || NULL == pHead->pNext || iIndex1 == iIndex2 || iIndex1 < 0 || iIndex2 < 0)
	{
		return;
	}
	//确定大小关系
	int iMin = iIndex1;
	int iMax = iIndex2;
	if (iIndex1 > iIndex2)
	{
		iMin = iIndex2;
		iMax = iIndex1;
	}
	//根据下标找节点
	Node* pMin = FindNodeByIndex(iMin);
	Node* pMax = FindNodeByIndex(iMax);
	//找不到就结束
	if (NULL == pMin || NULL == pMax)
	{
		cout<<"查无此节点\n";
		return;
	}
	//头尾交换
	if (pMin == pHead && pMax == pEnd)
	{
		if (pHead->pNext == pEnd)  //两个节点
		{
			pEnd->pNext = pHead;
			pHead->pNext = NULL;
			//交换指向
			pHead = pEnd;
			pEnd = pHead->pNext;
		}
		else //多个节点
		{
			//找到尾巴的前一个节点
			Node* pMaxPre = FindNodeByIndex(iMax - 1);
			//尾巴变头
			pEnd->pNext = pHead->pNext;
			//头变尾巴
			pMaxPre->pNext = pHead;
			//头下一个为NULL
			pHead->pNext = NULL;
			//交换指向
			pHead = pEnd;
			pEnd = pMaxPre->pNext;
		}
	}
	//头和中间交换
	else if (pMin == pHead && pMax != pEnd)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			pMin->pNext = pMax->pNext;
			pMax->pNext = pMin;
			pHead = pMax;
		}
		//不相邻
		else
		{
			//找pMax的前一个指针
			Node* pMaxPre = FindNodeByIndex(iMax - 1);
			//记录头的下一个节点 即链表第二个节点
			Node* pHeadNext = pMin->pNext;
			//头节点连在max的位置上
			pMin->pNext = pMax->pNext;
			pMaxPre->pNext = pMin;
			//pMax挪到头
			pMax->pNext = pHeadNext;
			//改变新的头
			pHead = pMax;
		}
	}
	//尾和中间交换
	else if (pMin != pHead && pMax == pEnd)
	{
		if (pMin->pNext == pMax)  //相邻
		{
			//找到pMin的前一个
			Node* pMinPre = FindNodeByIndex(iMin - 1);
			//先把尾巴放中间
			pMinPre->pNext = pMax;
			pMax->pNext = pMin;
			//pMin next = NULL
			pMin->pNext = NULL;
			pEnd = pMin;
		}
		//不相邻
		else
		{
			//找到pMin的前一个
			Node* pMinPre = FindNodeByIndex(iMin - 1);
			//找pMax的前一个指针
			Node* pMaxPre = FindNodeByIndex(iMax - 1);
			//pmax放中间去
			pMinPre->pNext = pMax;
			pMax->pNext = pMin->pNext;
			//pMin放尾巴上去
			pMaxPre->pNext = pMin;
			pMin->pNext = NULL;
			pEnd = pMin;
		}
	}
	//中间两个相互交换
	else if (pMin != pHead && pMax != pEnd)
	{
		//相邻
		if (pMin->pNext == pMax)
		{
			//找到pMin的前一个节点
			Node* pMinPre = FindNodeByIndex(iMin - 1);
			Node* pMaxNext = pMax->pNext;
			//将pMax装在pMin 与pMinPre中间
			pMinPre->pNext = pMax;
			pMax->pNext = pMin;
			//把pMax拿下来
			pMin->pNext = pMaxNext;
		}
		//不相邻
		else
		{
			//找到pMin的前一个
			Node* pMinPre = FindNodeByIndex(iMin - 1);
			Node* pMinNext = pMin->pNext;
			//找pMax的前一个指针
			Node* pMaxPre = FindNodeByIndex(iMax - 1);
			Node* pMaxNext = pMax->pNext;
			//将pMin撞到pMax的位置
			pMaxPre->pNext = pMin;
			pMin->pNext = pMaxNext;
			//将pMax撞到pMin的位置
			pMinPre->pNext = pMax;
			pMax->pNext = pMinNext;
		}
	}
}
void List::SwapByIndex(int iIndex1, int iIndex2)
{
	if (NULL == pHead)
		return;
	//查找
	Node* pT1 = FindNodeByIndex(iIndex1);
	Node* pT2 = FindNodeByIndex(iIndex2);
	//都找到才能交换
	if (pT1 != NULL && pT2 != NULL)
	{
		//交换成员
		//int temp = pT1->iData;
		//pT1->iData = pT2->iData;
		//pT2->iData = temp;
		Node p = *pT1;
		memcpy(pT1, pT2, 4);
		memcpy(pT2, &p, 4);
	}
}
void List::SwapByData(int iData1, int iData2)
{
	if (NULL == pHead)
		return;
	//查找
	Node* pT1 = FindNodeByData(iData1);
	Node* pT2 = FindNodeByData(iData2);
	//都找到才能交换
	if (pT1 != NULL && pT2 != NULL)
	{
		//交换成员
		//Node p = *pT1;
		//*pT1 = *pT2;
		//*pT2 = p;
		//int temp = pT1->iData;
		//pT1->iData = pT2->iData;
		//pT2->iData = temp;
		Node p = *pT1;
		memcpy(pT1, pT2, 4);
		memcpy(pT2, &p, 4);
	}
}
void List::DeleteDataByIndex(int iIndex)
{
	Node* pHead = this->pHead;
	if (NULL == pHead)
		return;
	if (0 == iIndex)
		DeleteHead();
	else
	{
		//找前一个节点
		Node* pTemp = FindNodeByIndex(iIndex - 1);
		if (pTemp != NULL)
		{
			if (pTemp->pNext == pEnd)
				DeleteEnd();
			//记录被删除的节点
			Node* pT = pTemp->pNext;
			//链接
			pTemp->pNext = pT->pNext;
			//释放
			delete pT;
		}
		else
		{
			cout << "查无此节点\n";
		}
	}
}
void List::DeleteAllDataByData(int iData)
{
	Node* pHead = this->pHead;
	if (NULL == pHead)
		return;
	Node* pTemp = DeleteOneDataByData(iData);
	while (pTemp != NULL)
	{
		pTemp = DeleteOneDataByData(iData);
	}
}
Node* List::DeleteOneDataByData(int iData)
{
	Node* pHead = this->pHead;
	if (NULL == pHead)
		return NULL;
	if (pHead->iData == iData)
	{
		DeleteHead();
		return pHead;
	}
	else if (pEnd->iData == iData)
	{
		DeleteEnd();
		return pHead;
	}
	else
	{
		//循环找节点
		Node* pTemp = pHead;
		while (pTemp->pNext != NULL)
		{
			if (pTemp->pNext->iData == iData)
				break;
			pTemp = pTemp->pNext;
		}
		//判断
		if (pTemp->pNext != NULL)
		{
			Node* pT = pTemp->pNext; //记录
			pTemp->pNext = pT->pNext;
			delete  pT;
			return pHead;   //return pTemp->pNext  ----- pHead
		}
		else
		{
			cout << "查无此节点\n";
			return NULL;
		}
	}
}
void List::DeleteEnd()
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead)
		return;
	if (pHead == pEnd || pHead->pNext == NULL)//只有一个节点
	{
		delete pHead;
		pHead = NULL;
		pEnd = NULL;
	}
	else
	{
		//找到结尾的前一个
		Node* pT = pHead;
		while (pT->pNext != pEnd)
		{
			pT = pT->pNext;
		}
		delete pEnd;
		pEnd = pT;
		pEnd->pNext = NULL;
	}
}
void List::DeleteHead()
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead)
		return;
	if (pHead == pEnd || pHead->pNext == NULL)//只有一个节点
	{
		delete pHead;
		pHead = NULL;
		pEnd = NULL;
	}
	else
	{
		Node* pT = pHead;
		pHead = pHead->pNext;
		delete pT;
	}
}
void List::ChengeSomeData(int iResData, int iDecData)
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead)
	{
		cout << "查无此节点\n";
		return;
	}
	while (pHead != NULL)
	{
		if (pHead->iData == iResData)
			pHead->iData = iDecData;
		pHead = pHead->pNext;
	}
}
void List::ChengeSomeDataText(int iResData, int iDecData)
{
	//参数合法性检测
	if (NULL == pHead)
	{
		cout << "查无此节点\n";
		return;
	}
	while (FindNodeByData(iResData) != NULL)
	{
		ChengeData(iResData, iDecData);
	}
}
void List::ChengeData(int iResData, int iDecData)
{
	Node* pRec = FindNodeByData(iResData);
	if (NULL == pRec)
	{
		cout << "查无此节点\n";
	}
	else
	{
		pRec->iData = iDecData;
	}
}
void List::AddSomeNode(unsigned int iCount, unsigned int iData)
{
	for (unsigned int i = 0; i < iCount; i++)
	{
		AddToEnd(iData);
	}
}
void List::InsertNodeByIndex(int iIndex, int iData)
{
	//参数合法性检测
	if (iIndex < 0)
	{
		cout << "下标输入有误，请重新输入\n";
		return;
	}
	//下标为0，直接头添加
	if (0 == iIndex)
	{
		AddToHead(iData);
	}
	else
	{
		//找位置
		Node* pTemp = FindNodeByIndex(iIndex - 1);
		if (pTemp != NULL)
		{
			//申请节点空间
			Node* pT = new(Node);
			if (pT != NULL)
			{
				//节点成员赋值
				pT->iData = iData;
				pT->pNext = NULL;
				//链接 先连后断
				pT->pNext = pTemp->pNext;
				pTemp->pNext = pT;
			}
		}
		else
		{
			cout << "查无此节点";
		}
	}
}
Node* List::FindNodeByData(int iData)
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead || iData < 0)
	{
		cout << "链表为空/位置输入有误，无法查节点\n";
		return NULL;
	}
	//循环链表
	while (pHead != NULL)
	{
		if (pHead->iData == iData)
			return pHead;
		pHead = pHead->pNext;
	}
	return NULL;
}
Node* List::FindNodeByIndex(int iIndex)
{
	Node* pHead = this->pHead;
	//参数合法性检测
	if (NULL == pHead || iIndex < 0)
	{
		cout << "链表为空/位置输入有误，无法查节点\n";
		return NULL;
	}
	//循环链表
	int i = 0;
	while (pHead != NULL)
	{
		if (i == iIndex)
			return pHead;
		i++;
		pHead = pHead->pNext;
	}
	cout << "位置输入过大，无法查节点\n";
	return NULL;
}
void List::AddToHead(int iData)
{
	//创建节点
	Node* pTemp = new(Node);
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//连接链表
		if (NULL == pHead)//空链表
		{
			//*pHead = pTemp;
			pEnd = pTemp;
		}
		else
		{
			pTemp->pNext = pHead;
			//*pHead = pTemp;
		}
		pHead = pTemp;
	}
}
void List::Look()
{
	Node* pHead = this->pHead;
	while (pHead != NULL)
	{
		cout << " " << (pHead->iData);
		pHead = pHead->pNext;
	}
	cout << endl;
}
void List::FreeList()
{
	Node* pTemp = pHead;
	while (pTemp != NULL)
	{
		Node* pt = pTemp;
		pTemp = pTemp->pNext;
		delete pt;
	}
	pHead = NULL;
	pEnd = NULL;
}
void List::FreeListNULL()
{
	Node* pTemp = pHead;
	while (pTemp != NULL)
	{
		Node* pt = pTemp;
		pTemp = pTemp->pNext;
		delete pt;
	}
	pHead = NULL;
	pEnd = NULL;
}
void List::AddToEndNopEnd(int iData)
{
	//创建节点
	Node* pTemp = new(Node);
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//链接
		if (NULL == pHead)
		{
			pHead = pTemp;
		}
		else
		{
			Node* pt = pHead;
			while (pt->pNext != NULL)		//找尾巴
			{
				pt = pt->pNext;
			}
			pt->pNext = pTemp;
		}
	}
}
void List::AddToEnd(int iData)
{
	//创建节点
	Node* pTemp = new(Node);
	if (NULL != pTemp)
	{
		//节点成员赋值
		pTemp->iData = iData;
		pTemp->pNext = NULL;
		//连接链表
		if (NULL == pHead)//空链表
		{
			pHead = pTemp;
			//*pEnd = pTemp;
		}
		else
		{
			pEnd->pNext = pTemp;
			//*pEnd = pTemp;
		}
		pEnd = pTemp;
	}

}

主函数

#include<iostream>
#include"dl.h"
using namespace std;



int main()
{
	List ls;

	ls.AddToEnd(1);
	ls.AddToEnd(2);
	ls.AddToEndNopEnd(5);
	ls.AddToHead(3);
	//ls.FindNodeByIndex(2);
	//ls.FindNodeByData(2);
	ls.InsertNodeByIndex(2,3);


	ls.Look();
	
	

	return 0;
}

perfect~

千北@
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单向链表操作(C++实现)
aaron19890330的专栏
08-17 740
单向链表操作，某司笔试题答案： project1为链表新建，增、删节点，逆转等常规操作； project2为链表数字指定和插入+，-或空格； project3为聚类。 #include<iostream> #include<vector> usingnamespacestd; /*Project1 定义一个单向链表node,每个节点值为int. ...
C语言 数据结构之链表实现代码
09-01
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据管理。与数组不同，链表的元素不是在连续的内存空间中存储，而是通过指针链接在一起。链表分为多种类型，如单链表、双向链表、循环链表等。本文...
【数据结构基础_双向链表（有[*pHead]和[*pEnd]）_(C语言实现)】
Sugar_wolf的博客
11-29 761
双向链表（含头尾指针） 双向链表呢，顾名思义，就是比单向多一个向前指向节点的一个指针 本文主要是针对（含头尾指针）双向链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; //记录后一个节点地址 struct Node* pPre; //记录前一个节点的地址 }; 前面我用的是局部定义头尾指针（每次调用都需要传参），这次咱们使用全局的 定义头尾指针 struct Node* g_pHead = NULL;
c++中pHead指向第一个元素，并非是一个空
MonkeyMonkeyGo
06-06 1513
pHead-&gt;val就是第一个元素值。一直困扰好久，今天测试了一下。不然老是影响写程序。
【数据结构基础_有[*pHead]和[*pEnd]的单向链表_(C语言实现)】
Sugar_wolf的博客
11-18 1284
单向链表（含头尾指针） 本文主要是针对（含头尾指针）单向链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; }; 定义头尾指针 struct Node* pHead = NULL; struct Node* pEnd = NULL; pEnd指针是为了增加尾添加的效率，否则就要循环找尾 增加：1.尾添加 无（*pEnd）指针的尾添加 void AddToEndNopEnd(struct Node**
约瑟夫（Josephus）环问题（c++单向循环链表实现）
hhyer的博客
03-14 1943
约瑟夫（Josephus）环问题： 编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一人开始重新从1报数，如此下去，直到所有人全部出列为止。建立n个人的单循环链表存储结构，运行结束后，输出依次出队的人的序号。 思路 将n个人的password依次输入，将每个人的id，password，next写入一个结构体，形成链表的
c++/c/java数据结构--队列
lljloimjo的博客
12-24 146
JDK中的Queue接口就是"队列"，它的实现类也都是队列，用的最多的是LinkedList。本部分介绍2种C++实现。：关于"队列的声明和实现都在头文件中"的原因，是因为队列的实现利用了C++模板，而"C++编译器不能支持对模板的分离式编译"。："运行结果" 以及 "主函数main的逻辑"都和"C语言实现一"的一样。2. Java实现二：Java的 Collection集合 中自带的"队列"(LinkedList)的示例。2. C++实现二：C++的 STL 中自带的"队列"(list)的示例。
C++数据结构与算法（单向链表）
鄠邑原野的博客
07-24 603
目录 1创建链表 1.1创建链表的顺序结构写法 1.2利用循环语句创建链表（正向创建） 1.3利用循环语句创建链表（逆向创建） 1.4改进写法 2删除节点 3增加节点 4查找节点 4.1链表查找元素的节点数或者按照节点查找数据域 4.2查找链表中的最值 5修改节点 6链表逆置 7删除链表中的最值 8链表排序 9链表合并 9.1将两个不同排序的链表进行升序排列 9....
《C++笔记 第二部分 数据结构及STL容器篇》第4章 队列C++模板实现及STL容器
不问归期的博客
09-04 460
4.1队列简介 4.1.1 队列的特点 队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点： 队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。 在队尾添加元素，在队头添加元素。 4.1.2 队列的相关概念 队头与队尾： 允许元素插入的一端称为队尾，允许元素删除的一端称为队头。 入队：队列的插入操作。 出队：队列的删除操作。 例如我们有一...
typedef struct _MSG { char code; char name[32]; char text[128]; }msg_t; typedef struct _NODE { struct sockaddr_in clientaddr; struct _NODE *next; }node_t; int create_node(node_t **phead); void do_login(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr); void do_chat(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr); void do_quit(node_t *phead,int sockfd,msg_t msg,struct sockaddr_in client_addr);
07-22
- `int create_node(node_t **phead)`：函数接受一个指向指针的参数 `phead`，用于创建一个新的链表节点，并将其添加到链表的头部。该函数返回一个整数类型的值。 - `void do_login(node_t *phead, int sockfd, msg_...
int create_node(node_t **phead){ *phead = (node_t *)malloc(sizeof(node_t)); memset (*phead,0,sizeof(node_t)); }
07-22
这段代码定义了一个名为 `create_node` 的函数，其返回类型为 `int`，并接受一个指向指针的指针 `phead` 作为参数。 函数的目的是创建一个新的节点，并将其地址存储在 `*phead` 所指向的指针中。在函数内部，首先...
智能工厂的程序设计 之 程序框架：三种API（用户U、客户C、服务S）的三个分层
ChuanfangChen的博客
09-12 1154
三种API (用户、客户、服务) 的三个层：隔离层（应用DIY的缺省点）-要“分离”，隐藏层（客户定制的缺失点）- 有“掩体” 和 防腐层（服务自动部署的缺陷点）-被“覆盖”。三者分别指向“程序”的所有三类“变点”（切点、埋点和插点）： 横切点（实践常识的关注点 -预设路径），竖埋点（ 科学方法的兴趣点--预埋管道）和 斜插点（理论偏序集的扩展点--预留位置）；这三类“程序”“变点”分别需要：一个领域驱动设计、一个微服务架构和 一个 灵活的模块化框架。
【初阶数据结构】详解栈和队列（来自知识星空的一抹流光）
tianxiawushanu的博客
09-06 1248
本文主要讲解了栈和队列这两种数据结构。它们的概念，以及代码的实现均在本文形成呈现，干货满满！！！
数据结构算法——排序算法
qq_73643693的博客
09-07 827
数据结构中的常见算法——排序算法
栈的内容..
2301_79724394的博客
09-09 190
持续更新，小手动一动，点个关注，谢谢！
【算法】冒泡排序
最新发布
想写博客却不会写，那能怎么办？抓紧练习咯！
09-12 218
冒泡排序是一种简单的排序算法，基本思想是通过重复遍历待排序的数列，比较相邻元素并交换它们的位置，以将较大（较小）的元素 “冒泡” 到数列的末端。最好的情况：O(n) ，此时说明我们的数据已经处于一个有序的状态。1、稳定性：即相等的元素在排序后仍保持原有的顺序性。2、简单：实先简单，易理解，不易使用在大型数据中。最坏和平均的情况：O(n的2次方)四、java代码示例。
数据结构之数组矩阵存储
zhj2003_的博客
09-12 221
数组在编程中是十分常用的一种数据结构，以后遇到的许多算法都会有它的身影，比如KMP算法定义next数组、其随机存取的特点可以用来排序、动态规划等问题。上述内容如果有错误的地方，希望大佬们可以指正。我一直在学习的路上，您的帮助使我收获更大！我也会不断更新文章！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千北@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值