单链表的实现

最新推荐文章于 2023-04-06 13:34:21 发布
最新推荐文章于 2023-04-06 13:34:21 发布
阅读量249 收藏 1
点赞数 2
分类专栏： C语言 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58724706/article/details/121053522
版权

        无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

       这种链表每一个节点存一个数据，以及下一个节点的地址，这样可以很好地把每个节点串起来。

单链表是针对顺序表缺点来创建的。

目录

 结构体的创建

函数接口的实现

void SLTNodeDestroy(SLTNode** pphead)

SLTNode* BuyListNode(SLTDataType x)

void SLTNodePushBack(SLTNode** pphead, SLTDataType x)

void SLTNodePopBack(SLTNode** pphead)

void SLTNodePushFront(SLTNode** pphead, SLTDataType x)

void SLTNodePopFront(SLTNode** pphead)

void SLTNodePrint(SLTNode* pphead)

SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x)

void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) 

void SLTNodeErase(SLTNode** pphead, SLTNode* pos)

单链表完整代码

SList.h

SList.c

代码测试test.c

 结构体的创建

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

函数接口的实现

//void SLTNodeInit(SLTNode** ps);  //单链表不需要初始化
//对单链表的摧毁
void SLTNodeDestroy(SLTNode** pphead);
//尾插
void SLTNodePushBack(SLTNode** pphead, SLTDataType x);
//尾删
void SLTNodePopBack(SLTNode** pphead);
//头插
void SLTNodePushFront(SLTNode** pphead, SLTDataType x);
//头删
void SLTNodePopFront(SLTNode** pphead);
//打印单链表
void SLTNodePrint(SLTNode* pphead);
//在单链表中查找一个数据，并返回该地址
SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x);
//在pos前面插入一个数据
void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //不是对pos位置得数据改变，不用传二级指针
//删除pos位置的数据
void SLTNodeErase(SLTNode** pphead, SLTNode* pos);

是不是发现很多函数接口都是传的二级指针。具体为什么呢？

    SLTNode* plist = NULL; //在测试代码时，我们对第一个节点的初始化，指针接收

    SLTNodePushBack(&plist, 1); //假设我们在这里进行头插，这样有可能改变头结点，plist      是一级指针，为了能够顺利改变，我们在这里使用二级指针（指针变量也是变量）。

    否则，SLTNodePushBack(plist, 1); plist传过去后被形参接收，这里没办法找到plist指向        那块空间的地址，尽管形参对应的空间被改变，但是形参的改变不会影响实参。plist实际      指向的那块空间还是没有改变。

void SLTNodeDestroy(SLTNode** pphead)

void SLTNodeDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}
}

//摧毁动态开辟的空间的链表

void SLTNodeDestroy(SLTNode** pphead)  //头指针会被改变，所以要传二级指针
{
    SLTNode* cur = *pphead; //将首元素的值赋值给cur
    while (cur != NULL)  //当cur为空时，说明结点被删完了
    {
        SLTNode* next = cur->next; //从头开始删，删除头结点时，要提前记录下一个结点的            位置，来保证后面结点能够找到。
        free(cur); //释放结点
        cur = NULL;
        cur = next; //头结点位置变成提前记录的位置
    }
}

SLTNode* BuyListNode(SLTDataType x)

SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}
	return newnode;
}

动态开辟一个结点大小的空间，来存放数据和下一个结点的地址

SLTNode* BuyListNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); //动态开辟空间
    if (newnode == NULL)  //如果开辟失败就结束进程
    {
        printf("malloc fail\n");
        exit(-1);
    }
    else
    {
        newnode->data = x; //结点的位置存放一个数据
        newnode->next = NULL; //结点指向的下一个地址为空
    }
    return newnode; //返回开辟好结点的地址
}

void SLTNodePushBack(SLTNode** pphead, SLTDataType x)

void SLTNodePushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找到尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLTNodePushBack(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x); //插入数据时要开辟一个空间，用newnode接收这                                                                      开辟好空间个地址
    if (*pphead == NULL)   //*pphead==NULL为空，说明第一个结点没有数据，当链表为空时
    {
        *pphead = newnode; //这时候把newnode赋值给第一个空结点
    }
    else
    {
        //找到尾结点
        SLTNode* tail = *pphead; //用一个指针记录尾结点，避免对头结点进行修改
        while (tail->next != NULL)//当下一个结点为空，那么当前结点不为空，且为最后一结点
        {
            tail = tail->next; //tail指针不断指向后面结点的地址
        }
        tail->next = newnode; //最后一个结点的下一个结点被赋值成要插入的结点，相当于尾插
    }
}

void SLTNodePopBack(SLTNode** pphead)

void SLTNodePopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		SLTNode* cur = *pphead;
		free(cur);
		cur = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

删除单链表最后一个结点

void SLTNodePopBack(SLTNode** pphead)
{
    assert(pphead);//判断接收的结点是有效地址
    assert(*pphead);//判断第一个结点是否为空，为空，则没有结点
    if ((*pphead)->next == NULL) //判断链表中是否只有一个结点
    {
        SLTNode* cur = *pphead; 
        free(cur); //释放第一个结点
        cur = NULL;
    }
    else
    {
        SLTNode* prev = NULL; //记录最后一个结点的前一个结点的地址，第一次置为NULL
        SLTNode* tail = *pphead;//记录最后一个结点
        while (tail->next != NULL)  //tail最后会指向最后一个结点
        {
            prev = tail; //perv被赋值成（原来）tail的地址
            tail = tail->next; //tail指向下一个结点的位置
        }
        free(tail);
        tail = NULL;
        prev->next = NULL;//prev存放的是原链表倒数第二个结点的地址，这时候要当成尾结点
    }
}

void SLTNodePushFront(SLTNode** pphead, SLTDataType x)

void SLTNodePushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

在链表第一个位置前插入一个数据

void SLTNodePushFront(SLTNode** pphead, SLTDataType x)//传二级指针，可能修改第一                                                                                                       个结点
{
    SLTNode* newnode = BuyListNode(x); //开辟好要加入的结点
    if (*pphead == NULL)  //判断链表中没有结点的情况
    {
        *pphead = newnode; //第一个空结点被赋值成newnode
    }
    else//当链表中有至少一个结点时
    {
        newnode->next = *pphead;//新节点的下一个结点指向头结点
        *pphead = newnode;//头结点再变成新节点，这时候相当于头插了
    }
}

void SLTNodePopFront(SLTNode** pphead)

void SLTNodePopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

删除链表中的第一个结点

void SLTNodePopFront(SLTNode** pphead)
{
    assert(pphead);//判断接收的结点是有效地址
    assert(*pphead);//判断第一个结点是否为空，为空，则没有结点
    if ((*pphead)->next == NULL)//当链表头结点的下一个结点为空，则单链表中只有一个结点
    {
        free(*pphead); //释放头结点
        *pphead = NULL; //头结点置空
    }
    else//当链表有有个以上的结点时
    {
        SLTNode* next = (*pphead)->next;//提前记录头结点下一个结点的位置，防止找不到
        free(*pphead);//释放头结点，有上一个步骤，就不怕找不到后面的结点
        *pphead = next; //这时候头结点变成原结点的下一个结点，这时候就是头删了
    }
}

void SLTNodePrint(SLTNode* pphead)

void SLTNodePrint(SLTNode* pphead)
{
	SLTNode* cur = pphead;
	while (cur!= NULL)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

打印单链表中的数据

void SLTNodePrint(SLTNode* pphead)
{
    SLTNode* cur = pphead; //用一个指针代表头结点，避免头结点的随意被改变
    while (cur!= NULL) //cur为空的时候停止，说明不为空的结点的数据已经被打印了
    {
        printf("%d ", cur->data);
        cur = cur->next;//cur不断指向下一个结点
    }
    printf("\n"); 
}

SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x)
 

SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x)
{
	SLTNode* cur = pphead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL; //没找到
}

在单链表中查找一个数据

SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x)
{
    SLTNode* cur = pphead;//用一个指针代表头结点，避免头结点的随意被改变
    while (cur != NULL)//cur为空的时候停止，说明不为空的结点的数据已经被判断过了
    {
        if (cur->data == x) //当找到要查找的数据时
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL; //没找到
}

void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) 

void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) //不是对pos位置得数据改变，不用传二级指针
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

在pos位置前插入一个数据

void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) //不是对pos位置    得数据改变，不用传二级指针
{
    assert(pphead);
    assert(pos); //判断pos传过来的值不是有效值
    SLTNode* newnode = BuyListNode(x);//开辟新节点
    if (*pphead == pos) //当第一个结点为pos时
    {
        newnode->next = *pphead; 
        *pphead = newnode;
    }
    else
    {
        SLTNode* prev = *pphead;
        while (prev->next != pos)//当pos下一个结点为pos时就停止，
        {
            prev = prev->next;
        }
        prev->next = newnode;//这时候prev记录pos前一个结点，prev下一个结点指向新节点
        newnode->next = pos;//新节点下一个结点指向pos
    }
}

void SLTNodeErase(SLTNode** pphead, SLTNode* pos)

void SLTNodeErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLTNodePopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

删除单链表中pos位置的结点

void SLTNodeErase(SLTNode** pphead, SLTNode* pos)
{
    assert(pphead);
    assert(*pphead);//判断第一个结点是否为空，为空就没有结点，就不能删
    assert(pos); //判断pos传过来的值不是有效值
    if (*pphead == pos) //当pos值为头结点时，相当于头删
    {
        SLTNodePopFront(pphead); //头删
    }
    else //当pos不指向第一个结点时
    {
        SLTNode* prev = *pphead;//记录pos前一个结点，这样能够使前后结点连接上
        while (prev->next != pos) //prev事项pos前一个结点时结束
        {
            prev = prev->next;
        }
        prev->next = pos->next; //pos前一个结点pos的下一个结点
        free(pos);//释放pos结点，这样pos位置的结点就删除了，前后链表连接上了
        pos = NULL;
    }
}

单链表完整代码

SList.h

#define  _CRT_SECURE_NO_WARNINGS 1
#pragma once

#include<stdio.h>
#include<assert.h>  
#include<stdlib.h>

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

//void SLTNodeInit(SLTNode** ps);  //单链表不需要初始化
//对单链表的摧毁
void SLTNodeDestroy(SLTNode** pphead);
//尾插
void SLTNodePushBack(SLTNode** pphead, SLTDataType x);
//尾删
void SLTNodePopBack(SLTNode** pphead);
//头插
void SLTNodePushFront(SLTNode** pphead, SLTDataType x);
//头删
void SLTNodePopFront(SLTNode** pphead);
//打印单链表
void SLTNodePrint(SLTNode* pphead);
//在单链表中查找一个数据，并返回该地址
SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x);
//在pos前面插入一个数据
void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x); //不是对pos位置得数据改变，不用传二级指针
//删除pos位置的数据
void SLTNodeErase(SLTNode** pphead, SLTNode* pos);

SList.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SLTNodeDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}
}

SLTNode* BuyListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		newnode->data = x;
		newnode->next = NULL;
	}
	return newnode;
}

void SLTNodePushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找到尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLTNodePopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		SLTNode* cur = *pphead;
		free(cur);
		cur = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

void SLTNodePushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

void SLTNodePopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

void SLTNodePrint(SLTNode* pphead)
{
	SLTNode* cur = pphead;
	while (cur!= NULL)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

SLTNode* SLTNodeFind(SLTNode* pphead, SLTDataType x)
{
	SLTNode* cur = pphead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL; //没找到
}

void SLTNodeInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) //不是对pos位置得数据改变，不用传二级指针
{
	assert(pphead);
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}

void SLTNodeErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (*pphead == pos)
	{
		SLTNodePopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

代码测试test.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"SList.h"
void Test1()
{
	SLTNode* plist = NULL;
	SLTNodePushBack(&plist, 1);
	SLTNodePushBack(&plist, 2);
	SLTNodePushBack(&plist, 3);
	SLTNodePushBack(&plist, 4);
	SLTNodePushBack(&plist, 3);
	SLTNodePushBack(&plist, 3);

	SLTNodePopBack(&plist);

	//SLTNodePopFront(&plist);

	SLTNodePushFront(&plist, 10);
	SLTNodePushFront(&plist, 20);

	SLTNode* pos = SLTNodeFind(plist, 10); //不用取地址
	if (pos == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		SLTNodeInsert(&plist, pos, 100);
	}

	pos = SLTNodeFind(plist, 3);
	//int i = 1;
	//while (pos)
	//{
	//	printf("要查找的数据的第%d个的地址：%p\n", i,&(pos->data));
	//	i++;
	//	pos = SLTNodeFind(pos->next, 3);
	//}
	if(pos!=NULL)
	SLTNodeErase(&plist, pos);

	SLTNodePrint(plist);
	SLTNodeDestroy(&plist);
	plist = NULL;
}
int main()
{
	Test1();
	return 0;
}

测试结果如下：

暴走的橙子～
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
【 数据结构 】单链表的实现 - 详解（C语言版）
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。
单链表的基本实现(详细图解+解说)
Eliauk_U的博客
03-16 4755
目录 一.前言： 二.链表的结构实现: 三.单链表的功能实现-增删查..... 1.结点的申请 2.数据的头插 3.数据的打印 4.数据的尾插 5.数据的头删 6.数据的尾删 7.数据的查找 8.数据的指定插入和指定删除 9.链表的销毁 四.后言 一.前言： 我们都知道，顺序表是一块连续的可以存放数据的存储空间，其可以通过下标或指针解引用的方式快速访问某个位置的数据，但是由于空间的连续性，想要灵活的插入和删除数据便较为困难。 区别于顺序表，链表由一个个独立的可以存放数..
单链表实现
kunmu6666的博客
10-02 601
C语言实现数据结构链表
【数据结构】单链表实现
qq_55829345的博客
01-16 495
单链表的实现，几个牛客网和力扣的链表题目。
单链表实现的多项式运算.cpp
03-25
利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意...
C语言单链表实现
01-16
c语言单链表的简单实现代码，有初学者的小伙伴可以参考一下。
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
【数据结构】单链表的实现
最新发布
adcxhw的博客
04-06 917
快来看呀，小陳同学开始啃数据结构咯。
单链表简单实现
南猿北者博客
10-31 2108
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
单链表的操作（超详细），保证你看完不后悔
热门推荐
princekin
04-22 3万+
编程实现单链表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
单链表的实现（C语言）
weixin_57604904的博客
10-11 1275
单链表的实现
算法—详细讲解单向链表的实现（python）
python全栈
11-11 1122
链表 链表是一种物理存储单元上非连续、非顺序的存储结构 数据元素的逻辑顺序通过链表中的指针链接次序实现 链表由一系列节点组成，节点可以在运行时动态生成 每个节点包含两个部分：存储数据元素的数据区、存储下一个节点地址的指针域 每去存储一个数据就去申请一个节点 单向链表特点： 无法根据某一个节点去访问前一个节点 第一个节点为头节点 最后一个节点的指针域为空，称为尾节点 单向链表的实现 链表头部新增一个节点 1、新增节点node指针域指向原链表的头节点 node=Node(2) node.next=self
【数据结构】---【单链表完整介绍和实现】
m0_74044018的博客
04-05 704
单链表的实现逻辑是什么？他的实现功能基本全部实现！详细讲解！
C语言实现单链表（超多配图，这下不得不学会单链表了）
2301_76269963的博客
03-16 7888
C语言实现单链表

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值