【数据结构与算法】队列的介绍与实现（详细+经典例题）

最新推荐文章于 2022-10-09 13:15:28 发布
最新推荐文章于 2022-10-09 13:15:28 发布
阅读量672 收藏 5
点赞数 8
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53306029/article/details/122298671
版权

队列的介绍与实现

1.队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.队列的实现

2.1整体描述

typedef int QDataType;//队列中存储的元素类型（这里用整型举例）
typedef struct QueueNode//创建一个结点类型，类型包含了该结点的数据和指向下一结点的指针。
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue//创建一个结构体用于存放队列的队头和队尾。
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;
void QueueInit(Queue* pq);//初始化队列
void QueueDestory(Queue* pq);销毁队列元素
void QueuePush(Queue* pq, QDataType x);  //队尾入队列
void QueuePop(Queue* pq);                // 队头出队列
int QueueSize(Queue* pq);//记录队列有效数据个数
QDataType QueueFront(Queue* pq);//获取队头元素
QDataType QueueBack(Queue* pq);//获取队尾元素
bool QueueEmpty(Queue* pq);//判空（检测队列是否为空）

2.2具体实现

初始化队列

首先我们需要创建一个结点类型，类型包含了该结点的数据和指向下一结点的指针。

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

队列与普通链表有所不同，普通链表只需要知道链表的头指针，而队列的信息包括了队头和队尾，所以我们需要再创建一个结构体用于存放队列的队头和队尾。

typedef struct Queue
{
	QueueNode* phead;//队头
	QueueNode* ptail;//队尾
}Queue;

然后，我们需要一个初始化函数，对刚创建的队列进行初始化。

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	//起始时队列为空
pq->phead = pq->ptail = NULL;
}
销毁队列

队列中的每一个结点所占用的内存空间都是动态开辟的，当我们使用完队列后需要及时释放队列中的每一个结点。

void QueueDestory(Queue* pq)//释放
{
	assert(pq);

	QueueNode* cur = pq->phead;
	//遍历链表，逐个释放结点
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}
队尾入队列

入队列，即申请一个新结点并将其链接到队尾，然后改变队尾的指针指向即可。

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));//申请新结点
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;//新结点赋值
	newnode->next = NULL;//新结点指针域置空
	if (pq->phead == NULL)//队列中原本无结点
	{
		pq->phead = pq->ptail = newnode;//队头、队尾直接指向新结点
	}
	else//队列中原本有结点
	{
		pq->ptail->next = newnode;//最后一个结点指向新结点
		pq->ptail = newnode;//改变队尾指针指向
	}
}
队头出队列

出队列，即释放队头指针指向的结点并改变队头指针的指向

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	if (pq->phead->next == NULL)//队列中只有一个结点
	{
		free(pq->phead);
		pq->phead = NULL;
		pq->ptail = NULL;
	}
	else//队列中有多个结点
	{
		QListNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;//改变队头指针指向
	}
}
获取队头元素

获取队列头部元素，即返回队头指针指向的数据即可。

//获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	return pq->phead->data;//返回队头指针指向的数据
}
获取队尾元素

获取队列尾部元素，即返回队尾指针指向的数据即可。

//获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//检测队列是否为空

	return pq->ptail->data;//返回队尾指针指向的数据
}
检测队列是否为空

检测队列是否为空，即判断队头指针指向的内容是否为空。

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;
}
记录队列有效数据个数

队列中有效元素个数，即队列中的结点个数。我们只需遍历队列，统计队列中的结点数并返回即可。

int QueueSize(Queue* pq)
{
	assert(pq);

	QueueNode* cur = pq->phead;//接收队头
	int count = 0;//记录结点个数
	while (cur)//遍历队列
	{
		count++;
		cur = cur->next;
	}
	return count;//返回队列中的结点数
}

3.简单测试

插入1 2 3 4 5五个元素，并遍历输出

int main()
{
	Queue q;
	QueueInit(&q);//初始化
	QueuePush(&q, 1);//队尾入数据
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);

	while (!QueueEmpty(&q))//
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");

	return 0;
}

运行结果：
在这里插入图片描述

4.队列经典例题

4.1设计循环队列

设计循环队列《–（戳这里）
在这里插入图片描述

在这里插入图片描述
代码：

typedef struct {
int *a;
int front;
int rear;
int k;
} MyCircularQueue;

//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
q->a=(int *)malloc(sizeof(int*)*(k+1));
q->front=0;
q->rear=0;
q->k=k;
return q;
}
//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
assert(obj);
return obj->front==obj->rear;
}
//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
assert(obj);
//取余操作防止溢出
return (obj->rear+1)%(obj->k+1)==obj->front;
}

//入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
assert(obj);
if(myCircularQueueIsFull(obj))                      //若队列满则无法进行入队操作
        return false;
    obj->a[obj->rear] = value;
   obj->rear++;
   //防止溢出
 if(obj->rear==obj->k+1)
 obj->rear=0;
    return true;

}
//从循环队列中删除一个元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
assert(obj);
if(myCircularQueueIsEmpty(obj))
return false;
++obj->front;
//防溢出
obj->front%=(obj->k+1);
return true;
}
//从队首获取元素
int myCircularQueueFront(MyCircularQueue* obj) {
assert(obj);
if(myCircularQueueIsEmpty(obj))
return -1;

return obj->a[obj->front];
}
//从队尾获取元素
int myCircularQueueRear(MyCircularQueue* obj) {
assert(obj);
if(myCircularQueueIsEmpty(obj))
return -1;

int prevrear=obj->rear-1;
if(obj->rear==0)
prevrear=obj->k;
return obj->a[prevrear];
}


void myCircularQueueFree(MyCircularQueue* obj) {
assert(obj);
free(obj->a);
free(obj);
}

4.2用队列实现栈

用队列实现栈《–（戳这里）

在这里插入图片描述
在这里插入图片描述
代码：

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;

void QueueInit(Queue* pq)//初始化
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
}
void QueueDestory(Queue* pq)//释放
{
	assert(pq);

	QueueNode* cur = pq->phead;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}

bool QueueEmpty(Queue* pq)//判空
	{
		assert(pq);
		return pq->phead == NULL && pq->ptail == NULL;
	}

void QueuePush(Queue* pq, QDataType x)//队尾插
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
}

	void QueuePop(Queue * pq)//队头删
	{
		assert(pq);
		assert(!QueueEmpty(pq));

		if (pq->phead->next == NULL)
		{
			free(pq->phead);
			pq->phead = pq->ptail = NULL;
		}
		else
		{
			QueueNode* next = pq->phead->next;
			free(pq->phead);
			pq->phead = next;
		}
	}
	int QueueSize(Queue* pq)
	{
		assert(pq);
		int n = 0;
		QueueNode* cur = pq->phead;
		while (cur)
		{
			n++;
			cur = cur->next;
		}
		return n;
	}

	QDataType QueueFront(Queue* pq)//取队头元素
	{
		assert(pq);
		assert(!QueueEmpty(pq));

		return pq->phead->data;
	}
	QDataType QueueBack(Queue* pq)//取队尾元素
	{
		assert(pq);
		assert(!QueueEmpty(pq));

		return pq->ptail->data;
	}
///
typedef struct {
Queue q1;
Queue q2;
} MyStack;


MyStack* myStackCreate() {
MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}

void myStackPush(MyStack* obj, int x) {
assert(obj);

if(!QueueEmpty(&obj->q1))
{
    QueuePush(&obj->q1,x);

}
else
{
    QueuePush(&obj->q2,x);
}
}

int myStackPop(MyStack* obj) {
assert(obj);
Queue* emptyQ=&obj->q1;
Queue* noneemptyQ=&obj->q2;

if(!QueueEmpty(&obj->q1))
{
    emptyQ=&obj->q2;
    noneemptyQ=&obj->q1;
//将非空队列的size-1个数据导入空队列
}
while(QueueSize(noneemptyQ)>1)
{
QueuePush(emptyQ,QueueFront(noneemptyQ));
QueuePop(noneemptyQ);

}
//删掉空队列中剩下的最后一个数据，这个数据相当与我们的栈顶数据。
int top =QueueFront(noneemptyQ);
QueuePop(noneemptyQ);

return top;
}

int myStackTop(MyStack* obj) 
{
assert(obj);
if(!QueueEmpty(&obj->q1))
{
    return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}

}

bool myStackEmpty(MyStack* obj) {
assert(obj);
return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
//释放
assert(obj);

QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
}

4.3用栈实现队列

用栈实现队列《–（戳这里）
在这里插入图片描述
在这里插入图片描述
代码：

typedef int STDatatype;//栈中存储的元素类型（这里用整型举例）
typedef struct Stack
{
	STDatatype* a;//栈
	int top;//栈顶
	int capacity;//容量，方便增容
}ST;
// 初始化栈
void StackInit(ST* ps);

// 销毁栈
void StackDestory(ST* ps);

// 入栈
void StackPush(ST* ps,STDatatype x);

// 出栈
void StackPop(ST* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(ST* ps);

// 获取栈中有效元素个数
int  StackSize(ST* ps);

// 获取栈顶元素
STDatatype StackTop(ST* ps);

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

//销毁栈
void StackDestory(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);//释放栈
	}
	ps->a = NULL;
	ps->top = 0;//-1也可以 //栈顶置0
	ps->capacity = 0;//容量置0
}

//入栈
void StackPush(ST* ps, STDatatype x)
{
	assert(ps);
	//检查空间够不够，不够就增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDatatype* tmp = realloc(ps->a, sizeof(STDatatype) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;//栈顶位置存放元素x
	ps->top++;//栈顶上移
}

//出栈
void StackPop(ST* ps)//删
{
	assert(ps);
	assert(!StackEmpty(ps));//检测栈是否为空
	--ps->top;//栈顶下移
}

//检测栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//获取栈中有效元素个数
int  StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

//获取栈顶元素
STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//检测栈是否为空

	return ps->a[ps->top - 1];//返回栈顶元素
}

typedef struct {
ST pushST;
ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->pushST);//初始化栈
StackInit(&q->popST);

return q;
}

void myQueuePush(MyQueue* obj, int x) {
assert(obj);
StackPush(&obj->pushST,x);//往pushST插元素

}



int myQueuePeek(MyQueue* obj) {
assert(obj);
if(StackEmpty(&obj->popST))
{
    while(!StackEmpty(&obj->pushST))
    {
        StackPush(&obj->popST,StackTop(&obj->pushST));//pushST栈顶元素插入到popST
        StackPop(&obj->pushST);//干掉pushST中原有插入popST中的元素
    }
}
return StackTop(&obj->popST);

}

int myQueuePop(MyQueue* obj) {
assert(obj);

int front=myQueuePeek(obj);//找到popST栈顶元素（即队列队头元素）
StackPop(&obj->popST);//取出栈顶元素

return front;
}

bool myQueueEmpty(MyQueue* obj) {
//判空
return StackEmpty(&obj->popST)&&StackEmpty(&obj->pushST);
}

void myQueueFree(MyQueue* obj) {
//释放
StackDestory(&obj->popST);
StackDestory(&obj->pushST);
free(obj);
}

– the End –

以上就是我分享的【队列的介绍与实现】相关内容，感谢阅读！

关注作者，持续阅读作者的文章，学习更多知识！
https://blog.csdn.net/weixin_53306029?spm=1001.2014.3001.5343

2022/1/4
————————————————

…狂奔的蜗牛～
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
经典数据结构队列的研究和实现.pdf
08-07
#资源达人分享计划#
队列的经典例题—数据结构
m0_61963422的博客
11-04 601
队列的经典例题
关于栈和队列一些例题
chihiro1122的博客
10-09 717
栈的例题
数据结构之队列（案例版）
会飞的冰箱的博客
12-30 1185
队列是一种特殊性的线性结构，它只允许在队列的首部（head）进行删除操作，这个称作”出队”，而在队列的尾部（tail）进行插入工作，叫做”入队”。这就是我们常说的”先进先出“原则。生活中有很多的这样的案例，例如我们排队买火车票，每个排队买票的窗口就是一个队列，人越靠前就越早买到火车票，越早买完就越早从队列出来，后来的在队尾进入。为了让大家更好的理解队列，在这里简单的介绍一个案例（这个案例来自《啊哈！
数据结构队列实例
weixin_30664539的博客
10-18 98
1 //数据结构 --队列 2 //静态队列-用数组实现 3 //静态队列通常是循环队列 4 //循环队列讲解 5 //1.静态队列为什么必须是循环队列？ 6 //2.循环队列需要几个参数来确定？ 7 /* 8 front 和 rear 9 1）队列初始化，font和rear的值都为零 10 2）队列非空 ...
数据结构与算法笔记+LeetCode经典例题分析
11-02
数据结构与算法笔记+LeetCode经典例题分析。 其中包括八大排序算法、动态规划背包问题、深度优先搜索、广度优先搜索、队列、优先队列、栈、并查集、树、二叉树、二叉搜索树、AVL平衡二叉树等等。
数据结构与算法的学习与实现，以及例题分享.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
基于Python实现的数据结构与算法源码集锦
最新发布
03-25
本项目采用Python语言编写，包含了丰富的数据结构与算法实现。全套源码共40个文件，其中39个为Python源文件（.py），以及1个Git忽略配置文件（.gitignore），用于维护版本控制时的忽略规则。 项目特点： - 纯Python...
C++数据结构与算法之双缓存队列实现方法详解
08-29
主要介绍了C++数据结构与算法之双缓存队列实现方法,结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项,需要的朋友可以参考下
数据结构 栈和队列的应用——经典题目分析
ZY-JIMMY
01-08 2654
目录 1、数制转换 (顺序栈) 2、表达式转换、求值 (顺序栈) 3、字符串逆序输出 (顺序栈) 4、括号匹配算法 (顺序栈) 5、判断字符串是否为回文字符串 (顺序栈、链式栈) 6、两个栈实现一个队列 7、两个队列实现一个栈 顺序栈与链栈的实现完整代码：https://blog.csdn.net/ZYZMZM_/article/details/85261502 顺序队列、循环队...
栈与队列经典例题详解
06-06
体育课经常排在上午3、4节，一节课下来大家都筋疲力尽、饥肠辘辘。将近下课，体育老师一吹口哨大家立即集合，不过这次集合大家都站成了一排，然后老师说向右看齐，这时每个人只能看到右侧比自己矮的人头，如果突然出现一个高于或等于自己身高的同学，那么这名同学以及其右侧的同学将会被挡住。那么，问题来了，现给定所有同学的身高（假设体育课大家修炼了一种神秘技能，改变了自己的身高，（身高最大值为2*106），要求每个人能往右侧看到的人数之和（建议使用long long存储）。
数据结构实例（内含17个详细经典实例）
12-26
数据结构实践教程：内含17个经典数据结构实例 根据五个不同数据结构，对每个结构都有2~4个经典实例。每个实例都有项目简介、设计思路、数据结构、完整程序、运行结果五个部分，可以直接拿来做一篇课程设计。实例名称有：学生成绩管理系统、考试报名管理、约瑟夫生者死者游戏、迷宫旅行游戏、八皇后问题、停车场管理、单词检索统计程序、Internet网络通路、家谱管理、表达式求值问题、图像压缩编码优化、公交路线管理、导航最短路径查询、电网建设造价计算、软件工程进度规划及综合不同中数据结构设计出来的景区旅游信息管理程序。
数据结构（C语言版） 清华大学出版社 第三章栈和队列 例题答案
09-06
主要讲述了C语言中栈和队列的有关内容，比如队列中链队列和循环队列的实现。
数据结构---队列的实现和个人分析
编程语言小筑
12-31 124
队列的一个显著的特征正好的和栈是相反的，它是按照先进先出（FIFO）的方式存储和检索元素，这就是说，对线插入队列的要先删除。还有就是队列是限制在两端进行插入和删除操作的线性表，允许进行存入操作的一端就叫“队尾”，允许进行删除操作的就是“对头”。当线性表中没有元素时，称为“空队“。那么，我们可以吧队列想象地理解成银行办理业务的一队人。 下面介绍顺序队列的定义和实现（以前写的代码） /*s...
队列的习题
金艺群的博客
11-20 872
假设称正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’ 则不是回文。试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。(要求用到队列) #include <stdio.h> #include "../SqStack.h" #include "../Queue.h" #define END '@' bool...
基础数据结构之队列题型
qq_52993545的博客
02-16 168
队列是一种先进先出的数据结构。 有一些题目我们需要先推导它们的性质，然后根据其性质使用队列。这种题目的难度往往较大。 蚯蚓 双端队列 单调队列问题 单调队列是一种经典题型。和单调栈一样，保存一堆单调递增的数据。不同的是，单调队列需要从最前面的元素开始操作，单调栈需要从最后面的元素进行操作。 最大子序和 ...
数据结构之队列操作示例
qq_44119514的博客
04-09 238
头文件： #include<iostream.h> #include<stdlib.h> #define MAXsize 100 //定义最大队列长度 typedef int Status; typedef int QElemType; typedef struct{ QElemType *base;//初始化的动态分配存储空间 int front; ...
数据结构与算法 队列(二) 常用实例
Genven_Liang的博客
02-01 684
数据结构与算法 队列(二) 常用实例 一、简述 记--记录常用的循环队列实现（C语言）， 以便后续使用。 实际应用：串口数据，协议数据，等不定长的数据需要进行缓冲解析；各种自定义数据缓冲等； 例子打包：外链:https://wwi.lanzouq.com/b0ca39uyj密码:hqc5 二、测试代码： 在相关的工程路径下，将queue.c放到源码路径下，添加queue.h头文件引用，即可使用例子中的循环队列。 queue.h文...
初识队列 (例题)
qq_62660119的博客
02-01 911
queue<int> aa; //定义一个队列 ——队列的基本操作—— aa.front() //返回队列的第一个元素 aa.back() //返回队列的最后一个元素 aa.empty() //如果队列为空则返回真 aa.push() //在队列末尾加一个元素 aa.pop() //删除队列首端的一个元素 aa.size() //返回队列中的元素个数 例一 无法吃午餐的学生数量 (leetcode 1700) https://leetcode-cn.com/problems..
数据结构java第四版例题源代码
12-16
数据结构Java第四版是一本非常经典的教材，其中包含了许多例题源代码。这些例题源代码涵盖了各种数据结构的实现和应用，如链表、栈、队列、树、图等。这些源代码不仅能帮助学习者理解数据结构的原理和实现细节，还能帮助他们通过实际的编程练习加深对知识的理解和掌握。 比如，书中可能包含了链表的创建、插入、删除等操作的源代码示例；栈的实现以及应用场景的示例代码；队列的实现和使用示例等等。这些源代码通常都是用Java语言编写的，易于理解和阅读，可以帮助读者更好地理解数据结构的相关算法和原理。 这些例题源代码对于学习者来说是非常有用的，可以作为参考和学习的素材。通过阅读和实际练习这些源代码，学习者可以更好地掌握数据结构的知识，提高自己的编程能力，为将来解决实际问题打下坚实的基础。 总之，数据结构Java第四版的例题源代码是学习数据结构的一个非常有用的资源，对于想要深入学习和应用数据结构的程序员来说，是非常值得阅读和实践的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

…狂奔的蜗牛～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值