【数据结构】队列——顺序实现+链式实现（带头结点+不带头结点）入队 出队 初始化 判空 双端队列 完整代码

最新推荐文章于 2024-05-02 10:00:00 发布
最新推荐文章于 2024-05-02 10:00:00 发布
阅读量1.7k 收藏 21
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 算法 开发语言 链表 c++ c语言 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61628700/article/details/131471538
版权

文章目录

四 队列

1.基本概念

  • 定义

    只允许在一端进行插入，在另一端删除的线性表。

  • 术语

    • 队头：允许删除的一端。
    • 队尾：允许插入的一端。

  • 特点：先进先出

2.队列的顺序存储

  • 定义

    #define MaxSize 10
#define ElemType int
//定义
typedef struct {
	ElemType data[MaxSize];//用静态数组存放队列元素
	int front, rear;//队头指针和队尾指针
}SqQueue;

  • 循环队列

    搞成循环队列可以节约存储空间。

    避免出现队尾指针Q.rear已经到MaxSize时，队头指针Q.front前有剩余空间的情况。

  • 在循环队列下，队列空的条件是

    Q.rear==Q.front

  • 在循环队列下，队列已满的条件是

    (Q.rear+1)%MaxSize==Q.front

    即尾指针加一等于头指针时，队列已满。

    注：此时会浪费一个存储空间（队尾指针没有存数据）。

    • 如果不浪费，即尾指针rear也存元素，则队满和队空判断条件相同，我们无法用逻辑表达区分两种情况。

  • 如果题目要求不能浪费一点点存储空间，则将队列定义为

    typedef struct {
	ElemType data[MaxSize];//用静态数组存放队列元素
	int front, rear;//队头指针和队尾指针
    int size;//队列大小
}SqQueue;
    • 此时队满条件：size==MaxSize
    • 队空条件：size==0

  • 完整代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MaxSize 10
#define ElemType int

//定义
typedef struct {
	ElemType data[MaxSize];//用静态数组存放队列元素
	int front, rear;//队头指针和队尾指针
}SqQueue;

//初始化队列
void InitQueue(SqQueue& Q)
{
	//初始时，队头队尾指针都指向0
	Q.front = Q.rear = 0;
}

//判空
bool QueueEmpty(SqQueue Q)
{
	if (Q.rear == Q.front)
		return true;
	else
		return false;
}

//创建
bool CreatQueue(SqQueue& Q)
{
	int n = 5;
	srand(time(0));
	while (n--)
	{
		//队满则报错
		//队满条件：队尾指针的下一个位置是队头
		if ((Q.rear + 1) % MaxSize == Q.front)
			return false;
		Q.data[Q.rear] = rand() % 100 + 1;//新元素插入队尾
		//将存储空间在逻辑上变成环状（循环队列）
		Q.rear = (Q.rear + 1) % MaxSize;//队尾指针加1取模
	}
	return true;
}

//入队
bool EnQueue(SqQueue& Q, ElemType x)
{
	//队满则报错
	//队满条件：队尾指针的下一个位置是队头
	if ((Q.rear + 1) % MaxSize == Q.front)
		return false;
	Q.data[Q.rear] = x;//新元素插入队尾
	//将存储空间在逻辑上变成环状（循环队列）
	Q.rear = (Q.rear + 1) % MaxSize;//队尾指针加1取模
	return true;
}

//出队
bool DeQueue(SqQueue& Q, ElemType& x)
{
	//判空
	if (Q.rear == Q.front)return false;

	x = Q.data[Q.front];//x存出队的元素
	Q.front = (Q.front + 1) % MaxSize;//头指针后移
	return true;
}

//获取队头元素，用x返回
bool GetHead(SqQueue Q, ElemType& x)
{
	if (Q.rear == Q.front)return false;

	x = Q.data[Q.front];
	return true;
}

void QPrint(SqQueue Q) 
{
	for (int i = Q.front; i < Q.rear-1; i=(i+1) % MaxSize)
	{
		printf("%d,", Q.data[i]);
	}
	printf("%d\n", Q.data[Q.rear-1]);
}


int main()
{
	SqQueue Q;
	InitQueue(Q);

	printf("创建:\n");
	CreatQueue(Q);
	QPrint(Q);
	printf("\n");

	printf("请输入入队元素：\n");
	int x;
	scanf_s("%d", &x);
	EnQueue(Q, x);
	QPrint(Q);
	printf("\n");

	int y;
	DeQueue(Q, y);
	printf("出队元素：%d\n", y);
	QPrint(Q);
	printf("\n");

	int z;
	GetHead(Q, z);
	printf("队头元素：%d\n", z);
}

3.队列的链式实现

3.1 定义

分两个结构体

1.节点结构体：存节点数据和下一个节点地址。

2.队列结构体：存队列的头尾指针。

//定义
//链式队列节点
typedef struct LinkNode {
	ElemType data;
	struct LinkNode* next;
}LinkNode;
//链式队列
typedef struct {
	LinkNode* front;//指向队列队头的指针
	LinkNode* rear;//指向队列队尾的指针
}LinkQueue;
  • 可分为带头结点和不带头结点，两者功能差不多，具体看题目要求选哪个。
  • 因为是链表，所以不存在队满的时候，也不需要用循环队列。

3.2 带头结点

3.2.1 初始化

1.创建一个头节点；

2.将头尾指针front和rear都指向头节点；

3.头节点的next赋空值NULL。

//初始化队列
void InitQueue(LinkQueue& Q)
{
	//初始时 front、rear都指向头结点
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next = NULL;
}
3.2.2 判空

当头尾指针都指向同一节点时，链表为空。

//判空
bool IsEmpty(LinkQueue& Q)
{
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}
3.2.3 入队

  • 步骤

    1.创建新节点，存数据+初始化指针域。

    2.新节点插入到原rear之后。

    3.更新rear，即使尾结点指向新插入节点。

void EnQueue(LinkQueue& Q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q.rear->next = s;//新节点插入到rear之后
	Q.rear = s;//修改表尾指针
}
3.2.4 出队

根据队列中是否只有一个结点分两种情况。

  • 有多个结点时

    1.头结点和出队结点的下一个结点相连。

    2.释放出队结点。

  • 只有一个结点时

    1.尾结点指向头结点。

    2.释放出队结点。

    • 此时相当于空队列。

bool DeQueue(LinkQueue& Q, ElemType& x)
{
	//空队
	if (Q.front == Q.rear)return false;
	LinkNode* p = Q.front->next;
	x = p->data;//用变量x返回队头元素
	Q.front->next = p->next;//修改头指针的next指针，即连上出队节点的下一个节点
	//如果出队节点是尾节点，即队列中只有一个节点
	if (Q.rear == p)
		Q.rear = Q.front;//变成空队列
	free(p);//释放出队节点
	return true;
}
3.2.5 完整代码
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define ElemType int

//定义
//链式队列节点
typedef struct LinkNode {
	ElemType data;
	struct LinkNode* next;
}LinkNode;
//链式队列
typedef struct {
	LinkNode* front;//指向队列队头的指针
	LinkNode* rear;//指向队列队尾的指针
}LinkQueue;

//初始化队列
void InitQueue(LinkQueue& Q)
{
	//初始时 front、rear都指向头结点
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next = NULL;
}

//判空
bool IsEmpty(LinkQueue& Q)
{
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}

//创建
bool CreatQueue(LinkQueue& Q)
{
	int n = 5;
	srand(time(0));
	while (n--)
	{
		LinkNode* t = (LinkNode*)malloc(sizeof(LinkNode));
		t->data = rand() % 100 + 1;
		t->next = NULL;
		Q.rear->next = t;
		Q.rear = t;
	}
	return true;
}

//新元素入队
void EnQueue(LinkQueue& Q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q.rear->next = s;//新节点插入到rear之后
	Q.rear = s;//修改表尾指针
}

//出队
//用x返回元素
bool DeQueue(LinkQueue& Q, ElemType& x)
{
	//空队
	if (Q.front == Q.rear)return false;
	LinkNode* p = Q.front->next;
	x = p->data;//用变量x返回队头元素
	Q.front->next = p->next;//修改头指针的next指针，即连上出队节点的下一个节点
	//如果出队节点是尾节点，即队列中只有一个节点
	if (Q.rear == p)
		Q.rear = Q.front;//变成空队列
	free(p);//释放出队节点
	return true;
}

void QPrint(LinkQueue&Q)
{
	LinkNode* p = Q.front->next;
	while (p != Q.rear)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("%d\n\n", Q.rear->data);
}

int main()
{
	LinkQueue Q;
	InitQueue(Q);

	CreatQueue(Q);
	QPrint(Q);

	printf("请输入要入队的元素：\n");
	int x;
	scanf_s("%d", &x);
	EnQueue(Q, x);
	QPrint(Q);

	int y;
	DeQueue(Q, y);
	printf("出队元素为：%d\n", y);
	QPrint(Q);
}

3.3 不带头结点

3.3.1 初始化

//初始化队列
void InitQueue(LinkQueue& Q)
{
	//初始时 front、rear都指向NULL
	Q.front = NULL;
	Q.rear = NULL;
}
3.3.2 入队

根据入队元素是否是队列中第一个结点分两种情况。

  • 如果入队结点是第一个结点

    则头尾指针都指向入队结点。

  • 如果不是

    则新结点插入到队尾结点之后，并更新队尾结点

void EnQueue(LinkQueue& Q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	//在空队列中插入第一个元素
	if (Q.front == NULL)
	{
		Q.front = s;//队头队尾指针都指向第一个元素
		Q.rear = s;
	}
	else
	{
		Q.rear->next = s;//新节点插入到队尾节点之后
		Q.rear = s;//更新队尾节点
	}
}
3.3.3 出队
  • 如果是最后一个结点出队，则需要恢复成空队状态。
bool DeQueue(LinkQueue& Q, ElemType& x)
{
	//空队
	if (Q.front == NULL)
		return false;

	LinkNode* p = Q.front;//p指向此次出队的节点
	x = p->data;//用变量x返回队头元素
	Q.front = p->next;//头指针指向出队节点的下一个节点
	
	//如果是最后一个节点出队
	//恢复成空队状态
	if (Q.rear == p)
	{
		Q.front = NULL;//front指向NULL
		Q.rear = NULL;//rear指向NULL
	}
	free(p);//释放节点空间
	return true;
}
3.3.4 完整代码
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define ElemType int

//定义
//链式队列节点
typedef struct LinkNode {
	ElemType data;
	struct LinkNode* next;
}LinkNode;
//链式队列
typedef struct {
	LinkNode* front;//指向队列队头的指针
	LinkNode* rear;//指向队列队尾的指针
}LinkQueue;

//初始化队列
void InitQueue(LinkQueue& Q)
{
	//初始时 front、rear都指向NULL
	Q.front = NULL;
	Q.rear = NULL;
}
//判空
bool IsEmpty(LinkQueue& Q)
{
	if (Q.front == NULL)
		return true;
	else
		return false;
}

//创建
bool CreatQueue(LinkQueue& Q)
{
	int n = 5;
	srand(time(0));
	while (n--)
	{
		LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
		s->data = rand() % 100 + 1;
		s->next = NULL;
		//在空队列中插入第一个元素
		if (Q.front == NULL)
		{
			Q.front = s;//队头队尾指针都指向第一个元素
			Q.rear = s;
		}
		else
		{
			Q.rear->next = s;//新节点插入到队尾节点之后
			Q.rear = s;//更新队尾节点
		}
	}
	return true;
}

//入队
void EnQueue(LinkQueue& Q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	//在空队列中插入第一个元素
	if (Q.front == NULL)
	{
		Q.front = s;//队头队尾指针都指向第一个元素
		Q.rear = s;
	}
	else
	{
		Q.rear->next = s;//新节点插入到队尾节点之后
		Q.rear = s;//更新队尾节点
	}
}

//出队
bool DeQueue(LinkQueue& Q, ElemType& x)
{
	//空队
	if (Q.front == NULL)
		return false;

	LinkNode* p = Q.front;//p指向此次出队的节点
	x = p->data;//用变量x返回队头元素
	Q.front = p->next;//头指针指向出队节点的下一个节点
	
	//如果是最后一个节点出队
	//恢复成空队状态
	if (Q.rear == p)
	{
		Q.front = NULL;//front指向NULL
		Q.rear = NULL;//rear指向NULL
	}
	free(p);//释放节点空间
	return true;
}

void QPrint(LinkQueue& Q)
{
	LinkNode* p = Q.front;
	while (p != Q.rear)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("%d\n\n", Q.rear->data);
}

int main()
{
	printf("不带头节点：\n");

	LinkQueue Q;
	InitQueue(Q);

	CreatQueue(Q);
	QPrint(Q);

	printf("请输入要入队的元素：\n");
	int x;
	scanf_s("%d", &x);
	EnQueue(Q, x);
	QPrint(Q);

	int y;
	DeQueue(Q, y);
	printf("出队元素为：%d\n", y);
	QPrint(Q);
}

4.双端队列

  • 定义

    允许从两端插入删除的线性表。

  • 衍生

    • 输出受限的双端队列

      只允许从一端插入，两端删除。

    • 输出受限的双端队列

      只允许从两端插入，一端删除。

在这里插入图片描述

吧啦吧啦嘭
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【数据结构C/C++】顺序与链式队列详解(附代码)
Zhangsama1的博客
08-17 9393
文章目录前言一、顺序队列二、链式队列1.引入库2.读入数据总结 前言 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出(First Input First Ouput)，的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。 既然是线性表，那么就可以分为顺序存储结构和链式存储结构。 队列存储结构的实现有以下两种方式： 顺序队列：在顺序表的基础上实现的队列结构； 链队列：在链表的基础上实现的队列结构；
数据结构之队列（顺序队和链队）（C语言附完整代码）
m0_62795460的博客
04-12 6004
队列简称队，它是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。把进行插入的一端称为队尾，把进行删除的一端称为队头或队首。向队列中插入新元素称为进队或入队，从队列中删除元素称为出队或离队。由于队列的插入和删除操作分别是在各自的一端进行的，每个元素必然按照进入的次序出队，所以又把队列称为先进先出表。采用顺序存储结构的队列称为顺序队声明顺序队//存放队中元素 int front , rear;//队首和队尾指针 } SqQueue;采用链式存储结构的队列称为链队。
MySQL如何设计库表结构
最新发布
Dxy1239310216的博客
05-02 2062
在设计MySQL表结构时，我们需要根据业务需求和数据特点进行需求分析，并遵循规范化、字段设计、索引设计、主键设计和关联设计等原则。通过合理的表结构设计，我们可以提高数据库的性能和可维护性，为系统的稳定运行提供有力的支持。同时，还需要注意在实际应用中权衡利弊，选择适合的表结构和索引策略。希望本文能对您在设计MySQL表结构时提供一些帮助。
数据结构——顺序队列【c语言版】
clear-ninghongkang的博客
11-21 4395
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 下面是采用采用顺序存储结构来实现的顺序队 假设栈的元素个数最大不超过正整数MaxSize，所以元素具有同一数据类型（ElemType），用下来方式来声明顺序栈的类型SqQueu...
队列的实现（完整代码+详细注释版）【数据结构】
小賀のBlog
08-02 3239
注释详细完整且健壮的两种方式实现队列的代码： 顺序队列 // // main.c // SequenceQueue // // Created by Eason on 2020/8/2. // Copyright © 2020 Eason. All rights reserved. // #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 21 /
数据结构— —队列(顺序表实现)
m0_65635427的博客
11-04 2142
数据结构队列顺序实现
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
队列链式存储（带头结点）.zip
02-26
本文件“队列链式存储（带头结点）.zip”提供了一个C++实现的队列链式存储结构，特别地，它使用了带头结点的设计，这对于理解和实现队列具有很好的教学价值。 链式存储的队列不同于数组实现的队列，它不依赖于连续...
Java定义队列结构，并实现入队、出队操作完整示例
08-25
本文主要介绍了Java定义队列结构，并实现入队、出队操作，结合完整实例形式分析了java数据结构中队列的定义、入队、出队、判断队列是否为空、打印队列元素等相关操作技巧。 一、队列结构的定义 在Java中，队列结构...
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
C++数据结构之实现循环顺序队列
08-31
循环顺序队列是一种在计算机科学中常见的数据结构，它继承了普通顺序队列的特性，同时解决了顺序队列在处理满状态时可能出现的问题。在循环顺序队列中，队列的头部和尾部通过循环的方式连接在一起，形成一个闭合的...
顺序队列的代码实现
荧光百叶草的博客
08-04 198
和顺序栈相类似，在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存储从队头到队尾的元素外，尚需附设两个整形变量front和rear分别指示队头元素及队尾元素的位置。附设整型变量size用来表示队列的最大存储元素个数。队列的操作与栈的操作类似，不同的是，删除是在表的头部（队头）进行的。队列也有两种存储表示，顺序表示和链式表示。
写一段C语言队列出队的代码
weixin_42588555的博客
02-10 227
下面是一段简单的队列出队的代码： #include <stdio.h> #define MAX_SIZE 100 int queue[MAX_SIZE]; int front = 0; int rear = 0; void dequeue() { if (front == rear) { printf("队列已空，无法出队\n"); return; } ...
数据结构队列顺序存储代码实现(C语言)
山山而川~
04-09 1659
队列是先入先出的，即先入队的数据先出队 下面程序是队列的顺序存储结构的实现，具有入队，出队，求队列长度的的功能 程序开头 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 #define Ok 1 #define ERROR 0 typedef int QElemType; typedef int ...
C++数据结构顺序队列（含完整代码）
qq_63184211的博客
02-10 438
允许插入的一端叫队尾，允许删除的一端叫队头。入队：在队列中插入元素；出队；空队列队列也叫先进先出（First In First Out）的线性表。操作：创建、入队、出队、获取队头数据、判断是否为空、判断是否为满；STL中有queue容器。分为顺序存储和链式存储。顺序存储：用一段连续的内存空间依次存储。
C/C++数据结构-完整代码（三）队列【Queue】（顺序存储，链式存储）增删改查
程序员猫爪
09-09 1091
队列 1、队列的基本概念 队列是一种特殊的线性表， 特殊之处在于它只允许在表的前端（front）进行删除操作， 而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。 进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列中没有元素时，称为空队列。 队列的数据元素又称为队列元素。 在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。 因为队列只允许在一端插入，在另一端删除， 所以只有最早进入队列的元素才能最先从队列中删除， 故队列又称为先进先出（FIFO—firs
数据结构与算法 - 队列(完整代码)
JKR10000的博客
03-28 2144
样例输入: in 1 in 3 in 5 in 9 in 12 out end 样例输出: Queue length: 4 Queue data: 3 5 9 12 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef int T; struct LNode { ...
C++数据结构——顺序队列（基本代码实现与案例）
eyes++的博客
06-19 967
#include<iostream> using namespace std; enum error_code{ success,overflow,underflow }; class queue{ public: queue(int len); bool empty()const; bool full()const; error_code get_front(int &x)const; error_code append(const int x); er
【数据结构】队列（queue）-顺序队列（动态图解、c++、java）
扑腾的江鱼复习仓库
01-13 1888
URLeisure的单向队列“完美”复习资料。
采用链式存储实现队列的初始化、入队、出队、销毁队操作完整代码
03-28
这里是使用C语言实现队列的完整代码，包括初始化、入队、出队和销毁队列操作。采用链式存储结构实现队列。 ```c #include <stdio.h> #include <stdlib.h> // 队列结点结构体 typedef struct node { int data; // 数据域 struct node *next; // 指针域 } Node; // 队列结构体 typedef struct { Node *front; // 队头指针 Node *rear; // 队尾指针 } Queue; // 初始化队列 void initQueue(Queue *q) { q->front = NULL; q->rear = NULL; } // 入队操作 void enQueue(Queue *q, int data) { // 创建新结点 Node *newNode = (Node *)malloc(sizeof(Node)); if (newNode == NULL) { printf("Error: memory allocation failed.\n"); return; } newNode->data = data; newNode->next = NULL; // 将新结点插入队尾 if (q->rear == NULL) { // 队列为空，插入第一个结点 q->rear = newNode; q->front = newNode; } else { q->rear->next = newNode; q->rear = newNode; } } // 出队操作 int deQueue(Queue *q) { if (q->front == NULL) { // 队列为空 printf("Error: queue is empty.\n"); return -1; } // 取出队头结点 Node *temp = q->front; int data = temp->data; q->front = temp->next; // 如果队列只有一个结点，则出队后队列为空 if (q->front == NULL) { q->rear = NULL; } free(temp); // 释放出队结点的内存 return data; } // 销毁队列 void destroyQueue(Queue *q) { while (q->front != NULL) { Node *temp = q->front; q->front = q->front->next; free(temp); } q->rear = NULL; } // 测试队列操作 int main() { Queue q; initQueue(&q); enQueue(&q, 1); enQueue(&q, 2); enQueue(&q, 3); printf("%d\n", deQueue(&q)); // 输出1 printf("%d\n", deQueue(&q)); // 输出2 enQueue(&q, 4); printf("%d\n", deQueue(&q)); // 输出3 printf("%d\n", deQueue(&q)); // 输出4 printf("%d\n", deQueue(&q)); // 输出错误信息 destroyQueue(&q); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值