链式存储---单链表

于 2023-09-22 12:34:38 发布
阅读量145 收藏 1
点赞数 2
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobai_wwx/article/details/133161193
版权

目录

一、什么是链表

二、链表的作用

三、链表的分类

使用最多的2种结构：

四、需要实现的接口

五、接口的实现

链表的打印

头部插入

尾部插入

头部删除

尾部删除

指定位置插入

查找

指定位置删除

销毁

完整代码

声明：

定义：

测试：

       在上一篇文章中介绍 了线性表的一种存储方式，也就是顺序表。也提到了顺序表所存在的一些问题，在本文中将会介绍另一种存储方式，链式存储，很好的解决了顺序表存储存在的问题。

一、什么是链表

1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。

2、节点由两个部分组成：一是存储数据元素的数据域，二是存储地址的指针域

二、链表的作用

实现数据元素按照一定顺序存储，可以在任意位置插入和删除。

三、链表的分类

1、单向或双向

2、带头或者不带头

指的是是否带有哨兵位(作为哨兵位的头节点一般不存储有效数据)

3、循环或者非循环

这几种情况组合起来有8种结构，但不是每种结构都会经常用到。

使用最多的2种结构：

1、无头单向非循环链表。

2、带头双向循环链表。

在这里我们要介绍的就是第一种，无头单向非循环链表：

四、需要实现的接口

//打印
void SLTprintf(SLTNode* phead);
//头插
void SLTPushFront(SLTNode** pphead, LTdatetype x);
//尾插
void SLTPushBack(SLTNode** pphead, LTdatetype x);
//头删
void SLTPopFront(SLTNode** pphead);
//尾删
void SLTPopBack(SLTNode** pphead);
//在pos前插入
void SLTInsertbefore(SLTNode** pphead, SLTNode* pos, LTdatetype x);
//在pos后插入
void SLTInsertAfter(SLTNode* pos, LTdatetype x);
//查找
SLTNode* LTFind(SLTNode* phead, LTdatetype x);
//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后面的值
void SLTEraseAfter(SLTNode* pos);
//销毁
void DestroySLT(SLTNode** pphead);

五、接口的实现

链表的打印

void SLTprintf(SLTNode* phead)
{//打印
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->NEXT;
	}
	printf("NULL\n");
}

头部插入

SLTNode* CreatNode(LTdatetype x)
{//开辟空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->NEXT = NULL;
	return newnode;
}

void SLTPushFront(SLTNode** pphead, LTdatetype x)
{//头插
	assert(pphead);
	SLTNode* newnode = CreatNode(x);
	newnode->NEXT = *pphead;   //将头节点的地址储存
	*pphead = newnode;         //将新开辟的节点更替为新的头节点
}

尾部插入

void SLTPushBack(SLTNode** pphead, LTdatetype x)
{//尾插
	assert(pphead);
	SLTNode* newnode = CreatNode(x);
	if (*pphead == NULL)
	{//如果头节点是空指针，则开辟的第一块空间被作为头节点
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->NEXT != NULL)
		{
			tail = tail->NEXT;
		}
		tail->NEXT = newnode;
	}
}

头部删除

void SLTPopFront(SLTNode** pphead)
{//头删
	assert(pphead);
	assert(*pphead);
	SLTNode* front = *pphead;
	*pphead = front->NEXT;
	free(front);
	front = NULL;
}

尾部删除

void SLTPopBack(SLTNode** pphead)
{//尾删
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
    //只有一个节点
	if (tail->NEXT == NULL)
	{
		free(tail);
		tail = NULL;
		*pphead = tail;
		return;//最后一个节点空间释放，不再向下访问，避免造成野指针 
	}
	//有多个节点2个及以上
	while (tail -> NEXT -> NEXT)
	{//拿到倒数第二个节点
		tail = tail->NEXT;
	}
	tail->NEXT = NULL;//要将倒数第二个节点的NEXT置NULL
	free(tail->NEXT);
}

指定位置插入

分为了两种，一种是在pos(指定位置)前插入，一种是在pos后插入

void SLTInsertbefore(SLTNode** pphead, SLTNode* pos, LTdatetype x)
{//选择插入  在pos前面插入
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{//要在第一个位置选择插入，直接进行头插
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->NEXT != pos)
		{
			prev = prev->NEXT;
		}
		SLTNode* newnode = CreatNode(x);
		prev->NEXT = newnode;
		newnode->NEXT = pos;
	}
}
void SLTInsertAfter(SLTNode* pos, LTdatetype x)
{//在pos后面插入
	assert(pos);
	SLTNode* newnode = CreatNode(x);
	newnode->NEXT = pos->NEXT;  //将pos后面的节点链接上新节点
	pos->NEXT = newnode;        //再将新节点链接给pos
}

查找

SLTNode* LTFind(SLTNode* phead, LTdatetype x)
{//查找  兼顾修改
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
            //cur->data = n //修改
			return cur;
		}
		cur = cur->NEXT;
	}
	return NULL;
}

指定位置删除

分为两种，一种是删除pos位置的节点，一种是删除pos后面的一个节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{//删除pos位置的节点
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->NEXT != pos)
		{
			prev = prev->NEXT;
		}
		prev->NEXT = pos->NEXT;
		free(pos);
		pos = NULL;
	}
}
void SLTEraseAfter(SLTNode* pos)
{//删除pos位置后面的节点
	assert(pos);
	assert(pos->NEXT);
	SLTNode* next = pos->NEXT; 
	pos->NEXT = next->NEXT;
	free(next);
	next = NULL;
}

销毁

void DestroySLT(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->NEXT;
		free(cur);
		cur = next;
	}
	*pphead = NULL;//将指向被释放空间的指针置NULL
}

完整代码

声明：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTdatetype;

typedef struct SLlistNode
{
	LTdatetype data;
	struct SLlistNode* NEXT;
}SLTNode;

//打印
void SLTprintf(SLTNode* phead);
//头插
void SLTPushFront(SLTNode** pphead, LTdatetype x);
//尾插
void SLTPushBack(SLTNode** pphead, LTdatetype x);
//头删
void SLTPopFront(SLTNode** pphead);
//尾删
void SLTPopBack(SLTNode** pphead);
//在pos前插入
void SLTInsertbefore(SLTNode** pphead, SLTNode* pos, LTdatetype x);
//在pos后插入
void SLTInsertAfter(SLTNode* pos, LTdatetype x);
//查找
SLTNode* LTFind(SLTNode* phead, LTdatetype x);
//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后面的值
void SLTEraseAfter(SLTNode* pos);
//销毁
void DestroySLT(SLTNode** pphead);

定义：

#include"SLlist.h"

void SLTprintf(SLTNode* phead)
{//打印
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->NEXT;
	}
	printf("NULL\n");
}

SLTNode* CreatNode(LTdatetype x)
{//开辟空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->NEXT = NULL;
	return newnode;
}

void SLTPushFront(SLTNode** pphead, LTdatetype x)
{//头插
	assert(pphead);
	SLTNode* newnode = CreatNode(x);
	newnode->NEXT = *pphead;   //将头节点的地址储存
	*pphead = newnode;         //将新开辟的节点更替为新的头节点
}

void SLTPushBack(SLTNode** pphead, LTdatetype x)
{//尾插
	assert(pphead);
	SLTNode* newnode = CreatNode(x);
	if (*pphead == NULL)
	{//如果头节点是空指针，则开辟的第一块空间被作为头节点
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->NEXT != NULL)
		{
			tail = tail->NEXT;
		}
		tail->NEXT = newnode;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* front = *pphead;
	*pphead = front->NEXT;
	free(front);
	front = NULL;
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
    //只有一个节点
	if (tail->NEXT == NULL)
	{
		free(tail);
		tail = NULL;
		*pphead = tail;
		return;//最后一个节点空间释放，不再向下访问，避免造成野指针 
	}
	//有多个节点2个及以上
	while (tail -> NEXT -> NEXT)
	{//拿到倒数第二个节点
		tail = tail->NEXT;
	}
	tail->NEXT = NULL;//要将倒数第二个节点的NEXT置NULL
	free(tail->NEXT);
}

void SLTInsertbefore(SLTNode** pphead, SLTNode* pos, LTdatetype x)
{//选择插入  在pos前面插入
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{//要在第一个位置选择插入，直接进行头插
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->NEXT != pos)
		{
			prev = prev->NEXT;
		}
		SLTNode* newnode = CreatNode(x);
		prev->NEXT = newnode;
		newnode->NEXT = pos;
	}
}

void SLTInsertAfter(SLTNode* pos, LTdatetype x)
{
	assert(pos);
	SLTNode* newnode = CreatNode(x);
	newnode->NEXT = pos->NEXT;  //将pos后面的节点链接上新节点
	pos->NEXT = newnode;        //再将新节点链接给pos
}

SLTNode* LTFind(SLTNode* phead, LTdatetype x)
{//查找  兼顾修改
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->NEXT;
	}
	return NULL;
}

//删除pos位置的节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->NEXT != pos)
		{
			prev = prev->NEXT;
		}
		prev->NEXT = pos->NEXT;
		free(pos);
		pos = NULL;
	}
}
//删除pos位置后面的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->NEXT);
	SLTNode* next = pos->NEXT; 
	pos->NEXT = next->NEXT;
	free(next);
	next = NULL;
}

void DestroySLT(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->NEXT;
		free(cur);
		cur = next;
	}
	*pphead = NULL;//将指向被释放空间的指针置NULL
}

测试：

#include"SLlist.h"

void Menu()
{
	printf("******************************\n");
	printf("       1、尾插   2、头插       \n");
	printf("       3、尾删   4、头删       \n");
	printf("       5、查找   6、插入       \n");
	printf("       7、删除   8、打印       \n");
	printf("       0、退出                 \n");
	printf("******************************\n");
}

int main()
{
	int input = 0;
	SLTNode* plist = NULL;
	do
	{
		int n = 0, x = 0;
		Menu();
		printf("请选择要进行的操作：>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入插入数据的个数和需要插入的数据：>");
			scanf("%d", &n);
			while (n--)
			{
				scanf("%d", &x);
				SLTPushBack(&plist, x);
			}
			printf("操作成功！\n");
			break;
		case 2:
			printf("请输入插入数据的个数和需要插入的数据：>");
			scanf("%d", &n);
			while (n--)
			{
				scanf("%d", &x);
				SLTPushFront(&plist, x);
			}
			printf("操作成功！\n");
			break;
		case 3:
			printf("请输入删除的数据的个数：>");
			scanf("%d", &n);
			while (n--)
			{
				SLTPopBack(&plist);
			}
			printf("操作成功！\n");
			break;
		case 4:
			printf("请输入删除的数据的个数：>");
			scanf("%d", &n);
			while (n--)
			{
				SLTPopFront(&plist);
			}
			break;
		case 5:
			printf("请输入要查找的数据：>");
			scanf("%d", &n);
			SLTNode* tmp = LTFind(plist, n);
			if (tmp == NULL)
			{
				printf("无此数据！\n");
			}
			else
			{
				SLTprintf(tmp);
			}
			break;
		case 6:
			printf("请选择要在哪一个数据后面插入，并输入插入的内容：>");
			scanf("%d %d", &n, &x);
			SLTNode* ret = LTFind(plist, n);
			if (ret == NULL)
			{
				printf("选择错误，无此数据！\n");
			}
			else
			{
				SLTInsertAfter(ret, x);
				printf("操作成功！\n");
			}
			break;
		case 7:
			printf("请选择要删除哪一个数据后面的数据：>");
			scanf("%d", &x);
			SLTNode* ret1 = LTFind(plist, x);
			if (ret1 == NULL)
			{
				printf("选择错误，无此数据！\n");
			}
			else
			{
				SLTEraseAfter(ret1);
				printf("操作成功！\n");
			}
			break;
		case 8:
			SLTprintf(plist);
			break;
		case 0:
			DestroySLT(&plist);
			printf("退出程序！\n");
			break;
		default:
			printf("选择错误！请重新选择！\n");
			break;
		}
	} while (input);
	return 0;
}

本篇文章介绍了无头单向非循环链表，但是在使用上没有另一种常用的结构方便，下篇文章将会介绍链表部分的重点结构，带头双向循环链表。

异码平穿
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
线性表的链式实现-----单链表
07-02
在实际应用中，线性表的实现方式多种多样，其中链式存储是一种常见的实现方法，而单链表是链式存储结构的一种基本形式。 单链表的每个元素称为节点，每个节点包含两部分：数据域和指针域。数据域用于存储元素的值，...
关于链表的总结以及其作用
wislosophia的博客
05-13 2万+
一、链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 2、结点包括两个部分：一、存储数据元素的数据域（内存空间），二、存储指向下一个结点地址的指针域。 3、相对于线性表顺序结构，操作复杂。 二、链表的作用 1、实现数据元素的存储按一定顺序储存，允许在任意位置插入和删除结点。 2、包括
数据结构之链表（定义、作用、分类、代码实现、优缺点）
Mr_Guan的博客
09-18 718
链表主要分为单链表、双链表、循环链表、静态链表。
链表基本介绍
Mic_x_的博客
04-05 254
1.链表是一种常用的数据结构，它通过指针将一些数据节点连接成数据链。相对于数组，链表具有更好的动态性（非线性储存）链式存储。3.建立链表时无需预先知道数据总量，可以随机分配空间，可以高效得在链表中任意位置实时插入或删除数据。2.数据域用来存储数据，指针域用于建立与下一个结点的联系。4.链表的开销，主要是访问顺序性和组织链的空间缺失。
什么是链表？（图解）
热门推荐
十二匹的博客
09-09 4万+
一：链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。 3、相对于线性表顺序结构，操作复杂。 4.链表分为 （1）单链表 （2）双链表 （3）单向循环链表 （4）双向循环链表 二：...
C 语言中的链表有什么用？
Programming Talk
02-22 1974
C 语言中的链表是一种常见的数据结构，它在内存中通过节点之间的指针链接实现动态存储和访问数据。链表的主要用途是存储和管理动态大小的数据集合，因为链表可以在运行时自由添加和删除节点，而不需要提前分配固定大小的内存。
循环单链表-双链表_循环单链表-双链表_throat6v2_
09-30
循环单链表是一种链式存储结构，它的每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域存储指向下一个节点的引用。在循环单链表中，最后一个节点的指针域不指向空，而是指向链表的第一个节点...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
01-单链表和项目实战笔记
最新发布
07-03
单链表作为一种重要的链式存储结构，在计算机科学中扮演着关键角色。它是一种非连续存储方式，利用一系列任意地址的存储单元来存放线性表中的元素。与数组不同的是，单链表中的每个元素不仅包含数据部分，还包含一个...
cpp代码-单链表的算法
07-14
在IT领域，特别是编程，单链表是一种基本的数据结构，它是链式存储结构的一种实现方式。本主题将深入探讨使用C++实现单链表的算法。C++是一种强大的面向对象编程语言，它允许我们高效地处理数据结构和算法。 单链表...
数据结构—单向链表
c123pp的博客
04-17 212
这里借用百度百科的概念： 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 通过加粗的字体可以看出单向链表有以下特点 1. 链接方向是单向的 2. 顺序读取从头部开始 3. 链表是由一个个结点组装起来的 4. 每个结点都有指针成员变量指向列表中的下一个结点 由一张图简单说明： head就是头部，也称为头节点。next1、n
关于链表的理解
legendarykk的博客
07-04 1545
链表的使用
c语言链表用处,c语言链表的用途是什么
weixin_39559559的博客
05-21 2094
1、链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。2、例程：/**对链表的综合操作*功能有建立，排序，插入，删除，输出*/#inc...
C语言链表讲解
m0_37799466的博客
05-06 467
一、C语言中有了数组为什么还要使用链表 链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。数组是大家在学习C语言中学到的第一种数据存储方法，其可以存储各种类型的数据，那么为什么还要使用链表来储存数据呢？这里首先先讲解一下两者的特性； 数组的特性，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但...
链表的作用和好处？如何用JS来写一个链表
weixin_33989780的博客
03-28 1220
链表是一种数据结构，里面的每个元素都包含下一个元素的位置信息，和数组做个对比，数组在内存中存放需要一段连续的位置，而数组则不用，可以分开存储在内存的任意位置。 这样做的好处是插入和删除速度快，步骤少，如果要在头部插入一个新的元素，链表只需要将第一个元素的位置信息添加进新的元素里即可，操作步骤为O(1)，而数组则需要将里面所有的元素都往后移一位，步骤为O(n)。 坏处在于查找很慢，在链表里如果要找到...
线性表的链式存储方式
微风
06-04 7149
今天这一篇是我动手实现的第三个数据结构的存储类型，真的收获很多，觉得数据结构其实是数据和它的存储结构的总和，一个数据没有存储结构那仫他在计算机中就如同没有稳定的“家”，此时我们是没有办法访问它的，今天就分享一下我实现链式表的一些心得希望能帮助那些数据结构的初学者。
c语言的链表的作用,链表（链式存储结构）及创建（C语言详解版）
weixin_42508290的博客
05-16 1260
前面详细地介绍了顺序表，本节给大家介绍另外一种线性存储结构——链表。链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与例如，使用链表存储 {1,2,3}，数据的物理存储状态如图 1 链表随机存储数据我们看到，图 1 根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的直接后继元素。如图 2 所示：图 2 各数据元素配...
链表在实际开发中的作用
weixin_32770485的博客
10-09 2610
提到链表这个数据结构 相信大家都不会陌生. 链表属于线性数据结构一种，他保存左右俩边相连的节点对象。 链表好的一点是增删快，因为只需要创建节点就可以。不好的地方是查询慢 因为没办法通过索引查找。 目前在java 语言中 有很多数据容器API 底层实现都使用到了链表 例如 LinkedList 散列表 等等。 具体给大家举一个实际开发的例子，比如说，如果我查询我的好友时候 你需要返回给我一个排好序...
什么是链表？
weixin_60297362的博客
09-29 1866
目录 一、链表是什么 二、链表的作用 三、链表和数组的区别 一、链表是什么 1.链表是一种常见的存储解构，它有着非连续性、非顺序性的特点。数据元素的逻辑顺序是通过链表中每个节点里的指针地址所实现的，又一些列节点组成，节点可动态生成。 2.每个节点包括两个区域 存储数据内容的数据区域 存储下一个节点地址的指针区域，其示意如下图： 每个结点的存储单元是独立的，若干个结点通过指针域依次相链接可构成一个链表。其示意如下图： 3.链表可分为： （1）单链表 （2...
数据结构--链式存储结构
10-19
数据结构中的链式存储结构是一种非连续、非顺序的存储结构，它通过指针将一组零散的存储单元串联起来，形成一个链表。链表中的每个节点包含两个部分，一个是数据域，用于存储数据元素，另一个是指针域，用于指向下一个节点的地址。链式存储结构相对于顺序存储结构的优点在于可以动态地分配内存空间，不需要预先分配固定大小的空间，同时也方便插入和删除操作。链式存储结构常见的类型有单链表、双向链表和循环链表。 引用中提到了链式存储结构的相关术语和小结，可以帮助更好地理解链式存储结构。引用中则介绍了数据结构中的线性结构和线性表的顺序表示和实现，以及顺序表的案例，这些内容可以帮助更好地理解链式存储结构与其他存储结构的区别和联系。引用则强调了链表中元素的逻辑次序与物理次序不一定相同，这也是链式存储结构的一个重要特点。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值