数据结构——队列

已于 2024-01-21 18:10:58 修改
阅读量1.2k 收藏 24
点赞数 27
分类专栏： 数据结构 文章标签： 数据结构
于 2024-01-05 00:20:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eristic0618/article/details/135396441
版权

目录

一、队列

1.1 队列的基本概念

1.2 队列的实现

二、队列的接口实现

（1）初始化队列

（2）销毁队列

（3）入队

（4）出队

（5）获取队头元素

（6）获取队尾元素

（7）获取队列中有效元素个数

（8）检测队列是否为空

三、关于队列的OJ题

3.1 用队列实现栈

3.2 用栈实现队列

3.3 设计循环队列

一、队列

1.1 队列的基本概念

队列是一种特殊的线性表，其特点是只允许在表的前端进行删除数据操作，在表的后端进行插入操作

队列和栈一样，也是一种操作受限的线性表。我们前面学习了栈（数据结构——栈-CSDN博客），知道栈遵循后进先出（LIFO）的原则。与栈相对的，队列中的数据元素遵循：FIFO（First In First Out），即先进先出的原则

队列中，进行插入操作（入队）的一端称为队尾，进行删除操作（出队）的一端称为队头

1.2 队列的实现

我们可以使用数组结构或链表结构来实现队列。如果使用数组来实现队列的话，数组的头插头删需要对每一个元素进行移动操作，效率不如链表。所以二者取其优，我们使用链表的结构实现队列会更简便高效。

关于链表，我们在前面已经学习过了单链表和带头双向循环链表。在这里我们用单链表即可解决问题。

二、队列的接口实现

我们先创建一个头文件"Queue.h"和两个源文件"Queue.c"和"Test.c",具体作用为：

  • Queue.h：栈的定义，头文件的引用和接口函数的声明
  • Queue.c：接口函数的实现
  • Test.c：测试各个函数

明确了使用哪种链表后，我们还要考虑更多的细节问题。出队的时候，由于队列的先进先出原则，我们要删除队头即链表头节点，所以需要一个指针保存头节点的地址；而入队的时候，我们则要从队尾即链表尾节点插入元素，所以还需要一个指针来保存尾节点的地址，所以我们不止需要一个结构体来表示队列节点，还需要一个结构体来保存头尾节点的地址。

我们先展示"Queue.h"的完整代码，最后再展示"Queue.c"的完整代码。

不要忘记在两个源文件中引用"Queue.h"

#pragma once //防止头文件被二次引用

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int QDataType; //如果要修改存储的数据类型可直接在此修改

typedef struct QueueNode //链式结构：表示队列节点
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue //队列的结构
{
	QNode* phead; //指向队头
	QNode* ptail; //指向队尾
	int size; //可选，方便函数实现
}Queue;

//队列的增删查改接口实现（因为指针在结构体中所以不需要传二级指针）

void QueueInit(Queue* que);//初始化队列

void QueueDestroy(Queue* que);//销毁队列

void QueuePush(Queue* que, QDataType x);//入队

void QueuePop(Queue* que);//出队

QDataType QueueFront(Queue* que);//获取队头元素

QDataType QueueBack(Queue* que);//获取队队元素

int QueueSize(Queue* que);//获取队列中有效元素个数

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

接下来我们开始逐个实现接口函数。 

（1）初始化队列

void QueueInit(Queue* que)
{
	assert(que); //断言，防止传入空指针
	que->phead = NULL; //初始化指向头节点的指针
	que->ptail = NULL; //初始化指向尾节点的指针
	que->size = 0; //初始化队列大小
}

（2）销毁队列

void QueueDestroy(Queue* que)
{
	assert(que); //断言，防止传入空指针
	QNode* cur = que->phead; //创建一个指针变量用来保存每次的头节点位置
	while (cur) //当cur==NULL时队列销毁完毕，跳出循环
	{
		que->phead = que->phead->next; //更新头节点地址
		free(cur); //释放原来的头节点
		cur = que->phead; //cur指向新的头节点
	}
	que->phead = que->ptail = NULL; //置空
	que->size = 0; //更新size
}

（3）入队

void QueuePush(Queue* que, QDataType x)
{
	assert(que); //断言，防止传入空指针
	QNode* newnode = (QNode*)malloc(sizeof(QNode)); //创建新节点
	if (newnode == NULL) //防止空间开辟失败
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x; //初始化新节点数据
	newnode->next = NULL; //新节点指向NULL
	if (que->phead == NULL || que->ptail == NULL) //如果队列为空
	{
		assert(que->phead == NULL);
		assert(que->ptail == NULL); //两个断言避免因为人为误操作导致的特殊错误
		que->phead = que->ptail = newnode; //两个指针都指向新节点
	}
	else //如果队列不为空
	{
		que->ptail->next = newnode; //原来的尾节点指向新节点
		que->ptail = newnode; //新节点变成尾节点
	}
	que->size++; //更新size
}

（4）出队

void QueuePop(Queue* que)
{
	assert(que); //断言，防止传入空指针
	assert(!QueueEmpty(que)); //断言，队列为空则报错
	if (que->phead->next == NULL) //如果队列只剩一个节点
	{
		free(que->phead); //释放唯一的节点
		que->phead = que->ptail = NULL; //两个指针置空
	}
	else //队列不止一个节点时
	{
		QNode* cur = que->phead; //保存头节点地址
		que->phead = que->phead->next; //头节点更新
		free(cur); //释放原来的头节点
	}
	que->size--; //更新size
}

（5）获取队头元素

QDataType QueueFront(Queue* que)
	assert(que); //断言，防止传入空指针
	assert(!QueueEmpty(que)); //断言，队列为空则报错
	return que->phead->data; //返回队头元素
}

（6）获取队尾元素

QDataType QueueBack(Queue* que)
{
	assert(que); //断言，防止传入空指针
	assert(!QueueEmpty(que)); //断言，队列为空则报错
	return que->ptail->data; //返回队尾元素

（7）获取队列中有效元素个数

int QueueSize(Queue* que)
{
	assert(que); //断言，防止传入空指针
	return que->size; //size即有效元素个数
}

（8）检测队列是否为空

bool QueueEmpty(Queue* que)
{
	assert(que); //断言，防止传入空指针
	return que->size == 0; //表达式为真返回true，否则返回false
}

所有接口都完成后，我们在Test.c中调试一下

一切正常，恭喜你完成了队列的接口实现！下面是"Queue.c"的完整代码：

#include "Queue.h"

void QueueInit(Queue* que)//初始化队列
{
	assert(que);
	que->phead = NULL;
	que->ptail = NULL;
	que->size = 0;
}

void QueueDestroy(Queue* que)//销毁队列
{
	assert(que);
	QNode* cur = que->phead;
	while (cur)
	{
		que->phead = que->phead->next;
		free(cur);
		cur = que->phead;
	}
	que->phead = que->ptail = NULL;
	que->size = 0;
}

void QueuePush(Queue* que, QDataType x)//队尾入队列
{
	assert(que);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (que->phead == NULL || que->ptail == NULL)
	{
		assert(que->phead == NULL);
		assert(que->ptail == NULL);
		que->phead = que->ptail = newnode;
	}
	else
	{
		que->ptail->next = newnode;
		que->ptail = newnode;
	}
	que->size++;
}

void QueuePop(Queue* que)//队头出队列
{
	assert(que);
	assert(!QueueEmpty(que));
	if (que->phead->next == NULL)
	{
		free(que->phead);
		que->phead = que->ptail = NULL;
	}
	else
	{
		QNode* cur = que->phead;
		que->phead = que->phead->next;
		free(cur);
	}
	que->size--;
}

QDataType QueueFront(Queue* que)//获取队列头部元素
{
	assert(que);
	assert(!QueueEmpty(que));
	return que->phead->data;
}

QDataType QueueBack(Queue* que)//获取队列队尾元素
{
	assert(que);
	assert(!QueueEmpty(que));
	return que->ptail->data;
}

int QueueSize(Queue* que)//获取队列中有效元素个数
{
	assert(que);
	return que->size;
}

bool QueueEmpty(Queue* que)//检测队列是否为空
{
	assert(que);
	return que->size == 0;
}

队列的接口实现到此结束，趁热打铁，接下来我们来做几道关于队列的OJ题练练手吧

下面的OJ题建议对栈有了一定了解后再做，如果有兴趣可以移步 数据结构——栈-CSDN博客

三、关于队列的OJ题

3.1 用队列实现栈

OJ题链接：225. 用队列实现栈 - 力扣（LeetCode）

 这道题要求我们用两个队列来实现栈和其接口功能，核心思路是：

  1. 两个队列都为空时压栈，就往任意一个队列中放元素
  2. 有一个队列不为空时压栈，就往那个非空的队列中放元素
  3. 出栈，就将非空的队列中的元素出队到另一个空队列，剩下最后一个元素，再将其弹出，就能实现栈的后进先出了

核心思路如图：

有了核心思路，大家可以尝试自己做一下这道题

需要说明的是，如果我们使用C语言来做这道题会略显麻烦，因为我们需要自己写一个队列。但是刚刚我们已经写好了，所以直接cv上去即可。

将"Queue.h"和"Queue.c"整个复制到代码栏中，然后实现题目的核心代码

typedef struct
{
    Queue q1;
    Queue q2;
} MyStack;

MyStack *myStackCreate()
{
    MyStack *obj = (MyStack *)malloc(sizeof(MyStack));
    if (obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack *obj, int x)
{
    if (!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack *obj)
{
    Queue *Emptyque = &obj->q1;
    Queue *NonEmptyque = &obj->q2;
    if (!QueueEmpty(&obj->q1))
    {
        Emptyque = &obj->q2;
        NonEmptyque = &obj->q1;
    }
    while (NonEmptyque->size > 1)
    {
        QueuePush(Emptyque, QueueFront(NonEmptyque));
        QueuePop(NonEmptyque);
    }
    int top = QueueFront(NonEmptyque);
    QueuePop(NonEmptyque);
    return top;
}

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

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

void myStackFree(MyStack *obj)
{
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

3.2 用栈实现队列

OJ题链接：232. 用栈实现队列 - 力扣（LeetCode）

这道题要求我们用两个栈实现队列和其接口功能，核心思路是：

  1. 一个栈（pushstack）用来入队，一个栈（popstack）用来出队
  2. 入队时，将元素压入pushstack中
  3. 出队时，如果popstack非空，则直接从popstack出栈；如果为空，则将pushstack中的所有元素出栈并压入popstack中，就能实现队列的先入先出了

核心思路如图：

有了核心思路，大家可以尝试自己做一下这道题

使用C语言来做这道题需要自己写一个栈。如果曾经写过直接cv上去即可。

题目的核心代码如下：

typedef struct
{
    Stack pushstack;
    Stack popstack;
} MyQueue;

MyQueue *myQueueCreate()
{
    MyQueue *obj = (MyQueue *)malloc(sizeof(MyQueue));
    if (obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    StackInit(&obj->pushstack);
    StackInit(&obj->popstack);
    return obj;
}

void myQueuePush(MyQueue *obj, int x)
{
    StackPush(&obj->pushstack, x);
}

int myQueuePop(MyQueue *obj)
{
    // if(!StackEmpty(&obj->popstack))
    // {
    //     int front = StackTop(&obj->popstack);
    //     StackPop(&obj->popstack);
    //     return front;
    // }
    // else
    // {
    //     while(!StackEmpty(&obj->pushstack))
    //     {
    //         StackPush(&obj->popstack , StackTop(&obj->pushstack));
    //         StackPop(&obj->pushstack);
    //     }
    //     int front = StackTop(&obj->popstack);
    //     StackPop(&obj->popstack);
    //     return front;
    // }
    int front = myQueuePeek(obj);
    StackPop(&obj->popstack);
    return front;
}

int myQueuePeek(MyQueue *obj)
{
    if (StackEmpty(&obj->popstack))
    {
        while (!StackEmpty(&obj->pushstack))
        {
            StackPush(&obj->popstack, StackTop(&obj->pushstack));
            StackPop(&obj->pushstack);
        }
    }
    return StackTop(&obj->popstack);
}

bool myQueueEmpty(MyQueue *obj)
{
    return StackEmpty(&obj->pushstack) && StackEmpty(&obj->popstack);
}

void myQueueFree(MyQueue *obj)
{
    StackDestory(&obj->pushstack);
    StackDestory(&obj->popstack);
    free(obj);
}

3.3 设计循环队列

OJ题链接：622. 设计循环队列 - 力扣（LeetCode）

我们可以拓展了解一下一种特殊的队列：循环队列，也被称为环形队列。循环队列就是把顺序队列首尾相连，从逻辑上看成一个环。循环队列可以用数组实现，也可以使用循环链表实现。

面对循环队列，有一个重要的问题，就是判满和判空。因为是循环结构，队头（front）和队尾（rear）相等的时候，到底是空还是满呢？为了避免导致错误，我们可以设计一个比目标容量 k 大一节的循环队列，使队列为满时队尾在队头前面。

这里我们使用数组来实现循环队列，此时

判空：front = rear

判满：(rear + 1) % ( k + 1 ) = front 

题目代码如下：

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

MyCircularQueue *myCircularQueueCreate(int k)
{
    MyCircularQueue *obj = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    obj->front = obj->rear = 0;
    obj->k = k;
    obj->a = (int *)malloc(sizeof(int) * (k + 1));
    return obj;
}

bool myCircularQueueIsFull(MyCircularQueue *obj)
{
    return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

bool myCircularQueueIsEmpty(MyCircularQueue *obj)
{
    return obj->front == obj->rear;
}

bool myCircularQueueEnQueue(MyCircularQueue *obj, int value)
{
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear] = value;
        obj->rear++;
        if (obj->rear == obj->k + 1)
            obj->rear = 0;
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue *obj)
{
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        if (obj->front == obj->k + 1)
            obj->front = 0;
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue *obj)
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue *obj)
{
    if (myCircularQueueIsEmpty(obj))
        return -1;
    // if(obj->rear == 0)
    //     return obj->a[obj->k];
    // else
    //     return obj->a[obj->rear-1];
    return obj->a[(obj->rear + obj->k) % (obj->k + 1)]; //很巧妙的方法
}

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

完.

阿瑾0618
关注
专栏目录
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
C++数据结构——队列
热门推荐
GeekZW的博客
06-26 17万+
C++数据结构——队列参考博客：http://www.cnblogs.com/QG-whz/p/5171123.htmlhttp://www.169it.com/article/2718050585107790752.html1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；（...
数据结构 —— 队列
林深不见鹿 的博客
10-16 2810
队列 1.队列的介绍 队列是一种先进先出的数据结构，这和栈有所不同，但又更容易理解。类似于食堂排队打饭，车站排队买票。 后来的人排在队伍最后边，先来的人先打饭或者买票走。如图 队列总是从队尾插入元素,而从队首移除元素，满足先进先出的规则。因此需要一个队首指针front指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。 ，需要一个队首指针front来指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。和栈类似，当使用数组来实现队列时，队首指针front和队尾指针rear为i
数据结构——队列和链表
荔枝当大佬的博客
02-27 1225
还有一个多月就要打蓝桥杯了，荔枝最近开始学习一些基本的数据结构和算法，接下来在数据结构这个专栏里可以看到荔枝学习的脚步哦哈哈哈哈。在这篇文章中，荔枝主要做了一下队列和链表的基础知识笔记。
数据结构——队列（FIFO）
Xyzone007的博客
08-02 5311
数据结构——队列（FIFO） 队列的分类：顺序队列、链队列 顺序队列 在 FIFO 数据结构中，将首先处理添加到队列中的第一个元素。队列是典型的 FIFO 数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素。 顺序队列： 队列的头——front 队列的尾——back 1）空队列： 队列中必然会有front和back，当队列为空队列时，则有和front=back； 与栈的区别：栈先入后
初阶数据结构——队列
dtxew love c++
11-02 2262
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 ????????博主的微信公众号关注啦，关注我每天学习一道题，点我关注 前言 我们在前面已经学习了栈这种数据结构，已经了解了它是一种操作受限的线性表，其只能在栈顶进行插入与删除操作，遵循后进先出的规则 而队列，与栈的本质差不多，都是操
数据结构——队列（银行叫号系统）
司马青衫
12-19 1万+
数据结构——队列（银行叫号系统） 一、实验目的 （1）掌握队列的链式存储结构 （2）掌握队列的基本操作，并能进行应用实践 （3）使用C/C++语言和队列实现”银行叫号系统“专题 二、实验任务 设计一个控制台程序，模拟银行排队业务，要求实现功能： （1）输出程序界面，提示客户输入银行窗口数量和开放窗口时间 （2）客户随机时间进入银行，程序在事件表中记录客户进入时间和离开时间，并将客户排入窗口队列，办理完业务后退出队列 三、实验代码 1.事件列表 1）定义事件结点 typedef struct Event//定
数据结构——队列 c++详解
m0_54615144的博客
07-28 8745
1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点： （1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构； （2）在队尾添加元素，在队头删除元素。...
数据结构——队列的应用.doc
07-11
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在本实验中，我们主要探讨了队列的应用，特别是在实现杨辉三角输出上的应用。 首先，我们需要理解循环队列。循环队列...
算法和数据结构——队列.pdf
08-07
队列是一种基础且重要的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的插入（入队）发生在队尾，而删除（出队）则发生在队头。这个概念可以类比于现实生活中人们排队购物的情景...
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1061
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 791
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 574
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 744
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 652
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 928
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
数据结构——栈和队列（队列的定义、顺序队列以及链式队列的基本操作）
weixin_74209413的博客
09-13 1180
队列和栈一样，也是限定只能在表的“端点”进行的线性表。队列在插入的时候，只能在表尾进行插入，在删除的时候，只能在表头进行删除。（先进先出），表尾即队尾，表头即队头。栈和队列是线性表的子集（是插入和删除位置受限的线性表）由于队列的操作具有先进先出的特性，使得队列成为程序设计中解决类似排队问题的有用工具。队列的逻辑结构与同线性表相同，仍为一对一关系。队列的存储结构有顺序队和链队，以循环顺序队列更常见。关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同。
史君华讲解：数据结构——栈、队列和数组
“胡学钢 数据结构课件 PPT，涵盖了数据结构中的栈、队列和数组等内容，由史君华主讲，适用于合肥师范学院计算机科学与技术系的学习。” 在计算机科学中，数据结构是组织和管理数据的一种方式，它直接影响到算法的...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值