数据结构——顺序表的定义和实现

最新推荐文章于 2024-08-06 00:35:28 发布
最新推荐文章于 2024-08-06 00:35:28 发布
阅读量3.8k 收藏 27
点赞数 4
分类专栏： c++数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47634044/article/details/113097848
版权

顺序表

顺序表是基于数组的顺序存储的一种线性结构，并且每一个表项的逻辑结构和物理存放顺序一致，其中包含了对表项（数据元素）进行的相关操作，例如增删改查等等操作。
那么顺序表有什么用呢？对于一般的数组而言（基本数据类型），我们可以利用下标进行元素的增加和修改，但却没有办法表示实际元素个数或者长度（如果你初始化数组的话当我没说），而对于一些自定义数据结构class、struct等数据类型，进行相关操作就显得不是很方便。

顺序表的关键包括数组指针、当前标项位置、最大可容纳表项个数。
静态存储和动态存储的区别：其实顺序表开始时给数组分配的大小是一样的，只不过静态存储不能够当存满的时候实现自动扩充而导致存储失败，动态存储多了一个函数功能去实现溢出处理。

                                                 顺序表的类定义

template <class T>
class SeqList {
protected:
	T* data{};//存放数组
	int maxSize{};//最大可容纳表项的个数
	int last{};//当前已存表项的最后位置
	void reSize(int newSize);//改变data数组空间大小
public:
	SeqList(int sz = defaulatSize);//构造函数
	SeqList(SeqList<T>& L);//复制构造函数
	~SeqList() { delete[]data; }//析构函数
	bool copySeqList(SeqList<T>& L);
	int Size()const { return maxSize; }//计算表最大可容纳表项的个数
	int Length()const { return last + 1; }//计算最新表内表项的长度
	int Search(T& x)const;//搜索X在表中的位置，函数返回表项的序号
	int Locate(int i)const;//定位第I个表项，函数返回表项序号
	bool getData(int i, T& x)const//获取第I个表项的值
	{
		if (i > 0 && i <= last + 1)
		{
			x = data[i - 1];
			return true;
		}
		else
			return false;
	}
	void setData(int i, T& x)//用X修改第I个表项的值
	{
		if (i > 0 && i <= last + 1)
			data[i - 1] = x;
	}
	bool Insert(int i, T& x);
	bool Remove(int i, T& x);
	bool IsEmpty()
	{
		return (last == -1) ? true : false;
	}
	bool IsFull()
	{
		return (last == maxSize - 1) ? true : false;
	}
	void input();
	void output();
	bool setOne(T& x);
};
  1. 溢出处理功能实现。
void SeqList<T>::reSize(int newSize)//默认是对表的扩展大小为newSize
{
	if (newSize <= 0)
	{
		cerr << "数组大小不能为负值" << endl; return;
	}
		T* newarray = new T[newSize+maxSize];
		if (newarray == NULL)
		{
			cerr << "存储分配错误" << endl; exit(1);
		}
		int n = last + 1;
		T* srcptr = data;//再次开辟一个大一点的连续空间
		T* destptr = newarray;
		for (int i = 0; i < n; i++)
			*destptr++ = *srcptr++;
		delete[]data;//销毁原来的
		data = newarray; //数据指针指向新的数组
		maxSize = maxSize+newSize;//新数组最大容量发生改变
	}
};

构造函数：

//默认的构造函数，无用户设定时，sz=defaultSize
template<class T>
SeqList<T>::SeqList(int sz)
{
	if (sz > 0)
	{
		maxSize = sz; 
		last = -1;
		data = new T[maxSize];
	}
	else{
             cerr<<"输入参数有误，请检查后再次操作！"<<endl;
       }
};
//复制构造函数，注意浅拷贝和深拷贝的区别，前者共用，后者独立
template<class T>
bool SeqList<T>::copySeqList(SeqList<T>& L)
{
	last = L.Length() - 1;//类似于指针的东西，一直都是处于最新表项所在的表的编号位置
	T value;
	for (int i = 1; i <= last + 1; i++)
	{
		L.getData(i, value); //这里比较容易理解错误，i的值是逻辑上的第一个
		data[i - 1] = value;//
	}
};

需要注意的是我们认知的个数、位置和存储是差1的，比如，第一个表项在数组里是a[0]，表项个数最大值为maxSize-1……

插入和删除操作，指定位置插入表项和指定位置删除表项：

template<class T>
bool SeqList<T>::Insert(int i, T& x)
{
	if (last == maxSize - 1) return false;//已经存满，返回失败
	if (i<0 || i>last + 1)//插入只能插入在已经存在的，不能再空的空间插入
		return false;
		/*插入表项存储位置为I，实际为第I+1个位置，所以是尾插在第I个后面，
		有点难解释，自己试一下就知道了*/
	for (int j = last; j >= i; j--)
		data[j + 1] = data[j];
	data[i] = x;
	last++;
	return true;
};
template<class T>
bool SeqList<T>::Remove(int i, T& x)//逻辑位置第I个
{
	if (i<0 || i>last + 1) return false;//删除的表项位置不合理
	x = data[i - 1];//记录删除表项的值，传给参数X
	for (int j = i; j < last; j++)
		data[j - 1] = data[j];//后面的向前面覆盖
	last--;
	return true;
};

文件操作进行存储和读取顺序表数据：

template<class T>
void load(SeqList<T>& p)//传入函数参数
{
	ifstream f;//定义文件流对象，注意ifstream为读
	f.open("Date_a.dat", ios::binary);//“文件名”，
	//iOS：：binary表示二进制读取，如果文件不存在则自动创建
	if (!f)//判断文件是否为空
	{
		return;
	}
        T m;
	//Address对象，方便使用标准模板库函数p.push_back添加元素
	while (f.peek() != EOF)//循环条件
	{

		f.read((char*)&m, sizeof(T));
		p.setOne(m);
	}
	f.close();//注意文件流的打开和关闭成对出现
}
template<class T>
void save(SeqList<T>& p)
{
	ofstream f;//
	f.open("Date_a.dat", ios::binary);
	if (!f)
	{
		return;
	}
	int num = p.Length();//容器中实际元素的个数
	T tem{};
	for (int i = 1; i <= num; i++)
	{
		p.getData(i, tem);
		f.write((char*)&tem ,sizeof(T));
	}
	f.close();
}

完整代码：

#include<iostream>
#include<stdlib.h>
#include<fstream>
using namespace std;
const int defaulatSize = 100;
template <class T>
class SeqList {
protected:
	T* data{};//存放数组
	int maxSize{};//最大可容纳表项的个数
	int last{};//当前已存表项的最后位置
	void reSize(int newSize);//改变data数组空间大小
public:
	SeqList(int sz = defaulatSize);//构造函数
	SeqList(SeqList<T>& L);//复制构造函数
	~SeqList() { delete[]data; }//析构函数
	bool copySeqList(SeqList<T>& L);
	int Size()const { return maxSize; }//计算表最大可容纳表项的个数
	int Length()const { return last + 1; }//计算最新表内表项的长度
	int Search(T& x)const;//搜索X在表中的位置，函数返回表项的序号
	int Locate(int i)const;//定位第I个表项，函数返回表项序号
	bool getData(int i, T& x)const//获取第I个表项的值
	{
		if (i > 0 && i <= last + 1)
		{
			x = data[i - 1];
			return true;
		}
		else
			return false;
	}
	void setData(int i, T& x)//用X修改第I个表项的值
	{
		if (i > 0 && i <= last + 1)
			data[i - 1] = x;
	}
	bool Insert(int i, T& x);
	bool Remove(int i, T& x);
	bool IsEmpty()
	{
		return (last == -1) ? true : false;
	}
	bool IsFull()
	{
		return (last == maxSize - 1) ? true : false;
	}
	void input();
	void output();
	bool setOne(T& x);
};

template<class T>
SeqList<T>::SeqList(int sz)
{
	if (sz > 0)
	{
		maxSize = sz; 
		last = -1;
		data = new T[maxSize];

	}
};
template<class T>
bool SeqList<T>::copySeqList(SeqList<T>& L)
{
	last = L.Length() - 1;//类似于指针的东西，一直都是处于最新表项所在的表的编号位置
	T value;
	for (int i = 1; i <= last + 1; i++)
	{
		L.getData(i, value); //这里比较容易理解错误，i的值是逻辑上的第一个
		data[i - 1] = value;//
	}
};
template<class T>
SeqList<T>::SeqList(SeqList<T>& L)
{
	maxSize = L.Size(); //新建立的表的最大容纳量要一样
	last = L.Length() - 1;//类似于指针的东西，一直都是处于最新表项所在的表的编号位置
	T value;
	data = new T[maxSize];
	if (data == NULL)
	{
		cerr << "存储分配错误！" << endl; exit(1);
	}
	for (int i = 1; i <= last + 1; i++)
	{
		L.getData(i, value); //这里比较容易理解错误，i的值是逻辑上的第一个
		data[i - 1] = value;//
	}
};
template<class T>
void SeqList<T>::reSize(int newSize)//默认是对表的扩展
{
	if (newSize <= 0)
	{
		cerr << "数组大小不能为负值" << endl; return;
	}
	if (newSize != maxSize)
	{
		T* newarray = new T[newSize];
		if (newarray == NULL)
		{
			cerr << "存储分配错误" << endl; exit(1);
		}
		int n = last + 1;
		T* srcptr = data;//再次开辟一个大一点的连续空间
		T* destptr = newarray;
		for (int i = 0; i < n; i++)
			*destptr++ = *srcptr++;
		delete[]data;
		data = newarray; maxSize = newSize;
	}
};
template<class T>
int SeqList<T>::Search(T& x)const//返回的是逻辑位置，是从第一个开始的【1-last+1】
{
	for (int i = 0; i <= last; i++)
		if (data[i] == x)
			return i + 1;
	return 0;
};
template<class T>
int SeqList<T>::Locate(int i)const
{
	if (i >= 1 && i <= last + 1)
		return i;//返回的还是逻辑值位置，需要观看着自己理解（自动减去一），这么做是为了当输入i值比较超越的时候返回0
	else
		return 0;
};
template<class T>
bool SeqList<T>::Insert(int i, T& x)
{
	if (last == maxSize - 1) return false;
	if (i<0 || i>last + 1)//插入只能插入已经存在的，不能再空的空间插入
		return false;
	for (int j = last; j >= i; j--)
		data[j + 1] = data[j];
	data[i] = x;
	last++;
	return true;
};
template<class T>
bool SeqList<T>::setOne(T& x)
{
	if (last == maxSize - 1) return false;
	data[last + 1] = x;
	last++;
	return true;
};
template<class T>
bool SeqList<T>::Remove(int i, T& x)
{
	if (i<0 || i>last + 1) return false;
	x = data[i - 1];
	for (int j = i; j < last; j++)
		data[j - 1] = data[j];
	last--;
	return true;
};
template<class T>
void SeqList<T>::input() 
{
	cout << "开始建立顺序表，请输入顺序表最后元素当前位置：";
	cout << "有效值不超过" << maxSize - 1 << ":";
	cin >> last;

	for (int i = 0; i <= last; i++)
	{
		cin >> data[i]; 
	}
	cout << "元素添加完成！" << endl;
};
template<class T>
void SeqList<T>::output() {
	cout << "顺序表当前元素最后位置为：" << last << endl;
	for (int i = 0; i <= last; i++)
		cout << "#" << i + 1 << ":" << data[i] << endl;
};
void menu()
{
		cout << "1、计算顺序表最大容纳量" << endl;
		cout << "2、计算表的长度" << endl;
		cout << "3、初始化顺序表" << endl;
		cout << "4、输出顺序表内容" << endl;
		cout << "5、判断顺序表是否为空" << endl;
		cout << "6、判断顺序表是否满" << endl;
		cout << "7、搜索元素" << endl;
		cout << "8、获取第I个表项值" << endl;
		cout << "9、修改第I个表项值" << endl;
		cout << "10、指定位置插入元素" << endl;
		cout << "11、顺序添加元素"<<endl;
		cout << "12、删除指定位置元素" << endl;
		cout << "0、结束程序！" << endl;
}
template<class T>
void load(SeqList<T>& p)//传入函数参数
{
	ifstream f;//定义文件流对象，注意ifstream为读
	f.open("Date_a.dat", ios::binary);//“文件名”，
	//iOS：：binary表示二进制读取，如果文件不存在则自动创建
	if (!f)//判断文件是否为空
	{
		return;
	}
        T m;
	//Address对象，方便使用标准模板库函数p.push_back添加元素
	while (f.peek() != EOF)//循环条件
	{

		f.read((char*)&m, sizeof(T));
		p.setOne(m);
	}
	f.close();//注意文件流的打开和关闭成对出现
}
template<class T>
void save(SeqList<T>& p)
{
	ofstream f;//
	f.open("Date_a.dat", ios::binary);
	if (!f)
	{
		return;
	}
	int num = p.Length();//容器中实际元素的个数
	T tem{};
	for (int i = 1; i <= num; i++)
	{
		p.getData(i, tem);
		f.write((char*)&tem ,sizeof(T));
	}
	f.close();
}


int main()
{
	int n; int x; int ii;
	SeqList<int> List (100);
	load(List);
	while (true)
	{
		menu();
		cout << "请输入你的操作：";
		cin >> n;
		if (n == 0)
			break;
		switch (n)
		{
		case 1:cout << List.Size() << endl;; break;
		case 2:cout << List.Length()<<endl; break;
		case 3:List.input(); break;
		case 4:List.output(); break;
		case 5:cout << List.IsEmpty()<<endl; break;
		case 6:cout << List.IsFull()<<endl; break;
		case 7:cout << "请输入元素值："; cin >> x; cout <<"元素所在序号为："<< List.Search(x) << endl; break;
		case 8:cout << "请输入要查元素序号值："; cin >> ii; List.getData(ii, x); cout << "元素值为："<< x<< endl; break;
		case 9:cout << "请输入要修改的元素表项值和改后值："; cin >> ii >> x;  List.setData(ii,x); break;
		case 10:cout << "请输入要插入的位置和元素："; cin >> ii >> x; List.Insert(ii, x); break;
		case 11:cout << "请输入要添加的元素值："; cin >> x; List.setOne(x); break;
		case 12:cout << "请输入要删除元素的位置："; cin >> ii; List.Remove(ii, x); cout << "成功删除元素"+x << endl; break;
		default:cout << "请输入有效操作！" << endl;
		}
	}
	//cout<<List.IsEmpty()<<endl;
	//cout << List.IsFull()<<endl;
	//List.input();
	//List.output();
	save(List);
	return 0;
}

总结一下：
1、顺序表中的表项序号是从1开始，第一个表项存放于data[0],第二个表项存放于data[1]……第n个表项存放于data[n-1]。由此可知，表项序号与它再数组中的实际存放位置差1。
2、由于函数的参数传递是单向值传递，若不用&例如在主函数中调用 List_Sq(SqList L)创建一个顺序表L，如下面代码，把实参myL的值传给形参L，在函数中初始化L(赋值)，当函数返回时，myL并没有被初始化，因为形参L不能反向传给实参。而加上引用&（在C语言中叫带地址传递）就不一样了，形参L变成实参myL的别名，实参和形参实际是同一段内存空间，当然修改形参就是修改实参。
3、const的作用。例如在函数int Length()const的作用，将关键字const放在函数参数表后面、函数体的前面起一种保护作用，表明它不能改变操作它的对象的数据成员的值，除此之外，const成员函数执行时不能调用非const成员。

半痴半醉半天真
关注
专栏目录
数据结构Python版（一）——顺序表
⚡
06-14 5311
线性表就是数据元素的排列像一条线一样的表。线性表严格的定义是具有相同特性的数据元素组成的一个有限序列。其特征有3个：不同于集合，线性表中可以出现值相同的元素。线性表的逻辑结构一般表示为 (a0,a1,⋯ ,an−1)(a_0,a_1,\cdots,a_{n-1})(a0​,a1​,⋯,an−1​)，用 n(n≥0)n(n\geq0)n(n≥0) 表示线性表的长度（即线性表中元素的个数）。当 n=0n=0n=0 时，表示线性表是一个空表，不包含任何数据元素。线性表的逻辑特征：每个元素最多只有一个前驱元素，也最
【数据结构之顺序表的的表示和实现】
m0_66604512的博客
07-05 1439
顺序表是线性表的一种，是指用一组地址连续的存储单元依次存储线性表的数据元素。其特点是，逻辑上相邻的数据元素，其物次序也是相邻的。所以顺序表具有随机存取的性质。 顺序表中的基本操作有很多取值、赋值、查找、插入、删除、排序、销毁、重置等等。...............
顺序表的表示与实现
weixin_30496431的博客
04-23 216
1 #include<iostream.h> 2 #include<stdlib.h> 3 #define LIST_INIT_SIZE 100 4 #define OK 1 5 #define OVERFLOW -2 6 #define ERROR 0 7 typedef int Status; 8 ...
【数据结构】顺序表详解以及实现（C语言实现）
最新发布
wheeldown的博客
08-06 596
存储密度高：顺序表的每一个节点都有对应的数据元素，没有额外开销，存储密度高访问性高：可以通过首地址然后i根据连续性找到后续相应的元素物理位置相邻：物理位置和逻辑位置一致，保持相邻，但这也意味着插入和删除操作可能涉及到大量元素的移动。顺序表分为静态顺序表和动态顺序表，静态顺序表在结构体中给的是定长数组，缺点很明显，所以我们主要讨论动态顺序表动态顺序表主要涉及的内存函数有malloc()和relloc()函数。动态顺序表主要有。
线性表——顺序表示和实现（顺序表）
Xuanf_q的博客
03-21 608
线性表——顺序表 实现代码方式：数组 说明： 1.数据元素从下标0开始 2.顺序表元素个数初始是为0，有一个时为1，即——size比元素个数大1 3.也是size比数组下标大1 4.有上限——MaxSize #pragma once #include<stdio.h> /*线性表——顺序表 实现代码——数组 1.数据元素从下标0开始 2.顺序表元素个数初始是为0，有一个时为1...
数据结构——线性表的顺序表示与实现（顺序表）
流楚丶格念的博客
09-22 7707
文章目录线性结构的定义：线性表一、线性表的定义和特点例1 分析26 个英文字母组成的英文表例2 分析学生情况登记表顺序存储结构存在问题二、线性表的类型定义 线性结构的定义： 若结构是非空有限集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继。 可表示为：（a1 , a2 , ……, an） 线性表 线性结构表达式：（a1 , a2 , ……, an） 线性结构的特点： ① 只有一个首结点和尾结点； ② 除首尾结点外，其他结点只有一个直接前驱
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构——顺序表（定义详解及建立顺序表与实现其操作）
Three__Curry的博客
01-26 8275
数据结构——顺序表（定义详解及创立顺序表并操作） 顺序表定义：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 简单来说，顺序表存储有两个特点： 1.逻辑顺序和物理顺序一致。 2.数据元素之间的关系
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并提供了相应的代码示例。本文档适用于C++初学者以及准备期末考试的学生...
数据结构——单链表的定义和实现
流楚丶格念的博客
09-23 7052
文章目录单链表的定义单链表的实现 单链表的定义 单链表的实现
线性表的顺序表示及实现
1+1=王的博客
11-09 1264
线性表的顺序表示及实现线性表的定义和特点1. 定义2.线性表的逻辑特征线性表的顺序表示顺序表的基本实现总结 线性表的定义和特点 1. 定义 线性表（Linear List）：由n（n>=0）个具有相同特性的数据元素（结点）a1,a2, … , 组成的有限序列。 其中数据元素的个数n定义为表的长度； 当n = 0 时称为空表； 将非空的线性表（n>0）记作：（a1 , a2 , … ,...
顺序表讲解和实现
DR5200的博客
02-16 1623
文章目录一.线性表二.顺序表 一.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 二.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： （1）静态顺序表
顺序表的描述及实现
m0_53768564的博客
12-03 331
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数..
数据结构之顺序表的定义、属性以及算法实现（C/C++描述）
陈子青的博客
05-17 1473
顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以 快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素：  用 elems 记录存储位置的基地址  分配一段连续的存储空间 size  用 length 记录实际的元素个数，即顺序表的长度 结构体定义 #define MAX_SIZE 100 struct _SqList { ElemType *elems; // 顺序表的基地址 int len.
数据结构——线性表的顺序表示和实现（c语言）
Sup_klz的博客
03-27 5755
PS:数据结构（C语言版）——清华大学出版社， 2.1节代码实现#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST...
数据结构——顺序表讲解及实现
lain2002的博客
08-06 273
一位老实人的数据结构的学习
数据结构--顺序表及实现（c语言）
kaximoudu的博客
03-31 950
线性表是具有相同特性数据元素的一个有限序列。 顺序表是线性表的一种，在逻辑结构上具有一对一关系，每一个结点有且只有一个前驱和后继结点，表头没有前驱结点，表尾没有后继结点 顺序表的优点 1、存储密度大 2、可以随机存取表中的任一元素,时间复杂度为O(1) 顺序表的缺点 1、在插入，删除的时候，需要移动大量的元素，时间复杂度为O(n^2) 2、实际情况无法预知顺序表的容量大小，定义一个存储数组时，...
【顺序表类定义】【顺序表各种操作类函数表示】【顺序表容量不够问题的解决——doubleSpace函数】【顺序表优缺点】
不再痛苦的秘密，你找到了吗
05-01 728
目录 【概念及类定义】 【概念】 【类定义】 【容量不够的问题】 【各个函数的具体实现】 【顺序表的优缺点】 【概念及类定义】 【概念】 顺序表即为线性表的顺序存储，线性表结点存放在存储器上一段连续的空间中，即一个数组。因为顺序表在进行插入操作时，需要额外的存储空间，所以在申请内存空间时，要留有余地。 【类定义】 template<class elemType> class seqList :public list<elemType>//...
数据结构实验：线性表操作与实现——顺序表与链表
通过这个实验，学生能够深入理解线性表的两种存储结构，锻炼他们在实际编程中应用这些概念的能力，同时提升对数据结构基本操作的理解和实现。实验过程不仅要求学生掌握理论知识，还要求他们具备编写高效、正确代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值