脚踏实地《数据结构第二章》第三节：单链表

最新推荐文章于 2024-05-11 12:35:00 发布
最新推荐文章于 2024-05-11 12:35:00 发布
阅读量1.1k 收藏 8
点赞数 1
分类专栏： # 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuggjggg/article/details/122501068
版权

一：定义与本节概览

在这里插入图片描述
在这里插入图片描述

二：用代码定义单链表

在这里插入图片描述
在这里插入图片描述

代码定义：

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

上面定义的代码等价于下面的代码：

struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
};
typedef struct LNode LNode;
typedef struct LNode *LinkList;

在这里插入图片描述
举例：

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;
LNode * GetElem(LinkList L, int i){
	int j=1;
	LNode *p = L->next;
	if(i==0)
		return L;
	if(i<1)
		return NULL;
	while(p!=NULL && j<i){
		p=p->next;
		j++;
	}
	return p;
}

强调这是一个单链表 ——使用LinkList 强调这是一个结点 ―—使用LNode *

在这里插入图片描述

2.1 不带头结点的单链表

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;
//初始化一个空的链表
bool InitList(LinkList &L){
	L = NULL;//空表，暂时还没有任何结点(防止脏数据)
	return true;
}
void test(){
	LinkList L;//声明一个指向单链表的指针，在这个地方并没有创建一个结点
	//初始化一个空表
	InitList(L);5
	// ......后续代码......
}
//判断单链表是否为空
bool Empty(LinkList L){
	if(L == NULL)
		return true;
	else
		return false;
}
//或者是
bool Empty(LinkList L){
	return (L==NULL);
}

在这里插入图片描述

2.2 带头结点的单链表

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;
//初始化一个空的链表
bool InitList(LinkList &L){
	L = (LNode *)malloc(sizeof(LNode));//分配一个头结点
	if(L==NULL)//内存不足，分配失败
		return false;
	L->next = NULL;//头结点之后暂时还没有节点
	return true;
}
void test(){
	LinkList L;//声明一个指向单链表的指针，在这个地方并没有创建一个结点
	//初始化一个空表
	InitList(L);5
	// ......后续代码......
}
//判断单链表是否为空(带头节点)
bool Empty(LinkList L){
	if(L->next == NULL)
		return true;
	else
		return false;
}

在这里插入图片描述

2.3 对比

在这里插入图片描述

分析：

  1. 不带头结点的话，头指针所指向的下一个结点，这个结点就是用于实际存放数据的结点
  2. 带头结点的话，头指针所指向的下一个结点（头结点），这个结点（头结点）是不存放实际的数据元素的，只有这个头结点之后的下一个结点才会用于存放数据

三：知识回顾重要考点

在这里插入图片描述
typedef关键字――数据类型重命名

四：单链表的插入

在这里插入图片描述

Listlnsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。
需求：

  1. 找到第i-1个结点,将新结点插入其后

4.1 按位序插入（带头结点）

在这里插入图片描述

4.1.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//在第i 个位置插插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
	if(i<0)//因为是位序（从1开始），如果小于1的话，就不合法
		return false;
	LNode *p;//指针p指向当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p = L;//L指向头结点,头结点是第0个结点(不存数据)
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL)//i值不合法，当i的值大于链表的长度时
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next=p->next;//这一端和代码和下一行的代码不能颠倒，颠倒后s的next会指向自己
	p->next=s;//将结点s连到p之后
	return true;//插入成功
}

4.1.2 时间复杂度

最好时间复杂度：O(1)
最坏时间复杂度：O(n)
平均时间复杂度：O(n)

4.2 按位序插入（不带头结点）

在这里插入图片描述

4.2.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//在第i 个位置插插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
	if(i<1)
		return false;
	//如果不带头结点,则插入、删除第1个元素时，需要更改头指针L
	if(i==1){//插入第1个结点的操作与其他结点操作不同
		LNode *s = (LNode *)malloc(sizeof(LNode));//新建一个结点
		s->data = e;
		s->next=L;
		L=s;//头指针指向新结点
		return true;
	}
	LNode *p;//指针p指向当前扫描到的结点
	int j=1;//当前p指向的是第几个结点
	p = L;//L指向头结点,头结点是第0个结点(不存数据)
	while(p!=NULL && j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL)//i值不合法，当i的值大于链表的长度时
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next=p->next;//这一端和代码和下一行的代码不能颠倒，颠倒后s的next会指向自己
	p->next=s;//将结点s连到p之后
	return true;//插入成功
}

结论:不带头结点写代码更不方便，推荐用带头结点注意:考试中带头、不带头都有可能考察，注意审题

4.2.2 时间复杂度

4.3 指定结点的后插操作

4.3.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//后插操作:在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)//i值不合法，当i的值大于链表的长度时
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL)//内存分配失败
		return false;
	s->data = e;
	s->next=p->next;//这一端和代码和下一行的代码不能颠倒，颠倒后s的next会指向自己
	p->next=s;//将结点s连到p之后
	return true;//插入成功
}

4.3.2 时间复杂度

时间复杂度：O(1)

4.3.3 简化4.2.2和4.2.1之中的代码

在这里插入图片描述

4.4 指定结点的前插操作

4.4.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//前插操作:在p结点之前插入结点s
bool InsertPriorNode (LNode *p, LNode *s){
	if(p==NULL !! s==NULL)
		return false;
	s->next=p->next;
	p-next=s;//s连到p之后
	ElemType temp=p->data;//交换数据域部分
	p->data=s->data;
	s->data=temp;
	return true;
}

在这里插入图片描述

4.4.2 时间复杂度

时间复杂度：O(1)

五：单链表的删除

ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

5.1 按位序删除（带头结点)

在这里插入图片描述

5.1.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//将删除的元素的内容存放到e中，因为e是引用数据类型
bool ListDelete(LinkList &L, int i, ElemType &e){
	if(i<1)
		return false;
	LNode *p;//指针p指向当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p = L;//L指向头结点，头结点是第0个结点(不存数据)
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL)//i值不合法
		return false;
	if(p->next ==NULL)//第i-1个结点之后已无其他结点
		return false;
	LNode *q = p->next;//令q指向被删除结点
	e = q->data;//用e返回元素的值
	p->next = q->next;//将*q结点从链中“断开”
	free(q);//释放结点的存储空间
	return true;//删除成功

}

5.2.2 时间复杂度

最坏、平均时间复杂度:O(n)
最好时间复杂度:O(1)

5.2 删除指定结点

5.2.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;


//删除指定结点p
bool DeleteNode(LNode *p){
	if(p->next ==NULL)//第i-1个结点之后已无其他结点
		return false;
	LNode *q = p->next;//令q指向被删除结点
	p->data=p->next->data;//和后继结点交换数据域
	p->next = q->next;//将*q结点从链中“断开”
	free(q);//释放结点的存储空间
	return true;//删除成功
}

问题：如果要删除的结点是最后的一个结点，那么就会出现问题，因为p->data=p->next-data会出错
在这里插入图片描述

5.2.2 时间复杂度

时间复杂度：O(1)

六：知识回顾与重要考点

在这里插入图片描述

七：单链表的查找(带头结点)

在这里插入图片描述

7.1 按位查找

7.1.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;



//按位查找，返回第i 个元素（带头结点)
LNode * GetElem(LinkList L, int i){
	if(i<0)
		return NULL;
	LNode *p;//指针p指向当前扫描到的结点
	p = L;//当前p指向的是第几个结点
	int j=0;//L指向头结点，头结点是第0个结点(不存数据)
	while(p!=NULL && j<i){//循环找到第i 个结点
		p=p->next;
		j++;
	}
	return p;
}

7.1.2 时间复杂度

平均时间复杂度：O(n)

7.1.3 对之前的删除插入代码进行封装

在这里插入图片描述

7.2 按值查找

7.2.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;



//按值查找，找到数据域==e 的结点
LNode * LocateElem(LinkList L, ElemType e){
	LNode *p = L->next;
	while(p != NULL && p->data != e)//从第1个结点开始查找数据域为e的结点
		p = p->next;
	return p;//找到后返回该结点指针，否则返回NULL
}

7.2.2 时间复杂度

平均时间复杂度：O(n)

7.3 求表的长度

7.2.1 实现代码

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;



//求表的长度
int Length(LinkList L){
	int len = 0;//统计表的长度
	LNode *p = L;
	while(p->next != NULL){
		p = p->next;
		len++;
	}
	return len;
}

7.2.2 时间复杂度

平均时间复杂度：O(n)

八：知识回顾与重要考点

在这里插入图片描述

九：单链表的建立

在这里插入图片描述

9.0 初始化带头结点的单链表

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//初始化一个单链表(带头结点)
bool InitList(LinkList &L){
	L = (LNode *)malloc(sieof(LNode));//分配一个头结点
	if(L==NULL)//内存不足，分配失败
		return false;
	L->next = NULL;//头结点之后暂时还没有节点
	return true;
}
void test(){
	LinkList L;//声明一个指向单链表的指针
	//初始化一个空表InitList(L);
	InitList(L);
	//......后续代码......
}

9.1 尾插法

9.1.1 方法一实现

//在第i个位置插插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
	if(i<1)
		return false;
	LNode *p;//指针p指向当前扫描到的结点
	int j=0;//当前p指向的是第几个结点
	p = L;//L指向头结点，头结点是第0个结点(不存数据)
	while(p!=NULL && j<i-1){//循环找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL)//i值不合法
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;//将结点s连到p之后
	return true;//插入成功
}

时间复杂度
平均时间复杂度：O(n^2)

在这里插入图片描述

9.1.2 方法二实现

//后插操作:在p结点之后插入元素e

//后插操作:在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)//i值不合法，当i的值大于链表的长度时
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL)//内存分配失败
		return false;
	s->data = e;
	s->next=p->next;//这一端和代码和下一行的代码不能颠倒，颠倒后s的next会指向自己
	p->next=s;//将结点s连到p之后
	return true;//插入成功
}

9.1.3 方法三实现（实际核心代码）

LinkList List_TailInsert(LinkList &L){//正向建立单链表
	int x;//设ElemType为整型
	L=(LinkList)malloc(sizeof(LNode));//建立头结点
	LNode *s,*r=L;//r为表尾指针
	scanf("%d",&x);//输入结点的值
	while(x!=9999){//输入9999表示结束
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;//r指向新的表尾结点
		scanf("%d",&x);
	}
	r->next=NULL;//尾结点指针置空
	return L;
}

时间复杂度
平均时间复杂度：O(n)

在这里插入图片描述

9.2 头插法

9.2.1 实现方式二后插操作

typedef struct LNode{//定义单链表结点类型
	ElemType data;//每个节点存放一个数据元素
	struct LNode *next;//指针指向下一个节点
}LNode,*LinkList;

//后插操作:在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)//i值不合法，当i的值大于链表的长度时
		return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	if(s==NULL)//内存分配失败
		return false;
	s->data = e;
	s->next=p->next;//这一端和代码和下一行的代码不能颠倒，颠倒后s的next会指向自己
	p->next=s;//将结点s连到p之后
	return true;//插入成功
}

9.2.2 实现代码方式一（实际核心代码）

LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));//建立头结点
	L->next=NULL;//初始为空链表，如果不执行这段代码的话，L就可能会指向内存其他的区域
	scanf("%d",&x);//输入结点的值
	while(x!=9999){//输入9999表示结束
		s=(LNode *)malloc(sizeof(LNode));//创建新结点
		s->data=x;
		s->next=L->next;
		L->next=s;//将新结点插入表中，L为头指针
		scanf("%d",&x);
	}
	return L;
}

在尾插法中，最好也将其初始为空链表
在这里插入图片描述

在这里插入图片描述

十：知识回顾与考点

重要考点：链表的逆置
在这里插入图片描述

?abc!
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
汽车行业：智能驾驶深度报告：仰望天空与脚踏实地.pdf
07-02
汽车行业：智能驾驶深度报告：仰望天空与脚踏实地.pdf
数据结构3— —单链表(定义、两种实现方式)
qq_43581971的博客
09-17 471
0.线性表存储/物理结构 1）顺序表（顺序存储结构） 2）链表（链式存储） 1.单链表 1）定义 2）代码实现 3）两种实现方式 0.线性表存储/物理结构 1）顺序表（顺序存储结构） 优：随机存取，存储密度高 缺：容量不可变、需要大片连续空间 2）链表（链式存储） 单链表 双链表 循环链表 静态链表 1.单链表 1）定义 用“链式存储（存储结构）”实现“线性结构（逻辑结构）” 一个结点存储一个数据元素 各结点间的先后关系用一个指针表示 2）代码实现 struct LNode{ //定义单链表结
数据结构部分__2、链表的定义及其操作的实现
Themess的博客
05-11 222
1、单链表的定义： typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; LNode表示节点，LinkList指针可以理解为链表，data数据域，next指针域。 2、头插法： LinkList headinsert(LinkList &L) { L=(LinkList)malloc(sizeof(LNode)); L->next=NULL; int x;
脚踏实地《数据结构第二章》第五节：循环链表
учёба
03-05 682
一：定义 二：循环单链表 2.1 初始化代码 typedef struct LNode{//定义单链表结点类型 ElemType data;//每个节点存放一个数据元素 struct LNode *next;//指针指向下一个节点 }LNode, *LinkList; //初始化一个循环单链表 bool InitList(LinkList &L){ L = (LNode *)malloc(sizeof(LNode));//分配一个头结点 if(L==NULL)//内存不足，分配失败
脚踏实地《数据结构第三章栈和队列》第一节：栈
учёба
03-27 1577
脚踏实地，2023战考场 本节常考题型 栈 问题一：有那些合法的出栈顺序?总数 进栈和出栈交替进行的话，就有上图中这么多的出栈顺序 一：栈的基础概念 1.1 栈（Stack）的基本概念（定义） 栈( Stack）：是只允许在一端进行插入或删除操作的线性表 生活中：烤串、叠碗等 一些术语：如图所示 栈顶：允许插入和删除的一端 栈底：不允许插入和删除的一端 栈顶元素 栈底元素 空栈 特点：后进先出 1.2 栈的基本操作 InitStack(&S)：初始化栈。构造一个空栈S，分配内存空间。创
九年级政治 第三站脚踏实地拥抱明天教案 北师大版.doc
11-16
九年级政治 第三站脚踏实地拥抱明天教案 北师大版.doc
20210527-国联证券-汽车行业智能驾驶深度报告：仰望天空与脚踏实地.pdf
05-28
20210527-国联证券-汽车行业智能驾驶深度报告：仰望天空与脚踏实地.pdf
汽车行业：智能驾驶深度报告：仰望天空与脚踏实地.zip
10-16
汽车行业：智能驾驶深度报告：仰望天空与脚踏实地
202110-元宇宙：仰望星空和脚踏实地.pdf
12-13
202110-元宇宙：仰望星空和脚踏实地.pdf
数据结构第一次实验
qq_75125305的博客
05-07 171
【代码】数据结构第一次实验。
【C 数据结构-动态内存管理】3. 伙伴系统管理动态内存
普罗米修斯的博客
05-07 821
2m2021222m。
拓扑排序——数据结构
2301_79629384的博客
05-08 291
拓扑排序的本质是这样的：你有一堆任务或者课程，某些任务必须在其他任务之前完成，就像先去健身再去约会，这样你看起来更加帅气迷人。在拓扑排序中，每个任务或者课程都是图中的一个节点，而某个任务依赖另一个任务的关系，就用有向边来表示。就像精心策划一场约会，了解每一步的逻辑和顺序，才能确保一切按部就班，避免任何尴尬的等待或冲突。拓扑排序是对有向无环图（DAG）的顶点进行线性排序的方法。关键在于每个顶点代表了一个任务，而每条有向边代表了任务间的先后依赖关系。这个排序保证了每个任务只在它依赖的任务完成后才开始。
C#[数据结构]之数组
beenles的博客
05-07 943
数组是由相同类型的元素按顺序存储在一段连续的内存空间中而构成的数据结构。数组的长度是固定的，一旦定义后，其长度通常不可改变。数组是一种线性数据结构，元素通过索引（index）访问，索引通常从 0 开始递增。
【高阶数据结构】并查集 {并查集原理；并查集优化；并查集实现；并查集应用}
芥末虾的博客
05-07 468
【高阶数据结构】并查集 {并查集原理；并查集优化；并查集实现；并查集应用}
【数据结构陈越版笔记】第1章 概论
最新发布
随手写写
05-11 996
陈姥姥的书里讲的定义挺通俗易懂的，我这里直接把严蔚敏书的定义拿过来数据：数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。数据元素：数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。数据对象：数据对象是性质相同的数据元素的集合，是数据的一个子集。例如，整数数据对象是集合N0±1±2⋯N0±1±2⋯数据结构：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。通常有4类基本结构“集合。
数据结构--顺序表和链表的区别
zy1215058242的博客
05-10 343
顺序表和链表之间各有优劣，我们不能以偏概全，所以我们在使用时要关注任务的注重点，以此来确定我们要使用两者中的哪一个。
数据结构 第七章 图（一）
2401_84080967的博客
05-07 1268
图由顶点和边组成，所以我们在表示一个图的时候，使用GVEG=(V,E)GVE，来表示一个G图，其中的V表示G图中的顶点，E表示G图中的边；对于G图中顶点和边的表示就是采用集合的形式来表示，Vv1v2v3⋅⋅⋅⋅Vv1​v2​v3​⋅⋅⋅⋅，同样的对于边E也可以采用集合来表示出来；同时图的顶点集不可以为空，图的边集可以为空，每一条线都要连接两个节点。
Redis5.0的Stream数据结构
IT深耕十余载，大道之简
05-11 270
它以一个有序的、不断增长的日志序列来存储事件流数据。每个事件都是一个包含多个字段的消息，它们被追加到Stream的末尾。Redis 5.0中引入的Stream数据结构是一种新的、持久化的、可查询的、可扩展的消息队列服务。它可以被视为一个日志或消息队列，由一个有序的、不断增长的日志序列来存储事件流数据。其中，键表示消息的唯一标识（通常是一个递增的序列号），值标识消息的内容。这些命令为开发者提供了丰富的操作手段，使得Stream数据结构可以方便地应用于各种场景，如实时消息传递、事件溯源、分布式日志记录等。
脚踏开关 footswitch:设置程序及教程.zip
08-05
脚踏开关（footswitch）是一种用脚步操作的开关装置，常用于各种设备和仪器的控制功能上。"设置程序及教程.zip"是一个文件，可能包含了脚踏开关的程序设置和使用教程。 这个文件中可能包含了一些软件或固件程序，用于配置和控制脚踏开关的各种功能。通过这些程序，用户可以设置脚踏开关的各种操作模式、输入输出配置、信号处理等参数。在使用脚踏开关之前，用户需要安装并配置这个程序。 同时，这个文件中可能还包含了脚踏开关的使用教程。教程可能提供了使用脚踏开关的基本操作说明和注意事项，以及一些示例应用方法和常见问题解答。通过学习这些教程，用户可以更好地理解脚踏开关的使用方法，避免一些常见错误和困惑。 总之，"设置程序及教程.zip"文件提供了脚踏开关的程序配置和使用指南。用户可以通过安装和配置这些程序，以及学习使用教程，更好地掌握脚踏开关的功能和操作方法。这样就能更高效地利用脚踏开关，满足各种设备和仪器的控制需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

?abc!

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

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

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

打赏作者

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

抵扣说明：

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

余额充值