限定性线性表——队列

最新推荐文章于 2024-05-21 20:56:54 发布
最新推荐文章于 2024-05-21 20:56:54 发布
阅读量780 收藏 27
点赞数 31
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55869380/article/details/137435549
版权
  • 语言：C语言
  • 软件：Visual Studio 2022
  • 笔记书籍：数据结构——用C语言描述
  • 如有错误，感谢指正。若有侵权请联系博主

一、队列的定义

队列是另一种限定性线性表，它只允许在表的一端插入元素，而在表的另一端删除元素，所以队列具有先进先出的特性。这与我们日常生活中的排队是一样的，最早进入队列的人最先离开，新来的人总是加入队尾。在队列中，允许插入的一端称为队尾，允许删除的一端则称为队头。

下面给出队列的抽象数据定义：
 

ADT Queue{
    数据对象：可以是任意类型的数据，但必须性质相同。
    结构关系：队列中数据元素之间是线性关系。
    基本操作：
    1、InitQueue(Q)
       操作前提：Q为未初始化的队列。
       操作结果：将Q初始化为一个空队列。
    2、IsEmpty(Q)
       操作前提：队列Q已经存在。
       操作结果：若队列为空，则返回TRUE,否则返回FALSE。
    3、IsFull(Q)
       操作前提：队列Q已经存在。
       操作结果：若队列为满，则返回TRUE，否则返回FALSE。
    4、EnterQueue(Q,x)
       操作前提：队列Q已经存在。
       操作结果：在队列Q的队尾插入x。操作成功，返回值为TRUE，否则返回值为FALSE。
    5、DeleteQueue(Q,x)
       操作前提：队列Q已经存在。
       操作结果：将队列Q的队头元素出队，并用x带回其值。操作成功，返回值为TRUE，否则返回值为FALSE。
    6、GetHeat(Q,x)
       操作前提：队列Q已经存在。
       操作结果：取队列Q的对头元素(该元素不出队)，并用x带回其值。操作成功，返回值为TRUE，否则返回值为FALSE。
    7、ClearQueue(Q)
       操作前提：队列Q已经存在。
       操作结果：将队列Q置为空队列。
}ADT Queue;

二、链队的表示和实现

1、链队列结点结构

说明：为了操作方便采用带头节点的链表结构，并设置一个队头指针font和一个队尾指针rear，对头指针始终指向头节点，队尾指针指向最后一个元素。对于空的链队列，队头指针和队尾指针均指向头结点。

93548db5b6204c4db37594549f199ed7.png

链队列

//结点的结构
typedef struct Node
{
	QueueElementType data;
	struct Node* next;
}LinkQueueNode;
//头指针尾指针结构
typedef struct
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
}LinkQueue;

2、InitQueue初始化队列

/*初始化队列*/
int InitQueue(LinkQueue *Q) {
	Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (Q->front != NULL) {
		Q->rear = Q->front;
		Q->front->next = NULL;
		return (TRUE);
	}
	else return (FALSE);
}

说明：

第三行：开辟一个新的结构体空间（头结点），并将头节点赋值给头指针。

第四行：判断开辟的头结点是否为空，这里是考虑到有可能空间满了，没法再分配内存了。

第五、六、七行：全是满足条件执行的，先将队头指针指向的地址赋值给队尾指针指向的地址，即空链队的队头指针和队尾指针均指向头结点。再将创建的头结点的指针域置空。最后一个是返回结果，结束函数。

第九行：开辟的空间为空，即没开辟空间，返回FALSE结束循环。

3、IsEmpty判断队列是否为空

/*队列判空*/
int IsEmpty(LinkQueue* Q) {
	if (Q->front->next == NULL) return (TRUE);
	return (FALSE);
}

说明：

第三行：对头结点的指针域是否为空进行判断，若为空则队列为空返回 TRUE，否则返回FALSE。这一行也可以改为判断对头指针和队尾指针是否都指向同一个结点来判断。后边出队操作中用的第二个方法。

4、IsFull队列判满

链的特性，只要内存足够可以一直往队列里存储数据

5、EnterQueue链队列入队操作

/*链队列入队操作*/
int EnterQueue(LinkQueue* Q, QueueElementType x) {
	LinkQueueNode* r = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (r == NULL) return (FALSE);
	r->data = x;
	r->next = NULL;
	Q->rear->next = r;
	Q->rear = r;
	return (TRUE);
}

说明：

第三行：声明一个结点指针，并为该结点指针开辟空间赋值。

第四行：判断是否开辟成功，若没开辟空间，则r就为空，结束函数，否则执行后续代码。

第五行：将参数x的数据赋值给开辟的结点中的数据域。

第六行：将指针域置空。

第七行：将新结点赋值给队尾指针所指向的结点的指针域。

第八行：将新结点地址赋值给队尾指针。

最后返回 TRUE，表示入队操作成功。

6、 DeleteQueue链队列出队操作

/*链队列出队操作*/
int DeleteQueue(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	if (Q->rear == r)
		Q->rear = Q->front;
	*x = r->data;
	free(r);
	return (TRUE);
}

说明：

第三行：最开始判断队列是否为空队列，若为空，直接返回FALSE，结束函数。

第四行：声明一个结点类型指针，用于存储出队的结点。

第五行：将头指针指向的头结点的指针域地址赋值给上一行声明的r指针。

第六行：将需要取出的结点的指针域数据赋值给头结点（Q->front）的指针域。即更新了头结点指针域所指向的地址。至此，将队列中队头数据取出，赋值在r中。

第七、八行：判断取出的这个结点是否为最后一个结点，若是最后一个结点，则需要即将队尾指针指向头节点。

第九行：将取出的结点中的数据取出赋值给参数x，这里必须用指针，函数形参和实参是值传递；

第十行：用free函数释放该该结点空间，即数据取出了销毁存储数据的空间，防止内存泄漏。

第十一行：返回TRUE，函数结束。

7、GetHead取队头操作

/*队列取对头元素*/
int GetHead(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	*x = Q->front->next->data;
	return (TRUE);
}

说明：

第三行：判断是否为空队列，若为空，返回FALSE直接结束函数。

第四行：将头首元结点的数据值赋值给x。Q->front是头结点，头结点的指针域（即Q->front->next）指向的是首元结点。

第五行：返回TRUE 函数结束。

8、ClearQueue队列置空操作

/*置空队列*/
int CleaQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	while (Q->rear != r) {
		free(r);
		r = Q->front->next;
		Q->front->next = r->next;
	}
	free(r);
	Q->rear = Q->front;
	return (TRUE);
}

说明：

第三行：判断队列是否为空，若为空返回FALSE结束函数。

第四行：声明一个结点指针用于存储需要删除的结点。

第五行：将队列的队头赋值给声明的结点r，为了初始化结点r，便于while循环内判断。

第六行：更新队头数据。

第七行：判断需删除的结点是否是队尾，若是队尾，则跳出循环，不是队尾，持续循环。

第八行：将取出的队头空间删除释放。

第九行：再将队头指针赋值给声明的结点r。

第十行：更新队头数据。

第十二行：若链队内结点全删除，只剩最后一个结点，即跳出循环执行这一行。将最后一个结点的空间释放。

第十三行：将队尾指针指向头节点。

第十四行：返回TRUE，函数结束。

9、链队列的全套代码

#include <iostream>
#include <stdio.h>

#define QueueElementType int
#define TRUE 1
#define FALSE 0

typedef struct Node
{
	QueueElementType data;
	struct Node* next;
}LinkQueueNode;

//对头指针与队尾指针
typedef struct
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
}LinkQueue;

/*初始化队列*/
int InitQueue(LinkQueue *Q) {
	Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (Q->front != NULL) {
		Q->rear = Q->front;
		Q->front->next = NULL;
		return (TRUE);
	}
	else return (FALSE);
}

/*队列判空*/
int IsEmpty(LinkQueue* Q) {
	if (Q->front->next == NULL) return (TRUE);
	return (FALSE);
}

/*链队列入队操作*/
int EnterQueue(LinkQueue* Q, QueueElementType x) {
	LinkQueueNode* r = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
	if (r == NULL) return (FALSE);
	r->data = x;
	r->next = NULL;
	Q->rear->next = r;
	Q->rear = r;
	return (TRUE);
}

/*链队列出队操作*/
int DeleteQueue(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	if (Q->rear == r)
		Q->rear = Q->front;
	*x = r->data;
	free(r);
	return (TRUE);
}

/*队列取对头元素*/
int GetHead(LinkQueue* Q, QueueElementType* x) {
	if (Q->front == Q->rear) return (FALSE);
	*x = Q->front->next->data;
	return (TRUE);
}

/*置空队列*/
int CleaQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	Q->front->next = r->next;
	while (Q->rear != r) {
		free(r);
		r = Q->front->next;
		Q->front->next = r->next;
	}
	free(r);
	Q->rear = Q->front;
	return (TRUE);
}

/*打印队列里的数据*/
int PrintLinkQueue(LinkQueue* Q) {
	if (Q->front == Q->rear) return (FALSE);
	LinkQueueNode* r;
	r = Q->front->next;
	printf("[");
	while (Q->rear != r) {
		printf("'%d',",r->data);
		r = r->next;
	}
	printf("'%d']",r->data);
}

void LinkQueueText() {
	LinkQueue* Q, Queue;
	QueueElementType* x, data;
	x = &data;
	Q = &Queue;
	InitQueue(Q);
	printf("——————————队列插入测试——————————\n");
	printf("请输入你要入队的数据,非数值结束：");
	while (1 == scanf_s("%d", x)) {
		EnterQueue(Q, data);
	}
	printf("\n队列里的数据为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列出队测试——————————\n");
	DeleteQueue(Q, x);
	printf("出队元素为：%d\n", data);
	DeleteQueue(Q, x);
	printf("出队元素为：%d\n", data);
	printf("队列剩余元素为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列取对头元素测试——————————\n");
	GetHead(Q, x);
	printf("第一次取对头元素为：%d\n", data);
	GetHead(Q, x);
	printf("第二次取对头元素为：%d\n", data);
	printf("队列剩余元素为：");
	PrintLinkQueue(Q);
	printf("\n——————————队列置空和队列是否为空测试——————————\n");
	printf("空为1，非空为0，队列置空前：%d\n", IsEmpty(Q));
	CleaQueue(Q);
	printf("空为1，非空为0，队列置空后：%d", IsEmpty(Q));
}

int main() {
	LinkQueueText();
}

10、测试结果

28c33a618b35484bb2bce18deb87d247.png

三、循环队列（顺序队列）的表示和实现 

1、循环队列结点结构

循环队列是队列的一种顺序表示和实现方法。与顺序栈类似，在队列的顺序存储结构中，用一组地址连续的存储单元依次存放从队头到队尾的位置是动态变化的因此需要附设俩个指针front和rear，分别指示队头元素和队尾元素在数组中的位置。

8feef4eea18d479bbdb2ef6f5d33ea45.png

typedef struct {
	QueueElementTye element[QueueMAXSIZE];
	int front;
	int rear;
}SeqQueue;

第三、四行：定义一个头结点一个尾节点，用于进和出。

 2、InitQueue初始化队列

/*初始化队列*/
void InitQueue(SeqQueue* Q) {
	Q->front = Q->rear = 0;
}

3、IsEmpty判断队列是否为空

/*队列判空*/
int IsEmpty(SeqQueue* Q) {
	if (Q->front == Q->rear) return TRUE;
	return FALSE;
}

4、IsFull队列判满

/*队列判满*/
int IsFull(SeqQueue* Q) {
	if ((Q->rear+1) % QueueMAXSIZE == Q->front) return TRUE;
	return FALSE;
}

因为判空是头尾相连的，故没法用这个判满 再次空出一个空间 用于判断。

5、EnterQueue队尾插入

/*队尾插入*/
int EnterQueue(SeqQueue* Q, QueueElementTye x) {
	if (IsFull(Q) == TRUE) return FALSE;
	Q->element[Q->rear] = x;
	Q->rear = (Q->rear+1)%QueueMAXSIZE;
	return TRUE;
}

6、DeleteQueue队头出队

/*队头出队*/
int DeleteQueue(SeqQueue* Q, QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	Q->front = (Q->front + 1) % QueueMAXSIZE;
	return TRUE;
}

7、GetHead取队头元素

/*取队头元素*/
int GetHead(SeqQueue* Q,QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	return TRUE;
}

 8、ClearQueue置空队列

/*置空队列*/
void ClearQueue(SeqQueue* Q) {
	memset(Q->element,NULL,sizeof(Q->element));
	Q->front = Q->rear = 0;
}

 9、循环队列的全套代码

#include <iostream>
#include <stdio.h>

#define QueueElementTye int
#define QueueMAXSIZE 5
#define TRUE 1
#define FALSE 0


typedef struct {
	QueueElementTye element[QueueMAXSIZE];
	int front;
	int rear;
}SeqQueue;

/*初始化队列*/
void InitQueue(SeqQueue* Q) {
	Q->front = Q->rear = 0;
}

/*队列判空*/
int IsEmpty(SeqQueue* Q) {
	if (Q->front == Q->rear) return TRUE;
	return FALSE;
}

/*队列判满*/
int IsFull(SeqQueue* Q) {
	if ((Q->rear+1) % QueueMAXSIZE == Q->front) return TRUE;
	return FALSE;
}

/*队尾插入*/
int EnterQueue(SeqQueue* Q, QueueElementTye x) {
	if (IsFull(Q) == TRUE) return FALSE;
	Q->element[Q->rear] = x;
	Q->rear = (Q->rear+1)%QueueMAXSIZE;
	return TRUE;
}

/*队头出队*/
int DeleteQueue(SeqQueue* Q, QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	Q->front = (Q->front + 1) % QueueMAXSIZE;
	return TRUE;
}

/*取队头元素*/
int GetHead(SeqQueue* Q,QueueElementTye* x) {
	if (IsEmpty(Q) == TRUE) return FALSE;
	*x = Q->element[Q->front];
	return TRUE;
}

/*置空队列*/
void ClearQueue(SeqQueue* Q) {
	memset(Q->element,NULL,sizeof(Q->element));
	Q->front = Q->rear = 0;
}

/*打印队列内的数据*/
void PrintSeqQueue(SeqQueue* Q) {
	int i = Q->front, j = Q->rear;
	while (i != j) {
		printf("%d  ", Q->element[i]);
		i = (i + 1) % QueueMAXSIZE;
	}
	printf("\n");
}

void SeqQueueText() {
	SeqQueue* Q, Qu;
	int i;
	QueueElementTye* x, data;
	Q = &Qu;
	x = &data;
	InitQueue(Q);
	printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
	while (1 == scanf_s("%d", &i)) {
		if (i == 1) {
			printf("\n请输入你要入队的数据，非数字结束");
			scanf_s("%d", &data);
			EnterQueue(Q, data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 2) {
			DeleteQueue(Q, x);
			printf("出队的数据为：%d\n", data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 3) {
			PrintSeqQueue(Q);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 4) {
			GetHead(Q, x);
			printf("队头的数据为：%d\n", data);
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 5) {
			ClearQueue(Q);
			printf("置空完成！\n");
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 6) {
			printf("满栈为1，非满为0：%d\n", IsFull(Q));
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
		if (i == 7) {
			printf("空栈为1，非空为0：%d\n", IsEmpty(Q));
			printf("1.入队，2.出队，3.查询整个队列，4.查询队头，5.置空队列，6.为满查询，7.为空查询，q结束。请输入你想执行的操作:");
			continue;
		}
	}
}

int main() {
	SeqQueueText();
}

10、循环队列运行结果：

892b20878626404cad5097a1713d7b91.png

小强不秃头
关注
  • 31
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线性表——数据机构.md
03-11
线性表——数据机构.md
线性表——链表PPT学习教案.pptx
10-01
线性表——链表PPT学习教案.pptx
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案.pptx
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
线性表栈队列的所有源文件
11-08
该压缩包包含线性表、栈、队列的线性存储和链式存储结构的源文件
C语言（指针）7
奋斗的小羊的博客
05-14 1087
指针超超超详解
1830. 【提高组NOIP2007】统计数字(count.pas/c/cpp)
wrnxrxsb的博客
05-14 526
某次科研调查时得到了n个自然数，每个数均不超过1500000000（1.5*10^9）。已知不相同的数不超过10000个，现在需要统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。输出文件count.out包含m行（m为n个自然数中不相同数的个数），按照自然数从小到大的顺序输出。每行输出两个整数，分别是自然数和该数出现的次数，其间用一个空格隔开。100%的数据满足：1<=n<=200000，每个数均不超过1 500 000 000（1.5*10^9）第1行是整数n，表示自然数的个数。
c/c++笔试题总结
qq_71286244的博客
05-19 532
c/c++面试题总结
自己手写一个双向链表【C风格】
最新发布
weixin_45690131的博客
05-21 181
双向链表简单实现
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 274
C语言如何在链表中的指定位置插⼊结点？
C语言从头学07——算数运算符
m0_72128260的博客
05-17 384
简单介绍C语言中的算数运算符。
IOU的C语言快速实现
jikechong的专栏
05-16 684
对两个矩形相交的点以及某个矩形的顶点落在另一个矩形内的点集合S进行时钟序排序overlap_points : 两个矩形相交的点以及某个矩形的顶点落在另一个矩形内的点集合S和个数的结构体。计算出两个矩形相交的点以及某个矩形的顶点落在另一个矩形内的点集合Soverlap_points : 两个矩形相交的点以及某个矩形的顶点落在另一个矩形内的点集合S和个数的结构体。overlap_points : 两个矩形相交的点以及某个矩形的顶点落在另一个矩形内的点集合S和个数的结构体。
查找实验（C语言）
hpz3292887609的博客
05-21 256
算法1：采用顺序存储结构创建静态查找表，对查找表进行顺序查找和改进的顺序查找，并对其查找效率进行比较；算法2：采用顺序存储结构创建静态查找表——有序表，对有序表进行二分查找；（1）掌握静态查找表算法（重点掌握折半查找）；（2）掌握动态查找表——二叉排序树查找算法；
跨平台应用开发进阶(五十四)cordova自定义插件
IT全栈 华强工作室
05-15 893
在前期博文《ReactNative进阶（一）：ReactNative 学习资料汇总》中，提到目前主流的移动跨平台技术方案大体可以分为三类，使用原生内置浏览器加载HTML5的Hybrid技术方案，采用此种方案的主要有CordovaIonic和微信小程序；使用JavaScript语言进行开发，然后使用原生组件进行渲染，采用此方案的主要有Weex和轻快应用；使用自带渲染引擎和自带原生组件来实现跨平台，采用此种方案的主要是Flutter。注意⚠️：存放自定义cordova插件目录不能有空格可能会报错！
C语言学习细节｜C语言面向对象编程！函数指针如何正确使用
糖炒栗子
05-15 593
函数指针就是一个指向函数的指针变量，与指向数据的指针不同，函数指针保存的是函数的地址，这使得程序可以动态地调用不同的函数，而无需在编译时确定具体的函数。可以在程序运行时动态得传递和调用不同的函数。
【数据结构】排序(选择排序,堆排序)
m0_72651735的博客
05-15 296
当begin 和maxi 的位置重合，那么begin 和mini 在交换的时候，就把最小值换到了 begin(maxi) 处，最大值被换走了。在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素。每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完。若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。4. 稳定性：不稳定。
不相交集合的数据结构
Zhang_Qin123的博客
05-15 894
链表中的每个节点都包含。
暴力数据结构之二叉树（堆的相关知识）
2301_80689220的博客
05-15 870
【代码】暴力数据结构之二叉树（堆的相关知识）
数据结构：栈
Auroral_0218的博客
05-17 656
栈（Stack）是一种线性数据结构，具有特殊的操作规则。栈中的数据项按照后进先出（Last In First Out, LIFO）的原则进行插入和删除操作。入栈（Push）：在栈顶插入一个元素。如果栈已满，则无法插入新元素。出栈（Pop）：从栈顶删除一个元素，并返回被删除的元素。如果栈为空，则无法进行删除操作。栈顶（Top）：栈中最后插入的元素。栈底（Bottom）：栈中第一个插入的元素。栈的大小（Size）：栈中元素的数量。栈的空间限制：栈的大小有限，当栈已满时，无法再进行入栈操作。
顺序线性表——课上练
09-12
顺序线性表是一种常见的数据结构，它是一系列元素按照一定的顺序排列的数据集合。顺序线性表中的元素在内存中是连续存储的，可以通过索引直接访问。 在课上练习顺序线性表时，你可以尝试以下几个问题： 1. 创建一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值