C++线性表的链式存储结构

最新推荐文章于 2023-03-12 09:04:32 发布
最新推荐文章于 2023-03-12 09:04:32 发布
阅读量1.5k 收藏 17
点赞数 3
分类专栏： 数据结构 C++ 链式线性表 文章标签： C++线性表的链式存储结构 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43336390/article/details/101055374
版权

C++实现线性表的链式存储结构：

为了解决顺序存储不足：用线性表另外一种结构-链式存储。在顺序存储结构(数组描述)中，元素的地址是由数学公式决定的，而在链式储存结构中，元素的地址是随机分布的，每个元素都有一个明确的指针指向线性表的下一个元素的位置（即地址）。

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。在顺序结构中，每个数据元素只需要存数据元素信息就行了，而在链式结构中，除了存储数据元素信息外，还要存储它的后继元素的存储地址。所以一般结点包括两个信息：数据和指针。链表就是n个节点组成的，如果每个结点只包含一个指针，那么就是单链表。

有头有尾：我们把链表中第一个结点的存储位置叫作头指针，那么整个链表的存取就必须是从头指针开始进行的。而线性链表的最后一个结点指针为空（NULL）。从下图中可以看到，结点都是由两部分组成，数据域和指针域。
在这里插入图片描述
有时，为了更方便对链表进行操作，会在单链表的第一个结点前加一个头结点。头结点的数据域可以不存储任何信息，也可以存储如线性表长度等附加信息，头结点的指针域存储指向第一个结点的指针。
在这里插入图片描述
头指针和头结点的异同

  1. 指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。

  2. 头指针具有标识作用，所以常用头指针冠以链表的名字。

  3. 无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

（这句话真的歧义，若没有头结点，头指针head指向第一个节点，当空表时，head=NULL。应该是必须要有头指针。）

头结点

（1）头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（也可存放链表的长度）

（2）有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其它结点的操作就统一了。

（3）头结点不一定是链表必须的要素。

链式存储结构的线性表进行的基本操作。主要包括：

  • 插入：操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入
  • 删除：操作方式可分为删除指定元素、删除指定位置的元素，删除第一个元素，删除最后一个元素
  • 显示数据
  • 查找：查询指定的元素（可根据某个数据成员完成查询操作）
  • 定位操作：定位指定元素的序号
  • 更新：修改指定元素的数据
  • 数据文件的读写操作
  • 计算链表的长度

这是测试函数写的一个大概功能展示

定义一个结点类
/*Define a friend class to facilitate direct manipulation of data*/
template<class T>
class LinkList;
template <class T>
class LinkNode
{
	friend class LinkList<T>;
	private:
			T _data;
			LinkNode<T>  *_next;
	public:
		LinkNode(T x ) 
		{
			_data = x;
			_next = NULL;
		}
};
链表的主要函数构成
template <class T>
class LinkList
{
		
	private:
			LinkNode<T> * _head;
	public:
	LinkList()
	{_head = NULL;}
	LinkNode<T>* _CreateNode(const T& x);//Create a new node
	void clear(LinkNode<T>* &cur);//Delete a new node
	void PushBack(const T& x);//tail insertion to create a linked list
	void PushFront(const T& x);//Head insertion to create a linked list
	void PopBack();	//Remove an element from the tail
	void PopFront();//Remove an element from the head
	int Length();//Find the length of the linear table
	LinkNode<T>* Find(T x);//Find a number
	void Insert_right(int pos, const T& x);//Insert after the nth
	void Insert_cur(int pos, const T& x);//Insert at the specified location
	void Insert_left(int pos, const T& x);//Insert in front of the nth
	void Delete_pos(int pos);//Delete the nth element
	void Delete_val(const T& x);//Delete specified element
	void reset(const T &x,const T &y);//Update an element
	int located(const T &x);//Locate the serial number of the specified element
	void Print();// Print linear table
	bool writeToFile();//Write file
	T* readFromFile();//Read in data file
	int readlen();
};
各个函数的实现
Print()函数
template<class T>
void LinkList<T>::Print()
{
	LinkNode<T>  *tmp = _head;
	while (tmp != NULL)
	{
		cout << tmp->_data << "-->";
		tmp = tmp->_next;
	}
	cout << "NULL" << endl;
}
创建一个新的结点，并为其分配空间
template <class T>
LinkNode<T>* LinkList<T>:: _CreateNode(const T& x)
{
	LinkNode<T>* tmp = new LinkNode<T>(x);
	return tmp;
}
清除某一个节点，释放空间
template<class T>
void LinkList<T>::clear(LinkNode<T> *&cur)
{
		cur->_next = NULL;
		delete  cur;
		cur = NULL;
}
获得链表的长度
template<class T>
int LinkList<T> ::Length()
{
	
	int len = readlen();/*调用一个读文件的函数，来判别链表状态，Call a function that reads the file to determine the state of the linked list*/
	if(len>0){
		return len;
	}
	else {
	len=0;
	if (_head == NULL)
	{
		return 0;
	}
	else
	{
		LinkNode<T> * begin = _head;
		while (begin != NULL)
		{
			begin = begin->_next;
			len++;
		}
	}
	}
	return len;
}
前插法建立链表

从一个空表开始，重复读入数据，执行以下两步
（1）生成新的结点，将读入数据存放在新节点的的_data域中
（2）将该节点插入到链表的前端，直到读入到结束符为止。

template <class T>
void LinkList<T> :: PushFront(const T& x)	
{
	if (_head == NULL)
	{
		_head = _CreateNode(x);
	}
	else
	{
		LinkNode<T>  * prev = _CreateNode(x);
		prev->_next = _head;
		_head = prev;
	}
}
用后插法建立链表

需要设置一个尾部指针end,总是指向新链表的最后一个节点，新节点链接到它所指链尾节点的后面。end最初要置于附加头节点位置

template <class T>
void LinkList<T> ::PushBack(const T& x)		
{
	if (_head == NULL)
	{
		_head = _CreateNode(x);
	}
	else
	{
		LinkNode<T> * end = _head;
		while (end->_next != NULL)
		{
			end = end->_next;
		}
		end->_next = _CreateNode(x);
	}
}
从尾部删除一个数据

考虑只有一个节点情况，多个结点的情况。
多个结点，首先找到尾部元素，然后调用clear()函数，清理掉尾部第一个元素

template <class T>
void LinkList<T> :: PopBack()			
{
	if (_head == NULL)
	{
		cout << "The List is empty!!!" << endl;
		return;
	}
	else if (_head->_next == NULL)
	{
		clear(_head);
	}
	else
	{
		LinkNode<T> * temp = _head;
		LinkNode<T> * end = _head;
		while (end->_next != NULL)
		{
			temp = end;
			end = end->_next;
		}
		temp->_next = NULL;
		clear(end);
	}
}
从头部删除一个元素

实现方法和从尾部删除一个元素基本相似，不多加以解释

template <class T>
void LinkList<T> ::PopFront()				
{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
			return;
		}
		else if (_head ->_next == NULL)
		{
			clear(_head);
		}
		else
		{
			LinkNode<T> * tmp = _head;
			_head = _head->_next;
			clear(tmp);
			tmp = NULL;
	}
}
查找某一个元素

遍历整个链表，并将其数据_data与x进行比对，如果是其他类型就需要重载运算符==

template <class T>
LinkNode<T>* LinkList<T> ::Find (T x)
{
	if (_head == NULL)
	{
		cout << "List is empty,not found!!!" << endl;
		return NULL;
	}
	else if(_head->_data==x)
	{
		return _head;
	}
	else
	{
		LinkNode<T> * n = _head ;
		while (n->_next != NULL && n->_data != x )
		{
			n = n->_next;
			if (n->_data == x)
			{
				return n;
			}
		}
	}
	return NULL;
}
在第pos个元素后插入一个新元素

创建一个新的结点，通过移动begin指针，pos控制指针最终位置，将新元素插入到之后

template <class T>
void LinkList<T> ::Insert_right(int pos,const T& x)
{
	int len = Length();
	if (pos <= len)
	{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
			return;
		}
		else
		{
			LinkNode<T> * begin = _head;
			LinkNode<T> * tmp = _CreateNode(x);
			while (--pos)
			{
				if (begin->_next != NULL)
				{
					begin = begin->_next;
				}
			}
			tmp->_next = begin->_next;
			begin->_next = tmp;
		}
	}
	else
	{
		cout << "Input Error!!!" << endl;
	}
}
在第pos个元素插入一个新元素

因为写了一个在后面插入的函数，为了偷懒，就直接调用了Insert_right()这个函数

template <class T>
void LinkList<T> ::Insert_cur(int pos,const T& x)
{
	int len = Length();
	if (pos <= len)
	{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
			return;
		}
		else
		{
			Insert_right(pos-1, x);
		}
	}
	else
	{
		cout << "Input Error!!!" << endl;
	}
}
在第pos个元素前插入一个新元素

创建一个新的结点，通过移动begin指针，pos控制指针最终位置，将新元素插入到之前，与插入之后实现方法基本类似，只是需要注意pos的控制

template <class T>
void LinkList<T> ::Insert_left(int pos,const T& x)
{
	int len = Length();
	int temp=pos-1;
	if (pos <= len)
	{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
			return;
		}
		else
		{
			LinkNode<T> * begin = _head;
			LinkNode<T> * tmp = _CreateNode(x);
			while (--temp)
			{
				if (begin->_next != NULL)
				{
					begin = begin->_next;
				}
			}
			tmp->_next = begin->_next;
			begin->_next = tmp;
		}
	}
	else
	{
		cout << "Input Error!!!" << endl;
	}
}
删除第pos个元素

依旧利用pos控制指针位置，然后删除就ok

template <class T>
void LinkList<T> ::Delete_pos(int pos)		
{
	int len = Length();
	if (pos <= len)
	{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
		}
		else if (_head->_next == NULL)
		{
			clear(_head);
		}
		else
		{
			LinkNode<T> * begin = _head->_next;
			LinkNode<T> * temp = _head;
			pos = pos - 1;
			while (--pos)
			{
				if (begin->_next != NULL)
				{
					begin = begin->_next;
					temp = temp->_next;
				}
			}
			temp->_next = begin->_next;
			begin->_next = temp;
		}
	}
	else
	{
		cout << "Input Error!!!" << endl;
	}
}
查找某一个元素位置并返回其位置

用一个temp进行计数，遍历整个链表，一一进行比对其——data数据（若是其它类型就需要重载运算符“=”，后面的函数提到比对的都需要实现，才能进行比对）比对成功就返回，其它类的实现依然需要重载

template <class T>
int LinkList<T> ::located(const T &x)
{
	if (_head == NULL)
	{
		cout << "List is empty,not found!!!" << endl;
		return -1;
	}
	else if(_head->_data==x)
	{
		return 1;
	}
	else
	{
		LinkNode<T> * n = _head ;
		int temp=0;
		while (n->_next != NULL && n->_data != x )
		{
			n = n->_next;
			temp++;
			if (n->_data == x)
			{
				return temp+1;
			}
		}
	}
	return -1;
}
删除指定的元素遍历链表

一一比对，找到就调用chear()函数删除并清理空间

template <class T>
void LinkList<T> ::Delete_val(const T &x)
{
	if (_head == NULL)
	{
		cout << "List is empty!!!" << endl;
		return;
	}
	else if (_head->_next == NULL && _head->_data == x)
	{
		clear(_head);
		return;
	}
	else
	{
		if(_head->_data==x){
			while(1){
				if(_head->_data!=x)break;
				PopFront();
			}
		}
		else
		{
			while(1)
			{
				LinkNode<T> * n = Find(x);
				if(n==NULL)break;
				else{
					LinkNode<T> * begin = _head;
					while (begin->_next != n && begin->_next != NULL)
					{
						begin = begin->_next;
					}
					begin->_next = n->_next;
					clear(n);
				}
				
			}
			return ;
		}
	}
	return;
}
更新指定元素的值

遍历链表，一一比对（前面提到了重载的），找到要更新的元素后就将新的值赋值给它

template <class T>
inline void LinkList<T>::reset(const T &x,const T &y)
{
		if (_head == NULL)
		{
			cout << "List is empty!!!" << endl;
			return ;
		}
		else
		{
			while(1)
			{
				LinkNode<T> * n = Find(x);
				if(n==NULL)break;
				else{
					n->_data=y;
				}
			}
		}
}
链表的数据写入文件

能实现所有数据的储存，但是如果是其他类，写入没有问题，如果想从同一个文件中读入之前写的数据，遇到一些困难没有实现，但是基本数据类型是ok的,测试函数就表现出来了的（其它类的读入需要重载输入流，输出流）

template <class T>
inline bool LinkList<T>::writeToFile()
{
	ofstream writefile("data.txt");
	int len;
	len=Length();
	writefile<<len<<endl;
	LinkNode<T> * begin=_head;
	while(begin!=NULL)
	{
		writefile<<begin->_data<<endl;
		begin=begin->_next;
	}
	return true;
}
从文件读入先前写入的数据，上面有提到只能满足基本数据类型
template <class T>
inline T* LinkList<T>::readFromFile()
{
	ifstream readfile("data.txt");
	int length;
	readfile>>length;
	T *temp=new T[length];
	for(int i=0;i<length;i++)
	{
		readfile>>temp[i];
	}
	return temp;
}
为了更好的操作，测试相关函数的功能，写了这样一个函数来从文件得到链表长度的函数
template <class T>
inline int LinkList<T>::readlen()
{
	ifstream readfile("data.txt");
	int length;
	readfile>>length;
	return length;
}
写到这基本上函数的功能都实现了，这个链表结构肯定有很多不完善的地方，第一次写博客，还望大家见谅。上面提到了其它类的重载问题，我就把写的一个point类分享给大家。
class Point
{
	private:
		double x;
		double y;
	public:
		Point(double x=0.0,double y=0.0)
		{this->x=x,this->y=y;}
		void setdata(double a,double b)
		{this->x=a;this->y=b;}
		Point operator=(Point a);//重载运算符“=”
		int operator==(Point a);//重载运算符“==”
		int operator!=(Point a);
		double getx()
		{return x;}
		double gety()
		{return y;}
		//重载输入流
		friend istream &operator>>(istream &is,Point &p)
		{
			is>>p.x;
			is>>p.y;
			return is;
		}//重载输出流
		friend ostream &operator<<(ostream &os,Point p)
		{
			os<<"("<<p.x<<","<<p.y<<")";
			return os;
		}
};

inline Point Point::operator=(Point a)
{
	this->x=a.x;
	this->y=a.y;
	return *this;
}
inline int Point::operator==(Point a)
{
	if(this->x==a.getx()&&this->y==a.gety())
	{
		return 1;
	}
	else {
		return 0;
	}
}
inline int Point::operator!=(Point a)
{
	if(this->x!=a.getx()&&this->y!=a.gety())
	{
		return 1;
	}
	else if(this->x!=a.getx()||this->y!=a.gety()){
		return 1;
	}
	else {
		return 0;
	}
}
一个输入之后的展示

int类型的展示
point类的实现
以上是C++顺序表使用过程中最常用的主要操作，相关完整代码已经push到GitHub，需要的小伙伴自行clone，如果觉得还不错的话，欢迎Star,这里是传送门C++链式顺序表，除此之外，想要了解更多的C,C++,Java,Python等相关知识的童鞋，欢迎来我的博客相逢的博客，我们一起讨论！

北徯
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线性表的链式存储结构
03-28
1、用头插法建立长度为n的带头结点的单链表。 2、查找单链表中第K个结点。 3、插入一个新元素X到指定位置i。 4、删除指定位置i处的结点
线性表链式存储-使用c语言实现,线性表的链式存储结构的实现及其应用(C/C++实现)...
weixin_35276012的博客
05-17 810
存档-----------#include typedef char ElemType;#include "LinkList.h"void main(){LinkList h;ElemType e;int i=;int t=;cout<InitList(h);cout<cout<cin>>e;i=;while(e!='#'){ListInsert(h,i,e);i++...
C语言数据结构——线性表的链式存储结构
0117
02-21 1467
文章目录线性表的链式存储结构1.基本概念2.设计与实现3.优点和缺点 线性表的链式存储结构 1.基本概念 链式存储定义：为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身的信息之外，还需要存储指示其直接后继的信息。 n个结点连接成一个链表，即为线性表(a1 a2 a3…an)的链式存储结构，因此此链表的每个结点中包含一个指针域，所以叫做单链表。单链表正是通过每个结点的指针域...
数据结构学习笔记第四节：线性表的链式存储C和C++的实现
y_927的博客
05-06 313
一、线性表链式存储结构的定义 1、线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的也可及时布偶连续的。即这些数据元素可以存储在内存未被占据的任意位置。 2、以前的顺序结构中，每个元素只需要存放数据元素就可以了。现在链式结构中，除了要存放数据元素的信息外，还要存储它的后继元素的存储地址。我们把存储数据元素信息的区域称为数据域，把存储直接后继位置的域称...
严蔚敏数据结构C语言版——线性表的链式存储方式详细代码
NJ_zbx的博客
03-12 902
严蔚敏数据结构C语言版线性表的链式存储方式代码
【数据结构 C++】线性表（二）链式存储
qq_45397526的博客
03-28 768
链式存储与顺序存储有一些不同的地方，而且比顺序存储要难。 在了解链式存储之前，我们先回顾一下指针。 链式存储一、指针1、什么是指针2、指针变量1）、定义指针变量：int *p；2）、程序中的*p（除定义外）3、指针与数组1）、指针与数组名2）、指针数组二、链表1、链表定义2、头结点3、链表实现1）、定义节点类2）、定义链表类3）、构造函数4）、析构函数5）、返回链表的长度6）、返回链表i处的节点值...
算法与数据结构线性表的顺序存储与链式存储(Swift版)
如果频繁就私信一下呢
10-29 188
接触过数据结构的小伙伴应该都知道程序 = 数据结构 + 算法。数据结构乃组织组织数据的结构，算法就是对这些结构中的数据进行操作，可见数据结构的重要性，就连算法也是依赖于数据结构的。 在博客的开头，我们先简单的聊些数据结构整体的东西。数据结构整体可以分为物理结构和逻辑结构，物理结构指的是数据在磁盘、内存等硬件上的存储结构，主要包括顺序结构和链式结构。而逻辑结构是数据本身所形成的结构，包括集合结构、线性结构、树形结构以及图形结构。针对不同的数据结构我们可以依据算法接决不同的问题，如我们在以后博客中要介绍的最小
数据结构学习：c++实现队列的链式存储结构（链队列）
每天进步一点点
10-18 1823
前面一篇博客实现了如何使用c++实现队列的链式存储结构，参见链接：c++ 实现队列的顺序存储结构 我自己认为无论是线性表、栈还是队列等等结构，链式结构总是要比顺序结构难一点，因为顺序存储结构就是玩数组嘛，数组大家都能玩的转; 但链式结构肯定就有指针，而有了指针，程序必将变得复杂，所以实现起来可能稍微有点困难，但是换句话说，链式不就是玩指针嘛，相信大家指针也一定都一定能玩的转. 话不多说，进入正题：...
数据结构C++边学边做--队列的链式存储结构实现
qq_39400324的博客
02-10 1625
队列的链式存储结构实现一、链队列的定义二、链队列数据结构定义三、链队列类实现1.类声明2.LinkQueue->构造函数3.~LinkQueue->析构函数4.EnQueue->入队5.DeQueue->出队6.GetQueue->取队头7.Empty->判断空队列四、链队列的测试1.主函数2.输出结果五、源代码获取（免积分） 一、链队列的定义   采用链式存储结构实现的队列称为链队列（linked queue）。可以对单链表进行改造得到链队列，表头对应队头，表尾对应队尾
线性表的顺序存储实现C++
m0_63823490的博客
02-24 122
数据结构教科书上的线性表的顺序存储C++实现
线性表的链式存储结构c++模板类实现
06-20
哈工大软设设计与开发实践1的课程要求代码，个人写的很粗糙简陋，仅供参考
数据结构实验报告2线性表的链式存储结构.doc
07-11
学院： 专业： 班级： "姓名 " "学号 " "实验组" " "实验时间 "2011-11-11 "指导教师" "成绩 " " "实验项目名称"线性表的链式存储结构 " "实"了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法" "验...
链表的C++实现（线性表的链式存储C++实现）
04-05
使用C++类模板实现了线性表的链式存储结构（链表），类中包含了线性表的常用方法：向线性表中插入一个元素、删除一个元素、清空线性表、获取一个元素、获取线性表长度等。大致实现了STL中的链表的基本功能，通过对比...
数据结构实验报告1线性表的顺序存储结构.doc
07-11
熟练掌握线性表的基本操作在顺序存储和链式存储上的实现； " "验 "2. 以线性表的各种操作（建立、插入、删除等）的实现为重点； " "目 "3. 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现； " "的 " " ...
带头节点的链式存储线性表
07-16
带头节点的线性表的链式存储实现，实现了带头节点链表的创建，不同功能的插入操作，按位置插入，头插入尾插入。也有按数据，按位置删除链表的功能。压缩包中有可执行文件，也有makefile，在linux下直接make即可生成...
C++数据结构实验一：线性表的应用
03-29
1．熟练掌握线性表的基本运算。 2．掌握顺序表和单链表...4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种基本操作的实现算法。
实验二 线性表的链式存储和实现
12-28
利用约瑟夫环算法按出列的先后顺序输出每一个人的信息。
链式存储结构下线性表的实现
09-13
链式存储结构下线性表的实现,dev通过,C++
基于C++实现（控制台）链式存储结构的线性表【100010613】
02-04
详情介绍：...基于链式存储结构的线性表实现：依据最小完备性和常用性相结合的原则，以函数形式定义了线性表的初始化表、销毁表、清空表、判定空表、求表长和获得元素等12种基本运算 。
c++链式存储结构线性表基本操作
最新发布
11-18
以下是C++链式存储结构线性表基本操作的介绍： 1. 定义链表结构体 ```c++ struct LNode{ int data; // 节点的数据域 LNode *next; // 节点指针域 }; ``` 2. 初始化链表 ```c++ LNode *initList(){ LNode *head = new LNode; // 创建头结点 head->next = NULL; // 头结点指针域为空 return head; } ``` 3. 判断链表是否为空 ```c++ bool isEmpty(LNode *head){ return head->next == NULL; } ``` 4. 获取链表长度 ```c++ int getLength(LNode *head){ int length = 0; LNode *p = head->next; while(p != NULL){ length++; p = p->next; } return length; } ``` 5. 插入节点 ```c++ bool insertNode(LNode *head, int index, int value){ if(index < 1 || index > getLength(head) + 1){ return false; } LNode *p = head; for(int i = 1; i < index; i++){ p = p->next; } LNode *newNode = new LNode; newNode->data = value; newNode->next = p->next; p->next = newNode; return true; } ``` 6. 删除节点 ```c++ bool deleteNode(LNode *head, int index){ if(index < 1 || index > getLength(head)){ return false; } LNode *p = head; for(int i = 1; i < index; i++){ p = p->next; } LNode *q = p->next; p->next = q->next; delete q; return true; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值