【数据结构】—C语言实现单链表（超详细！）

最新推荐文章于 2024-04-10 11:47:35 发布
最新推荐文章于 2024-04-10 11:47:35 发布
阅读量3.9k 收藏 72
点赞数 28
分类专栏： 数据结构与算法炼体 淬体中 文章标签： c语言 开发语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64038246/article/details/132020415
版权

                                     食用指南：本文在有C基础的情况下食用更佳

                                    🔥这就不得不推荐此专栏了： C语言

                                    ♈️今日夜电波： あなたは煙草　私はシャボン——今泉愛夏 

                                                                    1:31 ━━━━━━️💟──────── 4:36
                                                                            🔄   ◀️   ⏸   ▶️    ☰

                                   💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍 

目录

一、单链表介绍

单链表是什么？

单链表需要实现的基本功能？

单链表的基本结构是怎么样的？

二、总体思路

        结构体定义

        接口函数定义

三、具体每个接口函数的实现

        1、打印

        2、申请新的节点

        3、尾插

        4、头插

        5、尾删

        6、头删

        7、找节点（用于后续的插入以及删除操作）

        8、基于第7小点在pos之前插入x

        9、基于第7小点在pos以后插入x

        10、基于第7小点删除pos位置

        11、基于第7小点删除pos的后一个位置

        12、销毁链表，释放空间

四、总体代码

1、头文件

2、主体函数文件

3、测试用例

一、单链表介绍

单链表是什么？

        单链表是一种常见的数据结构，它由一个个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表需要实现的基本功能？

        基本的操作为：增、删、查、改

        具体为：

  1. 插入元素：将新元素插入到链表的指定位置，可以是链表的头部、尾部或中间位置。
  2. 删除元素：从链表中删除指定位置的元素。
  3. 查找元素：根据给定的值，在链表中查找对应的元素，并返回其位置。
  4. 遍历链表：按顺序访问链表中的每个元素。
  5. 获取链表长度：获取链表中元素的个数。
  6. 判断链表是否为空：判断链表是否为空链表。
  7. 清空链表：删除链表中的所有元素，使其成为一个空链表。

单链表的基本结构是怎么样的？

        一张图让你理解

        注：此文实现的是没有带哨兵的单链表

        注意：最后一个节点的next指针指向的是NULL

二、总体思路

        如何实现？按照单链表的基本介绍以及功能来一步一步实现！首先实现什么？->节点！最基本的元素，没有节点之后的都实现不了。接着实现什么？接口！按照功能将每一个接口都写好，以此来保证后续所写功能的连续性。最后，按照接口将每一个功能都实现即可！注意在编写的过程中也要反复的比对接口，及时修改接口的传参或者地址的传递。

        对此节点定义如下：

        结构体定义

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

        int 型 data 用于储存数据，结构体指针型 next 用于指向下一个节点。

        接口函数定义

//打印
void SLTPrint(SLTNode* phead);
//生成新的节点
SLTNode* BuySListNode(SLTDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
// 找节点
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
// 删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);
// 删除pos的后一个位置
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SLTDestroy(SLTNode** pphead);

       重点：

        此为对本版本单链表的不断优化后得到的接口。其中* phead 存储的是结构体类型的地址，即：他是用于改变结构体内的数据而设置的，* pos也是同理。而重点在于**pphead，他存储的结构体指针的地址，他是用于改变结构体指针的，即改变的是结构体的地址。x则是用于传参，输入需要添加的数据。

        你可能有个疑问，在此处为什么要使用**pphead呢？

        注意看在用到**pphead的函数，其中大多都是插入以及删除的操作，仔细看操作，例如：在插入时指针为空，而申请了新的节点，再将节点的地址替换原来的指针。删除了最后一个节点，将节点制空。即将节点替换为NULL。因此，使用**pphead是有必要的。

三、具体每个接口函数的实现

        1、打印

void SLTPrint(SLTNode* phead)//打印全部节点
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

        2、申请新的节点

SLTNode* BuySListNode(SLTDataType x)//申请新的节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
}

        3、尾插

void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* newnode = BuySListNode(x);
	//pphead空指针，对地址进行操作
	if(!*pphead)
	*pphead = newnode;
	else//不为空，以下为对结构体进行操作
	{
		SLTNode* dit = *pphead;
		while (dit->next)
		{
			dit = dit->next;
		}
		dit->next = newnode;
	}
}

        4、头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	SLTNode* newnode = BuySListNode(x);
	if (!*pphead)//加这个干啥？
	*pphead = newnode;
	else
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

        5、尾删

void SLTPopBack(SLTNode** pphead)//尾删
{
	//判空
	assert(pphead);
	assert(*pphead);//空链表不能删
	//一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SLTNode* tail = *pphead,*ftail=*pphead;
		while (tail->next != NULL)
		{
			ftail = tail;
			tail = tail->next;
		}
		free(ftail->next);
		ftail->next = NULL;
	}
}

        6、头删

void SLTPopFront(SLTNode** pphead)//头删
{
	assert(*pphead);//判空

	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

        7、找节点（用于后续的插入以及删除操作）

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)//查找
{
	//判空
	assert(phead);
	//遍历找值
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

        8、基于第7小点在pos之前插入x

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)// 在pos之前插入x
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		/*SLTNode* newnode=BuySListNode(x);
		newnode->next = pos;
		*pphead=newnode;*/
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* pre = *pphead;

		/*while (pre != NULL)
		{
			if (pre->next == pos)
			{
				SLTNode* newnode = BuySListNode(x);
				newnode->next = pos;
				pre->next = newnode;
				
			}
		}*/
		while (pre->next != pos)
		{
			pre = pre->next;
		}
		SLTNode* newnode = BuySListNode(x);
		newnode->next = pos;
		pre->next = newnode;
	}
}

        9、基于第7小点在pos以后插入x

void SLTInsertAfter(SLTNode* pos, SLTDataType x)// 在pos以后插入x
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

        10、基于第7小点删除pos位置

void SLTErase(SLTNode** pphead, SLTNode* pos)// 删除pos位置
{
	assert(pphead);
	assert(pos);
	
	if (*pphead == pos)//在头
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* dit = *pphead;
		while (dit->next != pos)
		{
			dit = dit->next;
		}
		dit->next = pos->next;
		free(pos);
		//pos=NULL//此为形参无用
	}

}

        11、基于第7小点删除pos的后一个位置

void SLTEraseAfter(SLTNode* pos)// 删除pos的后一个位置
{
	assert(pos);
	assert(pos->next);//检查pos是否为尾结点

	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

        12、销毁链表，释放空间

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);

		cur = next;
	}
	
	*pphead = NULL;
}

四、总体代码

1、头文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 01
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>


typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//打印
void SLTPrint(SLTNode* phead);
//生成新的节点
SLTNode* BuySListNode(SLTDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);
// 找节点
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
// 删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);
// 删除pos的后一个位置
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SLTDestroy(SLTNode** pphead);

2、主体函数文件

#include"SList.h"

SLTNode* BuySListNode(SLTDataType x)//申请新的节点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
}

void SLTPrint(SLTNode* phead)//打印全部节点
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}


void SLTPushBack(SLTNode** pphead, SLTDataType x)//尾插
{
	SLTNode* newnode = BuySListNode(x);
	//pphead空指针，对地址进行操作
	if(!*pphead)
	*pphead = newnode;
	else//不为空，以下为对结构体进行操作
	{
		SLTNode* dit = *pphead;
		while (dit->next)
		{
			dit = dit->next;
		}
		dit->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	SLTNode* newnode = BuySListNode(x);
	if (!*pphead)//加这个干啥？
	*pphead = newnode;
	else
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

void SLTPopBack(SLTNode** pphead)//尾删
{
	//判空
	assert(pphead);
	assert(*pphead);//空链表不能删
	//一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SLTNode* tail = *pphead,*ftail=*pphead;
		while (tail->next != NULL)
		{
			ftail = tail;
			tail = tail->next;
		}
		free(ftail->next);
		ftail->next = NULL;
	}
}

void SLTPopFront(SLTNode** pphead)//头删
{
	assert(*pphead);//判空

	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)//查找
{
	//判空
	assert(phead);
	//遍历找值
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)// 在pos之前插入x
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		/*SLTNode* newnode=BuySListNode(x);
		newnode->next = pos;
		*pphead=newnode;*/
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* pre = *pphead;

		/*while (pre != NULL)
		{
			if (pre->next == pos)
			{
				SLTNode* newnode = BuySListNode(x);
				newnode->next = pos;
				pre->next = newnode;
				
			}
		}*/
		while (pre->next != pos)
		{
			pre = pre->next;
		}
		SLTNode* newnode = BuySListNode(x);
		newnode->next = pos;
		pre->next = newnode;
	}
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)// 在pos以后插入x
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLTErase(SLTNode** pphead, SLTNode* pos)// 删除pos位置
{
	assert(pphead);
	assert(pos);
	
	if (*pphead == pos)//在头
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* dit = *pphead;
		while (dit->next != pos)
		{
			dit = dit->next;
		}
		dit->next = pos->next;
		free(pos);
		//pos=NULL//此为形参无用
	}

}

void SLTEraseAfter(SLTNode* pos)// 删除pos的后一个位置
{
	assert(pos);
	assert(pos->next);//检查pos是否为尾结点

	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

void SLTDestroy(SLTNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);

		cur = next;
	}
	
	*pphead = NULL;
}

3、测试用例

#include"SList.h"

void text()
{
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 10);
	SLTPushFront(&plist, 20);
	SLTPushFront(&plist, 30);
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
	
	SLTNode* p = SLTFind(plist, 10);//把找到的地址给p
	SLTInsert(&plist, p, 100);
	SLTPrint(plist);
	SLTInsertAfter(p, 200);
	SLTPrint(plist);
	SLTErase(&plist, p);
	SLTPrint(plist);
	SLTNode* pp = SLTFind(plist, 100);
	SLTEraseAfter(pp);
	SLTPrint(plist);
	SLTDestroy(&plist);
}

int main()
{
	
	text();
	return 0;
}

        测试结果：

                感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！ 

                                                                  给个三连再走嘛~ 

慕斯( ˘▽˘)っ
关注
  • 28
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
单链表详解（C语言版）
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
用C语言实现单链表操作
xuzhougeng blog
02-02 6576
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
C语言简单的数据结构：单链表
2302_82004664的博客
04-10 1437
我们在使用顺序表的时候我们发现了一些问题： 1.涉及到中间插入和头插时会进行数据的移动，导致效率较低 2.增容的空间会进行数据的拷贝 3.每次申请的空间不一定被使用，导致空间浪费 以上都说明顺序表不是很完美的，那有什么解决方法呢？ 没错那就是：链表 概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的。 所以链表也是线性表的一种（物理结构上不一定时线性的，逻辑结构是连续的）
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3790
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
【数据结构】---单链表【C语言实现】
mike_jun的博客
07-10 4198
1. 单向链表 我们都熟悉数组，它作为一个顺序储存方式数据结构为我们的程序设计带来了大量的便利，几乎任何的高级程序设计，算法设计都离不开数组的灵活使用。 但是，数组最大的缺点就是我们的插入和删除时需要移动大量的元素，显然这需要消耗大量的时间。 数组找到指定元素很快，O（1）复杂度就可以，而链表只能是遍历，O(n)的复杂度。 数组是顺序存储的，链表是通过指针实现不连续的存储 相比起数组，链表解决了数组不方便移动，插入，删除元素的弊端，但相应的，链表付出了更加大的内存牺牲换来的这些功能的实现。 ...
创建单链表详解之C语言版
sunnyoldboy博客
10-21 6411
链表是用一组任意的存储单元存储数据元素。如果是存储线性表中的元素，则称为线性链表。 链表中的结点地址在内存中可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。因此链表中结点的逻辑顺序和物理顺序不一定相同。 如果链表的结点中只有一个指针域，则该链表称为单链表，这也是常用的线性表的存储模式。 单链表适合于比较频繁的增加或者删除线性表中元素，不需要移动元素。
单链表数据结构代码（C语言）
m0_51512094的博客
04-25 2371
利用单链表数据结构实现一组数据的存储，通过简单的交互实现单链表的增删改查。 //ADT 线性表（List） 链式存储结构 LinkList #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //定义单链表 typedef struct Node {
数据结构-C语言实现单链表-数据结构学习
最新发布
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
用C语言实现数据结构中的单链表代码！！！
05-14
有单链表的增加、删除、查找等等实现
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
数据结构C语言-单链表操作实验
04-23
数据结构C语言版，单链表操作的菜单式实验，包括单链表的初始化、创建、求表长、插入删除元素、销毁和清空单链表等操作，具体操作根据屏幕提示进行。
数据结构——基于C语言实现单链表的应用.rar
08-11
//初始化表 //头插法添加结点 // 尾插法添加结点 //查找的函数（按序号查找） //根据长度输出单链表的数据 // 插入一个新的结点 //单链表的删除操作
c语言实现单链表算法示例分享
09-04
下面将详细介绍c语言实现单链表算法的示例。 1. 单链表的定义 单链表是一种链式数据结构，其中每个节点由数据域和指针域组成。数据域存储当前节点的数据，指针域存储下一个节点的地址。单链表的每个节点可以看作是...
C语言实现单链表（常规操作）
06-19
C语言实现单链表（常规操作） LinkList CreateHeadListH(); // 头插法创建单链表 LinkList CreateHeadListT(); // 尾插法创建单链表 int ListEmpty(); // 单链表判空 int ListLength(); // 求单链表长度...
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
最完整C语言单链表
亿只萌新的博客
11-06 2928
用C语言创建一条链表，并对其增删改查排序。
C语言单链表代码
weixin_42104550的博客
08-26 2798
下面的内容对初学者来说很抽象，建议多画图理解，或者去看熟悉我的C语言内存结构以及指针研究的文章再来理解链表。 顺序表的缺点可以用链表来解决，链表也分为单链表和双链表。这一文只展示单链表的代码。为什么单链表的访问效率极高，而且不会因为表的长度而影响的。因为链表在每一个数据前面都有一个地址头，也就是说链表的每个数据其实是有头有尾的，头是一个指向尾的地址，尾部才是真正的用户存储的数据。 每个数据是这样存储的，next是地址指针 data才是数据。每个数据都是独立的一个节点，只是这些块节点有next指针把它们串
C语言单链表
myCs05的博客
01-18 356
【代码】C语言单链表。
c++使用链表实现队列的代码
11-19
链表是一种常用的数据结构，可以用于实现队列。队列是一种先进先出（FIFO）的数据结构，可以用于处理数据的按序处理。使用链表来实现队列的代码可以通过定义节点结构和队列结构来实现。 首先，需要定义节点结构，包括数据项和指向下一个节点的指针。然后定义队列结构，包括指向队列头和队列尾的指针。接着，可以实现一系列的操作函数，如插入节点到队列尾、从队列头删除节点等。 具体的链表实现队列的代码可以如下所示： ``` // 定义节点结构 struct Node { int data; Node* next; }; // 定义队列结构 struct Queue { Node* front; Node* rear; }; // 初始化队列 void initQueue(Queue* q) { q->front = NULL; q->rear = NULL; } // 插入节点到队列尾 void enqueue(Queue* q, int value) { Node* newNode = new Node; newNode->data = value; newNode->next = NULL; if (q->rear == NULL) { q->front = newNode; } else { q->rear->next = newNode; } q->rear = newNode; } // 从队列头删除节点 int dequeue(Queue* q) { if (q->front == NULL) { return -1; } Node* temp = q->front; int value = temp->data; q->front = temp->next; delete temp; if (q->front == NULL) { q->rear = NULL; } return value; } ``` 以上就是使用链表实现队列的简单代码，通过这些操作函数可以实现队列的基本功能。链表实现队列的好处在于可以动态地添加和删除节点，非常灵活。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

慕斯( ˘▽˘)っ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值