C++实现单循环链的各种操作

已于 2022-07-03 15:59:43 修改
阅读量1.1k 收藏 16
点赞数 2
文章标签： c++ 开发语言 数据结构 链表 算法
于 2022-07-03 15:58:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58240448/article/details/125585237
版权

1.什么是单链

        如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。

                        

2.循环单链表节点结构体

         循环单链表的节点与普通单链表的节点相同并无本质的区别！

struct LNode {
	int data;    // 数据域
	LNode* next; // 指针域
};

typedef LNode LNode;     // LNode表示单链表的一个结点
typedef LNode* LinkList; // LinkList表示一个单链表

        对循环单链表节点进行初始化：主要还是为了避免异常！

bool InitList(LinkList& L) {
	L = new LNode;//C/语言中使用：L = (LNode *)malloc(sizeof(LNode));与前者作用等价申请新节点
	if (!L) {
		cout << "申请节点失败！" << endl;
		return false;
	}
	L->next = NULL;//初始化节点的后继指针为空，避免引起错误！
	return true;
}

3.对循环单链表的操作

 3.1打印循环单链表

bool PrintList(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	cout << "该循环单链表的值为：";
	while (p->next != r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
		cout << p->data<<" ";//输出该节点的数据
		p = p->next;//未到链尾，移动指针向后移动到下一个节点
	}	
	cout << endl;
	return true;
}

3.2 求出循环单链表的长度

int Length(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	int i=0;//记录长度
	while (p)//能进入此循环证明p存在
	{
		i++;//p存在，让长度加一
		p = p->next;//p向后移动
		if (p->next == r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
			//cout << "该循环单链表的长度为:"<<i << endl;//输出长度
			return i;//返回长度
		}
	}
}

3.3 使用尾插法创建单循环链表

bool TailCirculateList(LinkList& L) {
	LNode* p = L;//p是头节点
	LNode* t = L;//t是头节点
	int x;
	cout << "使用尾插法实现的单链表，请输入要创建的个数：" ;
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl; 
		return false; 
	}
	else if (x == 1) {//只输入一个节点时是特殊情况，进行特殊处理
		LNode* r = new LNode;
		cout << "请输入要输入的值：";
		cin >> r->data;
		p->next = r;
		r->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {//x>1的情况
		LNode* r = new LNode;//申请新节点r
		cin >> r->data;//为新节点r填充数据
		p->next = r;//让头节点指向新的节点
		p = r;//p移动到新节点，尾插法在链尾插入新节点，所以头节点（其实只是个工作指针）也要移动到链尾，便于第下次添加
		x--;
	}
	p->next = t;//此时p是链尾节点，为了构造成循环链，让尾节点指向头节点

	PrintList(L);//打印单循环链
	return true;
}

3.4 使用头插法创建单循环链表

bool HeadCirculateList(LinkList& L){

	LNode* t = L;//t是头节点
	LNode* h = L;//h是头节点
	LNode* p = new LNode;//申请一个新节点p
	int x;
	cout << "使用头插法实现的单链表，请输入要创建的个数：";
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl;
		return false;
	}
	else if (x == 1) {//只输入一个数据时，特殊情况，进行处理
		LNode* p = new LNode;
		cout << "请输入要输入的值：";
		cin >> p->data;
		t->next = p;
		p->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {
		LNode* r = new LNode;//申请一个新节点r
		cin >> r->data;//为新节点填充数据
		t->next = r;//头节点指向新节点
		r->next = h;//让新节点指向头节点
		h = t->next;//让工作指针回到头节点
		x--;
	}
	PrintList(L);//打印单循环链
	return true;
}

3.5 按值查找循环单链表

bool GetValueElem(LinkList& L) {
	LNode* p = L->next;
	LNode* t = L;
	int x,i=0;
	cout << "请输入您要查找的值：";
	cin >> x;
	while (p)
	{
		i++;
		if (p->data == x) {
			cout << "恭喜您要查找的值在该单链表中且在该链表的第"<<i<<"位！" << endl;
			return true;
		}
		else
		{
			p = p->next;
			if (p->next == t->next) {
				cout << "抱歉您要查找的值不在该单链表中！" << endl;
				return false;
			}
		}
		
	}
}

3.6 按位查找循环单链表   

bool GetBitElem(LinkList& L) {
	LNode* p = L;
	int x;
	cout << "请输入您要查找的位：";
	cin >> x;
	int k = x;
	if (x<1 || x>Length(L)) {
		cout << "您输入的位数无意义或不存在！" << endl;
		return false;
	}
	while (x)
	{
		p = p->next;
		x--;
	}
	cout << "您要查找的第" << k << "位的数据为:" << p->data << endl;
	return true;
}

3.7 在循环单链表中按位插入节点

bool Insert(LinkList& L) {
	LNode* p = L;
	LNode* r = L;
	cout << "请输入你要插入的位数:";
	int x;
	cin >> x;
	if (x<=0 || x>Length(L)) {
		cout << "您插入的位数无意义或不存在！" << endl;
		return false;
	}
	cout << "请输入你要插入的值：";
	if (x < Length(L)) {
		LNode *q = new LNode;
		cin >> q->data;
		if (x == 1) {
			q->next = p->next;
			 p->next=q;
			 q = p;
			PrintList(L);//打印单循环链
			return true;
		}
		while (x)
		{
			p = p->next;
			x--;
		}
		q->next=p->next;
		p->next = q;
		PrintList(L);//打印单循环链
		return true;
	}
	else if (x == Length(L)) {//在链尾插入
		LNode* q = new LNode;
		cin >> q->data;
		while (x)
		{
			p = p->next;
			x--;
		}
		p->next = q;
		q->next = r;
		PrintList(L);//打印单循环链
		return true;
	}
}

3.8 在单循环链表中按位删除节点

bool DeleteBit(LinkList& L) {
	int n;
	LNode* p = L;
	LNode* r;
	InitList(r);
	cout << "请输入你要删除的节点的位数;";
	cin >> n;
	int k = n;
	if (n <1 || n> Length(L)) {
		cout << "您想删除的节点不存在" << endl;
		return false;
	}
	else if (n == Length(L)) {
		while (n)
		{
			p = p->next;
			n--;
		}
		r->next = p->next;
		r->data = p->next->data;
		p->next = r->next->next;
		cout << "要删除第" << k << "位的值" << p->data << "删除成功！";
		free(r);
		PrintList(L);//打印单链表
		return true;
	}
	while (n) {
		if (n == 1) {
			r->next = p->next;
			r->data = p->next->data;
			p->next = r->next->next;	
			cout << "要删除第"<<k<<"位的值" << r->data << "删除成功！" ;
			free(r);
			PrintList(L);//打印单链表
			return true;
		}
		n--;
		p = p->next;//节点向后移动
	}
}

3.8 在单循环链表中按值删除节点

bool DeleteValue(LinkList& L) {
	LNode* p = L;
	LNode* r;
	InitList(r);
	int v,x=Length(L);
	cout << "请输入你要删除的值;";
	cin >> v;
	while (x)
	{
		if (p->next->data == v) {
			r->data = p->next->data;
			r->next = p->next->next;
			p->next = r->next;
			free(r);
			cout << "要删除值为" << v << "的节点删除成功！";
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		x--;
	}
	cout << "要删除值为" << v << "的节点在单链表中不存在！";
	return false;
}

3.8 在单循环链表中按位修改节点的值

bool ReviseBit(LinkList& L) {
	int n,v;
	LNode* p = L;
	cout << "请输入你要修改的节点的位数;";
	cin >> n;
	if (n<1 || n>Length(L)) {
		cout << "你要修改的节点的位数不存在或无意义！"<<endl;
		return false;
	}
	cout << "请输入你要修改的节点的值;";
	cin >> v;
	while (n)
	{
		p = p->next;
		n--;
	}
	p->data = v;
	PrintList(L);//打印单链表
	return true;
}

3.8 在单循环链表中按值修改节点的值

bool ReviseValue(LinkList& L) {
	int n=Length(L),q,h;
	LNode* p = L;
	cout << "请输入你要修改的前的值和修改后的值;";
	cin >> q;
	cin >> h;
	while (n)
	{
		if (p->next->data == q) {
			p->next->data = h;
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		n--;
	}
	cout << "该单链表中不存在值为"<<q<<"的节点！" << endl;
	return false;
}

4.完整代码


#include<iostream>

using namespace std;

struct LNode {
	int data;    // 数据域
	LNode* next; // 指针域
};

typedef LNode LNode;     // LNode表示单链表的一个结点
typedef LNode* LinkList; // LinkList表示一个单链表

//函数申明
int Length(const LinkList& L);
bool InitList(LinkList& L);
bool PrintList(const LinkList& L);




//1.初始化
bool InitList(LinkList& L) {
	L = new LNode;//C/语言中使用：L = (LNode *)malloc(sizeof(LNode));与前者作用等价申请新节点
	if (!L) {
		cout << "申请节点失败！" << endl;
		return false;
	}
	L->next = NULL;//初始化节点的后继指针为空，避免引起错误！
	return true;
}
//2.打印单链表
bool PrintList(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	cout << "该循环单链表的值为：";
	while (p->next != r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
		cout << p->data<<" ";//输出该节点的数据
		p = p->next;//未到链尾，移动指针向后移动到下一个节点
	}	
	cout << endl;
	return true;
}
//3.求单链表的长度
int Length(const LinkList& L) {
	LNode* p = L->next;//p是第一个节点
	LNode* r = L;//r是头节点
	int i=0;//记录长度
	while (p)//能进入此循环证明p存在
	{
		i++;//p存在，让长度加一
		p = p->next;//p向后移动
		if (p->next == r->next) {//如果头节点的后继指针与首节点的指针指向同一个节点，证明已经到了链尾
			//cout << "该循环单链表的长度为:"<<i << endl;//输出长度
			return i;//返回长度
		}
	}
}
//4.使用尾插法创建单循环链 
bool TailCirculateList(LinkList& L) {
	LNode* p = L;//p是头节点
	LNode* t = L;//t是头节点
	int x;
	cout << "使用尾插法实现的单链表，请输入要创建的个数：" ;
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl; 
		return false; 
	}
	else if (x == 1) {//只输入一个节点时是特殊情况，进行特殊处理
		LNode* r = new LNode;
		cout << "请输入要输入的值：";
		cin >> r->data;
		p->next = r;
		r->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {//x>1的情况
		LNode* r = new LNode;//申请新节点r
		cin >> r->data;//为新节点r填充数据
		p->next = r;//让头节点指向新的节点
		p = r;//p移动到新节点，尾插法在链尾插入新节点，所以头节点（其实只是个工作指针）也要移动到链尾，便于第下次添加
		x--;
	}
	p->next = t;//此时p是链尾节点，为了构造成循环链，让尾节点指向头节点

	PrintList(L);//打印单循环链
	return true;
}
//5.使用头插法创建单循环链
bool HeadCirculateList(LinkList& L){

	LNode* t = L;//t是头节点
	LNode* h = L;//h是头节点
	LNode* p = new LNode;//申请一个新节点p
	int x;
	cout << "使用头插法实现的单链表，请输入要创建的个数：";
	cin >> x;
	if (x < 1) {
		cout << "您输入的个数无效！" << endl;
		return false;
	}
	else if (x == 1) {//只输入一个数据时，特殊情况，进行处理
		LNode* p = new LNode;
		cout << "请输入要输入的值：";
		cin >> p->data;
		t->next = p;
		p->next = t->next;
		return true;
	}
	cout << "请输入要输入的值：";
	while (x) {
		LNode* r = new LNode;//申请一个新节点r
		cin >> r->data;//为新节点填充数据
		t->next = r;//头节点指向新节点
		r->next = h;//让新节点指向头节点
		h = t->next;//让工作指针回到头节点
		x--;
	}
	PrintList(L);//打印单循环链
	return true;
}
//6.按值查找单链表
bool GetValueElem(LinkList& L) {
	LNode* p = L->next;
	LNode* t = L;
	int x,i=0;
	cout << "请输入您要查找的值：";
	cin >> x;
	while (p)
	{
		i++;
		if (p->data == x) {
			cout << "恭喜您要查找的值在该单链表中且在该链表的第"<<i<<"位！" << endl;
			return true;
		}
		else
		{
			p = p->next;
			if (p->next == t->next) {
				cout << "抱歉您要查找的值不在该单链表中！" << endl;
				return false;
			}
		}
		
	}
}
//7.按位查找单链表
bool GetBitElem(LinkList& L) {
	LNode* p = L;
	int x;
	cout << "请输入您要查找的位：";
	cin >> x;
	int k = x;
	if (x<1 || x>Length(L)) {
		cout << "您输入的位数无意义或不存在！" << endl;
		return false;
	}
	while (x)
	{
		p = p->next;
		x--;
	}
	cout << "您要查找的第" << k << "位的数据为:" << p->data << endl;
	return true;
}


//8.插入节点
bool Insert(LinkList& L) {
	LNode* p = L;
	LNode* r = L;
	cout << "请输入你要插入的位数:";
	int x;
	cin >> x;
	if (x<=0 || x>Length(L)) {
		cout << "您插入的位数无意义或不存在！" << endl;
		return false;
	}
	cout << "请输入你要插入的值：";
	if (x < Length(L)) {
		LNode *q = new LNode;
		cin >> q->data;
		if (x == 1) {
			q->next = p->next;
			 p->next=q;
			 q = p;
			PrintList(L);//打印单循环链
			return true;
		}
		while (x)
		{
			p = p->next;
			x--;
		}
		q->next=p->next;
		p->next = q;
		PrintList(L);//打印单循环链
		return true;
	}
	else if (x == Length(L)) {//在链尾插入
		LNode* q = new LNode;
		cin >> q->data;
		while (x)
		{
			p = p->next;
			x--;
		}
		p->next = q;
		q->next = r;
		PrintList(L);//打印单循环链
		return true;
	}
}
//9.按位删除节点
bool DeleteBit(LinkList& L) {
	int n;
	LNode* p = L;
	LNode* r;
	InitList(r);
	cout << "请输入你要删除的节点的位数;";
	cin >> n;
	int k = n;
	if (n <1 || n> Length(L)) {
		cout << "您想删除的节点不存在" << endl;
		return false;
	}
	else if (n == Length(L)) {
		while (n)
		{
			p = p->next;
			n--;
		}
		r->next = p->next;
		r->data = p->next->data;
		p->next = r->next->next;
		cout << "要删除第" << k << "位的值" << p->data << "删除成功！";
		free(r);
		PrintList(L);//打印单链表
		return true;
	}
	while (n) {
		if (n == 1) {
			r->next = p->next;
			r->data = p->next->data;
			p->next = r->next->next;	
			cout << "要删除第"<<k<<"位的值" << r->data << "删除成功！" ;
			free(r);
			PrintList(L);//打印单链表
			return true;
		}
		n--;
		p = p->next;//节点向后移动
	}
}
//10. 按值删除节点
bool DeleteValue(LinkList& L) {
	LNode* p = L;
	LNode* r;
	InitList(r);
	int v,x=Length(L);
	cout << "请输入你要删除的值;";
	cin >> v;
	while (x)
	{
		if (p->next->data == v) {
			r->data = p->next->data;
			r->next = p->next->next;
			p->next = r->next;
			free(r);
			cout << "要删除值为" << v << "的节点删除成功！";
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		x--;
	}
	cout << "要删除值为" << v << "的节点在单链表中不存在！";
	return false;
}
//11.按位修改循环单链表的节点
bool ReviseBit(LinkList& L) {
	int n,v;
	LNode* p = L;
	cout << "请输入你要修改的节点的位数;";
	cin >> n;
	if (n<1 || n>Length(L)) {
		cout << "你要修改的节点的位数不存在或无意义！"<<endl;
		return false;
	}
	cout << "请输入你要修改的节点的值;";
	cin >> v;
	while (n)
	{
		p = p->next;
		n--;
	}
	p->data = v;
	PrintList(L);//打印单链表
	return true;
}
//12.按值修改循环单链表的节点
bool ReviseValue(LinkList& L) {
	int n=Length(L),q,h;
	LNode* p = L;
	cout << "请输入你要修改的前的值和修改后的值;";
	cin >> q;
	cin >> h;
	while (n)
	{
		if (p->next->data == q) {
			p->next->data = h;
			PrintList(L);//打印单链表
			return true;
		}
		p = p->next;
		n--;
	}
	cout << "该单链表中不存在值为"<<q<<"的节点！" << endl;
	return false;
}
int main() {
	LinkList(L);
	InitList(L);//初始化
	HeadCirculateList(L);//使用头插法
	cout << endl;//换行，为了美观
	TailCirculateList(L);//使用尾插法
	GetValueElem(L);//按值查找
	GetBitElem(L);//按位查找
	Insert(L);//插入节点
	DeleteBit(L);//按位删除节点
	DeleteValue(L);//按值删除节点
	ReviseBit(L);//按位修改值
	ReviseValue(L);//按值修改
}

5. 运行结果及截图

在windows11操作系统的Visual Studio 2019编译器中运行的结果如下图所示！

孤城寻欢
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
循环链表（C++实现）
st66688的博客
09-22 3186
循环链表内容整理
C++开发基础之循环链表详解含示例
最新发布
小乖兽技术的博客
02-02 1415
循环链表的结构可以通过定义一个节点结构体来实现。每个节点包含两个主要成员：数据和指向下一个节点的指针。int data;// 节点中存储的数据Node* next;// 指向下一个节点的指针在循环链表中，需要注意的一点是最后一个节点的指针不是NULL，而是指向头节点，形成了一个环。因此，在创建循环链表时，需要特别处理最后一个节点的指针，使其指向头节点。另外，为了方便操作循环链表，还可以定义一个指向头节点的指针，以便快速访问和操作循环链表的各个节点。// 指向循环链表头节点的指针。
栈的操作与实现
weixin_61611746的博客
02-13 231
栈的操作与实现
链队列（详解）---＞数据结构、C++实现
m0_54158068的博客
03-30 6835
链队列（详解）--->数据结构（队列）、C++实现
【C++】【五】循环链表
格物致知
11-16 341
【C++】【五】循环链表
操作系统的模拟实现 C++编写
04-14
本资源用c++模拟操作系统的实现 主要内容：1.进程控制 2.分页式存储管理 3.设备管理4.文件管理 5.进程调度 有问题 联系 lx15636825085@163.com
C/C++实现多项式操作
10-28
C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现多项式操作C/C++实现...
操作系统—页面置换算法（C++实现）
05-13
页面置换算法: 资源包含三个算法：OPT---最佳置换算法、//FIFO---先进...操作：用户输入物理块数、页面待要访问的个数、每个页面编号，计算出缺页数、置换数、缺页率 语言：C++ 运行环境：Visual Studio 2013/更高版本
C++实现GPS的单点定位
04-01
在C++中实现GPS单点定位涉及到以下几个关键概念： 1. **GPS信号解析**：GPS信号由卫星发射，包含了卫星的位置、时间戳和信号质量等信息。C++程序需要解析这些二进制数据，转换为可以处理的格式。这通常涉及到NMEA...
操作系统请求分页存储器管理C++代码实现
05-25
5.在虚拟存储器基础上完成地址转换，缺页时能够实现页面置换； 6.页面置换过程中能够模拟 FIFO、 LRU置换算法， 可将多次地址转换过程中所涉 及到的页面视为进程的页面访问序列，从而计算置换次数和缺页率 。 7.OPT ...
循环链表c++
06-10
使用c++语言实现的循环链表，功能齐全，包括插入、删除、寻找等功能
循环链表实现约瑟夫环问题
11-06
循环链表实现约瑟夫环问题 约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
LeetCode Notes_#206 Reverse Linked List（C++,Python）
baji9701的博客
01-10 173
LeetCode Notes_#206 Reverse Linked List（C++,Python）LeetCode Linked List Contents 题目思路思考解答C++Python 题目 Reverse a singly linked list. Example: Input: 1->2->3->4->5->NULL Out...
【数据结构】实现单链表（c++）
zhaoyaqian552的专栏
05-27 643
头文件： #pragma once #include using namespace std; template class List; // 结点类 template class NodeList { friend class List; public: NodeList(); NodeList(Type d, NodeList *n = NULL); priva
c++链表的插入和遍历（详细）
m0_46308537的博客
10-09 771
c++链表的插入和遍历（详细）
循环链表的实现 C++
weixin_43862688的博客
03-27 695
自己写的一个实现循环链表的小程序，功能不是特别多，实现了一些最基本的方法。 // circleList.cpp : 实现循环链表 // #include "stdafx.h" #include <iostream> using namespace std; //定义节点 class Node { public: int data; Node *next; }; //创建循环...
c++实现单链表头插法、尾插法、删除、遍历
为啥不吃肉捏 的博客
03-17 2813
最近复习数据结构与算法，先从单链表开始。 首先明确链表参数为 ** head（即二级指针）的原因：只要是要修改head指针必须传递head的地址（用**head），否则传递head值即可(*p)。与普通变量类似，当需要修改普通变量的值，需传递其地址，否则传递普通变量的值即可。 首先定义Node类，即链表的结点： class Node { public: int data; //数据域 Node *next; //指针域 }; 老生常谈，头插法上一张动图： 1.创建头结点 Node *
如何用C++创建一个单链表并打印
weixin_47035879的博客
03-17 2027
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 .
C++创建并打印单链表
Coast_Tt的博客
04-25 2168
下面代码实现了使用C++语言根据输入数据创建一个单链表： 例如输入：1 2 3 4 5 -1(结束符) 打印链表：1->2->3->4->5->NULL #include <iostream> using namespace std; struct ListNode { int val; struct ListNode *next; }; / 创建单链表 head作为第一个元素节点 void...
数据结构(C++)描述 第二章 线性表
11-29
在后续的内容中，我们将详细讨论线性表的定义、操作、特性，以及在C++中如何具体实现顺序存储的线性表，包括数组的使用、动态内存分配、指针操作等。此外，还会介绍如何通过函数封装这些操作，以实现更模块化的代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值