单链表（C/C++）

最新推荐文章于 2024-11-09 19:15:00 发布
最新推荐文章于 2024-11-09 19:15:00 发布
阅读量942 收藏 18
点赞数 32
分类专栏： 数据结构 文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74830524/article/details/135730506
版权

        本篇将给出单链表的实现，头部插入/删除，尾部插入/删除，元素查找，指定位置前插入数据，指定位置之后插入元素，删除当前元素，删除当前元素之后的元素。

        在给出这些操作，先给出单链表的定义，之后还会给出一些链表的扩展。

1.什么是单链表

        链表的定义为：是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

        以上为链表的定义，那么什么是单链表呢，就是在链表中的元素只存在数据域和指针域，指针域存放的是下一个元素的地址。即：

        其中的火车头表示链表的头街点，对于单链表来说，分为带头结点的单链表和不带头结点的单链表。 因为在平时使用中，对于不带头结点的单链表使用得最为频繁，所以本篇以不带头结点的单链表为重点。（带头结点的单链表的头结点为：存储第一个元素位置的结点。而平时说的头结点指第一个结点）。

        为什么需要用指针来保存下一个结点的位置呢？

        因为链表中的每个元素都是独立申请的（需要插入数据时才会去申请一块结点的空间），所以需要使用指针来保存下一个结点位置。方便之后查找。

2.链表和顺序表的优点/缺点

        顺序表和链表都属于数据结构中的线性结构，那么这两种线性数据结构有什么区别呢？

        1.存储方式上：顺序表的存储为逻辑相邻+物理项链；而链表的存储方式仅仅为逻辑相邻，使用指针作为链接。

        2.插入和删除操作的效率：顺序表的插入和删除操作都需要移动元素来维持原来的相对顺序，平均时间复杂度为O(n)；链表的插入和删除操作只需要调整相对应的指针，无需移动元素，平均时间复杂度为O(1)。

        3.随机访问的效率：对于顺序表来说，元素的在内存中的存储是连续的，可以直接通过下标进行访问，时间复杂度为O(1)；对于链表来说，由于元素在内存中是不连续存储的，需要通过指针依次访问查找，时间复杂度为O(n)。

        4.空间利用上：对于顺序表来说，每次开辟或者增容的空间，可能会存在浪费的情况；而对于链表来说，虽然开辟的空间都能用到，但存在许多的内存碎片。

3.单链表操作的实现

        以下为不带头结点的单链表的抽象数据结构，以及对应的一些操作。

#define _CRT_SECURE_NO_WARNINGS 1   //在vs2022中解除对部分函数的警告
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;

typedef struct Node {
	DataType data;
	struct Node* next;
}SLTNode;

//打印单链表
void SLTPrint(SLTNode* phead);

//头部插入删除/尾部插入删除
void SLTPushBack(SLTNode** pphead, DataType x);
void SLTPushFront(SLTNode** pphead, DataType x);
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//单链表的查找
SLTNode* SLTFind(SLTNode* phead, DataType x);

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x);
//指定位置之后插入
void SLTInsertAfter(SLTNode* position, DataType x);

//指定位置删除/指定位置后删除
void SLTErase(SLTNode** pphead, SLTNode* position);
void SLTEraseAfter(SLTNode* position);

//链表的销毁
void SLTDestroy(SLTNode** pphead);

        对于以上的函数，我们可以发现：只有打印当前链表和查找数据传入头结点的一级指针，而其他有关头结点的操作传入的都是头结点的二级指针，是因为：

        以下为对应函数的实现方式，在每个函数中都有对应的注释解释：

//打印所有的元素
void SLTPrint(SLTNode* phead) {
	//先判断当前链表是否为NULL
	if (phead == NULL) {
		printf("该链表没有元素!\n");
		return;
	}
	SLTNode* current = phead;
	while (current) {
		printf("%d->", current->data);
		current = current->next;
	}
	printf("NULL\n");
}

//创建一个新的结点
SLTNode* CreateNode(DataType x) {
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL) {
		perror("MALLOC:");
		exit(1);
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

//尾结点插入
void SLTPushBack(SLTNode** pphead, DataType x) {
	//传过来的单链表地址不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若需要插入的为头结点,直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//若不为头结点，找到最后一个结点
	SLTNode* current = *pphead;
	while (current->next) {
		current = current->next;
	}
	//此时current的下一个为NULL
	current->next = newNode;
	return;
}

//头结点插入
void SLTPushFront(SLTNode** pphead, DataType x) {
	//传过来的头结点指针不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若头结点为NULL，直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//将新节点的指针指向当前头结点
	newNode->next = *pphead;
	//头结点移动
	*pphead = newNode;
	return;
}

//删除尾结点
void SLTPopBack(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	//若单单链表只有一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//若只有头结点一个元素
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//找到尾结点，同时需要找到尾结点的前一个结点，便于删除
	SLTNode* current = *pphead;
	SLTNode* previous = *pphead;
	//当指针为NULL是表明为尾结点
	while (current->next) {
		previous = current;
		current = current->next;
	}
	//当前current为最后一个结点，previous为倒数第二个结点
	free(current);
	current = NULL;
	previous->next = NULL;
	return;
}

//头结点位置删除
void SLTPopFront(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	SLTNode* current = *pphead;
	//将头结点指向下一个结点
	*pphead = current->next;
	free(current);
	current = NULL;
	return;
}

//查找元素
SLTNode* SLTFind(SLTNode* phead, DataType x) {
	if (phead == NULL) {
		printf("该链表没有任何信息\n");
		return NULL;
	}
	SLTNode* current = phead;
	while (current) {
		if (current->data == x) {
			return current;
		}
		current = current->next;
	}
	return NULL;
}

//在position前插入元素
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x) {
	//头结点的地址不能为NULL，对应位置的元素也不能为NULL
	assert(pphead);
	assert(position);
	//既然对应位置不能为NULL，说明链表一定存在元素，链表头结点也不能为NULL
	assert(*pphead);
	//如果此时只有头结点一个元素,且刚好为position
	if (*pphead == position) {
		SLTNode* newNode = CreateNode(x);
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}
	//需要找打position前的一个元素
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	if (current == NULL) {
		printf("没找不到该元素位置，插入失败！\n");
		return;
	}
	else {
		//当前current为position的前一个元素
		SLTNode* newNode = CreateNode(x);
		//将新生成的结点链接起来
		newNode->next = position;
		current->next = newNode;
	}
}

void SLTInsertAfter(SLTNode* position, DataType x) {
	assert(position);
	SLTNode* newNode = CreateNode(x);
	//下面两句不能调换顺序！
	newNode->next = position->next;
	position->next = newNode;
}

void SLTDestroy(SLTNode** pphead) {
	//传过来的链表不能为NULL
	assert(pphead);
	assert(*pphead);
	SLTNode* current = *pphead;
	if (current != NULL) {
		SLTNode* next = current->next;
		free(current);
		current = next;
	}
	current = NULL;
	*pphead = NULL;
}

//指定位置删除
void SLTErase(SLTNode** pphead, SLTNode* position) {
	//头结点及其地址不能为NULL
	assert(pphead);
	assert(*pphead);
	assert(position);
	//如果删除的为第一个结点
	if (position == *pphead) {
		*pphead = (*pphead)->next;
		free(position);
		position = NULL;
		return;
	}
	//找到对应位置的前一个结点
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	//找到最后一个结点都没有找到position
	if (current == NULL) {
		printf("没有找到对应结点!\n");
		return;
	}
	else {
		//当前current指针指向position的前一个位置
		current->next = position->next;
		free(position);
		position = NULL;
	}
}

//指定位置之后删除
void SLTEraseAfter(SLTNode* position) {
	assert(position);
	//之后一个结点也不能为NULL
	assert(position->next);
	SLTNode* next = position->next;
	position->next = next->next;
	free(next);
	next = NULL;
}

        以下为所有代码，及其运行测试结果： 

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

typedef int DataType;

typedef struct Node {
	DataType data;
	struct Node* next;
}SLTNode;

//打印所有的元素
void SLTPrint(SLTNode* phead) {
	//先判断当前链表是否为NULL
	if (phead == NULL) {
		printf("该链表没有元素!\n");
		return;
	}
	SLTNode* current = phead;
	while (current) {
		printf("%d->", current->data);
		current = current->next;
	}
	printf("NULL\n");
}

//创建一个新的结点
SLTNode* CreateNode(DataType x) {
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL) {
		perror("MALLOC:");
		exit(1);
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

//尾结点插入
void SLTPushBack(SLTNode** pphead, DataType x) {
	//传过来的单链表地址不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若需要插入的为头结点,直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//若不为头结点，找到最后一个结点
	SLTNode* current = *pphead;
	while (current->next) {
		current = current->next;
	}
	//此时current的下一个为NULL
	current->next = newNode;
	return;
}

//头结点插入
void SLTPushFront(SLTNode** pphead, DataType x) {
	//传过来的头结点指针不能为NULL
	assert(pphead);
	SLTNode* newNode = CreateNode(x);
	//若头结点为NULL，直接插入
	if (*pphead == NULL) {
		*pphead = newNode;
		return;
	}
	//将新节点的指针指向当前头结点
	newNode->next = *pphead;
	//头结点移动
	*pphead = newNode;
	return;
}

//删除尾结点
void SLTPopBack(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	//若单单链表只有一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//若只有头结点一个元素
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}

	//找到尾结点，同时需要找到尾结点的前一个结点，便于删除
	SLTNode* current = *pphead;
	SLTNode* previous = *pphead;
	//当指针为NULL是表明为尾结点
	while (current->next) {
		previous = current;
		current = current->next;
	}
	//当前current为最后一个结点，previous为倒数第二个结点
	free(current);
	current = NULL;
	previous->next = NULL;
	return;
}

//头结点位置删除
void SLTPopFront(SLTNode** pphead) {
	//删除结点，头结点和头结点地址都不能为NULL
	assert(pphead && (*pphead));
	SLTNode* current = *pphead;
	//将头结点指向下一个结点
	*pphead = current->next;
	free(current);
	current = NULL;
	return;
}

//查找元素
SLTNode* SLTFind(SLTNode* phead, DataType x) {
	if (phead == NULL) {
		printf("该链表没有任何信息\n");
		return NULL;
	}
	SLTNode* current = phead;
	while (current) {
		if (current->data == x) {
			return current;
		}
		current = current->next;
	}
	return NULL;
}

//在position前插入元素
void SLTInsert(SLTNode** pphead, SLTNode* position, DataType x) {
	//头结点的地址不能为NULL，对应位置的元素也不能为NULL
	assert(pphead);
	assert(position);
	//既然对应位置不能为NULL，说明链表一定存在元素，链表头结点也不能为NULL
	assert(*pphead);
	//如果此时只有头结点一个元素,且刚好为position
	if (*pphead == position) {
		SLTNode* newNode = CreateNode(x);
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}
	//需要找打position前的一个元素
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	if (current == NULL) {
		printf("没找不到该元素位置，插入失败！\n");
		return;
	}
	else {
		//当前current为position的前一个元素
		SLTNode* newNode = CreateNode(x);
		//将新生成的结点链接起来
		newNode->next = position;
		current->next = newNode;
	}
}

void SLTInsertAfter(SLTNode* position, DataType x) {
	assert(position);
	SLTNode* newNode = CreateNode(x);
	//下面两句不能调换顺序！
	newNode->next = position->next;
	position->next = newNode;
}

void SLTDestroy(SLTNode** pphead) {
	//传过来的链表不能为NULL
	assert(pphead);
	assert(*pphead);
	SLTNode* current = *pphead;
	if (current != NULL) {
		SLTNode* next = current->next;
		free(current);
		current = next;
	}
	current = NULL;
	*pphead = NULL;
}

//指定位置删除
void SLTErase(SLTNode** pphead, SLTNode* position) {
	//头结点及其地址不能为NULL
	assert(pphead);
	assert(*pphead);
	assert(position);
	//如果删除的为第一个结点
	if (position == *pphead) {
		*pphead = (*pphead)->next;
		free(position);
		position = NULL;
		return;
	}
	//找到对应位置的前一个结点
	SLTNode* current = *pphead;
	while (current->next != position&&current!=NULL) {
		current = current->next;
	}
	//找到最后一个结点都没有找到position
	if (current == NULL) {
		printf("没有找到对应结点!\n");
		return;
	}
	else {
		//当前current指针指向position的前一个位置
		current->next = position->next;
		free(position);
		position = NULL;
	}
}

//指定位置之后删除
void SLTEraseAfter(SLTNode* position) {
	assert(position);
	//之后一个结点也不能为NULL
	assert(position->next);
	SLTNode* next = position->next;
	position->next = next->next;
	free(next);
	next = NULL;
}

void Test01() {
	SLTNode* phead = NULL;
	SLTPushBack(&phead, 1);
	SLTPushBack(&phead, 2);
	SLTPushBack(&phead, 3);
	SLTPushBack(&phead, 4);
	SLTPrint(phead);  // 1 2 3 4

	SLTPushFront(&phead, 8);
	SLTPushFront(&phead, 7);
	SLTPushFront(&phead, 9);
	SLTPrint(phead);  // 9 7 8 1 2 3 4

	SLTPopBack(&phead);
	SLTPopBack(&phead);
	SLTPopBack(&phead);
	SLTPrint(phead);  //9 7 8 1

	SLTPopFront(&phead);
	SLTPopFront(&phead);
	SLTPopFront(&phead); 
	SLTPrint(phead);  //1

	SLTNode* P = SLTFind(phead,1);
	if (P != NULL) {
		printf("找到了！\n");  //找到了！
		printf("%d\n", P->data);//1
	}
	else {
		printf("未找到!\n");
	}

	SLTInsert(&phead, P, 100);
	SLTInsertAfter(P, 8); 
	SLTPrint(phead);	//100 1 8

	SLTPushBack(&phead, 12);
	SLTPushBack(&phead, 13);
	SLTPushBack(&phead, 14);
	SLTPrint(phead);	//100 1 8 12 13 14

	SLTEraseAfter(P);   
	SLTErase(&phead,P);
	SLTPrint(phead);    //100 12 13 14

	SLTDestroy(&phead);
}

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

        测试结果：

        以上就为单链表的所有操作。

4. 链表的分类

        链表的结果非常多样，结合以下情况组合起来一共就有8种（2*2*2）链表结构：

        带头或者不带头：

        单向或者双向：

         循环与不循环:

        尽管有八种链表结构，但是其中用得最多的是：不带头结点的不循环单向链表、带头结点的循环双向链表。 

         

桀桀桀桀桀桀
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C/C++ 单链表逆置算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 2586
单链表逆置算法是指将一个单链表中的节点顺序反转。单链表逆置算法的优点是简单易懂、实现较为直接。
反转单链表c/c++
weixin_45024973的博客
01-23 131
反转单链表
单链表C/C++实现
岳麓丹枫
05-11 338
#include <iostream>using namespace std; const int N = 10; typedef int ELEMTYPE;typedef struct Node { ELEMTYPE data; Node *next; }LNode,*LinkList; void initLinkList(LinkList &L); int ins
单链表c/c++ 数据结构
?_#的博客
09-12 272
  #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; /* struct node{}; node */ typedef struct node{ int data; struct node *next; }ListNode,*LinkList; //头插法建立单链表 LinkList CreateListOnHead(){ i...
c/c++ 数据结构 单链表
2301_78564545的博客
06-21 539
创建方法二：依然是头插法，但是在赋值时将数组最后一个元素赋值给第一个创建的节点（创建完后是最后一个），将数组倒数第二个元素赋值给第二个创建的节点（创建完后是倒数第二个节点），以此类推。单链表的销毁：从头节点开始依次往后释放各个节点的内存，剩最后一个节点时退出循环，再将其free();求单链表的长度：每循环一次count+1，直到p为最后一个节点，返回count。根据单链表的元素值求索引：当索引小于单链表长度且存在该元素才返回，否则返回-1。根据单链表的索引取值：索引有效才为真，否则为假。
C/C++数据结构之单链表
2301_80102396的博客
07-29 1405
显然这里要使得实参的头节点在链接一个节点，就是使得实参改变，它本身就是一个指针，所以形参我们就需要二级指针来接受实参，进行传址来改变实参。思路：头删比较简单，我们只需要把头节点的下一个节点用一个变量储存起来，然后我们把头节点释放，然后把头节点指向我们刚才变量存起来的那个地址即可；我们next是结构体类型指针，因为我们的next指向的是下一个节点，下一个节点也是结构体，所以我们需要使用结构体类型指针。在进行基本操作前提都是需要节点的，所以我们能将开辟节点的操作写为一个函数，这样在每次使用前调用即可。
数据结构二：单链表（C/C++实现）
qq_62078117的博客
07-30 114
采用C++的引用在修改指针的时候更方便，C中要修改指针的话就要用到指针的指针->二级指针。以上以上均为个人学习心得，如有错误，请不吝赐教~THE END。
C/C++单链表排序
2301_78638761的博客
04-11 404
1.尾插法建立链表。 2.读取链表。 3.对两个链表进行合并。 4.通过位置转换进行链表排序。
C/C++程序员面试指南.杨国祥(带详细书签).pdf
04-08
C、C++语言是IT行业的主流编程语言，也是很多程序员必备的软件基本功，是软件开发行业招聘考查的重点。本书以流行的面试题讲解为主要内容，介绍了C、C++语言基本概念，包括保留字、字符串、指针和引用、结构体、...
数据结构单链表初始化c/c++语言代码实现
01-22
在C或C++中，理解并实现单链表的初始化对于深入学习数据结构至关重要。下面将详细介绍单链表的结构，以及两种在C++中初始化单链表的方法。 一、单链表的基本结构 1. 节点定义：在C++中，我们首先需要定义一个节点...
C 语言冒泡排序算法详解
licy__的博客
11-09 192
冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置来实现排序。尽管冒泡排序的时间复杂度较高（O(n²)），但它因其简单易懂而常用于教学目的。本文将详细介绍冒泡排序的工作原理，并提供一个用 C 语言实现的示例。冒泡排序的基本思想是通过多次遍历待排序的列表，每次遍历时比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。这样，每遍历一次，最大的元素就会像气泡一样“浮”到列表的末尾。这个过程会重复进行，直到整个列表变得有序。
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 898
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
python - leetcode【数据结构-算法】-入门/通关手册
weixin_44151034的博客
11-05 1046
因为笔者马上要去面试了，正在刷leetcode，同时准备着与leetcode相关的python知识点。所以其实主要就是介绍上面两个和python相关的算法帖子。Python学习笔记【Python 和 LeetCode 】Python 基础｜LeetCode 算法知识点总结 ｜ 刷LeetCode笔记 ｜ 整理中。。。LeetCode刷题必知的Python知识Python 必知必会知识点python基础语法——常量、变量、注释、输入输出和运算符python教程。
【数据结构】B树
藓类少女的博客
11-06 862
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
【数据结构】汇编语言和机器语言的‘数据结构‘
最新发布
weixin_44939430的博客
11-09 685
在汇编中，链表的每个节点可以由两个连续的内存区域来表示，一个存储数据，另一个存储下一个节点的地址。
数据结构第七章查找-树表的查找(二叉排序树的查找)
2305_78057683的博客
11-06 147
【代码】数据结构第七章查找-树表的查找(二叉排序树的查找)
C语言入门案例练习1——冒泡法排序
ZIM的博客
11-09 200
持续进行这样的循环，直到整个数列都被排序完成。在每一轮中，比较的次数会逐渐减少，因为每一轮都会确定一个已经排好序的元素，从而减少后续需要比较的范围。通过不断地重复相邻元素比较和交换的过程，最终实现数列的有序排列。从数列的第一个元素开始，依次比较相邻的两个元素。如果前一个元素比后一个元素大（针对升序排列，降序则相反），那么就交换这两个元素的位置。接着，对除了已经排好序的末尾元素之外的剩余数列，重复上述的比较和交换操作。这样一轮比较下来，最大（升序时）或最小（降序时）的元素就会 “浮” 到数列的末尾。
数据结构-堆
wwwwwgery的博客
11-06 352
/存储元素的数组int Size;//堆当前元素的个数//堆的最大容量//最大堆//最小堆#define MAXDATA 1000//该值应根据具体情况定义为大于堆中所以可能元素的值//创建容量为MaxSize的空的最大堆return H;
数据结构学习：单链表操作与C/C++汇编应用
资源摘要信息:"本资源为关于数据结构、汇编语言和C/C++编程的知识集合，特别强调了单链表的基本操作以及与之相关的实验指导。资源标题暗示了包含内容的核心知识范围，而描述和文件名称列表则提供了具体的操作细节和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值