单链表的基本操作C语言实现

最新推荐文章于 2023-08-15 16:50:52 发布
最新推荐文章于 2023-08-15 16:50:52 发布
阅读量1.4k 收藏 13
点赞数 3
分类专栏： 数据结构 文章标签： 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sofia_m/article/details/78277901
版权

          单链表主要有以下基本操作：头插，尾插，头删，尾删，返回结点在链表中的位置，任意位置插入值为data的结点， 删除pos位置上的结点 ，求链表中节点的个数，销毁单链表 。

 

      代码如下所示：

List.h

#ifndef __LINKED_LIST__
#define __LINKED_LIST__

typedef int DataType;
typedef struct Node
{
	DataType _data;
	struct Node * _pNext;
}*pNode;

void InitList(pNode* pHead);//初始化
void PushBack(pNode* pHead,DataType _data);//尾插数据
pNode BuyNode(DataType data);//构建新节点
void PopBack(pNode* pHead);//尾删
void PrintList(pNode pHead);//打印链表
void PoshFront(pNode* pHead,DataType data);//头插数据
void PopFront(pNode* pHead);//头删
void DestoryList(pNode* pHead);//销毁链表
pNode Insert(pNode pos,DataType data);//定向插入
pNode FindList(pNode pHead,DataType data);//查找
void Erase(pNode* pHead,pNode pos);//定向删除
int SizeList(pNode pHead);//节点个数

// 逆向打印单链表 
void PrintListFromTail2Head(pNode pHead);
// 逆向销毁单链表 
void DestroyListFromTail2Head(pNode* pHead);
// 删除单链表的非尾结点 
void DeleteNotTailNode(pNode pos);
// 非头结点前插入data 
void InsertNotHead(pNode pos,DataType data);
// 单链表实现约瑟夫环 
pNode JosephCircle(pNode pHead, int M); 
// 单链表的逆置--前后指针 
pNode ReverseList_1(pNode pHead); 
// 单链表的逆置--头插法 
pNode ReverseList_2(pNode pHead); 
//使用递归实现单链表的逆置
pNode ReverseList_3(pNode pCur,pNode pHead);
//利用栈实现逆向打印链表
void PrintListFromTail2Head_Stack(pNode pHead);
// 查找链表的中间结点---要求不能遍历单链表 
pNode FindMidNode(pNode pHead);
//使用冒泡对单链表进行排序
void BubbleSort(pNode pHead);
//合并两个已序链表，合并之后新链表仍然有序
pNode MergeList(pNode pHead1,pNode pHead2);
//查找无头单链表的倒数第K个节点
pNode FindLastKNode(pNode pHead,int K);
//删除无头单链表的倒数第K个节点
pNode DeleteLastKNode(pNode* pHead,int K);
//返回链表的最后一个节点
pNode BackList(pNode pHead);
// 判断链表是否带环，如果带环求环的长度，并给出入口点
pNode HasCircle(pNode pHead);
int GetCircleLen(pNode pHead);
pNode GetEnterNode(pNode pHead,pNode pMeetNode);
//判断两个链表是否相交(不含环)
int IsCrossWithoutCircle(pNode pHead1,pNode pHead2);
//两个链表相交的交点(不含环)
pNode GetCrossWithoutCircle(pNode pHead1,pNode pHead2);
//判断两个链表是否相交(可能含环)
int IsCrossWithCircle(pNode pHead1,pNode pHead2);
//两个链表相交的交点(可能含环)
pNode GetCrossWithCircle(pNode pHead1,pNode pHead2);
#endif //__LINKED_LIST__

 

List.cpp

#include"LinkedList.h"
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<iostream>
#include<stack>

using namespace std;

void InitList(pNode* pHead)
{
	assert(pHead);
	*pHead = NULL;
}
pNode BuyNode(DataType data)
{
	pNode pNewNode = (pNode)malloc(sizeof(struct Node));
	if(NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;
	return pNewNode;
}
void PushBack(pNode* pHead,DataType _data)
{
	assert(pHead);
	if(NULL == *pHead)
	{
		*pHead = BuyNode(_data);
	}
	else
	{
		pNode pTailNode = *pHead;
		while(pTailNode->_pNext)
		{
			pTailNode = pTailNode->_pNext;
		}
		pTailNode->_pNext = BuyNode(_data);
	}
}

void PopBack(pNode* pHead)
{
	if(NULL == *pHead)
		return;
	else if(NULL == (*pHead)->_pNext)
	{
		free(*pHead);
		*pHead = NULL;
	}
	else
	{
		pNode pTailNode = *pHead;
		pNode pPre = NULL;
		while(pTailNode->_pNext)
		{
			pPre = pTailNode;
			pTailNode = pTailNode->_pNext;
		}
		pPre->_pNext = NULL;
		free(pTailNode);
	}
}
void PrintList(pNode pHead)
{
	pNode pCur = pHead;
	while(pCur)
	{
		printf("%d--->",pCur->_data);
		pCur = pCur->_pNext;
	}
	printf("NULL\n");
}
void PoshFront(pNode* pHead,DataType data)
{
	pNode pNewNode;
	assert(pHead);
	pNewNode = BuyNode(data);
	if(NULL == pNewNode)
		return;
	pNewNode->_pNext = *pHead;
	*pHead = pNewNode;

}
void PopFront(pNode* pHead)
{
	pNode pCur = *pHead;
	assert(pHead);
	if(NULL == pCur)
		return;
	else
	{
		*pHead = (*pHead)->_pNext;
		free(pCur);
	}
}
pNode FindList(pNode pHead,DataType data)
{
	pNode pCur = pHead;
	while(pCur)
	{
		if(pCur->_data == data)
			return pCur;
		else
			pCur = pCur->_pNext;
	}
	return NULL;
}
pNode Insert(pNode pos,DataType data)
{
	pNode pNewNode;
	if(NULL == pos)
		return NULL;
	pNewNode = BuyNode(data);
	if(NULL == pNewNode)
		return NULL;
	pNewNode->_pNext = pos->_pNext;
	pos->_pNext = pNewNode;
}
void Erase(pNode* pHead,pNode pos)
{
	assert(pHead);
	if(NULL == *pHead || NULL == pos)
		return;
	if(*pHead == pos)
		PopFront(pHead);
	else
	{
		pNode pCur = *pHead;
		while(pCur)
		{
			if(pCur->_pNext == pos)
				break;
			pCur = pCur->_pNext;
		}
		pCur->_pNext = pos->_pNext;
		free(pos);
	}
}
void DestoryList(pNode* pHead)
{
	//正向销毁
	pNode pCur = *pHead;
	pNode pNext = NULL;
	while(pCur)
	{
		pNext = pCur->_pNext;
		free(pCur);
		pCur = pNext;
	}
	*pHead = NULL;
}
int SizeList(pNode pHead)
{
	int count = 1;
	pNode pCur = pHead;
	while(pCur)
	{
		count++;
		pCur = pCur->_pNext;
	}
	return count;
}
//返回链表的最后一个节点
pNode BackList(pNode pHead)
{
	pNode pCur = pHead;
	if(NULL == pHead)
		return NULL;
	while(pCur->_pNext)
		pCur = pCur->_pNext;
	return pCur;
}
// 逆向打印单链表 --递归实现
void PrintListFromTail2Head(pNode pHead)
{
	if (pHead != NULL){
		if (pHead->_pNext != NULL){
			PrintListFromTail2Head(pHead->_pNext);
		}
		printf("%d\t", pHead->_data);
	}
}

//利用栈实现逆向打印链表
void PrintListFromTail2Head_Stack(pNode pHead){
	stack<pNode> nodes;

	pNode pCur = pHead;
	while (pCur != NULL){
		nodes.push(pCur);
		pCur = pCur->_pNext;
	}
	while (!nodes.empty()){
		pCur = nodes.top();
		printf("%d\t", pCur->_data);
		nodes.pop();
	}
}

// 逆向销毁单链表 
void DestroyListFromTail2Head(pNode* pHead)
{
	assert(pHead);
	if(pHead)
	{
		DestroyListFromTail2Head(&(*pHead)->_pNext);
		free(*pHead);
		*pHead = NULL;
	}
}
// 删除单链表的非尾结点
void DeleteNotTailNode(pNode pos)
{
	pNode pCur = NULL;
	if(pos)
	{
		pCur = pos->_pNext;
		pos->_data = pCur->_data;
		pos->_pNext = pCur->_pNext;
		free(pCur);
	}
}
// 非头结点前插入data 
void InsertNotHead(pNode pos,DataType data)
{
	pNode pNewNode;
	pNode pCur;
	if(NULL == pos)
		return;
	pNewNode = BuyNode(data);
	if(NULL == pNewNode)
		return;
	pCur = pos;
	pNewNode->_pNext = pCur->_pNext;
	pCur->_pNext = pNewNode;
}

// 单链表实现约瑟夫环 
pNode JosephCircle(pNode pHead, int M)
{
	pNode pCur;
	pNode pDel;
	int count = 0;
	if(NULL == pHead)
		return NULL;
	pCur = pHead;
	//构环
	while(pCur->_pNext)
	{
		pCur=pCur->_pNext;
	}
	pCur->_pNext = pHead;
	pCur = pHead;
	while(pCur != pCur->_pNext)
	{
		//报数
	    count = M;
	    while(--count)
	    {
		    pCur = pCur->_pNext;
	    }
	    //删节点
	    pDel = pCur->_pNext;
	    pCur->_data = pDel->_data;
	    pCur->_pNext = pDel->_pNext;
	    free(pDel);
	}
	//解环
	pCur->_pNext = NULL;
	return pCur;
}

// 单链表的逆置--前后指针 
pNode ReverseList_1(pNode pHead)
{
	pNode  pPre;
	pNode  pCur;
	pNode  pNext;
	if(NULL == pHead || NULL == pHead->_pNext)
		return NULL;
	pPre = pHead;
	pCur = pPre->_pNext;
	pNext = pCur->_pNext;
	pHead->_pNext = NULL;
	while(pNext)
	{
		pCur->_pNext = pPre;
		pPre = pCur;
		pCur = pNext;
		pNext = pCur->_pNext;
	}
	pCur->_pNext= pPre;
	return pCur;
}

// 单链表的逆置--头插法 
pNode ReverseList_2(pNode pHead)
{
	pNode pPre = NULL;
	pNode pCur = NULL;
	pNode pNewHead = NULL;
	if(NULL == pHead)
		return NULL;
	pPre = pHead;
	pCur = pHead->_pNext;
	while(pCur)
	{
		pPre->_pNext = pNewHead;
		pNewHead = pPre;
		pPre = pCur;
		pCur = pPre->_pNext;
	}
	pPre->_pNext = pNewHead;
	pNewHead = pPre;
	return pNewHead;
}
//使用递归实现单链表的逆置
pNode ReverseList_3(pNode pCur,pNode pHead)
{
	if((NULL == pCur) || (NULL == pCur->_pNext))
	{
		pHead = pCur;
		return pCur;
	}
	else
	{
		pNode pNext = ReverseList_3(pCur->_pNext,pHead);
		pNext->_pNext = pCur;
		pCur->_pNext = NULL;
		return pCur;
	}
}
 
pNode FindMidNode(pNode pHead)
{
	pNode pSlow = pHead;
	pNode pFast = pHead;
	if(NULL == pHead)
		return NULL;
	while(pFast && pFast->_pNext)
	{
		pSlow = pSlow->_pNext;
		pFast = pFast->_pNext->_pNext;
	}
	return pSlow;
}
//使用冒泡对单链表进行排序
void BubbleSort(pNode pHead){
	pNode pCur = pHead;
	pNode pPreCur = NULL;
	pNode pTail = NULL;
	int ischange = 0;
	if(NULL == pHead || NULL == pHead->_pNext)
		return;
	while(pTail != pHead){
		pPreCur = pHead;
		pCur = pHead->_pNext;
		ischange = 0;
		while(pCur != pTail){
			if(pPreCur->_data > pCur->_data){
				DataType temp = 0;
				temp = pPreCur->_data;
				pPreCur->_data = pCur->_data;
				pCur->_data = temp;
				ischange = 1;
			}
			pPreCur = pCur;
			pCur = pCur->_pNext;
		}
		if(!ischange)
			pTail = pPreCur;
	}
}
//合并两个已序链表，合并之后新链表仍然有序
pNode MergeList(pNode pHead1,pNode pHead2){
	pNode pNewHead = NULL;
	pNode pCur1 = pHead1;
	pNode pCur2 = pHead2;
	pNode pTailNode = NULL;
	if(NULL == pCur1)
		return pCur2;
	if(NULL == pCur2)
		return pCur1;
	if(pCur1->_data <= pCur2->_data){
		pNewHead = pCur1;
		pTailNode = pCur1;
		pCur1 = pCur1->_pNext;
	}
	else{
		pNewHead = pCur2;
		pTailNode = pCur2;
		pCur2 = pCur2->_pNext;
	}
	while( pCur1 && pCur2){
		if(pCur1->_data < pCur2->_data){
			pTailNode->_pNext = pCur1;
			pCur1 = pCur1->_pNext;
		}
		else{
			pTailNode->_pNext = pCur2;
			pCur2 = pCur2->_pNext;
		}
		pTailNode = pTailNode->_pNext;
	}
	if(pCur1)
		pTailNode->_pNext = pCur1;
	if(pCur2)
		pTailNode->_pNext = pCur2;

	return pNewHead;
}
pNode FindLastKNode(pNode pHead,int K){
	pNode pFast = pHead;
	pNode pSlow = pHead;
	if(NULL == pHead || K<=0)
		return NULL;
	while(K--){
		if(NULL == pFast)
			return NULL;
		pFast = pFast->_pNext;
	}
	while(pFast){
		pFast = pFast->_pNext;
		pSlow = pSlow->_pNext;
	}
	return pSlow;
}
//删除无头单链表的倒数第K个节点
pNode DeleteLastKNode(pNode* pHead,int K){
	pNode pFast = *pHead;
	pNode pPreSlow = NULL;
	pNode pSlow = *pHead;
	if(NULL == *pHead || K<=0)
		return NULL;
	while(K--){
		if(NULL == pFast)
			return NULL;
		pFast = pFast->_pNext;
	}
	while(pFast){
		pFast = pFast->_pNext;
		pPreSlow = pSlow;
		pSlow = pSlow->_pNext;
	}
	pPreSlow->_pNext = pSlow->_pNext;
	return *pHead;
}
//判断链表是否带环
pNode HasCircle(pNode pHead)
{
	pNode pFast = pHead;
	pNode pSlow = pHead;
	if(NULL == pHead)
		return NULL;
	while(pFast && pFast->_pNext)
	{
		pFast = pFast->_pNext->_pNext;
		pSlow = pSlow->_pNext;
		if(pSlow == pFast)
			return pFast;
	}
	return NULL;
}
//得到带环链表环的长度
int GetCircleLen(pNode pHead)
{
	pNode pMeetNode = HasCircle(pHead);
	pNode pCur = pMeetNode;
	int count = 1;
	if(NULL == pMeetNode)
		return 0;
	while(pCur->_pNext != pMeetNode)
	{
		count++;
		pCur = pCur->_pNext;
	}
	return count;
}
//含环链表入口点
pNode GetEnterNode(pNode pHead,pNode pMeetNode)
{
	pNode pH = pHead;
	pNode pM = pMeetNode;
	if(NULL == pHead || NULL == pMeetNode)
		return NULL;
	while(pH != pM)
	{
		pH = pH->_pNext;
		pM = pM->_pNext;
	}
	return pH;
}
//判断两个链表是否相交(不含环)
int IsCrossWithoutCircle(pNode pHead1,pNode pHead2)
{
	pNode pTailNode1 = NULL;
	pNode pTailNode2 = NULL;
	if(NULL == pHead1 || NULL == pHead2)
		return 0;
	pTailNode1 = BackList(pHead1);
	pTailNode2 = BackList(pHead2);
	if(pTailNode1 == pTailNode2)
		return 1;
	return 0;
}
//两个链表相交的交点(不含环)
pNode GetCrossWithoutCircle(pNode pHead1,pNode pHead2)
{
	int size1 = 0,size2 = 0;
	int grap = 0;
	pNode pCur1 = pHead1;
	pNode pCur2 = pHead2;
	if(!IsCrossWithoutCircle(pHead1,pHead2))
		return NULL;
	size1 = SizeList(pHead1);
	size2 = SizeList(pHead2);
	grap = size1 - size2;
	if(grap>0)
	{
		while(grap--)
			pCur1 = pCur1->_pNext;
	}
	else
	{
		while(grap++)
			pCur2 = pCur2->_pNext;
	}
	while(pCur1 != pCur2)
	{
		pCur1 = pCur1->_pNext;
		pCur2 = pCur2->_pNext;
	}
	return pCur1;
}
//判断两个链表是否相交(可能含环)
int IsCrossWithCircle(pNode pHead1,pNode pHead2)
{
	pNode pMeet1 = HasCircle(pHead1);
	pNode pMeet2 = HasCircle(pHead2);
	if(NULL == pMeet1 && NULL == pMeet2)//都不带环
	{
		if(BackList(pHead1) == BackList(pHead2))
			return 1;
	}
	else if(pMeet1 && pMeet2)//都带环
	{
		pNode pCur = pMeet1;
		while(pCur->_pNext != pCur)
		{
			if(pCur == pMeet2)
				return 2;
			pCur = pCur->_pNext;
		}
		if(pCur == pMeet2)
			return 2;
	}
	return 0;
}


     然后就可以在函数模块调用以上单链表的基本操作。这里就不再放主函数了^_^

 

sofia_m
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现单链表基本操作
Yz529的博客
05-28 209
单链表基本的操作有增删改查： 基本操作代码如下： 初始化： typedef struct list_node { int data; struct list_node *next; } LinkList; //初始化单链表L为空--头结点,即创建头结点 LinkList *ListInit(LinkList *L) { L = (LinkList *)malloc(sizeof(LinkList)); if (!L) { exit(-1);
单链表c语言基本操作
Nutinsist的博客
03-13 2594
#include<stdio.h> #include<stdlib.h> typedef struct Lnode{ int data;//数据域 struct Lnode* next;//指针域 }Lnode,*LinkList; //链表的初始化 void initiList(LinkList L){ L = (LinkList)malloc(sizeof(LinkList)); L->next = NULL; return; } void destro.
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
c语言 链表基本操作
weixin_63178060的博客
08-29 8316
当链表不为空时，则需循环遍历链表，找到链表中最后一个结点，然后将其的next域指向新节点，即cur->next=newnode，此时，不需要将新节点的next域赋值为空，因为在创建结点函数中已将next域赋值为空。在进行头插元素的时候，第一步和第二步不能进行交换，如果先进pre->next=s,此时pre->next指向了s,在进行s->next=pre->next，就会使s->next指向自己本身，无法达到预期效果。如果给定位置正常，则直接将给定位置的next指向，给定位置的next的next。...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
C语言链表详解（通俗易懂）
weixin_61661271的博客
06-05 5万+
线性表是实际中广泛应用的重要数据结构，本文用通俗易懂的方法讲解它。
单链表基本操作接口-c语言实现
09-12
单链表是一种基础的数据结构，它由一系列...总结来说，这个项目是关于使用C语言实现单链表基本操作的示例，包括创建、插入、删除、查找和打印链表节点。通过这些操作，我们可以理解和掌握链表数据结构的使用和管理。
基于C语言实现单链表的基本操作
最新发布
03-25
以上就是使用C语言实现单链表的基本操作。通过这些函数，我们可以对链表进行各种常见的操作，例如创建、插入、删除、查找、打印、计算长度以及反转。在实际应用中，可以根据具体需求扩展这些功能，比如合并两个已...
C语言实现单链表的操作
07-27
C语言实现单链表的所有基本操作，500行左右，键盘输入
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
用C语言实现单链表的各种操作(一)
09-05
本文将详细介绍如何用C语言实现单链表的各种操作。 首先，我们定义链表的结构体`LNode`，它包括一个数据域`ElemType data`和一个指向下一个节点的指针`struct LNode *next`： ```c typedef struct LNode{ ...
C语言之链表详解
Wang_XB_3434的博客
04-10 6205
链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个值和指向下一个节点的指针。链表的特点是可以动态添加和删除节点，而不需要预先知道数据的数量。与数组不同，链表中的节点不一定是连续的存储空间，因此可以有效地利用内存空间。int val;
C语言数据结构之链表
qq_53918454的博客
10-19 5243
从某个节点前面插入新节点比从后面插入要多进行一次判断，判断是否为头节点，另一个要注意的地方就是while里的判断条件是用p->next来判断的，这是因为我们可以通过p来找到p的后一个，但是找不到p的前一个，所以这里我们灵活变换一下，代码实现逻辑和从后面插入大同小异。删除一个节点实现逻辑也很好理解，肯定也是要不断遍历，找到对应节点后把原本指向它的结构体指针指向它的下一个，然后按道理我们要把它free掉，上面的代码就是实现尾插法创建链表，这种方式创建出链表中节点的顺序也就是我们正常所认为的顺序，最先的就是头。
链表基本操作（详解）
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
链表（C语言版）超详细讲解
h220321204的博客
08-15 1万+
而如果使用头插法，则需要遍历到链表的第一个节点，时间复杂度为O(n)，而且尾插法是由数据插入的顺序依次存储的，查找起来会更加方便。1、首先我们定义两个指针（x1,p）,x1作为头指针指向头结点（尾插法时不要移动头指针，我们只需移动p即可），p始终指向尾结点（这里我们初始化指向头结点），再申请一块结点并用x指向它。这样我们基础工作完成。
【C语言】 链表 超详细解析
m0_56051805的博客
09-29 1万+
【C语言】 链表 超详细解析
C语言中的链表
Innocence网的博客
09-11 3552
链表，一种常见的数据结构。
【数据结构】堆结构小根堆，大根堆，插入，删除等操作的实现
sofia_m的博客
01-21 1万+
一、堆的基本概念 【含义】：如果有一个关键码的集合K={k0,k1,k2, … ,k(n-1)}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：ki = k2*i+1 且 ki >= k2*i+2 )i=0,1,2 … ，则称这个堆为最小堆（或最大堆）。 【最小堆】：任一节点的关键码均小于等于它的左右孩子的关键码，位于堆顶节点的关键码最小。 【最大堆】：任一节点
单链表基本操作c语言
09-06
接下来，我们可以实现一些基本操作，比如创建单链表、插入节点、删除节点和遍历单链表等。 创建单链表的函数如下所示，可以根据给定的数组创建一个单链表： ```c struct ListNode* createLinkedList(int arr[], ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值