【数据结构】— 『栈』的实现以及 LeetCode『括号匹配问题』

已于 2022-09-06 16:26:24 修改
阅读量447 收藏 2
点赞数 9
分类专栏： 【数据结构初阶】 文章标签： 数据结构 c语言 leetcode
于 2022-09-06 16:23:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63938813/article/details/126686273
版权

꧁   各位大佬们好！很荣幸能够得到您的访问，让我们一起在编程道路上任重道远！꧂

☙ 博客专栏：【数据结构初阶】❧

⛅ 本篇内容简介：数据结构初阶中的栈的实现以及练习题【括号匹配问题】！

⭐ 了解作者：励志成为一名编程大牛的学子，目前正是大二的编程小白。

✍励志术语：编程道路的乏味，让我们一起学习变得有趣！

文章目录

✯ 顺序表与链表的总结

✡ 顺序表和链表的区别

✡ 顺序表和链表的优缺点

⛦ 顺序表的优缺点

⛦ 链表的优缺点

✯ 栈

✡ 栈的概念及结构

 ✡ 栈的实现

⛦ 栈的结构

⛦ 栈的初始化

⛦ 栈的入栈（压栈）

⛦ 栈的出栈

⛦ 获取栈顶的元素

⛦ 获取栈的有效元素个数

⛦ 栈的判空

⛦ 栈的销毁

⛦ 测试栈的接口功能

✡ 栈的源代码

⛦ Stack.h文件

⛦ Stack.c文件

⛦ test.c文件

✯【LeetCode】— 括号匹配问题

 ✡ 题目描述

 ✡ 解题思路

  ✡ 解题代码

✯ 结束语

✯ 顺序表与链表的总结

✡ 顺序表和链表的区别

不同点顺序表链表（双向循环带头）
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)  下标不支持：为O(N) 遍历
任意位置插入或者删除元素可能需要挪动元素，效率低，为O(N)只需要修改指针指向
插入动态顺序表，空间不够时需要扩容没有扩容的概念
应用场景元素高效存储+频繁访问任意位置插入与删除频繁
缓存利用率高低

✡ 顺序表和链表的优缺点

⛦ 顺序表的优缺点

优点：

· 尾插尾删效率很高

· 随机访问（用下标访问）

· CPU高速缓冲命中率更高（相比于链表）

缺点：

· 头部和中部的插入与删除效率很低（为O(N)）

· 扩容时 —— 性能消耗+空间浪费

⛦ 链表的优缺点

优点：

· 任意位置插入与删除效率很高（为O(1)）

· 按需申请与释放空间

缺点：

· 不支持随机访问

 CPU执行指令，不会直接访问内存

1. 先看数据在不在三级缓存，如果在（命中），直接访问

2. 如果不在（不命中），先加载到缓存，再访问

✯ 栈

✡ 栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入与删除元素操作，进行数据的插入和删除操作的一端称为栈顶，另外一端为栈底。栈中的数据元素遵守后进先出（Last In First out）的原则。

压栈：栈的插入操作叫做 进栈 / 压栈 / 入栈，入数据是在栈顶

出栈：栈的删除操作叫做出栈，出数据也在栈顶。

 

 ✡ 栈的实现

栈的实现一般可以使用数组或者链表实现，但是相对而言数组实现结构更加优一些，因为数组在尾上插入数据的代价比较小。

⛦ 栈的结构

 看到上面栈的物理结构，可以看到栈是一个数组，有top值和容量值（capacity）。

栈的结构分为静态版本以及动态增长版本，但是静态版本的栈一般不实用，这里我们不做过多的介绍了，直接介绍动态增长版本的栈。

代码实现：

//动态栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

⛦ 栈的初始化

//初始化栈
void StackInit(Stack* ps);

栈的初始化有两种形式：

①. top初始的值为 0

 

②. top初始的值为 -1

这里我们介绍top初始化为0的值，因为top值的位置就栈中元素个数。

代码实现：

//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

⛦ 栈的入栈（压栈）

//入栈
void StackPush(Stack* ps, STDataType x);

在入栈的过程中，需要注意的点有：

①. 需要考虑扩容问题，如果需要扩容将数组成2倍增长。

②. 需要在数组的top位置插入元素，最后top++。

代码实现：

//入栈
void StackPush(Stack* ps, STDataType x)
{
	//考虑扩容
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//入栈
	ps->a[ps->top] = x;
	ps->top++;
	
}

⛦ 栈的出栈

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

出栈需要注意的点：

①. 需要判断栈(Stack)是否为空。

②. 出栈就比较简单了，直接top - - 就行了。

代码实现：

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//判空
	assert(!StackEmpty(ps));

	//直接 --
	ps->top--;
}

⛦ 获取栈顶的元素

//获取栈顶元素
STDataType StackTop(Stack* ps);

top位置的数据是元素的个数，在数组中数组末的数据就是元素个数 -1 的位置，即：top -1。

代码实现：

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);

	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

⛦ 获取栈的有效元素个数

//栈的有效个数
int StackSize(Stack* ps);

元素个数就是top的值，在之前我们就已经解释过了！！！

//栈的有效个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

⛦ 栈的判空

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps);

在初始化时我们将top初始化为0，如果top一直是0，就说明栈是空的，返回非0，反之。

代码实现：

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

⛦ 栈的销毁

//栈的销毁
void StackDestroy(Stack* ps);
//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	//置空
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

⛦ 测试栈的接口功能

我们先将几个数据入栈，但栈不为空时，就获取栈顶的元素，并且要将栈顶的元素Pop，也就是出栈。

✡ 栈的源代码

⛦ Stack.h文件

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once

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

//typedef int STDataType;
//#define N 100
静态栈
//typedef struct Stack
//{
//	STDataType a[N];
//	int top;//栈顶
//};

//动态栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

//初始化栈
void StackInit(Stack* ps);

//入栈
void StackPush(Stack* ps, STDataType x);

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

//获取栈顶元素
STDataType StackTop(Stack* ps);

//栈的有效个数
int StackSize(Stack* ps);

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps);

//栈的销毁
void StackDestroy(Stack* ps);

⛦ Stack.c文件

#include"Stack.h"

//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

//入栈
void StackPush(Stack* ps, STDataType x)
{
	//考虑扩容
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//入栈
	ps->a[ps->top] = x;
	ps->top++;
	
}

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//判空
	assert(!StackEmpty(ps));

	//直接 --
	ps->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);

	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

//栈的有效个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	//置空
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

⛦ test.c文件

#include"Stack.h"

void test()
{
	Stack st;
	//初始化
	StackInit(&st);

	//入栈
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);

	while (!StackEmpty(&st))
	{
		//获取栈顶元素
		printf("%d ",StackTop(&st));
		//出栈
		StackPop(&st);
	}


	//销毁
	StackDestroy(&st);
}

int main()
{
	test();
	return 0;
}

✯【LeetCode】— 括号匹配问题

 ✡ 题目描述

20. 有效的括号.  OJ链接

 

 ✡ 解题思路

①. 我们在这里使用的是C语言实现这个题目，因为C语言没有库，所以我们需要自己写一个栈，但是我们之前已经写好了一个栈了，可以直接使用。

②. 如果字符是左括号 '（'  || ' [ ' || ' { ' ，我们就入栈，如果是右括号我们就取栈顶的元素，与字符串进行对比，如果左括号与相应的右括号不匹配时，就 return false。

 考虑边界情况：

③. 当栈中只有左括号时,就需要对栈进行判空处理，如果栈不为空，就 返回它的 bool 值。

④. 当没有左括号时，就说明没有括号入栈，也对栈进行判空，如果栈为空，就 return false。

 注意：养成好习惯，在每次 return 时，对栈进行销毁。

 

  ✡ 解题代码

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

//初始化栈
void StackInit(Stack* ps);

//入栈
void StackPush(Stack* ps, STDataType x);

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

//获取栈顶元素
STDataType StackTop(Stack* ps);

//栈的有效个数
int StackSize(Stack* ps);

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps);

//栈的销毁
void StackDestroy(Stack* ps);

//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

//入栈
void StackPush(Stack* ps, STDataType x)
{
	//考虑扩容
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//入栈
	ps->a[ps->top] = x;
	ps->top++;
	
}

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//判空
	assert(!StackEmpty(ps));

	//直接 --
	ps->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);

	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

//栈的有效个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

//栈的判空  为空返回非0，不为空返回0
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	//置空
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

bool isValid(char * s){
    //使用栈实现
    Stack st;
    //初始化
    StackInit(&st);

    
    while(*s!='\0')
    {
        //左括号就入栈
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&st,*s);
        }

        else
        {
            //右括号  出栈 对比

            // 栈为空时
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }

            char top=StackTop(&st);
            StackPop(&st);

            if((*s==')'&&top!='(')||
            (*s==']'&&top!='[')||
            (*s=='}'&&top!='{'))
            {
                StackDestroy(&st);
                return false;
            }

        }
        s++;
    }

    //栈不为空，为false
    bool flag=StackEmpty(&st);
    StackDestroy(&st);

    return flag;
}

✯ 结束语

【写在最后·想告诉你】

在互联网这个行业里

任何时候都要学好技术

永远都是 技术为王

甘宸しぐれ
关注
  • 9
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
数据结构题——括号匹配问题
qq_36805270的博客
05-08 8883
括号匹配问题是栈应用的一个经典场景，原理比较简单： 括号匹配原理 假设表达式中允许包含两种括号：圆括号和方括号，其嵌入的顺序随意，即（[ ] ( )）或[([ ] [ ])]等为正确的格式，[(])或([())或(())]均为不正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。 由此，在算法中设置一个栈，每读入一个括号，若是右括号，则或者使置于栈顶的最击破...
【数据结构】括号匹配问题
xiyang_DING
10-14 6660
假设表达式中包含三种括号：圆括号、方括号和花括号，它们可互相嵌套，编写一个检查表达式中括号是否配对的函数。
栈的应用--括号匹配问题
XUN__MLF的博客
05-06 4015
算法思路： 1、首先从左往右扫描各个括号 2、如果出现左半括号，就将其压入栈中， 3、如果扫描到右半括号，就将其和栈顶元素进行对比， 3.1、如果栈空（没有栈顶元素），则匹配失败， 3.2、如果栈不为空，弹出栈顶元素，将栈顶元素和该右半括号进行比较，小括号匹配小括号，如果匹配失败，结束 4、全部匹配完以后，判断栈是否为空，如果栈不为空，说明还有未匹配的左半括号，如果栈为空，说明括号匹配成功 代码实现 #include <stdio.h> /......
数据结构与算法(栈及利用栈实现简单括号匹配)
学习笔记
09-14 518
栈：一种有次序的数据项集合，在栈中，数据项的加入和移除 都仅发生在同一端，距离栈底越近的数据项，留在栈中的时间 就越长。这种次序通常称为“后进先出LIFO”： Last in First out 利用栈实现简单括号匹配 利用python实现栈 括号匹配代码： from pythonds.basic.stack import Stack def parChecker(symbolString): s = Stack() for symbol in symbolString: if symbol
leetcode数据结构的一些总结
04-14
在编程世界中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程问题，涵盖了各种算法和数据结构。这里我们主要关注“数据结构”的部分，尤其是通过LeetCode学习和总结的数据结构知识点。 首先，数据结构是...
左右括号匹配（栈实现C语言）1
08-03
栈是一种后进先出（LIFO）的数据结构，非常适合处理这种需要“延迟处理”的问题，例如括号匹配。在C语言中，我们可以通过结构体来定义一个简单的栈： ```c typedef int STDataType; typedef struct Stack { ...
栈的学习（数据结构）自我心得
02-07
总结来说，栈作为一种基础的数据结构，有着广泛的应用，它在括号匹配、函数调用、图的深度优先搜索等方面发挥着重要作用。理解其工作原理和特性，以及如何在实际编程中运用，是每个程序员必备的技能。通过不断学习和...
leetcode题库-leetcode:数据结构
06-29
在LeetCode中，栈常用于回溯、深度优先搜索等问题，如“括号匹配”；队列则常见于广度优先搜索和处理并发任务，如“最短距离的公交站”。 四、树与图 树是数据结构中的重要组成部分，包括二叉树、平衡树、堆等。...
数据结构：解决了来自leetcode和GeeksforGeeks的数据结构问题
03-04
在这个"数据结构：解决了来自leetcode和GeeksforGeeks的数据结构问题"的压缩包中，我们可以预期包含了解决这些知名在线平台上的各种数据结构挑战的Java代码。 1. **数组**：数组是最基础的数据结构，它提供了固定...
数据结构268：括号配对问题
退堂鼓演奏家
04-13 755
问题描述 现在有一行括号序列，请你检查这行括号是否配对。 输入说明 第一行输入一个数N（0<N<=100）,表示有N组测试数据。后面的N行输入多组输入数据，每组输入数据都是一个字符串S(S的长度小于10000，且S不是空串），测试数据组数少于5组。数据保证S中只含有"[","]","(",")"四种字符。 输出说明 每组输入数据的输出占一行，如果该字符串中所含的括号是配对的，则输出Ye...
数据结构：利用栈实现括号匹配和表达式求值
努力敲代码
07-01 1539
实验题目：从键盘输入一个表达式，将表达式用字符串保存后，输出表达式。利用栈判断表达式中的括号是否匹配，如匹配计算表达式的值，并输出匹配，否则，输出匹配失败。
数据结构：栈及其应用，括号匹配问题
mxc111213_的博客
01-22 917
设计并验证以下算法：设一个算术表达式中包含圆括号、方括号和花括号，判断其中的括号是否匹配。 (1) 算术表达式中可以包含三种括号“（”和“）”、“[”和“]”、“{”和“}”，并且这三种括号可以按任意的次序嵌套使用。比如，…[…{…}[…]]…(…)…。 (2) 设置一个运算符栈OPTR。当遇到的‘（’、‘[’或‘{’时进栈；当遇到‘（’、‘[’或‘{’时，判断栈顶是否为相应的括号，若是则退栈继续执行，否则提示出错并结束。 (3) 要求由键盘输入包括‘（’、‘[’或‘{’的算术表达式。 // // Crea
数据结构-C语言括号匹配问题(栈和计数方式两种思想)
kg的博客
10-30 2万+
题目描述现在，有一行括号序列，里面只包含”(“,”)”,”[“,”]”四种符号，请你检查这行括号是否配对。 如： []是匹配的 ([])[]是匹配的 ((]是不匹配的 ([)]是不匹配的 求解思想这里提供了两种求解方法：一种是使用栈进行求解；另一种是使用计数器进行求解。下面分别对两种方法进行描述以及给出相应代码。栈定义一个计数器用来判断正反括号的数量，遇见 { 则count+1
用c语言数组与指针模拟栈实现括号匹配
m0_63758097的博客
10-23 441
*思路：用数组存入元素，将数据的后半部分元素存入一个新的数组，接着定义两个指针分别指向两个数组，之后利用指针进行元素字符的比较。给定一个只包括'(',')','{','}','[',']'的字符串是否有效。i++,q++){//qian半部分。for(i=len1;i++){//hou半部分。=0)//输入的符号为奇数时不符合。printf("请输入要判断的括号：\n");3.每个右括号都有一个对应的相同类型的左括号。//给定字符串判断是否有效(利用数组)第五题（分数最高分为10分）
【数据结构】【栈】括号匹配算法（可直接运行）
热门推荐
treesorshining的博客
07-17 2万+
假设表达式中允许包含三种括号()、[]、{}，其嵌套的顺序任意，即([]{})或[()[]{}]等均为正确的格式，实现一个算法，完成对表达式中括号的检验。（5）从栈顶取出元素，检测此左括号与读入右括号是否匹配，如果不匹配，则返回匹配失败。（4）如果是右括号，则先检查栈是否为空，如果栈为空，则表示无左括号与之匹配，匹配失败。（6）检测栈是否为空，如果栈为空，则表示匹配完成后还有多余的括号，匹配失败。（4）直至第四个括号出现，发现其能与最近的第三个括号匹配，那第三个括号匹配完成，退出等待。...
C语言数据结构 3：栈和括号匹配
ss的博客
05-11 505
栈： 栈是一种操作受限的线性表只允许从一端插入和删除数据。栈有两种存储方式，即线性存储和链接存储（链表）。栈的一个最重要的特征就是栈的插入和删除只能在栈顶进行，所以每次删除的元素都是最后进栈的元素，故栈也被称为后进先出（LIFO）表。每个栈都有一个栈顶指针，它初始值为-1，且总是指向最后一个入栈的元素，栈有两种处理方式，即进栈（push）和出栈（pop）。 代码实现： #include <stdio.h> #include <malloc.h> #define STACK_
数据结构括号匹配问题
m0_52290532的博客
11-14 1787
数据结构括号匹配问题 要求大、中、小括号两两匹配，基本思路可以通过栈来实现。这里我使用的是简单的静态顺序栈，大小固定，同时定义了栈顶指针top。程序包含了栈的几个最基本的操作，初始化、判空、压入、弹出，此外还有一个匹配函数，该函数接受一个数组和其长度做参数，判断是否括号匹配成功。然后是处理括号的问题，思路是扫描数组中的括号，遇到左括号就进行压栈操作，遇到右括号先判断栈中是否还有元素(即左括号)，若没有则右括号“单身”，匹配失败，若栈中存在元素，就进行出栈操作，将栈顶的元素弹出与右括号进行配对，判断是否成功
【数据结构--栈的应用--括号匹配】
qq_61719813的博客
05-11 3669
文章目录括号匹配前言例如算法思想栈的定义及其操作括号匹配核心代码完整代码运行测试 括号匹配 前言 括号匹配问题是较为经典的栈的应用了，在Leetcode和数据结构数组时常出现 例如 给定一个字符串，其包含( , ) ,{ , } , [ , ]以及数字，要求判断其括号是否匹配，即： 左括号必须用相同类型的右括号闭合 左括号必须以正确的顺序闭合 实例 1： 输入: "[2 + (1 - 3)] * 4" 输出：1 实例 2： 输入："( ) )" 输出：0 算法思想 当遇到 ‘(’ ，‘[’
括号匹配问题(数据结构——栈)
qq_40596811的博客
09-16 5171
题目描述： 思路： 代码实现 #ifndef STACK #define STACK typedef struct { char str[200]; int top; }*stack, Stack; #endif #define max 20 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #inc...
数据结构与算法 全 数据结构与算法全 Java
最新发布
03-04
- **栈** 是后进先出（LIFO）的数据结构，常用于括号匹配、后缀表达式计算等。链表和数组都可以用来实现栈。 **习题** 部分提供了各种基于所学概念的实际编程练习，涵盖了LeetCode上的经典问题，如二分查找、链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

甘宸しぐれ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值