用栈实现算数表达式求值（C语言（基础版））

最新推荐文章于 2022-07-02 12:03:53 发布
最新推荐文章于 2022-07-02 12:03:53 发布
阅读量1w 收藏 208
点赞数 24
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchiang03/article/details/123895790
版权

栈 中缀表达式 运算符优先级 计算 链表结构
关键词由CSDN通过智能技术生成

要求：输入以#为结束的算数表达式（包括+，-，*，/）并求值

1.基础的栈结构书写（包括创建栈，判断栈是否为空，以及数据的压栈和出栈）【可参考MOOC上陈越姥姥的相关数据结构课程】

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct SNode* Stack;
struct SNode {									//链表结构
	char Data;
	int  Number;
	struct SNode* next;
};

Stack CreateStack(Stack S) {					//建立新的节点
	S = (Stack)malloc(sizeof(struct SNode));
	S->next = NULL;
	return S;
}

int IsEmpty(Stack S) {							//判断栈是否为空
	return(S->next==NULL);
}

void Push(char item,Stack S,int i) {					//压栈
	Stack TmpCell;
	TmpCell = (Stack)malloc(sizeof(struct SNode));
	TmpCell->Data = item;
	TmpCell->Number=i;
	TmpCell->next = S->next;
	S->next = TmpCell;
}

char Pop(Stack S) {								//出栈
	Stack FirstCell;
	char TopElem;
	if(IsEmpty(S)) {
		printf("堆栈空");
	} else {
		FirstCell = S->next;
		S->next = FirstCell->next;
		TopElem = FirstCell->Data;
		free(FirstCell);
		return TopElem;
	}
}

2.运算符先后顺序的判断

char Compare(char N,char S) {							//判断运算符的先后性
	if(N=='+'&&S=='+'||N=='-'&&S=='+'||N=='*'&&S=='+'||N=='/'&&S=='+')
		return '>';
	else if(N=='+'&&S=='-'||N=='-'&&S=='-'||N=='*'&&S=='-'||N=='/'&&S=='-')
		return '>';
	else if(N=='*'&&S=='*'||N=='*'&&S=='/'||N=='/'&&S=='/'||N=='/'&&S=='*')
		return '>';
	else if(N=='+'&&S=='*'||N=='-'&&S=='*'||N=='+'&&S=='/'||N=='-'&&S=='/')
		return '<';
	else if(N=='+'&&S=='#'||N=='-'&&S=='#'||N=='*'&&S=='#'||N=='/'&&S=='#')
		return '>';
	else if(N=='#'&&S=='+'||N=='#'&&S=='-'||N=='#'&&S=='*'||N=='#'&&S=='/')
		return '<';
}

3.运算

int operate(int a,char M,int b) {				//进行运算
	int s;
	switch(M) {
		case'+':
			s=a+b;
			break;
		case'-':
			s=a-b;
			break;
		case'*':
			s=a*b;
			break;
		case'/':
			s=a/b;
			break;
		default:
			printf("error");
			break;
	}
	return s;
}

4.运算与栈结构相结合

Stack OP(Stack OPTR,Stack OPND) {
	char N,M,W;
	int a,b,flag=0,i=1,j,A=0,B=0,C,D,E,F[10];
	Stack TOP_1,TOP_2;
	Push('#',OPTR,1);							//将‘#’压入OPTR栈中
	scanf("%c",&N);							//从键盘中读入字符
	TOP_1=OPND->next;						//将TOP_1设置为数据栈的栈顶
	TOP_2=OPTR->next;						//将TOP_2设置为运算符栈的栈顶

	while(N!='#') {
		if(N>='0'&&N<='9') {
			if(flag==0) {
				Push(N,OPND,i);
				flag=1; 
			} else {
				i++;
				Push(N,OPND,i);
			}
		} else if(N=='+'||N=='-'||N=='*'||N=='/'||N=='#') {
			i=1;
			flag=0;
			W=Compare(TOP_2->Data,N);
			switch(W) {
				case'<': {
					Push(N,OPTR,1);
					break;
				}
				case'>': {
					M=Pop(OPTR);
					TOP_1=OPND->next;
					i=TOP_1->Number;
					A=0;
					a=0;
					for(j=0; j<i; j++) {
						a=Pop(OPND)-'0';
						A=a*pow(10,j)+A;
					}
					TOP_1=OPND->next;
					i=TOP_1->Number;
					B=0;
					b=0;
					for(j=0; j<i; j++) {
						b=Pop(OPND)-'0';
						B=b*pow(10,j)+B;
					}
					C=operate(B,M,A);
					D=C;
					E=0;
					do {
						E++;
						F[E]=D%10;
						D=D/10;
					} while(D!=0);
					for(j=E; j>0; j--) {
						Push(F[j]+'0',OPND,E);
					}
					TOP_2=OPTR->next;
					if(TOP_2->Data=='#') {
						Push(N,OPTR,1);
						i=1;
					} else {						//还有BUG
						W=Compare(TOP_2->Data,N);
						switch(W) {
							case'<': {
								Push(N,OPTR,1);
								break;
							}
							case'>': {
								M=Pop(OPTR);
								i=TOP_1->Number;
								A=0;
								a=0;
								for(j=0; j<i; j++) {
									a=Pop(OPND)-'0';
									A=a*pow(10,j)+A;
								}
								TOP_1=OPND->next;
								i=TOP_1->Number;
								B=0;
								b=0;
								for(j=0; j<i; j++) {
									b=Pop(OPND)-'0';
									B=b*pow(10,j)+B;
								}
								C=operate(B,M,A);
								D=C;
								E=0;
								do {
									E++;
									F[E]=D%10;
									D=D/10;
								} while(D!=0);
								for(j=E; j>0; j--) {
									Push(F[j]+'0',OPND,E);
								}
								TOP_2=OPTR->next;
								if(TOP_2->Data=='#') {
									Push(N,OPTR,1);
									i=1;
								} else {						//还有BUG
									W=Compare(TOP_2->Data,N);
									M=Pop(OPTR);
									i=TOP_1->Number;
									A=0;
									a=0;
									for(j=0; j<i; j++) {
										a=Pop(OPND)-'0';
										A=a*pow(10,j)+A;
									}
									TOP_1=OPND->next;
									i=TOP_1->Number;
									B=0;
									b=0;
									for(j=0; j<i; j++) {
										b=Pop(OPND)-'0';
										B=b*pow(10,j)+B;
									}
									C=operate(B,M,A);
									D=C;
									E=0;
									do {
										E++;
										F[E]=D%10;
										D=D/10;
									} while(D!=0);
									for(j=E; j>0; j--) {
										Push(F[j]+'0',OPND,E);
									}
									Push(N,OPTR,1);
								}
								break;
							}
							default:
								printf("error");
								break;
						}
						i=1;
					}
					break;
				}
				default:
					printf("error");
					break;
			}
		}
		TOP_1=OPND->next;
		TOP_2=OPTR->next;
		scanf("%c",&N);
	}
	TOP_1=OPND->next;
	M=Pop(OPTR);
	i=TOP_1->Number;
	A=0;
	a=0;
	for(j=0; j<i; j++) {
		a=Pop(OPND)-'0';
		A=a*pow(10,j)+A;
	}
	TOP_1=OPND->next;
	i=TOP_1->Number;
	B=0;
	b=0;
	for(j=0; j<i; j++) {
		b=Pop(OPND)-'0';
		B=b*pow(10,j)+B;
	}
	C=operate(B,M,A);
	D=C;
	E=0;
	do{
		E++;
		F[E]=D%10;
		D=D/10;
	} while(D!=0);
	for(j=E; j>0; j--) {
		Push(F[j]+'0',OPND,E);
	}
	TOP_2=OPTR->next;
	if(TOP_2->Data=='#') {
		return OPND;
	} else {
		W=Compare(TOP_2->Data,N);
		M=Pop(OPTR);
		i=TOP_1->Number;
		A=0;
		a=0;
		for(j=0; j<i; j++) {
			a=Pop(OPND)-'0';
			A=a*pow(10,j)+A;
		}
		TOP_1=OPND->next;
		i=TOP_1->Number;
		B=0;
		b=0;
		for(j=0; j<i; j++) {
			b=Pop(OPND)-'0';
			B=b*pow(10,j)+B;
		}
		C=operate(B,M,A);
		D=C;
		E=0;
		do {
			E++;
			F[E]=D%10;
			D=D/10;
		} while(D!=0);
		for(j=E; j>0; j--) {
			Push(F[j]+'0',OPND,E);
		}
		return OPND;
	}
}

5.主函数

int main() {
	int B=0,b,j,i;
	Stack OPTR,OPND,TOP_1;
	OPTR=CreateStack(OPTR);
	OPND=CreateStack(OPND);
	OPND=OP(OPTR,OPND);
	TOP_1=OPND->next;
	i=TOP_1->Number;
	for(j=0; j<i; j++) {
		b=Pop(OPND)-'0';
		B=b*pow(10,j)+B;
	}
	printf("%d",B);
	return 0;
}

完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct SNode* Stack;
struct SNode {									//链表结构
	char Data;
	int  Number;
	struct SNode* next;
};

Stack CreateStack(Stack S) {					//建立新的节点
	S = (Stack)malloc(sizeof(struct SNode));
	S->next = NULL;
	return S;
}

int IsEmpty(Stack S) {							//判断栈是否为空
	return(S->next==NULL);
}

void Push(char item,Stack S,int i) {					//压栈
	Stack TmpCell;
	TmpCell = (Stack)malloc(sizeof(struct SNode));
	TmpCell->Data = item;
	TmpCell->Number=i;
	TmpCell->next = S->next;
	S->next = TmpCell;
}

char Pop(Stack S) {								//出栈
	Stack FirstCell;
	char TopElem;
	if(IsEmpty(S)) {
		printf("堆栈空");
	} else {
		FirstCell = S->next;
		S->next = FirstCell->next;
		TopElem = FirstCell->Data;
		free(FirstCell);
		return TopElem;
	}
}

char Compare(char N,char S) {							//判断运算符的先后性
	if(N=='+'&&S=='+'||N=='-'&&S=='+'||N=='*'&&S=='+'||N=='/'&&S=='+')
		return '>';
	else if(N=='+'&&S=='-'||N=='-'&&S=='-'||N=='*'&&S=='-'||N=='/'&&S=='-')
		return '>';
	else if(N=='*'&&S=='*'||N=='*'&&S=='/'||N=='/'&&S=='/'||N=='/'&&S=='*')
		return '>';
	else if(N=='+'&&S=='*'||N=='-'&&S=='*'||N=='+'&&S=='/'||N=='-'&&S=='/')
		return '<';
	else if(N=='+'&&S=='#'||N=='-'&&S=='#'||N=='*'&&S=='#'||N=='/'&&S=='#')
		return '>';
	else if(N=='#'&&S=='+'||N=='#'&&S=='-'||N=='#'&&S=='*'||N=='#'&&S=='/')
		return '<';
}

int operate(int a,char M,int b) {				//进行运算
	int s;
	switch(M) {
		case'+':
			s=a+b;
			break;
		case'-':
			s=a-b;
			break;
		case'*':
			s=a*b;
			break;
		case'/':
			s=a/b;
			break;
		default:
			printf("error");
			break;
	}
	return s;
}
Stack OP(Stack OPTR,Stack OPND) {
	char N,M,W;
	int a,b,flag=0,i=1,j,A=0,B=0,C,D,E,F[10];
	Stack TOP_1,TOP_2;
	Push('#',OPTR,1);							//将‘#’压入OPTR栈中
	scanf("%c",&N);							//从键盘中读入字符
	TOP_1=OPND->next;						//将TOP_1设置为数据栈的栈顶
	TOP_2=OPTR->next;						//将TOP_2设置为运算符栈的栈顶

	while(N!='#') {
		if(N>='0'&&N<='9') {
			if(flag==0) {
				Push(N,OPND,i);
				flag=1; 
			} else {
				i++;
				Push(N,OPND,i);
			}
		} else if(N=='+'||N=='-'||N=='*'||N=='/'||N=='#') {
			i=1;
			flag=0;
			W=Compare(TOP_2->Data,N);
			switch(W) {
				case'<': {
					Push(N,OPTR,1);
					break;
				}
				case'>': {
					M=Pop(OPTR);
					TOP_1=OPND->next;
					i=TOP_1->Number;
					A=0;
					a=0;
					for(j=0; j<i; j++) {
						a=Pop(OPND)-'0';
						A=a*pow(10,j)+A;
					}
					TOP_1=OPND->next;
					i=TOP_1->Number;
					B=0;
					b=0;
					for(j=0; j<i; j++) {
						b=Pop(OPND)-'0';
						B=b*pow(10,j)+B;
					}
					C=operate(B,M,A);
					D=C;
					E=0;
					do {
						E++;
						F[E]=D%10;
						D=D/10;
					} while(D!=0);
					for(j=E; j>0; j--) {
						Push(F[j]+'0',OPND,E);
					}
					TOP_2=OPTR->next;
					if(TOP_2->Data=='#') {
						Push(N,OPTR,1);
						i=1;
					} else {						//还有BUG
						W=Compare(TOP_2->Data,N);
						switch(W) {
							case'<': {
								Push(N,OPTR,1);
								break;
							}
							case'>': {
								M=Pop(OPTR);
								i=TOP_1->Number;
								A=0;
								a=0;
								for(j=0; j<i; j++) {
									a=Pop(OPND)-'0';
									A=a*pow(10,j)+A;
								}
								TOP_1=OPND->next;
								i=TOP_1->Number;
								B=0;
								b=0;
								for(j=0; j<i; j++) {
									b=Pop(OPND)-'0';
									B=b*pow(10,j)+B;
								}
								C=operate(B,M,A);
								D=C;
								E=0;
								do {
									E++;
									F[E]=D%10;
									D=D/10;
								} while(D!=0);
								for(j=E; j>0; j--) {
									Push(F[j]+'0',OPND,E);
								}
								TOP_2=OPTR->next;
								if(TOP_2->Data=='#') {
									Push(N,OPTR,1);
									i=1;
								} else {						//还有BUG
									W=Compare(TOP_2->Data,N);
									M=Pop(OPTR);
									i=TOP_1->Number;
									A=0;
									a=0;
									for(j=0; j<i; j++) {
										a=Pop(OPND)-'0';
										A=a*pow(10,j)+A;
									}
									TOP_1=OPND->next;
									i=TOP_1->Number;
									B=0;
									b=0;
									for(j=0; j<i; j++) {
										b=Pop(OPND)-'0';
										B=b*pow(10,j)+B;
									}
									C=operate(B,M,A);
									D=C;
									E=0;
									do {
										E++;
										F[E]=D%10;
										D=D/10;
									} while(D!=0);
									for(j=E; j>0; j--) {
										Push(F[j]+'0',OPND,E);
									}
									Push(N,OPTR,1);
								}
								break;
							}
							default:
								printf("error");
								break;
						}
						i=1;
					}
					break;
				}
				default:
					printf("error");
					break;
			}
		}
		TOP_1=OPND->next;
		TOP_2=OPTR->next;
		scanf("%c",&N);
	}
	TOP_1=OPND->next;
	M=Pop(OPTR);
	i=TOP_1->Number;
	A=0;
	a=0;
	for(j=0; j<i; j++) {
		a=Pop(OPND)-'0';
		A=a*pow(10,j)+A;
	}
	TOP_1=OPND->next;
	i=TOP_1->Number;
	B=0;
	b=0;
	for(j=0; j<i; j++) {
		b=Pop(OPND)-'0';
		B=b*pow(10,j)+B;
	}
	C=operate(B,M,A);
	D=C;
	E=0;
	do{
		E++;
		F[E]=D%10;
		D=D/10;
	} while(D!=0);
	for(j=E; j>0; j--) {
		Push(F[j]+'0',OPND,E);
	}
	TOP_2=OPTR->next;
	if(TOP_2->Data=='#') {
		return OPND;
	} else {
		W=Compare(TOP_2->Data,N);
		M=Pop(OPTR);
		i=TOP_1->Number;
		A=0;
		a=0;
		for(j=0; j<i; j++) {
			a=Pop(OPND)-'0';
			A=a*pow(10,j)+A;
		}
		TOP_1=OPND->next;
		i=TOP_1->Number;
		B=0;
		b=0;
		for(j=0; j<i; j++) {
			b=Pop(OPND)-'0';
			B=b*pow(10,j)+B;
		}
		C=operate(B,M,A);
		D=C;
		E=0;
		do {
			E++;
			F[E]=D%10;
			D=D/10;
		} while(D!=0);
		for(j=E; j>0; j--) {
			Push(F[j]+'0',OPND,E);
		}
		return OPND;
	}
}

int main() {
	int B=0,b,j,i;
	Stack OPTR,OPND,TOP_1;
	OPTR=CreateStack(OPTR);
	OPND=CreateStack(OPND);
	OPND=OP(OPTR,OPND);
	TOP_1=OPND->next;
	i=TOP_1->Number;
	for(j=0; j<i; j++) {
		b=Pop(OPND)-'0';
		B=b*pow(10,j)+B;
	}
	printf("%d",B);
	return 0;
}

运行结果：

 

赤昂DS
关注
  • 24
    点赞
  • 踩
  • 208
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
表达式求值(C语言栈实现)
11-07
表达式求值(C语言栈实现).已测试，没有任何错误和警告
c语言 实现二叉树操作 用栈实现算术表达式求值
11-09
在本课程设计中，主要涉及了两个核心主题...通过以上步骤，可以完成课程设计的要求，实现二叉树的构造与操作，以及算术表达式的中缀到后缀转换和求值。这些技能对于理解和应用数据结构，特别是C语言编程来说至关重要。
数据结构课程设计---------用栈来实现表达式求值
编程资料大全
08-12 1651
1、需求分析 设计一个程序，演示用算符优先法对算术表达式求值的过程。利用算符优先关系，实现对算术四则混合运算表达式的求值。 （1）输入的形式：表达式，例如2*(3+4) 包含的运算符只能有'+' 、'-' 、'*' 、'/' 、'('、 ')'； （2）输出的形式：运算结果，例如2*(3+4)=14； （3）程序所能达到的功能：对表达式求值并输出 2、系统设计 1、栈的抽象数据类型...
栈表达式求值（c语言数据结构）
awm123453的博客
05-10 3825
1、头文件 #include <iostream> #include <stdio.h> 2、定义常量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 #define OVERFLOW -2 3、个性化设置 using namespace std; typedef char SElemType; typedef int NElemType; typedef int St
栈实现算术表达式求值
hellolde的博客
07-17 9843
算术表达式求值 利用栈求解的一个典型的问题是算术表达式求值，例如：“3+4*2-(1+1)#”，这样的表达式计算，在计算过程中，不是读到一个运算就立即计算，而是要与后面的运算符进行优先级比较，以决定先算哪一个。 为解决问题，首先要进行一些约定。表达式由操作数、运算符和界限符组成。操作符和运算符是表达式的主要组成部分，界限符标志一个表达式的结束。表达式分为3类，及算术表达式、关系表达式、逻辑表达式这里只讨论算术表达式，并对表达式做如下简化： （1） ...
[源码和文档分享]C语言的基于栈实现的表达式求值
07-06 98
一、目的理解中缀表达式求值的过程理解中缀转后缀表达式求值的过程掌握堆栈的应用二、问题描述缀表达式，其中包含括号，加减乘除，乘方等运算，利用中缀表达式，对表达式分析并求值入的中缀表达式转换为后缀形式，显示后缀形式，并通过后缀形式求值 源码下载地址：https://www.write-bug.com/article/1409.html ...
算数表达式2_表达式二叉树_算数表达式求值_
10-03
这里，我们将深入探讨"算数表达式2_表达式二叉树_算数表达式求值_"这一主题，特别是通过二叉树结构来实现算术表达式的求值。 首先，我们需要理解什么是算数表达式。一个算数表达式通常包含数字、运算符（如加号"+...
算数表达式求值系统-c语言
最新发布
02-07
本程序由C语言的顺序栈进行编写，主要采用栈来实现在包含+、-、*、/运算符和 (、) 圆括号的表达式求值中常用的算法,中缀表达式求值的算法用C语言进行描述,在Visual C++6.0环境下实现。本程序由十一个函数模块来实现...
基于C++实现算数表达式求值(数据结构课设)【100012317】
05-22
在计算机科学领域，数据结构与算法是编程的基础，而算术表达式的求值则是其中一个重要且常见的任务。本文将深入探讨如何使用C++语言来实现一个算术表达式求值的程序，尤其针对数据结构课设中的算术表达式求值问题。 ...
数据结构栈实现表达式求值
01-12
### 数据结构栈实现表达式求值 #### 一、引言 在计算机科学领域，数据结构是存储和组织数据的一种特殊方式，它不仅能够提高算法的效率，还能够简化复杂问题的解决过程。栈是一种非常重要的线性数据结构，遵循后进先...
表达式求值（采用栈实现）
10-15
利用栈实现算术表达式的求值，表达式中可包含加+、减（负） -、乘*、除/、 乘方^、括号( )运算符，操作数可以为浮点数。 可采用直接求中缀表达式的方法， 也可采用先转换成后缀表达式后再求值的方法（参看课件） 。 实现时需注意如下： （ 1）带小数点的数值生成 （ 理解整数数值的生成，小数部分的处理与之类似）。 （ 2）考虑负号的情况。负号与减号形式上一样，如何区分？ • 输入的表达式串中第 1 个字符是’-’ – 可断定此’-’是负号 • 其余的’-’ – 若紧接在’(’之后的’-’可断定是负号 （ 3）负号的处理 • 方法 1：若已断定是负号，可先压入数值 0 进入操作数栈，如此，可 将负号看作减号。 • 方法 2： 若已断定是负号，则紧接其后的数字字符转换成数值后，要 将其对应的相反数(负数)压入操作数栈
栈实现表达式求值
12-27
栈实现表达式求值
C语言数据结构用栈实现表达式求值
10-26
C语言数据结构用栈实现表达式求值，全部工程代码。实现visual2010下运行
利用栈实现表达式求值
12-27
利用栈实现表达式求值，可以计算加减乘除。留出接口，可以扩展。
用栈实现表达式求值
ok0011的博客
06-16 1717
#include using namespace std; typedef double ElemType; #define maxsize 100 typedef struct SN { ElemType data[maxsize]; int top; } StackNode; StackNode StackInit() { StackNode s;
栈实现表达式求值（C语言）
热门推荐
2Know的博客
10-28 1万+
刚刚学习C语言的时候很多人就写过计算器，但是当时写的计算器只能进行一步四则运算；对于一次输入(1+2)*3+4这样的运算则没有办法计算。 本篇博文利用栈这种数据结构实现了支持带括号的表达式求值计算器；栈有栈底和栈顶指针，元素是先进后出；对于栈的操作最主要的是创建、压栈、弹栈；在实现计算器时，我们输入的表达式叫做中缀表达式，我们需要将其转为后缀表达式；然后利用后缀表达式求取表达式的值；
C语言-用栈实现表达式求值
m0_63223213的博客
07-02 1万+
为实现算符优先算法，可以使用两个工作栈。一个称做 OPTR，用以寄存运算符；另一个称做 OPND，用以寄存操作数或运
利用栈来实现算术表达式求值
u011256974的博客
12-02 6634
通过修改完善教材中的算法3.4，利用栈来实现算术表达式求值的算法。对算法3.4中调用的几个函数要给出其实现过程： (1) 函数In©：判断c是否为运算符； (2) 函数Precede(t1,t2)：判断运算符t1和t2的优先级； (3) 函数Operate(a,theta,b)：对a和b进行二元运算theta。 程序运行时，输入合法的算术表达式（中间值及最终结果要在0～9之间，可以包括加减乘除和括号） #include<stdio.h> #include<string.h> #inc
C语言栈实现算数表达式求值代码
05-04
下面是一个基于C语言栈实现算数表达式求值的代码示例： ```c #include #include #define MAX_SIZE 100 // 定义栈的数据结构 typedef struct Stack { int top; // 栈顶指针 int data[MAX_SIZE]; // 存储数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值