【数据结构】队列的基础知识

于 2023-09-06 13:42:41 发布
阅读量373 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/the_bad/article/details/132602331
版权

队列


队列是线性表的一种，同栈一样，它也属于 操作受限的线性表。

1. 队列的定义和特点

队列只允许在表的一端插入元素，另一端删除元素。

允许插入的一端被称为队尾；允许删除的一端被称为对头。

下图为入队列、出队列示意图：

入队和出队

a 1 a_1 a1​为对头元素， a n a_n an​为队尾元素。栈中元素按 a 1 , a 2 , ⋯   , a n a_1, a_2, \cdots , a_n a1​,a2​,⋯,an​的次序入对栈， 出队也只能按照这个顺序进行。

队列的修改规则：先进先出(First In First Out, FIFO)

2. 循环队列

2.1 存储结构表示

循环队列是利用一组地址连续的存储单元依次存放从对头到队尾的数据元素。

附设front指针来指示队列头元素；rear指针指示队列尾元素。

队列的顺序存储结构如下：

#define MAXQSIZE 100 //队列可能达到的最大长度
typedef struct
{
    QElemType *base; //存储空间的基地址
    int front;  //头指针 -> 更像是偏移量
    int rear;	//尾指针 -> 更像是偏移量
}SqQueue;

初始化创建空队列时，令front= rear = 0 ,

每当插入新的队列尾元素时，尾指针rear增1；每当删除队列头元素时，头指针front增1。

队列的假溢出：假设当前队列分配的最大空间为4，则当队列处于下图所示的状态时，不可再继续插入新的队尾元素，否则会出现溢出现象， 即因数组越界而导致程序的非法操作错误。而此时队列的实际可用空间并未占满。
队列假溢出

将顺序队列变为一个循环队列即可解决这类问题。

下图中，对头元素的 a 3 a_3 a3​，入队前队尾指针Q.rear是3；当下一个元素 a 4 a_4 a4​入队后，队尾指针Q.rear回到了0

Q.rear = (Q.rear + 1) % 4

循环队列

循环队列为空状态：

空循环队列

此时Q.front == Q.rear

下图为队满的状态，共有两种：

上面一种队列空间被占满，但是此时**Q.front == Q.rear**，与队空的判断条件一致，判断条件冲突了。

当Q.front == Q.rear时，无法区分队列是空还是满的状态。

因此通常使用下面一种：少用一个元素空间，此时(Q.rear+1)%MAXSIZE == Q.front

满循环队列

循环队列队空和对满的条件：

  1. 队空的条件：Q.front == Q.rear
  2. 队满的条件：(Q.rear+1)%MAXSIZE == Q.front

2.2 初始化

循环队列的初始化操作就是动态分配一个预定义大小为MAXSIZE的数组空间。

算法步骤：

  1. 为队列分配一个最大容量为MAXSIZE的数组空间，base指向数组空间的首地址。
  2. 头指针front和尾指针rear置为零， 表示队列为空。
Status InitQueue(SqQueue *Q)
{
    Q->base = (QElemType*)malloc(sizeof(QElemType)*MAXQSIZE); //分配容量为MAXSIZE的数组
    if (Q->base==NULL) exit(OVERFLOW); //存储分配失败
    Q->front = Q->rear = 0; //头指针和尾指针设置为零，队列为空
    return OK;
}

2.3 求队列长度

对于非循环队列，尾指针和头指针的差值便是队列长度。

对于循环队列，差值可能为负数，所以需要将差值加上MAXSIZE, 然后与MAXSIZE求余。

Status QueueLength(const SqQueue *Q)
{
    return (Q->rear-Q->front+MAXQSIZE)%MAXQSIZE;
}

2.4 入队

入队操作就是在队尾插入一个新元素。

算法步骤：

  1. 判断队列是否满，若满则返回ERROR
  2. 将新元素插入队尾
  3. 队尾指针加1
Status EnQueue(SqQueue *Q, QElemType e)
{
    if ((Q->rear+1)%MAXQSIZE == Q->front) return ERROR; //判断队列是否满
    Q->base[Q->rear] = e; //新元素插入队尾
    Q->rear = (Q->rear+1)%MAXQSIZE; //队尾指针加1
    return OK;
}

2.5 出队

出队操作就将对头元素删除。

算法步骤：

  1. 判断队列是否空，若空则返回ERROR
  2. 保存对头元素
  3. 队头指针加1
Status DeQueue(SqQueue *Q, QElemType *e)
{
    if (Q->rear == Q->front) return ERROR; //判断队列是否空
    *e = Q->base[Q->front]; //保存对头元素
    Q->front = (Q->front+1)%MAXQSIZE;; //队头指针加1
    return OK;
}

2.6 取得循环队列的队头元素

当队列为非空时，返回当前对头元素的值，对头指针不变。

QElemType GetHead(SqQueue *Q)
{
    if (Q->rear != Q->front)	return Q->base[Q->front];
}

2.7 案例

给出一个简单的案例，将数据元素类型QElemType设置为int，所以这是一个数据元素为int的循环队列。

包含上述4种操作，便于理解、应用。

下述代码运行环境：VS2019，其他环境可移植。

#include <stdio.h>
#include <malloc.h>

typedef struct
{
    int* base; //存储空间的基地址
    int front;  //头指针 -> 更像是偏移量
    int rear;	//尾指针 -> 更像是偏移量
}SqQueue;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

#define MAXQSIZE 100 //队列可能达到的最大长度

// 初始化循环队列
// 函数参数： Q -> 操作台地址
// 返回值：1代表运行正常
Status InitQueue(SqQueue* Q)
{
    Q->base = (int*)malloc(sizeof(int) * MAXQSIZE); //分配一个容量为MAXSIZE的数组
    if (Q->base == NULL) exit(OVERFLOW); //存储分配失败
    Q->front = Q->rear = 0; //头指针和尾指针设置为零，队列为空
    return OK;
}

// 求队列长度
// 函数参数： Q -> 操作台地址
// 返回值：1代表运行正常
Status QueueLength(const SqQueue* Q)
{
    return (Q->rear - Q->front + MAXQSIZE) % MAXQSIZE;
}

// 入队
// 函数参数： Q -> 操作台地址; e -> 入队参数
// 返回值：1代表运行正常; 0代表运行有问题
Status EnQueue(SqQueue* Q, int e)
{
    if ((Q->rear + 1) % MAXQSIZE == Q->front) return ERROR; //判断队列是否满
    Q->base[Q->rear] = e; //新元素插入队尾
    Q->rear = (Q->rear + 1) % MAXQSIZE; //队尾指针加1
    return OK;
}

// 出队
// 函数参数： Q -> 操作台地址; e -> 存放出队元素
// 返回值：1代表运行正常; 0代表运行有问题
Status DeQueue(SqQueue* Q, int* e)
{
    if (Q->rear == Q->front) return ERROR; //判断队列是否空
    *e = Q->base[Q->front]; //保存对头元素
    Q->front = (Q->front + 1) % MAXQSIZE;; //队头指针加1
    return OK;
}

// 取得队头元素
// 函数参数： Q -> 操作台地址
// 返回值：0代表运行有问题
int GetHead(SqQueue* Q)
{
    if (Q->rear == Q->front) return ERROR; //判断队列是否空
    return Q->base[Q->front];
}

int main()
{
    SqQueue queue; //创建队列的操作台
    int elem = 0;  //存放出栈元素

    InitQueue(&queue); //初始化队列

    EnQueue(&queue, 6);  //将数据6入队
    EnQueue(&queue, 89);  //将数据89入队
    EnQueue(&queue, 101);  //将数据101入队

    printf("The length of queue is : %d\n", QueueLength(&queue)); //打印队列长度
    printf("%d\n", GetHead(&queue)); //打印队头元素
    
    DeQueue(&queue, &elem); //出队
    printf("elem: %d\n", elem); //打印出队元素
    printf("The length of queue is : %d\n", QueueLength(&queue)); //打印队列长度
    printf("%d\n", GetHead(&queue));  //打印队头元素

    DeQueue(&queue, &elem); //出队
    printf("elem: %d\n", elem); //打印出队元素
    printf("The length of queue is : %d\n", QueueLength(&queue)); //打印队列长度
    printf("%d\n", GetHead(&queue));  //打印队头元素

	return 0;
}

3. 链队

3.1 链队的结构表示

链队是指采用链式存储结构实现的队列。通常链队用单链表来表示。

链队

如上图所示，一个链队需要两个指示队头和队尾的指针（分别称为头指针和尾指针）才能唯一确定。

这里和单链表一样， 为了操作方便起见，给链队添加一个头结点， 并令头指针始终指向头结点。

typedef struct QNode
{
    QElemType data; 	//数据
    struct QNode *next;	//指针
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front; //队头指针
    QueuePtr rear;	//队尾指针
}LinkQueue;

3.2 初始化

链队的初始化操作就是构造一个只有一个头结点的空队。

链队初始化

算法步骤：

  1. 生成新的头结点作为头结点，队尾和对头指针都指向该结点
  2. 将头结点的指针域置空
Status InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QNode*)malloc(sizeof(QNode)); //生成新结点
    Q->front->next = NULL; //将头结点的指针域置空
    return OK;
}

3.3 入队

链队在入队前不需要判断队是否满，需要为入队元素动态分配一个结点空间。

链队入队

算法步骤：

  1. 为入队元素分配结点空间，用指针p指向
  2. 将新结点数据域置为e
  3. 将新结点插入到队尾
  4. 修改队尾指针为p
Status EnQueue(LinkQueue *Q, QElemType e)
{
    QNode* p = (QNode*)malloc(sizeof(QNode)); //1. 为入队元素分配结点空间
    p->data = e; //2. 将新结点数据域置为e
    p->next = NULL;
    Q->rear->next = p; //3. 将新结点插入到队尾
    Q->rear = p; //4. 修改队尾指针为p
    return OK;
}

3.4 出队

链队在出队前需要判断队列是否为空，同时链队在出队后需要释放出队头元素的所占空间。

  1. 判断队列是否为空，若空则返回ERROR。
  2. 临时保存队头元素的空间，以备释放。
  3. 修改队头指针，指向下一个结点。
  4. 判断出队元素是否为最后一个元素，若是，则将队尾指针重新赋值， 指向头结点。
  5. 释放原队头元素的空间。

链队出队

Status DeQueue(LinkQueue* Q, QElemType* e)
{
    if (Q->rear == Q->front) return ERROR; //1. 判断队列是否空
    QNode* p = Q->front->next; //2. 临时保存队头元素的空间，以备释放
    *e = p->data;
    Q->front->next = p->next; //3. 修改队头指针，指向下一个结点
    if (Q->rear == p) Q->rear = p->next; //4. 判断出队元素是否为最后一个元素
    free(p); //5. 释放原队头元素的空间
    return OK;
}

3.5 取得队头元素

当队列非空时，此操作返回当前队头元素的值，队头指针保持不变。

QElemType GetHead(LinkQueue *Q)
{
	if (Q->front != Q->rear) return Q->front->next->data;
}

3.6 案例

给出一个简单的案例，将数据元素类型QElemType设置为int，所以这是一个数据元素为int的链队。

包含上述4种操作，便于理解、应用。

下述代码运行环境：VS2019，其他环境可移植。

#include <stdio.h>
#include <malloc.h>

typedef struct QNode
{
    int data; 	//数据
    struct QNode* next;	//指针
}QNode, * QueuePtr;

typedef struct
{
    QueuePtr front; //队头指针
    QueuePtr rear;	//队尾指针
}LinkQueue;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

#define MAXQSIZE 100 //队列可能达到的最大长度

// 初始化顺序栈
// 函数参数： Q -> 指针地址
// 返回值：1代表运行正常
Status InitQueue(LinkQueue* Q)
{
    Q->front = Q->rear = (QNode*)malloc(sizeof(QNode)); //生成新结点
    Q->front->next = NULL; //将头结点的指针域置空
    return OK;
}

// 入队
// 函数参数： Q -> 指针地址; e -> 入队参数
// 返回值：1代表运行正常; 0代表运行有问题
Status EnQueue(LinkQueue* Q, int e)
{
    QNode* p = (QNode*)malloc(sizeof(QNode)); //1. 为入队元素分配结点空间
    p->data = e; //2. 将新结点数据域置为e
    p->next = NULL;
    Q->rear->next = p; //3. 将新结点插入到队尾
    Q->rear = p; //4. 修改队尾指针为p
    return OK;
}

// 出队
// 函数参数： Q -> 指针地址; e -> 出队地址
// 返回值：1代表运行正常; 0代表运行有问题
Status DeQueue(LinkQueue* Q, int* e)
{
    if (Q->rear == Q->front) return ERROR; //1. 判断队列是否空
    QNode* p = Q->front->next; //2. 临时保存队头元素的空间，以备释放
    *e = p->data;
    Q->front->next = p->next; //3. 修改队头指针，指向下一个结点
    if (Q->rear == p) Q->rear = p->next; //4. 判断出队元素是否为最后一个元素
    free(p); //5. 释放原队头元素的空间
    return OK;
}

// 取得队头元素
// 函数参数： Q -> 指针地址; e -> 出队地址
// 返回值：队头元素
int GetHead(LinkQueue* Q)
{
    if (Q->front != Q->rear) return Q->front->next->data;
}

int main()
{
    LinkQueue queue; //创建指向队列的指针
    int elem = 0;  //存放出栈元素

    InitQueue(&queue); //初始化队列

    EnQueue(&queue, 6);  //将数据6入队
    EnQueue(&queue, 89);  //将数据89入队
    EnQueue(&queue, 101);  //将数据101入队

    printf("%d\n", GetHead(&queue)); //打印队头元素
    
    DeQueue(&queue, &elem); //出队
    printf("elem: %d\n", elem); //打印出队元素
    printf("%d\n", GetHead(&queue));  //打印队头元素

    DeQueue(&queue, &elem); //出队
    printf("elem: %d\n", elem); //打印出队元素
    printf("%d\n", GetHead(&queue));  //打印队头元素

	return 0;
}
夏日晴风
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构基础知识总结
04-04
数据结构基础知识总结，包含栈队列树图 散列表等，参加了一些个人的见解
数据结构之队列（链式队列）的基本操作与实现
热门推荐
BaoITcore的博客
11-14 1万+
这篇文章的末尾有完整的实现代码，书写不易，转载请附上本文章链接。 一、链式队列的概念 何为链式队列，想到链式队列大家应该都会想到顺序表的单链表的基本操作，我们来对比一下：单链表是用一个头指针或者是尾指针来实现元素的插入和删除等，即头插法和尾插法。而链式队列呢，我们都知道队列是一个在队首进行出队再队尾进行入队，而不是在一段完成任务，所以我们这里就需要两个指针分别指向队列的头front和尾rear，他们两个各司其职，当要进行出队操作时，头指针front说了算，当要进行入队操作时，尾指针re...
数据结构学习笔记-队列长度的计算
weixin_43727767的博客
06-30 1万+
 1.通用计算公式：l=(rear-front+n)%n   其中：l为当前队列的长度      rear为队列尾指针      front为队列头指针      n为队列可容纳的元素总数（即队列大小）  2.公式解析   队列中存在一种特殊情况：循环队列，一般定义循环队列的头指针front和尾指针rear均指向队列下标为0的位置，此时front=rear&l=0;在循环队列中插入元素，若队列未满（l<n）尾指针后移一位（rear++）;若队列已满（l==n）,则不能继续插入元素，应返回错误提
数据结构——链式队列【c语言版】
clear-ninghongkang的博客
11-22 6778
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 采用链式存储结构实现的队列称为链队 下面是采用单链表来实现链式队列的过程： 在链队中只允许单链表的表头进行删除操作（出队），表尾进行插入操作（入队），因此需要...
数据结构学习笔记——链式存储结构实现队列（链队）
小宇y的博客
06-12 7580
在链队中，队头指针指向队头结点，队尾指针指向队尾结点，由于不带头结点的链队操作较为麻烦，一般将链队设置为，带头结点的链式队列如下图（其中队头指针指向头节点）： 不带结点的链式队列如下图： 链队的存储类型可定义为： 三、链队的初始化 初始化时，通过malloc()函数创建一个只包含头结点的空链式队列Q，该头结点中包含队头指针front和队尾指针rear，然后将它们的指针域都指向空（NULL），代码如下： 四、判断链队是否为空队 判断链队是否为空，只需判断即可，代码如下： 由于通过链式存储实现队列，就不会存在
[C++/PTA] 队列操作
等风来
06-14 3712
请实现一个MyQueue类，实现出队，入队，求队列长度. 实现入队函数 void push(int x); 实现出队函数 int pop(); 实现求队列长度函数 int size(); 输入格式: 每个输入包含1个测试用例。每个测试用例第一行给出一个正整数 n (n
数据结构与算法知识总结
05-10
后面介绍的形形色色的结构都是由一些基础结构通过限制某种条件(例如栈，队列)，或通过结构的组合(例如结构体和结构体指针组合形成链表)来变化成各种功能强大的数据存储结构,所以我们应该清楚，数据结构我们是学不完...
Java模拟栈和队列数据结构的基本示例讲解
09-02
主要介绍了Java模拟栈和队列数据结构的基本示例,栈的后进先出和队列的先进先出是数据结构中最基础的知识,本文则又对Java实现栈和队列结构的方法进行了细分,需要的朋友可以参考下
数据结构知识总结与结构网图
08-14
该资源是一份关于数据结构知识的总结与结构网图。它包含了数据结构的内容概要、适用人群、使用场景及目标。 内容概要: 该资源涵盖了常见的数据结构，例如数组、链表、栈、队列、树、图等。每种数据结构都有详细的...
数据结构、表、栈，队列
01-06
数据结构的详细讲解与参考资料，是嵌入式开发必备的基础知识，标准实现，很有参考意义，抽象化、移值性好。。。
链式队列的基本操作（详细）
qq_43346784的博客
07-08 7500
队列的基本操作（）链式 ，详细
数据结构——链队列的基本算法
weixin_30776863的博客
11-11 606
代码主要来源：【数据结构】【清华大学】【严蔚敏】 关于栈和队列的基本操作概括起来主要的内容有以下八种： 构造、销毁 置空、判空 取头、求长 输入、输出 下面的代码包括了基本八种外加一个 Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))函数 //+++++++++++++++++++...
【数据结构】——队列
m0_65759588的博客
04-17 2408
队列（Queue）的抽象数据结构类型 //基本操作： InitQueue (&Q) //构造一个空队列Q。 //以下前提条件为队列已经存在 Des t royQueue (&Q) //队列Q被销毁， 不再存在。 ClearQueue (&Q) //将Q清为空队列。 QueueEmpty (Q) //若Q为空队列，则返回true, 否则返回false。 QueueLength(Q) //返回Q的元素个数，即队列的长度。 EnQueue (&Q, e} //
循环队列长度公式推导
我想喝可乐的博客
07-15 1万+
一、队列长度公式 队列长度=（Q.rear+MaxSize-Q.front）%MaxSize 二、队列长度公式各个变量意义 以上各个变量的意义如下： Q.rear：队尾。指向数列队尾元素的下一个空间。 Q.front：队头。指向数列队头元素。 MaxSize：队列的最大长度。如队列Q.data[10]的表示Q.data[0]~Q.data[9]一共十个元素。 三、队列相关知识说明 1、初始条件：Q.front==Q.rear==0； 2、进队操作：队列没满时，先将值送到队尾，再将队尾指针加
【数据结构】队列（循环队列和链队列）详细讲解各种操作
小吉妙妙屋
04-15 4423
详细讲解循环队列和链队列的定义，初始化，入队，出队，遍历等操作
数据结构之队列
qq_53889144的博客
10-13 231
[@TOP] 数据结构之队列 一、队列元素的数据类型 元素数组，大小为Maxsize-1，两个整型指针front，rear typedef struct { Elemtype data[MaxSize]; int front, rear;//rear后面的意思,有队头，队尾指针 }SqQuene; 二、队列初始化 约定在顺序队队头指针front指向当前队列队头元素的前一个位置,队尾指针rear指向当前队列队尾元素的位置。 void InitQuene(SqQuene*& Q) { Q =
顺序循环队列＆链队列
chengxuyuanlee的博客
11-13 1462
队列与栈同样是一种操作受限制的线性表，队列的特点是先进先出即 FIFO，一般在尾部插入头部删除，在通常使用过程中，顺序队列经常产生假溢出等情况，因此时常采用顺序循环队列。 除顺序队列外还有链队，双端队列等。接下来先从顺序循环队列开始…… 顺序队列 头尾指针与顺序栈是一个思路，本质其实是数组的下标，按照图2方式再进行入队时rear已到达最大数值，但数组0,1位还有空缺，因此产生了假溢出的情况。 因此为了在考虑过时间与空间的情况下，修改成循环队列并增加两个“指针”，即可方便操作。 ...
C语言 队列（循环队列和链队初始化进出队等基本操作）
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
RabbitMQ学习(十四)：队列长度限制(Queue Length Limit)
wds的博客
06-25 8723
说明 在上篇博文《RabbitMQ学习(十三)：死信交换机》中，我对官方文档有关死信交换机的内容进行了翻译和学习，文中提到消息成为死信的原因有三种，队列长度的限制就是其中之一。本篇博文我将继续翻译学习官方文档中有关队列长度限制的相关的内容，通过本文记录学习总结有关队列长度限制如何设置，超出限制队列如何处理等内容。 正文 概述 队列的最大长度限制可以是限制消息的数量，或者是消息的总字节数（总字节数表...
数据结构与算法基础知识
最新发布
09-14
很高兴回答你关于数据结构和算法的问题！在Java中，有许多基础的数据结构和算法可以使用。下面是一些常见的数据结构和算法的介绍： 1. 数组（Array）：数组是一种线性数据结构，可以存储相同类型的元素。它们在内存中是连续存储的，并且可以通过索引来访问元素。 2. 链表（Linked List）：链表是另一种常见的线性数据结构，它由节点组成，每个节点都包含一个数据项和一个指向下一个节点的指针。 3. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构。它支持两个基本操作：push（将元素放入栈顶）和pop（从栈顶删除元素）。 4. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构。它支持两个基本操作：enqueue（将元素放入队尾）和dequeue（从队头删除元素）。 5. 树（Tree）：树是一种非线性数据结构，它由节点和边组成。每个节点可以有零个或多个子节点。常见的树包括二叉树、二叉搜索树和平衡二叉树。 6. 图（Graph）：图是由节点和边组成的非线性数据结构。节点表示对象，边表示节点之间的关系。图可以是有向的或无向的。 在Java中，还有一些常见的算法，包括但不限于以下几种： 1. 排序算法：例如冒泡排序、选择排序、插入排序、快速排序和归并排序等。 2. 查找算法：例如线性查找和二分查找等。 3. 图算法：例如广度优先搜索（BFS）和深度优先搜索（DFS）等。 4. 动态规划：一种通过将问题分解成子问题来解决复杂问题的算法。 这只是数据结构和算法的一小部分基础知识，希望对你有所帮助！如果你还有其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值