数据结构之双链表（c语言附完整代码)

已于 2022-11-08 13:49:11 修改
阅读量2.1k 收藏 34
点赞数 8
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c语言 c++
于 2022-11-04 14:23:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62795460/article/details/127631745
版权

文章目录

一、定义

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。
示意图：
在这里插入图片描述

声明双链表

typedef struct DNode		//定义双链表结点类型
{
	ElemType data;           //数据域
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DLinkNode;

注意：本文章讨论的双链表是带头结点的双链表。
增加头结点的优点如下：
1.双链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。
2.无论双链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。

二、基本运算

在双链表中除了(建立双链表，插入元素，删除元素)，其余运算和单链表完全相同。

头插法建立双链表

void CreateListF(DLinkNode *&L,ElemType a[],int n)
//头插法建双链表
{
	DLinkNode *s;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;        //将头结点的前驱结点和后继结点均置为NULL
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL)
	        L->next->prior=s;
		L->next=s;
		s->prior=L;
	}
}

该运算依次从数组a中读取数据，生成一个新的结点，将该数据储放到新结点的数据域，然后将其插入到当前链表的表头（即头结点之后），直到所有的数据读完为止。
例如：数组 a={ 1,2,3,4 }，使用头插法得到的链表顺序为 4，3，2，1。
插入操作如下：

s->next=L->next;
if(L->next!=NULL)
    L->next->prior=s;
L->next=s;
s->prior=L;

首先修改s结点的后继指针next，使其指向头节点L的后继指针next所指结点，接着判断头结点L的后继指针next是否为NULL(此处等价于判断s结点的后继指针next是否为NULL),如果不为NULL,则修改s结点后继指针next所指结点的前驱指针prior，使其指向s，然后修改头结点的后继指针next，使其指向s结点，最后修改s结点的前驱指针prior，使其指向L。

本算法的时间复杂度为O（n）

尾插法建立双链表

void CreateListR(DLinkNode *&L,ElemType a[],int n)
//尾插法建双链表
{
	DLinkNode *s,*r;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
	r=L;					//r始终指向终端结点,开始时指向头结点
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=NULL;				//尾结点next域置为NULL
}

该运算依次从数组a中读取数据，生成一个新的结点，将该数据储放到新结点的数据域，然后将其插入到当前链表的表尾，直到所有的数据读完为止。其过程是设置一个指针r，让它始终指向当前链表的尾结点，每次插入一个新结点后，让r指向这个新结点，所有元素插入完后，将r所指结点(尾结点)的next域设置为NULL。

例如：数组 a={ 1,2,3,4 }，使用尾插法得到的链表顺序为 1，2，3，4。
插入操作如下：

r->next=s;
s->prior=r;
r=s;

首先修改r结点的后继指针next，使其指向s结点，然后再修改s结点的前驱指针prior，使其指向r结点，最后让r指向s结点。

本算法的时间复杂度为O（n）

初始化双链表

void InitList(DLinkNode *&L)
{
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
}

该运算建立一个空的双链表，其过程是创建一个头结点，并将其next域和prior域置为NULL。

本算法的时间复杂度为O（1）

销毁双链表

void DestroyList(DLinkNode *&L)
{
	DLinkNode *pre=L,*p=pre->next;
	while (p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}

该运算释放双链表L占用的内存空间，即逐一释放全部结点存储空间。设置p,pre两个指针指向两个相邻的结点，初始时pre指向头节点，p指向首结点(链表第一个元素)，当p不为NULL执行循环:先释放pre，然后pre，p同步后移一个结点。循环结束时，pre指向尾结点，再将其释放。

本算法的时间复杂度为O（n）

判断双链表是否为空表

bool ListEmpty(DLinkNode *L)
{
	return(L->next==NULL);
}

该运算判断双链表是否为空表，当头结点的next域为NULL时，表示链表为空，返回1，否则返回0。
本算法的时间复杂度为O（1）

求双链表的长度

int ListLength(DLinkNode *L)
{
	DLinkNode *p=L;
	int i=0;
	while (p->next!=NULL)
	{
		i++;
		p=p->next;
	}
	return(i);
}

该运算返回链表L中数据元素的个数，设置指针p(初始指向头节点)，i(初始值为0）用来记录链表中结点的个数，遍历链表，当p不为NULL时执行循环:i加1，p指向下一个结点。循环结束后返回i。
本算法的时间复杂度为O（n）

输出双链表

void DispList(DLinkNode *L)
{
	DLinkNode *p=L->next;
	while (p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

该运算逐一输出各结点的data域值，设置指针p(初始指向首结点)，p不为NULL执行循环:输出当前结点的数据域，p指向下一个结点。
本算法的时间复杂度为O（n）

求双链表中某个位置数据元素的值

bool GetElem(DLinkNode *L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L;
	if (i<=0) return false;		//i错误返回假
	while (j<i && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)
		return false;
	else
	{
		e=p->data;
		return true;
	}
}

该运算在双链表L中从开始找到第i个结点，如果存在第i个结点则将其data域值赋给e。设置指针p(初始指向头结点)，j(初始值为0)用来记录遍历过的结点个数，当j<i且p不为空时循环:j+1，p指向下一个结点。循环结束时有两种情况:如果p为NULL，表示单链表L中没有第i个结点(参数错误)，返回false;如果p不为NULL，表示找到第i个结点，将其data域值赋给e并返回true。
本算法的时间复杂度为O（n）

按元素的值查找

int LocateElem(DLinkNode *L,ElemType e)
{
	int n=1;
	DLinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		n++;
		p=p->next;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}

该运算在双链表中从头开始找到第一个data域值与e相等的结点，如果存在这样的结点，则返回逻辑序号，否则返回0。设置指针p(初始指向首结点)，i(初始值为1)，当p不为NULL且p结点的data域值不等于e时执行循环:p指向下一个结点，i加1。循环结束时有两种情况:如果p=NULL,表示不存在值为e的结点，返回0;否则表示存在值为e的结点，返回其逻辑序号i。
本算法的时间复杂度为O（n）

插入数据元素

bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (i<=0) 
	    return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;	
		s->next=p->next;		//将结点s插入到结点p之后
		if (p->next!=NULL) 
			p->next->prior=s;
		s->prior=p;
		p->next=s;
		return true;
	}
}

该运算在双链表第i个结点前插入值为e的结点。
实现过程是先在双链表L中找到第i-1个结点，用p指向它。如果存在这样的结点，将值为e的结点(指针s所指结点)插入到p结点的后面。设置指针p(初始指向头结点)，i(初始值为0)，当j<i-1且p为NULL时执行循环:j加1，p指向下一个结点。循环结束时有两种情况:如果p为NULL，表示未找到第i-1个元素(参数错误)，返回false;否则表示找到第i-1个结点，创建新结点s并将其data域值置为e，将结点s插入到结点p之后，最后返回true。
插入操作如下：

s->next=p->next;
if(p->next!=NULL)
    p->next->prior=s;
s->prior=p;
p->next=s;

此处插入操作与头插法建立双链表的插入操作相同(头插法建立双链表时的插入操作相当于把s结点插入到头结点L之后),此处是把s结点插入到p结点之后。
本算法的时间复杂度为O（n）
动画演示：
在这里插入图片描述

删除数据元素

bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L,*q;
	if (i<=0) return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		q=p->next;				//q指向要删除的结点
		if (q==NULL) 
			return false;		//不存在第i个结点
		e=q->data;
		p->next=q->next;		//从单链表中删除*q结点
		if (p->next!=NULL)
		    p->next->prior=p;
		free(q);				//释放q结点
		return true;
	}
}

该运算删除双链表L中第i个结点，并将其data域值赋给e。实现过程是先在双链表中找到第i-1个结点，用p指向它。如果存在这样的结点，且存在后继结点(q所指结点)，则删除q所指结点。设置指针p(初始指向头结点)，j(初始值为0)，当j<i-1执行循环:j加1，p指向下一个结点。当循环结束时有两种情况:如果p为NULL,表示未找到第i-1个结点(参数错误)，返回false;否则表示找到第i-1个结点，用q指向第i个结点，如果q为NULL,则表示不存在第i个结点(参数错误)返回false，如果q不为NULL,则表示存在第i个结点，删除q结点，返回true。
删除操作如下：

p->next=q->next;
if(q->next!=NULL)
     q->next->prior=p;

首先修改p结点的后继指针next，使其指向q结点的后继指针next所指的结点，然后判断q结点的后继指针next是否为NULL(此处等价于判断s结点的后继指针next是否为NULL),如果不为NULL,则修改q结点的后继指针next所指结点的前驱指针prior，使其指向p结点。
本算法的时间复杂度为O（n）
动画演示：
在这里插入图片描述

三、完整代码

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct DNode		//定义双链表结点类型
{
	ElemType data;
	struct DNode *prior;	//指向前驱结点
	struct DNode *next;		//指向后继结点
} DLinkNode;
void CreateListF(DLinkNode *&L,ElemType a[],int n)
//头插法建双链表
{
	DLinkNode *s;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
		if (L->next!=NULL) 
		   L->next->prior=s;
		L->next=s;
		s->prior=L;
	}
}
void CreateListR(DLinkNode *&L,ElemType a[],int n)
//尾插法建双链表
{
	DLinkNode *s,*r;
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
	r=L;					//r始终指向终端结点,开始时指向头结点
	for (int i=0;i<n;i++)
	{	
		s=(DLinkNode *)malloc(sizeof(DLinkNode));//创建新结点
		s->data=a[i];
		r->next=s;s->prior=r;	//将结点s插入结点r之后
		r=s;
	}
	r->next=NULL;				//尾结点next域置为NULL
}
void InitList(DLinkNode *&L)
{
	L=(DLinkNode *)malloc(sizeof(DLinkNode));  	//创建头结点
	L->prior=L->next=NULL;
}
void DestroyList(DLinkNode *&L)
{
	DLinkNode *pre=L,*p=pre->next;
	while (p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}
bool ListEmpty(DLinkNode *L)
{
	return(L->next==NULL);
}
int ListLength(DLinkNode *L)
{
	DLinkNode *p=L;
	int i=0;
	while (p->next!=NULL)
	{
		i++;
		p=p->next;
	}
	return(i);
}
void DispList(DLinkNode *L)
{
	DLinkNode *p=L->next;
	while (p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
bool GetElem(DLinkNode *L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L;
	if (i<=0) 
	   return false;		//i错误返回假
	while (j<i && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)
		return false;
	else
	{
		e=p->data;
		return true;
	}
}
int LocateElem(DLinkNode *L,ElemType e)
{
	int n=1;
	DLinkNode *p=L->next;
	while (p!=NULL && p->data!=e)
	{
		n++;
		p=p->next;
	}
	if (p==NULL)
		return(0);
	else
		return(n);
}
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
	int j=0;
	DLinkNode *p=L,*s;
	if (i<=0) 
	   return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		s=(DLinkNode *)malloc(sizeof(DLinkNode));	//创建新结点s
		s->data=e;	
		s->next=p->next;		//将结点s插入到结点p之后
		if (p->next!=NULL) 
			p->next->prior=s;
		s->prior=p;
		p->next=s;
		return true;
	}
}
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
	int j=0;
	DLinkNode *p=L,*q;
	if (i<=0) 
	   return false;		//i错误返回假
	while (j<i-1 && p!=NULL)
	{
		j++;
		p=p->next;
	}
	if (p==NULL)				//未找到第i-1个结点
		return false;
	else						//找到第i-1个结点p
	{
		q=p->next;				//q指向要删除的结点
		if (q==NULL) 
			return false;		//不存在第i个结点
		e=q->data;
		p->next=q->next;		//从单链表中删除*q结点
		if (p->next!=NULL) p->next->prior=p;
		free(q);				//释放q结点
		return true;
	}
}
int main()
{
	DLinkNode *L;
	ElemType e;
	ElemType a[]={1,2,3,4};
	CreateListF(L,a,4);        //尾插法建立链表 
	printf("尾插法所得顺序为: ");
	DispList(L);
	DestroyList(L);
	CreateListR(L,a,4);        //头插法建立链表 
	printf("头插法所得顺序为：");
	DispList(L);
	printf("链表的长度为:%d\n",ListLength(L));
	ListInsert(L,4,5);          //在链表第四个元素前插入5 
	printf("插入一个元素后链表的元素为:");
	DispList(L);
	ListDelete(L,1,e);          //删除链表中第一个元素，并将它的值赋给e 
	printf("删除的元素为:%d\n",e);
	printf("删除一个元素后链表的元素为:");
	DispList(L);
	printf("当前链表是否为空:%d\n",ListEmpty(L));
	GetElem(L,1,e);
	printf("链表第一个元素为:%d\n",e);
	printf("值为2的元素在链表中的位置为:%d\n",LocateElem(L,2));
	return 0;
}

参考资料：
李春葆《数据结构教程》（第五版）

hello_world&&
关注
  • 8
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数据结构之双向链表（C语言实现）
qq_57312085的博客
08-04 624
双向链表的几种插入，删除，指定位置输出 双向链表的长相 双向链表由前驱指针和后项指针还有数据域组成，把节点之间的前后指针相连接形成链表 双向链表节点的封装 双向链表与单链表相比，仅多了一个前驱指针 typedef struct Node { int data;//内容 struct Node* frontNode;//前驱指针 struct Node* nextNode;//后项指针 }*LPNODE; 双向链表的特点在于可以从左到右，也可以从右到左输出链表，因此.
【数据结构】之 链表 带头双向循环 （C语言）（含完整代码）
weixin_53936115的博客
12-30 1164
1、基本概念： 带头双向循环链表：一个节点有两个指针，一个指向前一个节点（前指针）一个指向下一个节点（后指针）；有一个头结点，该节点不存储如何值，头结点的前指针指向该链表的最后一个节点。最后一个节点的后指针指向头结点。 基本逻辑结构： 2、代码实现 2.1 准备工作： 首先对头文件的引用和创建一个结构体。这个结构体就是链表的节点，一个节点包含数据项和两个指针项，一个指针指向前一个节点的地址，另一个指针指向下一个节点的地址。DLNode* phead=NULL表示创建一个节点的指...
C语言数据结构之双向循环链表的实例
12-31
数据结构之双向循环链表 实例代码： #include #include #include typedef struct Node{ struct Node *pNext; int data; struct Node *prior; } NODE,*PNODE; PNODE CreatList(); void TreNode(PNODE pHead); bool isEmpty(PNODE pHead); int getCount(PNODE pHead); bool insertNode (PNODE pHead,int
数据结构---线性表之双链表（C语言）
03-29
数据结构---线性表之双链表，创建、插入、删除，完整的C代码
C语言：双链表
最新发布
2301_81214535的博客
06-09 1020
让我们一起在编程的道路上不断前行，创造更加美好的未来！
C语言-双向链表
qq_64831425的博客
02-25 882
C语言-双链表
【数据结构】C语言实现双链表
weixin_44104992的博客
07-31 542
C语言实现双链表
数据结构：双向链表
m0_62600887的博客
05-03 435
照搬代码 #include <stdio.h> #include <malloc.h> /** * Double linked list of integers. The key is char. */ typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; } DLNode, *DLNodePtr; /
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
【C语言数据结构】双链表详解（带头双向循环链表）
谁在夜里看海.的博客
04-05 2241
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2610
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
C语言中数据结构之链表归并排序实例代码
08-30
C语言中数据结构之链表归并排序实例代码 本文主要介绍了C语言中数据结构之链表归并排序实例代码的相关知识点，通过对链表归并排序的实现，帮助读者深入了解链表数据结构的应用。 一、链表数据结构 链表是一种常用...
C语言 数据结构双向链表简单实例
08-31
C语言数据结构双向链表简单实例 本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构...
C语言 数据结构之链表实现代码
09-01
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据管理。与数组不同，链表的元素不是在连续的内存空间中存储，而是通过指针链接在一起。链表分为多种类型，如单链表、双向链表、循环链表等。本文...
【数据结构--双链表】
qq_61719813的博客
05-04 3371
文章目录双向链表双向链表的定义双向链表的存储结构双向链表的初始化双向链表的插入双向链表的删除寻找尾结点正向打印反向打印链表节点的读取测试运行截图完整代码闵版代码（略改）总结 双向链表 双向链表的定义 什么是双向链表？ 双向链表顾名思义，就是链表由单向的链变成了双向链。双向链表(double linked list)是在单链表的每个结点中再设置一个指向其前驱结点的指针域。 非空带头结点的双向链表 双向链表的存储结构 //双链表节点结构体 typedef struct DoubleLinkNode {
数据结构-双向链表（C语言）
usiehheu的博客
05-03 1717
文章目录1、双向链表的定义2、双向链表的初始化3、双向链表的打印4、双向链表的插入5、双向链表的删除6、双向链表的元素定位7、链表清空8、测试二、完整代码 1、双向链表的定义 双向链表是链表的一种，与单链表不同的shi，它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。 typedef struct DoubleLinkNode { char data; struct DoubleLink
C语言双向链表的实现
m0_63666616的博客
05-03 4736
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
C语言算法基础——双向链表的实现代码
weixin_52109967的博客
07-22 648
菜鸟日常学习算法的总结！
双链表（数据结构）
qq_75132460的博客
05-16 595
一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是。，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。，一般不会单独用来存数据。，后面我们代码实现了就知道了。哨兵位即为head；1.单向带头循环链表。4.单向不带头非循环。8.双向不带头非循环。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

hello_world&&

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

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

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

打赏作者

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

抵扣说明：

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

余额充值