线性表(逻辑结构)--链表(存储结构)

最新推荐文章于 2023-03-09 23:19:22 发布
最新推荐文章于 2023-03-09 23:19:22 发布
阅读量808 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39280437/article/details/118735022
版权

链表

单链表

每个节点除去存放数据元素外，还需存储指向下一个节点的指针

定义

struct LNode{
	ElementType data;
	struct LNode *next;
};

//增加一个新的节点，在内存中申请新的节点所需要的空间，并用指针P指向这个节点
struct Lnode *p = (struct LNode *)malloc(sizeof(struct LNode));

//用typedef实现结构体的重命名，方便声明结构体类型的节点
typedef struct LNode LNode;
typedef struct Lnode *LinkList;
//后续声明只需要用LNode来代替struct LNode
LNode *p = (LNode *)malloc(sizeof(LNode));	

//上面两步也可以合并来完成
typedef struct LNode{
	EleType data;
	struct LNode *next;
}LNode,*LinkList;
//其中LNode是结构体类型，LinkList是指针类型
Lnode *p = (LNode *)malloc(sizeof(LNode));
LinkList q = (LinkList)malloc(sizeof(Lndoe));

LNode和LinkList本质上只是结构体类型和结构体的指针类型，但在使用时可以用LNode表示节点，用LinkList表示单链表更容易逻辑清晰。

例如在实现获取链表中第i个元素的函数中

//返回类型为LNode *突出返回的是一个节点
//入参类型LintList强调传入的是单链表
LNode *GetElementInLinkList(LinkList L,int i){
	if(i < 1)
		return NULL;
	else if(i = 1)
		return L;
	else
	{
		LNode *p = L;
		for(int j = 0;j < i&&p!=NULL;j++){
			p = p -> next;
		}
		return p;
	}
}

实现

不带头节点

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;

//初始化一个空的链表
bool InitList(LinkList &L){
	L = NULL;
	return true;
}

带头节点

带头结点可以用相同的代码逻辑处理第一个数据点和后续的数据点

typedef struct LNode{
	int data;
	struct LNode *next;
}Lnode, *LinkList;

//初始化一个单链表（带头节点）
bool InitList(LinkList &L){
	L = (LNode)malloc(sizeof(LNode));
	if(L == NULL)
		return false;//malloc分配内存空间失败
	L -> next = NULL;
	return ture; 
}

基本操作的实现

插入

按位序插入
  • 带头节点
  • 不带头节点

在第i个位置插入指定的元素e

//带头节点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,int e){
	LNode *p;
	p = L;//p指向L指向的地址
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	}
	if(p == NULL)
		return false;
	LNode *q =(LNode)malloc(sizeof(Lnode));
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}

上述代码没有改变L的指向，传入指针的地址看起来是危险且复杂的，做如下修改

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList p,int i,int e){
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	} 
	if(p == NULL)
		return false;
	LNode *q =(LNode)malloc(sizeof(Lnode));
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}

这样做减少了用到的变量，且不用进行结构体指针的地址运算。
时间复杂度非常容易得出
最小O(1)
最大O(n)
平均O(n)
当不带头节点时，NodeList的指向是可能发生变化的，所以需要传入指针的地址改变其指向

//不带头节点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L,int i,int e){
	if(i == 1){
		LNode *h = (LNode *)malloc(sizeof(LNode));
		if(h == NULL)
			return false;
		h -> data = e;
		h -> next = L;
		&L = &h;
		return true;
	}
	LNode *p;
	p = L;//p指向L指向的地址
	if(i < 1)
		return false;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		p = p -> next;
	}
	if(p == NULL)
		return false;
	LNode *q =(LNode *)malloc(sizeof(Lnode));
	if(q ==NULL)
		return false;
	q -> data = e;
	q -> next = p -> next;
	p -> next = q;
	return true;
}
指定节点的后插操作
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
//在p节点后插入
bool InsertNextNode(LNode *p,int e){
	if(p == NULL)
		return false;
	LNode *s = (LNode *)(malloc(sizeof(LNode));
	s -> data = e;
	s -> next = p -> next;
	p -> next = s;
	return true;
}
//
指定节点的前插操作

如果用在节点的前驱节点后插入的想法去实现，就会使实现非常困难，在此用到一个非常巧妙的方法，值交换

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
//在p节点前插入(先后插再交换值)
bool InsertNextNode(LNode *p,int e){
	if(p == NULL)
		return false;
	LNode *s = (LNode *)(malloc(sizeof(LNode));
	s -> next = p ->next;
	p -> next = s;
	s -> value = p;
	p -> value = e;
	return true;
}

删除

按位序删除
//按位序删除（带头节点）
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
bool Delete(LinkList L,int i,int &e){
	if(i < 1)
		return false;
	for(int j = 0; j < i - 1 && L != NULL; j++){
		L = L->next;
	}
	if( L == NULL)
		return false;
	LNode p = (LNode *)malloc(sizeof(LNode));
	p = L -> next;
	if( p == NULL)
		return false;
	e = p -> data;
	L -> next = p -> next;
	free(p);
	return true;
}
指定节点的删除
typedef struct LNode{
	ElementType data;
	struct LNode;	
}LNode,*LinkList;
bool Delete(LNode *p){
	LNode *q = p -> next;
	if(*q == NULL){
		free(p);
		return true;
	}	
	p -> data = q -> data;
	p -> next = q -> next;
	free(q);
	return true;
}

查找

按位查找
typedef struct LNode{
	elementType data;
	struct LNode *next;
}LNode, *LinkList;
//按位查找，返回第i位元素（带头节点）
LNode *GetElem(LinkList L,int i){
	if( i < 1 )
		return NULL;
	for(int j = 0;j < i - 1 && L != NULL;j++){
		L = L -> next;
	}
	return  L;
}
按值查找
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
LNode *GetElem(LinkList L,int e){
	for(;L != NULL&& L -> data != e;L = L->next);
	return L;
}

求表长

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

//带头节点
int Length(LinkList L){
	int len = 0;
	for(;L -> next != NULL;len ++);
	return len; 
}

建立

尾插法
typedef struct LNode{
	int 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;
}

//后插法带头节点不初始化
LinkList ListTailInsert(LinkList L){
	LNode *head = L;
	LNode *p = (LNode *)malloc(sizeof(LNode));
	p -> next = NULL;
	int x;
	scanf("%d",&x);
	while(x!=9999){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> data = x;
	    L -> next = p;
	    L = p;
	    scanf("%d",&x);	
	}
	return head;
}
头插法
//头插法带头节点带初始化
LintList ListHeadInsert(){
	LNode *L = (LNode *)malloc(sizeof(LNode));
	L -> next = NULL;
	int x;
	scanf("%d",&x);
	while(x != 9999){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> data = x;
		p -> next = L -> next;
		L -> next = p;
		scanf("%d",&x);
	} 
	return L;
}
头插法的应用，列表的逆转
typedef truct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;
LinkList reverOrder(LinkList oriList){ 
	LinkList L = (LinkList) malloc(sizeof(LNode));
	p -> value = 
	L -> next = null;
	oriList = oriList -> next;
	while(oriList != NULL){
		LNode *p = (LNode *)malloc(sizeof(LNode));
		p -> value = oriList -> value;
		p -> next = L -> next;
		L -> next = p;
		oriList = oriList -> next;
	}
	return L;
}

双链表

每个节点有前驱和后继

typedef struct DNode{
	ElemType data;
	struct LNode *prior,*next;
}DNode, *DLinkList;

初始化

//有头节点
typedef struct DNode{
	ElemType data;
	struct Lnode *prior,*next;
}DNode, *DLinkList;

bool InitDLL(DLinkList &L){
	L = (DNode *)malloc(sizeof(DNode));
	if(L == NULL)
		return false;
	h -> prior = NULL;
	h -> next = NULL;
	return ture;
}

//判空
bool Empty(DLinkList L){
	if(L -> next == NULL)
		return ture;
	return false;
}

插入

//在p节点后插入s节点
bool InsertNextDNode(DNode *p,DNode *s){
	if(p == NULL && s == NULL)	
	return false;
	if( p -> next != NULL)
		p -> next -> prior = s;
	s -> next = p -> next;
	s -> prior = p;
	p -> next = s;   
	return true;
}

删除

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,DLinkList;
//删除p节点的后继节点
bool DeleteNextDNode(DNode *p){
	if( p == NULL )return false;
	if( p -> next == NULL)return false;
	DNode *d = p -> next;
	p -> next = d -> next;
	if( d -> next != NULL)
		d -> next -> prior = p;
	free(d);
	return true;
}
//销毁表
void Destroy(DLinkList &L){
	while(L -> next != NULL)
		DeleteNextDNode(L);
	free(L);
	L = NULL;
}

遍历

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,DLinkList;
bool NextTraver(DNode *p){
	if( p == NULL|| p -> next == NUL)return false;
	while(p -> next != NULL){
		p = p-> next;
	}
	return true;
}
bool PriorTraver(DNode *p){
	if(p == NULL || p -> next == NULL || p -> next -> next == NULL)return false;
	while(p -> front -> front != NULL){
		p = p-> prior;
	}
	return true;
}

循环链表

循环单链表

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 = L;
	return true;
}

//判断表尾
bool IsTail(LinkList L,LNode *p){
	if( p -> next == L)return true;
	return false;
}

循环双链表

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}

//初始化循环双链表
bool InitDLL(DLinkList &L){
	L = (DNode *)malloc(sizeof(DNode));
	if(L == NULL)return false;
	L -> prior = L;
	L -> next =L;
	return true;
}

//判空
bool Empty(DLinkList L){
	if(L -> next == L)return true;
	return false;
}

//判断表尾
bool IsTail(DLinkList L,DNode *p){
	if(p -> next == L)return true;
	return false;
}

//在p后插入s
bool InsertCirDLL(DNode *p,DNode *s){
	if(p == NULL||s == NULL)return false;
	p -> next -> prior = s;
	
}

静态链表

单链表：各个节点在内存中星罗棋布，散落天涯。

静态链表：分配一整片连续的内存空间，各个节点集中安置（顺序表？）

静态链表的节点：

  • 数据项
  • 下一个元素的下标

定义及基本操作

#define MaxSize 10		//静态链表的最大长度
typedef struct {		//静态链表结构类型的定义
	Element data;		//存储数据元素
	int next;			//下一个元素的数组下标
}SLinkList[MaxSize];	
SLinkList L;
//初始化（head->next设为-1 el -> next设为-2）
bool Init(SLinkList L){
	if( L == NULL)return false;
	L[0] -> next = -1;
	for (int i = 1;i < MaxSize ;i++)
		L[i] -> next = -2;
	return ture;
}

顺序表和链表的比较

逻辑结构

都是线性表，都是线性结构

物理结构

  • 顺序表
    顺序存储
    优点：支持随机存取，存储密度高
    缺点：大片连续空间分配不方便，改变容量不方便
  • 链表
    链式存储
    优点：离散的小空间分配方便，改变容量方便
    缺点：不可随机存取，存储密度低

数据的运算/基本操作

创销、增删改查

创建

  • 顺序表
    需要分配一大片连续空间（数组）
  • 链表
    只需分配一个头节点，之后方便扩展

静态分配：静态数组（容量不可变）
动态分配：动态数组（malloc、free）容量可改变，但需要移动大量元素，时间成本高

销毁

  • 顺序表
    修改length = 0
    静态分配：系统自动回收
    动态分配：需要手动free
  • 链表
    依次删除各个节点（free）

增删

  • 顺序表
    时间复杂度O(n)，时间开销来自于移动每一项后续的数据元素，如果数据元素很大，则开销巨大
  • 链表
    时间复杂度O(N)，时间开销来自于查找前驱元素，查找后只需要修改指针即可。

改查

按位查找
  • 顺序表
    时间复杂度O(1)
  • 链表
    时间复杂度O(n)
按值查找
  • 顺序表
    遍历：时间复杂度O(n)
    若表内元素有序，可以二分查找
    二分查找：时间复杂度O(log(2,n))
  • 链表
    时间复杂度：O(n)

选择

  • 顺序表
    表长可预估，查询搜索操纵较多（增删操作较少）
  • 链表
    表长难以估计，经常增删元素

答题模板

问题：巴拉巴拉，用顺序表还是链表好？
顺序表和链表的逻辑结构都是线性结构，都属于线性表。
但是两者的存储结构不同，线性表采用顺序存储，支持随机存取，存储密度高，但大片连续内存空间分配不方便，扩容不方便；链表采用链式存储，离散的小空间分配方便，扩容方便，但不可随机存取，存储密度低。
由于采用不同的存储方式实现，因此基本操作的实现效率不同。当初始化时…，当插入数据元素时…，当删除一个数据元素时…，当查找一个数据元素时…。

西西阿西哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的逻辑结构
bingXxx的博客
12-11 7729
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
链表的概念和结构
weixin_56401913的博客
04-18 467
链表的概念和结构1.单链表2.双向链表3.循环链表 链表是一种物理存储结构上非连续的存储元素，数据元素的逻辑顺序是通过链表的引用链接依次实现的。 1.单链表 单链表的结点只有一个指向，即后继指针next指向下一个结点。 2.双向链表 双向链表的结点有两个指向，一个后继指针next指向下一个结点，还有一个前驱指针prev指向上一个结点。 单链表和双向链表的区别： 每个结点除了存储数据data外，还会会记录上一个结点和下一个结点的地址。 3.循环链表 循环链表的尾结点不指向空，而是指向头结点，类似一个环形
链表-单链表内存结构、逻辑结构、特点、定义、遍历、尾插、按顺序插入、修改、删除；有效节点个数、倒数第k个元素、单链表反转、合并2个有序单链表。双向链表-定义、增删改查。单向环形链表-Joseph
qq_39497997的博客
11-14 1487
1. 单链表介绍 1.1 内存结构 从内存上看：链表的空间不连续（有别于数组） 1.2 逻辑结构 逻辑上来看：链表属于线性结构 1.3 链表特点 链表是以节点的方式来储存的，是链式结构 节点分为数据域（data）和地址域（next）；data域存放数据，next域指向下一个节点 链表分带头结点的链表和没有头结点的链表，根据实际需求确定 2. 链表定义与使用 2.1 链表节点定义 no：英雄编号 name：英雄名字 nickName：英雄昵称 next：指向下一个HeroNode节点 //
线性链表的逻辑结构
逐波与逆流
11-18 2590
线性表是最简单、最基本、也是最常用的一种线性结构。它有两种存储方法：顺序存储和链式存储，它的主要基本操作是插入、删除和检索等。 2.1.1 线性表的定义 线性表是一种线性结构。线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。在实际问题中线性表的例子是很多的，如学生情况信息表
第三章 数据结构 线性表的逻辑结构 和 线性表的顺序存储结构，链式存储结构
weixin_43960370的博客
03-12 1230
线性表是最简单的数据结构，是由0个或多个类型相同的数据元素组成的有限序列。 线性表中的元素是一 一对应的。 引用 集合与线性表的区别在于元素是否可以重复。 ...
数据结构--线性表--思维导图.pdf
08-29
该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的关系。它具有有限的长度，元素之间...
线性表的实验--线性表的应用
11-07
链表存储结构中，每个节点包含系数、指数和指向下一个元素的指针。系统功能组成图包括多项式创建、插入、打印、比较、加减运算以及求值等功能模块。流程图则进一步详细描绘了这些操作的具体步骤。 4. 算法实现 代码...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-链表.pdf
08-15
用顺序存储结构存储的线性表称为顺序表，用链式存储结构存储的线性表称为链表。 顺序表是一种数组式的存储结构，将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表。顺序表的优点是存取速度快，...
04 2 线性表3-其它链表1
08-03
链表是线性表的链式存储表示，它的主要特点是逻辑相邻的元素在物理存储上不一定相邻。链表由一系列节点构成，每个节点包含两部分：数据域Data，用于存储元素，和指针Next，用于指向下一个节点。当链表为空时，头结点...
线性表、顺序表、链表、线性表的逻辑结构和线性表的存储结构的概念和特点
Ze_wait的专栏
06-13 2880
(1)线性表 概念：实际上是基于前面元素和后面元素之间的一种相邻关系的结构 特点： 1.是由n（n>=0）个元素组成的有序序列 2.都有唯一的第一个元素和唯一一个最后元素，当n=0时，线性表为空表。线性 表每个元素，初第一个外，都有且仅有一个前驱元素，初最后一个元素外，都有 且仅有一个后续元素 3.在该序列中，所有的元素都有相同的结构，要么是同样类型的数据，要么是同
链式存储结构-链表的基本操作
mr_yuyou的博客
07-09 634
数据结构
2. 数据结构-逻辑结构-线性表
qq_52226384的博客
08-09 763
前提知识回顾和关联 有了数据结构基本知识，数据结构是数据对象的逻辑结构+存储结构+运算（增删改查）。逻辑结构有集合、线性结构、树结构、图或网状结构。 显然线性表是数据逻辑结构的线性结构。它按照循序存储和链式存储（仅仅是分类标准，别混淆之前物理存储的概念）分为顺序表和链式表，链式表主要有单链表、双链表、循环链表、静态链表。 顺序表 地址连续的存储单元存储元素的表。由一个一维数组和一个序列长度构成。 顺序表是一个数据结构，数据结构三元组是逻辑结构、存储结构、运算。它的逻辑结构就是线性结构，它的存储结构是顺序存
数据结构--链表概念及常见链表结构
热门推荐
qq_35297945的博客
12-17 1万+
1 链表的概念 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表的结构由以下8种: 1、不带头单向循环结构 2、不带头单向非循环结构 3、不带头双向循环结构 4、不带头双向非循环结构 5、带头单向循环结构 6、带头单向非循环结构 7、带头双向循环结构 8、带头双向非循环结构 存储结构如下： 不带头单向循环结构 不带头单向非循环结构 不带头双向循环结构 不带头双向非循环结构 带头单向循环结构 带头单向非循环结构
链表题目及逻辑
今天天气很好
03-09 80
刷题，leetcode
数据结构与算法总结之：数据结构的存储结构与逻辑结构概念整理 && 链表二叉树等知识点重点习题整理
sexyme1011的博客
08-30 304
一、数据的存储结构 1、顺序存储 定义： 数据元素存储在连续的内存空间中，用元素的相对位置来表示关系。 优点： 1、支持随机访问 2、修改、访问效率高 3、存储空间连续，不易产生内存碎片 缺点： 1、内存空间利用率低 2、插入删除不方便 2、链式存储 定义： 数据存储在彼此独立的内存空间中，通过指针域存储元素地址表示元素间的关系。 优点： 1、空间利用率高 2、插入删除方便，适合频繁的增删数据 缺点： 1、不支持随机访问 2、内存不连续容易产生内存碎片 二、逻辑结构 1、集.
浅谈数据逻辑结构分类
倚树听风声的博客
05-13 1820
我们知道，数据是信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。 那么，数据元素又是数据的基本单位，通常作为一个整体进行考虑和处理。 由此，数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 一般来讲，数据结构包含三大要素：逻辑结构、存储结构、数据运算。 本文主要围绕数据结构的逻辑进行探讨，其他要素就不一一赘述。 数据逻辑结构的分类 常用的数据结构有：线性表，栈，队列，数组，串，树，图，堆八大类，如图所示： 1.线性表..
数据结构学习第二天——单链表
weixin_62410421的博客
04-29 979
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言——单链表的定义一、单链表的逻辑结构示意图二、单链表的实际操作1.定义单链表2.创建单链表3.打印单链表4.插入5.指定位置插入6.删除指定元素完整代码测试结果 前言——单链表的定义 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。.
数据结构：链表与逻辑问题
Kobe51920的博客
08-18 2715
优点 缺点 链表 1.用多少开多少，直接链上去，没有空间浪费 2.头尾插入效率高 O(1) 不支持随机访问，顺序访问 顺序表 1.支持随机访问,随机访问 1.增容时成倍增长，有空间浪费 2.中间或者头部插入数据时效率不高 O(N) ...
线性表的顺序存储结构优于链表存储结构
最新发布
07-08
线性表的顺序存储结构和链表存储结构都有各自的优缺点，不能一概而论。 顺序存储结构的优点： 1. 存储密度高，每个元素都占用同样大小的存储空间，便于计算存储位置，随机访问元素非常快速。 2. 线性表长度固定，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值