数据结构基础-C/C++实现单链表（带头结点）

已于 2022-04-15 09:51:56 修改
阅读量1.7k 收藏 13
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-04-11 13:52:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42908756/article/details/124097460
版权
  1. 定义结构体
/**
 * @brief 链表节点 
 */
typedef struct LinkedNode{
	// 存储数据  
	int data;
	// 下一个节点的地址 
	LinkedNode *next;	
}LinkedNode, *LinkedList;
  1. 初始化
/**
 * @brief 初始化一个带头结点的单链表
 * 
 * @return LinkedList 单链表的头节点
 */
LinkedList initLinkedListHaveHead() {
	// 为单链表申请一块内存空间，最为头节点
	LinkedList list = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 初始化头节点之后无数据
	list -> next = NULL;
	return list;
}
  1. 判空
/**
 * @brief 有头节点的单链表是否为空
 * 
 * @param l 有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyHaveHead(LinkedList l) {
	// 有头节点判断头节点的next是否为null
	return l -> next == NULL;
}
  1. 遍历打印
/**
 * @brief 遍历打印带头结点单链表
 * 
 * @param list 有头结点单链表
 */
void haveHeadPrint(LinkedList list) {
	LinkedNode *node = list -> next;
	int i = 0;
	while (node != NULL) {
		cout << "data" << i << "：" << node -> data << "\n" << endl;
		node = node -> next;
		i++;
	}
	
}
  1. 第一个位置插入
/**
 * @brief 有头节点的单链表在第一个位置插入
 * 
 * @param list 有头节点的单链表
 * @param data 要插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertToFirst(LinkedList &list, int data) {
	// 如果链表为空不进行插入
	if(list == NULL) {
		return false;
	}
	// 为新节点申请内存空间
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 新节点数据赋值
	node -> data = data;
	// 新节点的next指针指向头节点的next
	node -> next = list-> next;
	// 头节点的next指向新节点
	// 上面一部和这一步顺序不能调换不然将会丢失头节点之后的所有数据
	list -> next = node;
	return true;
}
  1. 按位查找
/**
 * @brief 有头节点按位查找
 * 
 * @param list 有头节点的单链表
 * @param index 要查找的下标（0开始）
 * @return LinkedNode* 节点指针
 */
LinkedNode* haveHeadGetByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return NULL;
	}

	// 下标不合法
	if (index < 0) {
		return NULL;
	}
	
	// 声明临时节点指针指向点链表的第一个元素下标为0
	LinkedNode *node = list -> next;
	int i = 0;
	// 得到对应位置的节点
	while(node != NULL && i < index) {
		node = node -> next;
		i++;
	}
	
	// 结束循环时i的值小于index的值
	// 证明index的值超过了最大下标返回null
	if(i < index) {
		return NULL;
	}
	
	return node;
}
  1. 后插
/**
 * @brief 节点后插入新节点
 * 
 * @param node 执行后插的节点
 * @param data 插入的数据
 * @return true 让如成功
 * @return false 插入失败
 */
bool insertByNodeAfter(LinkedNode *node, int data) {
	// 节点为null无法操作
	if (node == NULL) {
		return false;
	}
	
	// 为新节点申请内存空间
	LinkedNode *newNode = (LinkedNode *)malloc(sizeof(LinkedNode));

	// 新节点数据赋值
	newNode -> data = data;
	// 新节点的下一个元素为后插节点的下一个元素
	newNode -> next = node -> next;
	// 后插节点的下一个元素为新节点
	node -> next = newNode;
	return true;
}
  1. 前插
/**
 * @brief 节点前插入数据
 * 
 * 因为单链表只能向一个方向查找，所以前插操作可以将前插操作的节点数据更新为要插入的数据，然后在将前插节点的原本的数据进行后插
 * 
 * @param node 前插节点
 * @param data 插入数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool insertByNodeFront(LinkedNode *node, int data) {
	// 节点指针为null无法操作
	if (node == NULL) {
		return false;
	}

	// 将前插节点的数据进行保存
	int nodeData = node -> data;
	// 将前插节点的数据更新为要插入的数据
	node -> data = data;
	// 将前插节点的数据以后插方式插入到链表中
	return insertByNodeAfter(node, nodeData);
}
  1. 按下标插入
/**
 * @brief 带头结点的按位插入
 * 
 * @param list 带头结点的单链表
 * @param index 插入位置的下标
 * @param data 插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于零直接调用带头节点的单链表的在第一个位置插入的方法
	if (index == 0) {
		haveHeadInsertToFirst(list, data);
		return true;
	}

	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 调用有头节点的按位查找获取插入下标的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	
	// 如果返回的节点指针为null则证明下标不合法
	if (node == NULL) {
		return false;
	}
	
	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}
  1. 删除第一个
/**
 * @brief 带头结点删除第一个元素
 * 
 * @param list 到头节点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveFirst(LinkedList &list) {
	// 判断带头结点的单链表是否为空
	bool flag = isEmptyHaveHead(list);
	if (flag) {
		// 为空无法操作
		return false;
	}

	// 将带头结点的额第一个元素及逆行临时保存
	LinkedNode *node = list -> next;
	// 将头节点的next域指向第二个节点
	list -> next = node -> next;
	// 释放第一个节点
	free(node);
	// 删除成功
	return true;
}
  1. 按下标删除
/**
 * @brief 有头节点根据下标删除
 * 
 * @param list 有头节点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	
	// 获取删除节点的上一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 上一个节点为空无法操作
	if (node == NULL) {
		return false;
	}

	// 获取删除节点
	LinkedNode *removeNode = node -> next;
	// 将前一节点的next指向删除节点的next
	node -> next = removeNode -> next;
	// 释放删除节点的内存
	free(removeNode);
	// 删除成功
	return true;
}
  1. 按值查找
/**
 * @brief 有头节点的按值获取
 * 
 * @param list 带头结点的单链表
 * @param data 要查找的数据
 * @return LinkedNode* 根据条件查找到的节点
 */
LinkedNode* haveHeadGetValueFirst(LinkedList &list, int data) {
	// 临时指针指向第一个节点
	LinkedNode *node = list -> next;
	while (node != NULL) {
		// 循环如果没到最后一个几点，判断当前节点的数据是否和传入数据相等
		if (node -> data == data) {
			// 相等返回这个节点
			return node;
		}
		// 不相等继续往下一个节点判断
		node = node -> next;
	}
	// 整个链表没找到对应的值返回null
	return NULL;
}
  1. 根据下标修改元素值
/**
 * @brief 有头节点的根据下标修改元素值
 * 
 * @param list 有头结点单链表
 * @param index 下标
 * @param data 目标数据
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByIndex(LinkedList &list, int index, int data) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	// 非法参数
	if (index < 0) {
		return false;
	}
	// 获取要修改位置节点的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 节点为null下标为非法参数
	if (node == NULL) {
		return false;
	}
	// 将修改位置的数据赋值为新的值
	node -> next -> data = data;
	// 修改成功
	return true;
}
  1. 将链表中的某个值全部修改成另一个值
/**
 * @brief 有头结点将链表中的某个值全部修改成另一个值
 * 
 * @param list 有头结点单链表
 * @param source 原值
 * @param target 目标值
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByValue(LinkedList &list, int source, int target) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 临时变量指向链表的第一个元素
	LinkedNode *node = list -> next;
	while (node != NULL) {
		if (node -> data == source) {
			// 如果当前节点的数据和传入的source相同，则修改成target
			node -> data = target;
		}
		node = node -> next;
	}
	// 修改成功
	return true;
}
  1. 尾插法
/**
 * @brief 带头结点的尾插法
 * 
 * @param dataArr 初始数据数组
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的带头结点的单链表
 */
LinkedList haveHeadCreateByTail(int dataArr[], int initLength) {
	// 初始化一个带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	// 新节点指针
	LinkedNode *node = list;
	// 表尾指针
	LinkedNode *tail = list;
	for (int i = 0; i < initLength; i++) {
		// 新节点申请内存空间
		node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据
		node -> data = dataArr[i];
		// 新节点的next只想null
		node -> next = NULL;
		// 表尾指针的next指向新节点
		tail -> next = node;
		// 将尾指针指向当前节点
		tail = node;
	}
	// 返回这个单链表
	return list;
}
  1. 头插法
/**
 * @brief 有头节点的头插法
 * 
 * @param dataArr 初始数据
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的有头节点的单链表
 */
LinkedList haveHeadCreateByHead(int dataArr[], int initLength) {
	// 初始化一个空的带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	for (int i = 0; i < initLength; i++) {
		// 为新节点申请内存kong'jian
		LinkedNode *node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据赋值
		node -> data = dataArr[i];
		if (i == 0) {
			// 头插法第一个元素为初始化完最终的表尾元素，所以next为NULL
			node -> next = NULL;
		} else {
			// 出第一个元素外其他元素next指向头节点的next
			node -> next = list -> next;
		}
		// 头节点指向新节点
		list -> next = node;
	}
	// 返回这个带头节点的单链表
	return list;
}
  1. 逆置
/**
 * @brief 有头结点单链表逆置
 * 
 * @param list 有头结点单链表
 * @return LinkedList 逆置后的单链表
 */
LinkedList haveHeadInversion(LinkedList list) {
	// 定义指针指向存储原单链表的数据
	int *data;
	// 临时指针指向单链表的每个节点
	LinkedNode *node = list -> next;
	LinkedNode *temp;
	// 计数器
	int i = 0;
	while (node != NULL) {
		// 循环单链表的节点存储数据
		data[i] = node -> data;
		temp = node -> next;
		// 释放节点内存空间
		free(node);
		// 指向下一个节点
		node = temp;
		i++;
	}
	// 头插法逆置返回逆置后的单链表
	return haveHeadCreateByHead(data, i);
}

注：在第一个插入、按下标插入以及删除第一个、按下标删除的操作是可以整合在一起的，但是由于个人习惯将其分开，因为插入删除第一个的时间复杂度都是O(1), 但是下标插入、下标删除都是O(n)，并且在调用方法的时候代码的可用性比较高，简单明了。

若有错误欢迎指正，如有不懂也可相互交流

海绵！
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4946
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
单链表（c++带头结点，）
sense_long_h的专栏
08-29 926
#ifndef _SEQLIST_ #define _SEQLIST_ #include using namespace std; #include template class Slist; //节点类 template class Node { public: Node() :data(Type()), next(NULL){} Node(Type d, Node *n = NULL
C++课--单链表的基本操作
weixin_50518617的博客
06-09 1136
链表是一种重要的数据结构，能够动态地进行存储分配的一种结构链表，它与数组比较是不用事先确定存储空间， 链表的实现方式有两种（其实是我只会这两种） 第一种：是通过结构体指针实现。（课本上讲的就是这种方法） 第二种：是通过数组模拟实现。即链式向前星（不需要掌握） 这两种只是实现方式不同，本质是相同的； 下面讲解单链表如何实现： 首先链表的每个节点分为数据域和指针域； 头指针Head指向第一个元素 第一个元素存储第一个数据和指针域指向第二个元素的地址 （第二个元素不必要紧挨着第一个元素） 第二个元素存储第二个数据
C++QT5跨平台界面编程原理和实战大全
11-06
课程讲解基于QT5.9 SDK，包含QT界面编程的核心内容，并提供全部源码，课程讲解方式是接口讲解、分析、演示示例，课程讲解QTCreator在不同平台的配置方法，linux，windows，mac，课程演示主要以vs2015+QT5.9为主，开始会讲解QTCreator配置。课程源码基于c++ 11以上版本，建议至少安装vs2013以上。课程后会做一个图像编辑器的示例。
带头节点的单链表
m0_63852285的博客
11-16 1808
特点： 有一个head指针变量，它存放头结点的地址，称之为头指针。 头节点的指针域head->next，存放首元结点的地址。 每个节点都包含一个数据域和指针域，数据域存放数据，指针域存放下一节点的地址。 最后一个结点不在指向其他结点，它的指针域存放空指针。 链表依靠指针相连不需要占用一块连续的内存空间。 随着处理数据量的增加，链表可以无限制的延长。在插入和删除操作中，只需修改相关节点指针域的链接关系，不需要大量的改变数据的实际储存位置。链表的使用，可以使程序的内存利用率和时间效率大大增加。
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素
06-04
本篇文章将深入探讨在C++中实现数据结构，特别是顺序表和单链表的操作，以及如何处理它们的重复元素和逆序问题。 1. **顺序表**：顺序表是一种简单的数据结构，它的元素存储在一块连续的内存空间中，通过数组的形式...
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，...
ShiYan1_单链表_C++_顺序表_数据结构_
09-29
1．顺序表的验证 (1）定义...用描述学生信息的结构体作为线性表的数据元素类型测试带头结点的单链表。 （2）修改带头结点的单链表类模板中的插入函数，插入元素时按元素值从小到大的顺序插入数据元素到链表的适当位置。
c++实现 不带头结点单链表基本操作
11-24
在C++编程中，单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。不带头结点的单链表是指链表的第一个节点没有专门的头结点，而是直接由数据节点开始。这种链表的...
数据结构 数据结构 带头结点的单链表 操作大全（c++实现） 操作大全（c++实现）代码讲解
09-27
对博文中函数关系的说明 最全的带头结点的单链表操作（c++实现） 已由Keynote转为ppt 博客地址： blog.csdn.net/u012350104
引用表头文件
01-15
以map实现引用表。如有错误，欢迎指教。
clistctrl 自定义表头
03-03
clistctrl自定义表头，用户可以根据需要来定义自己的表头高度，还可以过滤想要的内容。
数据结构 带头结点的单链表 操作大全 最全的链表操作（c++实现）
09-27
1800多行代码 22个功能 最全的链表操作 如需转载请注明出处 我的博文：http://blog.csdn.net/u012350104 欢迎交流 讲解代码中函数的ppt：http://download.csdn.net/detail/u012350104/9143181 Made By Fred韩
带头节点的单链表的基本创建与操作函数
weixin_55626610的博客
11-04 801
我们在链表的头部加入一个“头结点”，如果没有头结点，第一个结点的插入和删除操作跟其他结点不同，需要单独分析，为了省去这个麻烦，因此我们定义了一个头结点，头结点的类型与数据结点一致，标识链表的头指针变量L中存放该结点的地址，这样即使是空表，头指针变量L也不为空了。
C语言数据结构单带头结点的链表和头指针型单链表的基本操作
m0_61799631的博客
04-20 1805
#include <stdio.h> #include <stdlib.h> #define newNode (LinkedList *)malloc(sizeof(LinkedList)) //快捷生成新结点 typedef struct k { //定义单链表 int data; struct k *next; } LinkedList; LinkedList *append() { //尾插法，返回一个带头结点的单链表，注意返回的只能是地址 i...
html设置表头格式
行善之人必有余庆
05-19 7189
设置表头格式 c管理表 物品名 类型 领取人 领取人所属部门 数量 圆珠笔 文具 李丽 PHP 1
C++单链表的建立（有头节点）
Jeff_Winger的博客
10-22 6087
#ifndef chainWithHeader_ #define chainWithHeader_ #include #include //数组 #include //STL中的算法 #include //istringstream流 #include//异常处理 #include//迭代器 #include//标准库中的数学操作函数 #include #include #include
你是一个学习数据结构的大二学生现在需要你结合课上知识完成结课实验报告，以下是实验要求：使用C++编写，（1）创建一个带头结点的单链表。 要求：此单链表长度为10；创建完成后，输出显示所创建单链表各结点的值。 （2）实现单链表的插入，并显示完成插入后单链表各结点的值。 要求：插入一个新的结点，其值为27，成为单链表的第5个结点；插入完成后，输出显示此时单链表的长度以及各结点的值。 （3）实现单链表的删除，完成删除后，输出单链表各结点的值。 （4）编程实现单链表的查找。 要求：如果查找成功，程序能够输出显示该结点位置信息；如果查找失败，程序应显示“该单链表中无此数据元素”信息。
最新发布
05-25
好的，让我们来完成这个实验报告吧！ ## 1. 创建带头结点的单链表 首先，我们需要创建一个带头结点的单链表，长度为10，并输出每个节点的值。 ```c++ #include <iostream> using namespace std; // 定义单链表结构体 struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {} }; int main() { // 创建头结点 ListNode* head = new ListNode(-1); // 创建单链表 ListNode* cur = head; for (int i = 0; i < 10; i++) { ListNode* node = new ListNode(i); cur->next = node; cur = cur->next; } // 输出单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; return 0; } ``` 输出结果为： ``` 0 1 2 3 4 5 6 7 8 9 ``` ## 2. 实现单链表的插入 接下来，我们需要实现单链表的插入，并在插入后输出单链表的各个节点的值。 ```c++ int main() { // 创建头结点 ListNode* head = new ListNode(-1); // 创建单链表 ListNode* cur = head; for (int i = 0; i < 10; i++) { ListNode* node = new ListNode(i); cur->next = node; cur = cur->next; } // 输出单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 插入新结点 ListNode* insertNode = new ListNode(27); cur = head; // 找到第4个节点 for (int i = 0; i < 4; i++) { cur = cur->next; } insertNode->next = cur->next; cur->next = insertNode; // 输出插入后的单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; return 0; } ``` 输出结果为： ``` 0 1 2 3 4 5 6 7 8 9 0 1 2 3 27 4 5 6 7 8 9 ``` ## 3. 实现单链表的删除 现在，我们需要实现单链表的删除，并在删除后输出单链表的各个节点的值。 ```c++ int main() { // 创建头结点 ListNode* head = new ListNode(-1); // 创建单链表 ListNode* cur = head; for (int i = 0; i < 10; i++) { ListNode* node = new ListNode(i); cur->next = node; cur = cur->next; } // 输出单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 插入新结点 ListNode* insertNode = new ListNode(27); cur = head; // 找到第4个节点 for (int i = 0; i < 4; i++) { cur = cur->next; } insertNode->next = cur->next; cur->next = insertNode; // 输出插入后的单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 删除结点 cur = head; // 找到第5个节点 for (int i = 0; i < 5; i++) { cur = cur->next; } cur->next = cur->next->next; // 输出删除后的单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; return 0; } ``` 输出结果为： ``` 0 1 2 3 4 5 6 7 8 9 0 1 2 3 27 4 5 6 7 8 9 0 1 2 3 27 5 6 7 8 9 ``` ## 4. 实现单链表的查找 最后，我们需要实现单链表的查找，并根据结果输出相应的信息。 ```c++ int main() { // 创建头结点 ListNode* head = new ListNode(-1); // 创建单链表 ListNode* cur = head; for (int i = 0; i < 10; i++) { ListNode* node = new ListNode(i); cur->next = node; cur = cur->next; } // 输出单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 插入新结点 ListNode* insertNode = new ListNode(27); cur = head; // 找到第4个节点 for (int i = 0; i < 4; i++) { cur = cur->next; } insertNode->next = cur->next; cur->next = insertNode; // 输出插入后的单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 删除结点 cur = head; // 找到第5个节点 for (int i = 0; i < 5; i++) { cur = cur->next; } cur->next = cur->next->next; // 输出删除后的单链表的值 cur = head->next; while (cur != nullptr) { cout << cur->val << " "; cur = cur->next; } cout << endl; // 查找结点 int searchVal = 4; cur = head->next; int pos = 1; while (cur != nullptr) { if (cur->val == searchVal) { cout << "查找成功，该结点位于第" << pos << "个位置" << endl; break; } cur = cur->next; pos++; } if (cur == nullptr) { cout << "该单链表中无此数据元素" << endl; } return 0; } ``` 输出结果为： ``` 0 1 2 3 4 5 6 7 8 9 0 1 2 3 27 4 5 6 7 8 9 0 1 2 3 27 5 6 7 8 9 查找成功，该结点位于第4个位置 ``` 好的，这就是本次实验报告了。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值