（C语言）数据结构之栈和队列面试题

已于 2023-10-29 21:49:58 修改
阅读量922 收藏 4
点赞数 5
分类专栏： 经验分享 数据结构 文章标签： 数据结构 c语言 链表
于 2022-08-11 12:38:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55712347/article/details/126276222
版权

目录

题目1.括号匹配问题

题目链接

思路：
判断括号的有效性可以使用栈这一数据结构来解决。
我们遍历给定的字符串s。当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。
当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么字符串s 无效，返回False。在上述的基础之上，在遍历结束后，如果栈中没有左括号，说明我们将字符串 s中的所有左括号闭合，返回True，否则返回 False。

实现代码：

typedef char 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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity==ps->top)
	{
		int newcapcaity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->a = (STDataType*)realloc(ps->a, newcapcaity * sizeof(STDataType));
		if (ps->a==NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapcaity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
	
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool isValid(char * s){
    ST MY_st;
    StackInit(&MY_st);
    while(*s)
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&MY_st, *s);
        }
        else
        {
            if(StackEmpty(&MY_st))
            {
                StackDestory(&MY_st);
                return false;
            }

            char tmp = StackTop(&MY_st);

            if((tmp=='('&&*s!=')')||(tmp=='['&&*s!=']')||(tmp=='{'&&*s!='}'))
            {
                StackDestory(&MY_st);
                return false;
            }
            StackPop(&MY_st);
        }
        s++;
    }

    if(StackEmpty(&MY_st))
    {
        StackDestory(&MY_st);
        return true;
    }
    else
    {
        StackDestory(&MY_st);
        return false;
    }

}

题目2.用队列实现栈

题目链接

思路：
为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作，
入栈操作时，首先将元素入队到 q1，然后出栈时先将q1的n-1个元素依次出队并入队到 q2
，此时q1仅剩的那一个元素即为栈顶元素，出队即可。此时q1没有元素了
下一次想出栈的时候就再倒一次，也就是把q2的前n-1个元素出队并入队到q1，然后q2把剩下的那个元素出队即可，此时q2为空下一次再入栈的时候，也就不用管q1还是q2，就直接谁有元素就往谁的里面入队元素即可。
总结：出栈倒一下，入栈入非空。

在这里插入图片描述

实现代码：

typedef int QDataType;

typedef struct QueueNode
{
	struct Queue* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;


void QueueInit(Queue* pq);//队列的初始化
void QueueDestroy(Queue* pq);//队列的销毁
void QueuePush(Queue* pq, QDataType x);//入队
void QueuePop(Queue* pq);//出队
QDataType QueueFront(Queue* pq);//队头元素
QDataType QueueBack(Queue* pq);//队尾元素
bool QueueEmpty(Queue* pq);//队列判空
int QueueSize(Queue* pq);//判断有效元素个数


void QueueInit(Queue* pq)//队列的初始化
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)//队列的销毁
//head->node->node->node->node->node->node->tail//单链表的结构
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)//入队
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode==NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		newnode->data=x;
		newnode->next = NULL;
	}

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;//pq->tail=newnode;
	}
	pq->size++;
}

void QueuePop(Queue* pq)//出队
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
		del = NULL;
	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)//队头元素
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

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

bool QueueEmpty(Queue* pq)//队列判空
{
	assert(pq);
	return pq->head==NULL&&pq->tail == NULL;//
}

int QueueSize(Queue* pq)//判断有效元素个数
{
	assert(pq);

	return pq->size;
}

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


MyStack* myStackCreate() {
    MyStack*obj=(MyStack*)malloc(sizeof(MyStack));//
    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* Empty=&obj->q1;
    Queue* nonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        nonEmpty=&obj->q1;
        Empty=&obj->q2;
    }
    int num=QueueSize(nonEmpty);
    if(nonEmpty==NULL)
    {
        return;
    }
    while(num>1)
    {
        QueuePush(Empty,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
        num--;
    }
    int tmp=QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return tmp;
}

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

bool myStackEmpty(MyStack* obj) {
    if(&obj->q1==NULL||&obj->q2==NULL)
    {
        return true;
    }
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

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

题目3.用栈实现队列

题目链接

思路：
一个队列是 FIFO 的，但一个栈是 LIFO 的。
这就意味着最新压入的元素必须得放在栈底。为了实现这个目的，我们创建两个栈一个专门用来进元素（pushST），一个用来出元素（popST），入队时只往pushST里存放元素，要出队时先把pushST中所有的元素移到popST 中，直接从 popST 弹出就可以了，
注意：当popST不为空的情况下是不需要从pushST里往popST中倒元素的。要出队时直接从popST里出栈即可。
这样设计可以避免来回颠倒元素，减少不必要的麻烦。

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

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);

STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity==ps->top)
	{
		int newcapcaity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->a = (STDataType*)realloc(ps->a, newcapcaity * sizeof(STDataType));
		if (ps->a==NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapcaity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
	
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

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


MyQueue* myQueueCreate() {
    MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushST);
    StackInit(&obj->popST);
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    int tmp=0;
    if(!StackEmpty(&obj->popST))
    {
        tmp=StackTop(&obj->popST);
        StackPop(&obj->popST);
    }
    else
    {
        while(!StackEmpty(&obj->pushST))/犯错之处！！！！！！！！！！！！
        {
        StackPush(&obj->popST,StackTop(&obj->pushST));
        StackPop(&obj->pushST);
        }
        tmp=StackTop(&obj->popST);
        StackPop(&obj->popST);
    }
    return tmp;
}

int myQueuePeek(MyQueue* obj) {
    
    
    if(StackEmpty(&obj->popST)&&!StackEmpty(&obj->pushST))
    {
        while(!StackEmpty(&obj->pushST))/犯错之处！！！！！！！！！！！！
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);
}

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

void myQueueFree(MyQueue* obj) {
    free(obj);
}

题目4.设计循环队列

题目链接
思路：
循环队列可用链表实现也可以用数组实现，链表要实现“循环”直接让最后结点的那个next域指向头结点即可，但是用数组实现的话怎么实现循环呢？
设有效个数为k个(为了解决判空和判满，多留出了一个空间，有效个数为k，实际数组个数为k+1)，数组的队头元素下标为front，队尾元素下一个位置的下标为back，（也有书上写front是对头元素的前一个，队尾元素为back，判空判满的表达式一样。）
每次入队的时候先要判断当先队列是否是满的，不为满，让back当前位置赋值要入队的元素，然后back正常++往后走，关键的来了再进行back=back %（k+1）操作即可实现循环。
那怎么区分什么时候空和什么时候满呢？
解决方法：
1、加一个size来记录当前元素的个数。
2、增加一个空间， 假如说长度4，那么就开5个空间，back位置下一个是front就满了（这样做是为了更好的区分队空和队满），所以说满的时候永远留一个空位置。

我们这里用第二种方法。
判断空：
当front和back相等的时候为空。

判断满：
当back的下一个为front时，即(back+1)%k+1和front相等的时候就是满了。
这个比较难想，可以看下面的动图：
下图的k应该是5，这里画错了。
在这里插入图片描述

实现代码：

typedef struct {
    int*a;
    int front;
    int back;
    int N;

} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
     MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
     obj->a=(int *)malloc(sizeof(int)*(k+1));///犯错之处！！！！！！！！
     obj->front=obj->back=0;
     obj->N=k+1;

     return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->back]=value;
    obj->back++;
    obj->back%=obj->N;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front%=obj->N;
    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;
    }
    int tmp=(obj->back-1+obj->N)%obj->N;
    return obj->a[tmp];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    
    free(obj);
    
}
有效的放假者
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2214
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
数据结构C语言篇《三》栈和队列概念，模拟函数实现，以及相关OJ面试题
愿你有青春亦可奔赴
05-22 1156
#pragma once typedef int DataType; typedef struct Stcak { DataType *arr; int capacity; //容量大小 int size; //有效元素个数---栈顶 }Stack; //栈的初始化 void StackInit(Stack *ps); //入栈 void StackPush(Stack *ps, DataType data); //出栈 void StackPop(Stack *ps); //获取栈顶元
c语言 数据结构面试题及答案,数据结构(C语言)【经典题库】含答案
weixin_32298151的博客
05-17 1099
数据结构(C语言)【经典题库】含答案 《数据结构与算法》复习题 选择题 1．在数据结构中，从逻辑上可以把数据结构分为 C 。 A．动态结构和静态结构 B．紧凑结构和非紧凑结构 C．线性结构和非线性结构 D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指 A 。 A．数据的存储结构 B．数据结构 C．数据的逻辑结构 D．数据元素之间的关系 3．在数据结构中，与所使用的计算机无关的是数据的 ...
C语言数据结构面试常见问题及答案
qq_43341279的博客
03-24 776
BFS从某个顶点开始，逐层访问与之相邻的顶点，直到找到目标顶点或遍历完所有顶点为止。后序遍历先遍历左子树，然后遍历右子树，最后访问根节点。特别是在使用C语言这样的底层语言时，对数据结构的掌握尤为重要。链表的大小可以动态调整，插入和删除元素时只需调整指针，效率较高。队列是一种先进先出（FIFO）的数据结构，允许在队尾进行插入操作，在队头进行删除操作。栈是一种后进先出（LIFO）的数据结构，只允许在一端进行插入和删除操作。图是由顶点（节点）和边组成的数据结构，可以表示复杂的关系网络。这通常需要借助队列来实现。
大公司的C语言面试，面试时体现你使用算法，数据结构解决问题的思路
11-06
大公司的C语言面试，面试时体现你使用算法，数据结构解决问题的思路
关于数据结构的10个面试题(c语言实现)
热门推荐
十八道胡同的博客专栏
04-21 1万+
1.        输入一个链表的头结点，从尾到头反过来输出每个结点的值。链表结点定义如下：struct ListNode{      int      m_nKey;      ListNode* m_pNext;};A:    递归方法逆序输出，栈方法逆序输出。(任意实现一种既可)void PrintListUsingRecursicve(pList
2018C语言及数据结构面试题
w1216702236的博客
01-20 2596
1、如何判断合法的IP地址,尽可能考虑各种情况 (腾讯面试题) 规则有： 正确的“192.168.3.44” （1）由数字字符和点号组成 （2）第一个数字字符不能是0 （3）数字字符和点号的存放 （4）每个数字的范围是0~255 代码如下： static int CountPoint(const char *str) { int count = 0; while(*str != ‘\0’) { i...
c语言面试题数据结构,若干数据结构 && 算法面试题【一】（更新完毕）
weixin_42112894的博客
05-24 537
一、两个栈实现一个队列二、实现一个栈要求：实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)为了在O(1)时间内取到栈内元素的最小值，显然遍历是行不通的。我们需要在入栈和出栈的操作中记录最小值。如果用一个变量(假设叫m)在入栈时记录并保存最小值，假如这个最小的元素出栈。比如：入栈元素分别为： 4 3 2 1这时m保存的最小值为 1但一旦将值为1的...
C语言 ，嵌入式 ，数据结构 面试题目（3）
constantin_的博客
03-13 1593
182 链表题：一个链表的结点结构struct Node{int data ;Node *next ;};typedef struct Node Node ;(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)Node * ReverseList(Node *head) //链表逆序{if ( head == NULL || head->next == NULL )re...
C语言版数据结构、算法与各类面试题，C99编译器。.zip
01-20
标题中的"C语言版数据结构、算法与各类面试题，C99编译器"提示了我们，这个压缩包包含的内容主要是关于C语言的数据结构、算法的学习资料，以及可能的面试题目，使用的编程环境是C99标准。这些知识点是计算机科学的...
c语言基础面试题（04-数据结构）.docx
11-21
（1.常用的数据结构类型：集合、线性、树形、图状。 2.数据结构： - 逻辑结构：数据元素之间的关系 - 存储结构：数据结构在计算机中的表示。存储结构分为：顺序存储结构和链式存储结构。 3.算法是对特定问题求解步骤的一种描述，算法具有如下特性：有穷性、确定性、可行性、输入、输出。 4.算法的度量： - 时间复杂度 - 空间复杂度）本试题是针对常见c语言面试常见算法题的练习。
快速排序 C语言 数据结构 程序员面试
05-19
快速排序 C语言 数据结构 程序员面试 效率很高的排序
C语言面试题大汇总之华为面试题.pdf
08-02
8. 队列和栈的数据结构特性： 队列是一种先进先出（FIFO）的数据结构，允许在两端进行操作，一端添加元素（入队），另一端移除元素（出队）。栈是一种后进先出（LIFO）的数据结构，只允许在一端进行操作，即只能从...
栈与队列问题（主要是栈的使用）
a631278993的博客
05-15 410
转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/6857537.html 一：问题概述 栈与队列的相关算法题，一般都是基于对栈、队列基本性质的熟练掌握的前提下，如何巧妙地组合、包装，以达到某种原来数据类型所没有的性质。比如：设计出一种能getMin()获取栈中最小值的栈、利用栈实现队列等等。问题的本意为考察栈、队列的基本性质与基本操作的...
c语言 数据结构面试题及答案,数据结构c语言版试题大全(含答案).docx
weixin_33267830的博客
05-17 689
有答案|数据结构C语言版期末考试试题(有答案)_计算机软件及应用_IT/计算机_专业资料。数据结构C语言版期末考试试题(有答案)您...PAGE精品文档，知识共享！1 绪论沈阳理工大学应用技术学院信息与控制学院计算机科学与技术教研室2011-5-8数据结构复习题：绪论单选题1、在数据结构中，与所使用的计算机无关的数据叫_____结构。A存储|B物理|C逻辑|D物理和存储2、在数据结构中，从逻辑上可...
【数据结构】C语言单链表面试题
Qregi的博客
01-24 348
// 链表相关面试题   //   //1. 比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？   //2. 从尾到头打印单链表   //3. 删除一个无头单链表的非尾节点   //4. 在无头单链表的一个非头节点前插入一个节点   //5. 单链表实现约瑟夫环   //6. 逆置/反转单链表   //7. 单链表排序（冒泡排序&快速排序）   //8. 合并两个有序链表
c语言面试题数据结构,C/C++及数据结构笔试题集锦
weixin_42131316的博客
05-24 558
嗯，这是我从学校bbs精华区整理的c/c++及数据结构的笔试以及部分面试题集锦，觉得只要搞懂了这些题目，大部分的笔试都不惧了。希望能给需要的人带来帮助。顺便攒rp ^_^不过大部分题目没有答案，欢迎补充哦~~~~一：已知类String的原型为：class String{public：String(const char *str = NULL);//普通构造函数String(const String...
leetcode-栈和队列
weixin_44723661的博客
07-13 150
232. 用栈实现队列 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false class MyQueue{ public: stack<int> stIn; st
C++笔记18•数据结构:AVL树•
最新发布
qq_64446190的博客
09-06 438
AVL树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

有效的放假者

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

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

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

打赏作者

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

抵扣说明：

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

余额充值