顺序表与链表

最新推荐文章于 2024-04-13 18:03:17 发布
最新推荐文章于 2024-04-13 18:03:17 发布
阅读量824 收藏 6
点赞数 19
分类专栏： # 数据结构 文章标签： 链表 p2p 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58367586/article/details/122917721
版权
本文详细介绍了顺序表和链表的基本概念、存储结构、插入、删除、查找等操作。顺序表采用数组存储，支持随机访问，但插入和删除效率较低。链表由指针连接元素，插入和删除高效，但访问较慢。此外，还对比了两者的存取方式、逻辑结构与物理结构、时间性能和空间性能。代码示例展示了动态顺序表的实现和单链表的操作。
摘要由CSDN通过智能技术生成

目录

1. 顺序表

1.1 顺序表的概念及其结构

1.2 顺序表的插入(头插,尾插,插入指定位置）

1.3 顺序表的删除(头删,尾删,删除指定位置)

1.4 顺序表的查找

1.5 顺序表的接口实现(供大家考察是否掌握）

2. 链表

2.1 链表的概念及其结构

2.2 单链表的插入(头插,尾插,指定位置插入）

2.3 单链表的删除(头删,尾删,指定位置删除)

2.4 单链表的查找

2.5 单链表的接口实现(供大家考察是否掌握)

3. 顺序表与链表的优缺点

3.1 存取方式

3.2 逻辑结构与物理结构

3.3 时间性能

3.4 空间性能

1. 顺序表

1.1 顺序表的概念及其结构

    基本概念:

     顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采         用数组存储,在数组中完成增删查改。如图1,它有如下特点:

  • 存储空间连续,既允许元素的顺序访问,又可以随机访问。
  • 要访问指定元素,可以使用索引(下标)来访问,时间复杂度为O(1);
  • 要在其中增加或者删除一个元素,都要涉及后面所有元素的向前或向后移动，时间复杂度为O(n);
  • 可以方便的存储表中的任一结点，存储速度快;
  • 长度固定，分配内存之前必须知道数组的长度;
  • 无需为表示结点间的逻辑关系而增加额外的存储空间，存储利用率提高；

     存储结构:

顺序表一般可以分为:

1.静态顺序表:使用定长数组存储;

2.动态顺序表:使用动态开辟的数组存储;

静态分配和动态分配有什么不同呢？其实也就是数组的不同。在静态分配时，我们在编写的时候，就已经确定了数组的大小。而动态分配时，没有确定它的大小，是根据动态分配语句在运行时才将它的大小进行分配。这样有一点的好处就是，在静态分配时，当我想要存放顺序表的数据元素过超过 100的时候则会产生错误溢出，而动态分配时，如果一旦超过了分配的空间大小，可以再重新分配一块内存空间，把旧的空间和所增加的数据元素转移到新申请的空间上，这样就不会产生溢出的问题了。这是动态分配的一个优点。

代码如下:

//顺序表的静态存储
#define N 8
typedef int SLDataType;
typedef struct SeqList
{
  SLDataType array[N];//定长数组
  size_t size;//有效数组的个数
}SeqList;


//顺序表的动态存储
typedef int SLDataType;
typedef struct SeqList
{ 
   SLDataType* array;//指向动态开辟的数组
   size_t size;//有效数据的个数
   size_t capacity;//空间容量的大小
}SeqList;
/*注解:我们发现这里用的是指针,指针是存放一个存储单元地址的.顺序表根据第一个数据元素的地址和数据元素的大小,就可以算出任意数据元素的位置.即只定义第一个元素的指针即可，描述整个顺序表。但它仅仅是个地址，没有确切的空间，因此我们使用是要开辟空间;
SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));
详细代码下面讲解;*/

静态顺序表的定长数组导致N定大,空间开少了不够用,开多了浪费,所以现实中都是使用动态顺序表,使用倍增-复制的办法来支持动态扩容，将顺序表变成“可变长度”的。下面我将实现动态顺序表;

1.2 顺序表的插入(头插,尾插,插入指定位置）

1)头插法:每一次在顺序表的最前方插入,其他数据后移

void SeqListPushFront(SL* ps, SLDataType x)
{
	//如果没有空间，或者空间不足，我们可以增容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//对数组进行二倍增容,使用三目运算符是为了防止0这种情况
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		//判断是否增容成功
		if(tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
    //从最后一个元素开始向前遍历到第一个元素，分别将它们向后移动一个位置
	for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;//将要插入的数据插入到头部
	ps->size++;//表长加1
}

2)尾插法:顺序表的末尾增加数据,其他元素不用改变

void SeqListPushBack(SL* ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->size] = x;
	ps->size++;
}

3)指定位置插入:从最后一个元素开始向前遍历到第指定位置，分别将它们向后移动一个位置

void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	//因为顺序表连续存储,所以首先要判断插入位置是否合法;
	assert(pos >= 0 && pos <= ps->size);
	//增容
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//从最后一个元素开始向前遍历到第指定位置，分别将它们向后移动一个位置
	for (int i = ps->size - 1; i >= pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
    //将x插入到指定位置
	ps->a[pos] = x;
    //表长加1
	ps->size++;
}

1.3 顺序表的删除(头删,尾删,删除指定位置)

1)头删:从删除位置遍历到最后一个元素的位置,将他们依次向前移一个位置;

void SeqListPopFront(SL* ps)
{
	//判断顺序表当前长度是否为0
	assert(ps->size > 0);  

    //从删除位置开始遍历到最后一个元素位置，将他们分别前移一个位置。
	for (int i = 1; i < ps->size; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
     //表长减一
	ps->size--;
}

2)尾删:将表长减去1即可;

void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->size--;
}

3)删除指定位置:首先判断指定位置是否合法然后从指定位置的下一个元素依次向前移动一步.

void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos + 1; i < ps->size; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;
}

1.4 顺序表的查找

查找:顺序表的一端开始，依次将每个元素的关键字同给定值 K 进行比较，直到相等或比较完毕还未找到.

int SeqListFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

1.5 顺序表的接口实现(供大家考察是否掌握）

大家可以参考其提供的接口进行练习考查是否已经掌握.

// 顺序表的动态存储
typedef struct SeqList
{
 SLDataType* array; // 指向动态开辟的数组
 size_t size ; // 有效数据个数
 size_t capicity ; // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* psl, size_t capacity);
// 顺序表销毁
void SeqListDestory(SeqList* psl);
// 顺序表打印
void SeqListPrint(SeqList* psl);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl);
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* psl);
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* psl);
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x); 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);

2. 链表

2.1 链表的概念及其结构

    基本概念:

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。这里以单链表为例，说明其特征,如图1 

  •  存储空间不连续，数据元素之间使用指针相连,每个数据元素只能访问周围的一个元素;
  • 长度不固定,可以任意增删;
  • 要访问指定元素,要从头开始遍历元素,直到找到那个元素位置,时间复杂度为O(N)；
  • 在指定的数据元素插入或删除，不需要移动其他元素,时间复杂度为O(1);

    链表结构: 

链表的结构非常多样,以下情况组合起来一共有8中链表结构:

1. 单向、双向 2. 带头、不带头 3. 循环、非循环

（注释:

单向:只包含指向下一个结点的指针，只能单向遍历;

双向:包含指向下一个结点的指针也包含指向前一个结点的指针,因此可以双向遍历;

带头:1.头结点是为了操作的统一和方便而设立的，放在链表第一个元素之前，其数据域大多无意义，但也可以用来保存链表长度。2.有了头结点，对链表头部的插入和删除操作就统一了。3.头结点不是链表的必要元素。

循环:将尾节点与首节点链接起来，形成了一个环状结构，在某些情况下会非常有用)

虽然有这么多链表的结构,但我们在实际运用中最常见到的还是两种结构:

这里由于篇幅原因,只讲解第一个无头单向非循环链表.

2.2 单链表的插入(头插,尾插,指定位置插入）

1）尾插(无头结点):1.创建新结点2.判断链表是否为空3.为空则让头指针指向新结点4.否则找到最后一个指针,指向新结点;

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SListPushBack(SLTNode** pphead, SLTDateType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);//创建新结点
	if (*pphead == NULL)
	{//判断链表是否为空
		*pphead = newnode;
	}
	else {
		//找到最后一个结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//将最后一个结点指向新结点
		tail->next = newnode;
	}
}

 2)头插(无头结点):1.创建新结点 2.新结点指向原链表 3.头指针指向新结点;(注:2,3顺序不能颠倒,否则新结点将找不到原链表的地址)

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;

}

 3)在pos位置之前插入结点:1.创建新结点;2.判断第一个是否是其指定的位置3.如果是再来个头插,否则,找到pos的前一个位置posPrev;4将其新结点插入到pos位置之前，posPrev之后;

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
// 在pos位置之前去插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);//创建新结点
    //判断第一个是否等于pos
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else {
        //找到pos的前一个位置
		SLTNode* posprev = *pphead;
		while (posprev->next != pos)
		{
			posprev = posprev->next;
		}
		posprev->next = newnode;
		newnode->next = pos;
	}
}

 4)在pos位置之后插入结点:1.创建新结点; 2.新结点的next指向pos的next；3.pos的next指向newnode;(注:2,3不能交换位置,否则将丢失pos之后的地址）

SLTNode* BuyListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

2.3 单链表的删除(头删,尾删,指定位置删除)

1)尾删:1.判断链表是否为空,为空则则停止删除;2.若只有一个结点,释放其结点,让其链表为空;3.若有两个或两个以上的结点,找到最后一个和其前驱;4.其前驱next为空,释放最后一个结点;

void SListPopBack(SLTNode** pphead)
{
	assert(*pphead != NULL);
	//1.一个的情况
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//2.两个或者两个以上
	else {
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

2)头删: 1.判断链表是否为空;2.头指针指向第一个结点的next;3.释放第一个结点;

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);//判断连表是否为空·
	SLTNode* cur = (*pphead)->next;
	free(*pphead);
	*pphead = NULL;
	*pphead = cur;
}

 3)指定位置删除:1.判断链表是否为空;2.如果pos等于第一个结点,则采用头删;3.找出pos的前一个prev 4.将prev的next指向pos的next;5.释放pos;

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SListPopFront(pphead);//头删,详见上面代码
    }
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		} 
		prev->next = pos->next;
		free(pos);
	}
}

2.4 单链表的查找

SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else {
			cur = cur->next;
		}
	}
	return NULL;
}

2.5 单链表的接口实现(供大家考察是否掌握)

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
 SLTDateType data;
 struct SListNode* next;
}SListNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);

3. 顺序表与链表的优缺点

3.1 存取方式

顺序表:可以顺序存取,也可以随机存取;

单链表:只能从表头顺序进行存取元素;

3.2 逻辑结构与物理结构

顺序表:逻辑上相邻的元素,对应的物理存储位置也相邻；

单链表:逻辑上相邻的元素，物理存储位置不一定相邻，其逻辑关系是通过指针链接来表示的;

3.3 时间性能

顺序表支持随机访问,时间复杂度为O(1);

顺序表插入和删除需要依次移动元素，时间复杂度为O(N);

单链表要访问指定元素,需要从头遍历,时间复杂度为O(N);

单链表的插入和删除不需要移动元素,时间复杂度为O(1)；

3.4 空间性能

顺序表:需要预先分配存储空间，分配过多就会造成存储空间的浪费，而分配过少则会发生上溢。动态存储分配虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且若内存中没有更大的连续存储空间，则会导致分配失败。


单链表:按需分配，且元素个数不受限制 

 以上是顺序表与链表的相关知识点，有不足的地方或者对代码有更好的见解，欢迎评论区留言共同商讨，共同进步！！ 

接受平凡 努力出众
关注
专栏目录
链表查找
MaxLykoS的博客
05-21 1001
已知一单链表按值递增有序，写一算法，删除表中值大于mink并且小于maxk的所有节点，并将所删除节点释放。 #include #include #include typedef struct node { int data; struct node *next; }Node; void Init_Node(Node *node); Node* Create_List(int list
顺序表和链表
passion
08-03 3013
顺序表和链表的简单介绍和实现
顺序表与链表操作
shugai1115的博客
03-06 377
操作 链表 顺序表 访问元素 O(n) O(1) 在头部插入/删除 O(1) O(n) 在尾部插入/删除 O(n) O(1) 在中间插入/删除 O(n) O(n) 注意虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找，...
顺序表的相关知识
Adavinajh的博客
06-04 992
顺序表的基本操作 （1）顺序表的初始化 顺序表的初始化就是把顺序表 初始化为空的顺序表，只需把顺序表的长度length置为0即可； void InitList(PSeqList L) { if (L == NULL) { return; } L->length = 0; } (2)求顺序表的长度 顺序表的长度就是就顺序表中的元素的...
数据结构与算法：顺序表和链表的常用操作 （很全，基本涵盖本章所有算法）
Specif1c的博客
06-23 2285
前言： 数据结构中的表操作算是里面较为简单的章节，但也比较重要，3月份学完的此章节，左思右想今天还是写篇 关于顺序表和链表的博客。 ps ： 复制代码可以在编译器上直接运行。 一、顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 #define N 100 typedef int SLDataTyp
顺序表和链表.pdf
04-24
### 顺序表与链表详解 #### 一、概述 本文档主要介绍顺序表和链表这两种基本的数据结构。在计算机科学中，数据结构是指在计算机中组织和存储数据的一种特殊方式，它允许高效地访问和修改数据。顺序表和链表作为...
数据结构和算法-2.顺序表与链表
最新发布
08-10
这份笔记深入解析了计算机科学中两种最基本的数据结构——顺序表与链表的原理、实现以及实际应用。通过对比顺序表和链表的不同特点，你将了解到它们各自的优势与适用场景。例如，笔记详细阐述了顺序表的扩展机制、...
线性结构及其应用，顺序表，链表，静态链表
03-30
本主题主要探讨线性结构的三个重要概念：顺序表、链表以及静态链表，这些都是数据结构与算法中的核心知识。 首先，顺序表是一种最基础的线性结构，它的特点是元素在内存中是连续存储的，可以通过数组的形式来实现。...
顺序访问链表中的节点——C语言基础
Lanyan9的博客
07-19 878
对链表中的节点进行顺序访问 前言：对链表的访问具体包括修改、运算和输出，作为C语言基础，这里只对输出进行阐释 一、算法描述 用一个工作指针p遍历整个链表，直到链表的结束标志为止，如果链表为空，输出提示信息。 二、代码讲解 //顺序输出函数 void list(struct stu *head){ struct stu *p; //构建一个遍历工作指针p p = head; //初始化 if(head != NULL){ printf("\nthe
数据结构---顺序表和链表
qq_46370017的博客
05-26 1408
数据结构中的顺序表和链表都属于线性表。何为线性表？即相同数据类型的有限序列。
链表的查找
2401_83430041的博客
04-13 315
先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下一个结点，如果到达最后一个结点的时候都没有匹配的数据，说明要查找数据不存在。
链表查找（线性表）
qq_63510071的博客
01-17 431
最开始的错误代码以及做题思路和草稿纸上写的过程画的图： #include<stdio.h> #include<stdlib.h> //提供malloc()和free() #include<string.h> //提供strcpy()等 struct Node { int data; //数据域 struct Node* next; //指针域(指向节点的指针） }; struct Node* head; struct Nod...
链表查找(线性表)
tainxiawuti的博客
11-10 312
#include<stdio.h> struct node{ node* next; int data; }; int main(){ int n,key; while(scanf("%d",&key)!=EOF){ scanf("%d",&n); node* head=new node; ...
计算机链表和顺序表真题,2021计算机考研知识点梳理：顺序表和链表的比较
weixin_42402228的博客
07-26 275
1.存取(读写)方式顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。例如在第i个位置上执行存或取的操作，顺序表仅需一-次访问，而链表则需从表头开始依次访问i次。2.逻辑结构与物理结构采用顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻。而采用链式存储时，逻辑_上相邻的元素，物理存储位置则不一定相邻，对应的逻辑关系是通过指针链接来表示的。3.查找，插入和删除操作对于按值查找，顺...
【数据结构】- 复杂度、顺序表、链表
huang_ftpjh的博客
07-14 398
主要看课后习题 算法的设计要求包括，正确性、可读性、健壮性和效率与低储存量需求。 （要改代码，尽量用接口，有问题时，不要用那个类，加个类进去） 数据结构中，从逻辑上可以把数据结构分为 线性结构和非线性结构。 计算机算法指的是解决问题的有限步骤。 算法复杂度 3次循环就是 线性 线性表是一个有限序列，可以为空 线性表第一个元素没有直接前驱，最后一个元素没有直接后继 假设线性表有n个元素，如果在第i个位置插入一个新元素，需向后移动 n-i+1个元素 链式 优点： 插入和删除不需...
线性表详解：顺序表与链表
例如，插入和删除操作在链表上通常比顺序表更快，因为不需要移动大量元素。 学习线性表，特别是链表，是理解更复杂数据结构如栈、队列、树的基础。熟练掌握链表操作，包括创建、遍历、修改和销毁链表，是编程技能的...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

接受平凡 努力出众

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

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

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

打赏作者

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

抵扣说明：

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

余额充值