将浮点型算式的中缀表达式转换成后缀表达式并算出式子结果

最新推荐文章于 2023-09-29 22:08:16 发布
最新推荐文章于 2023-09-29 22:08:16 发布
阅读量2.3k 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013457382/article/details/48193549
版权

最近因为需要了解如何将在Win应用程序控制台输入的算式表达式转化成其后缀表达式的算法，所以在网上搜索了一下，看到许多人的程序都只是对应于运算数在0~9的范围内的整型运算式，所以自己就写了一个可以计算浮点型算式的程序，一下是运行时的截图：


式子中的a,b,c是可供用户自行输入的变量。

首先，我先对输入的运算符进行了简单的合法性判断，我的判断代 码如下：


//函数的传入参数为一个字符型数组，该数组存放的是用户输入的表达式，还有一个引用传递的数组下标值  



bool IsValid(char exp[],int& position){
	
	bool flag=false;
	for(position;position<100;position++){
		if(exp[position]=='\0'){
			if(!(exp[0]=='(')&&!isdigit(exp[0])&&!(exp[0]=='a')&&!(exp[0]=='b')&&!(exp[0]=='c')){								//判断表达式是否以+，-，*，/等运算符开头，如是，则表达式不合格
				cout<<"the expression can not end of operator"<<endl;
				return false;
			}
			if(!(exp[position-1]==')')&&!isdigit(exp[position-1])&&!(exp[position-1]=='a')&&!(exp[position-1]=='c')&&!(exp[position-1]=='b')){
				cout<<"the expression can not end of operator"<<endl;			//判断表达式是否以+，-，*，/等运算符结尾，如是，则表达式不合格
				return false;
			}
			break;
		}else{
			if (!isdigit(exp[position]))
			{
				if (exp[position]=='(')
				{
					operatorstack.push(exp[position]);


				}else{
					if(exp[position]==')'){
						if (operatorstack.empty())
						{
							cout<<"the expression is unvalid!"<<endl;			//若表达式有多余的"(",")"，则不合格
							return false;
						}else{
							operatorstack.pop();
						}
					}else{
						if (exp[position]=='a'||exp[position]=='b'||exp[position]=='c')
						{
							continue;
						}
						if(exp[position-1]=='+'||exp[position-1]=='-'||exp[position-1]=='*'||exp[position-1]=='^'
							||exp[position-1]=='/'||exp[position-1]=='%'||exp[position-1]=='&'
							||exp[position-1]=='|'||exp[position-1]=='>'||exp[position-1]=='<'){
							cout<<"the expression can not contain two continuous operators"<<endl;			//若表达式中有两个以上的+，-，*，/等运算符出现，则不合格
							return false;
						}
						continue;
					}
				}
			}
		}
	}
	cout<<"the expression is valid!"<<endl;
	return true;
}
上面我给出的例子的判断合法性输出为：



初步判断完算式的合法性之后，就进行后缀表达式的输出，我的程序思想是取决于我式子存放的数据类型的，我是将算式存放在一个char型的数组内，所以在输出后缀表达式的时候我就利用了这个存放格式的特点，我的函数In2Pos(char exp[],int& position ,char* tmp)有三个参数，第一个为存放算式的数组，第二个为引用参数，作为数组开始检查的其实位置，第三个参数为存放后缀表达式的char数组：


1，首先，判断是否为算式末尾的回车换行符'\0'，若是，则说明已经到了算式的结尾，将操作符栈的操作符都存放到后缀表达式的数组中，退出程序，否则进行下面的判断，

2，判断当前字符是否为数字，或小数点，或用户赋值的变量a,b,,c,若是则存放到后缀表达式的数组中，若不是这进行第3步判断

3，栈为空时，遇到运算符，直接入栈
4，遇到左括号：将其入栈
5，遇到右括号：执行出栈操作，并将出栈的元素存放到后缀表达式的数组中，直到弹出栈的是左括号，左括号不存放到后缀表达式      的数组中。
6，遇到其他运算符：加减乘除等，弹出所有优先级大于或者等于该运算符的栈顶元素，并将出栈的元素存放到后缀表达式的数组        中，然后将该运算符入栈

7，最后回到第1步


一下是我的代码实现：


void In2Pos(char exp[],int& position ,char* tmp){
	 
	int i=0,j;
	for (j=0;j<100;j++)
	{
		tmp[j]='e';
	}
	stack<char> ope;
	for (position;position<100;position++)
	{
		if (exp[position]=='\0')
		{
			while (!ope.empty())
			{
				char exchange;
				exchange=ope.top();
				ope.pop();
				tmp[i++]=exchange;
			}
			
			return ;
		}else{
			if (isdigit(exp[position])||exp[position]=='.'||exp[position]=='a'||exp[position]=='b'||exp[position]=='c')
			{
				tmp[i++]=exp[position];
			}else{
				if (ope.empty())
				{
					ope.push(exp[position]);
				}else{
					if (judge(ope.top(),exp[position]))
					{


						while (!ope.empty()&&judge(ope.top(),exp[position]))
						{
							 
								if (exp[position]==')')
								{
									while(ope.top()!='(')
									{
										tmp[i++]=ope.top();
										ope.pop();
									}
									ope.pop();
									 
									break;
								}else{
									tmp[i++]=ope.top();
									ope.pop();
								}
							
							}
						  if (exp[position]!=')')
						  {
							  ope.push(exp[position]);
						  }
					}else{
						 
						ope.push(exp[position]);
						
					}
					
				}
			}
		}
	}
	return ;
}


以下是后缀表达式的输出：



接下来就是计算算式的值了，我的思想是：

1，首先，判断是否为算式末尾的回车换行符'\0'，若是，则说明已经到了算式的结尾，则将结果sum返回，如不是则接下去判断，

2，先判断字符是否为数字，若是，则不断地从该字符往后检测是否为数字知道遇到下一个运算符，期间将数字的整数部分和小数部分计算出来，然后相加起来，压入数字栈中，如果不是数字则接下去判断，

3，如果是用户赋值的变量，则将对应的数值压入数字栈中，

4，若是运算符，运算符栈为空时，遇到运算符，直接入栈
5，遇到左括号：将其入栈
6，遇到右括号：执行出栈操作，并将出栈的元素输出赋值给operator1，然后弹出数字栈的两个数值进行运算，在将运算结果压入数字栈，然后循环，直到弹出栈的是左括号，左括号直接弹出。
7，遇到其他运算符：加减乘除：弹出所有优先级大于或者等于该运算符的栈顶元素，并将出栈的元素输出赋值给operator1，然后弹出数字栈的两个数值进行运算，在将运算结果压入数字栈，然后将该运算符入栈

8，最后到了结尾，返回1


计算程序的代码为：


float Evaluate(char exp[],int& position){
	int j;
	float sum=0,tmp1=0,tmp2=0,tmp3=0;
	float firstnum,lastnum;
	char operator1;
	stack<float> num; <span style="white-space:pre">					</span>//数字栈
	stack<char> ope;<span style="white-space:pre">					</span>//运算符栈
	while(true){
		if (exp[position]=='\0')
		{
			while (!ope.empty())
			{
				operator1=ope.top();
				ope.pop();
				lastnum=num.top();
				num.pop();
				firstnum=num.top();
				num.pop();
				tmp3=count(firstnum,lastnum,operator1);
				num.push(tmp3);
			}
			sum=num.top();
			return sum;
		}else{
			if (isdigit(exp[position])||exp[position]=='.')
			{
				while (isdigit(exp[position])||exp[position]=='.')
				{
					if (exp[position]=='.')
					{
						position++;
						int point=0;
						float pnum=0;
						while(isdigit(exp[position])){
							point++;
							pnum=(float)(exp[position]-48);
							for (j=0;j<point;j++)
							{
								pnum=pnum/10;
							}
							tmp2+=pnum;
							position++;
						}
					}else{
						tmp1=tmp1*10+(int)(exp[position]-48);
						position++;
					}
				}
				tmp1=tmp1+tmp2;
				num.push(tmp1);
				tmp1=0;tmp2=0;
			}else if(exp[position]=='a'){
				num.push(a);
				position++;
			}else if(exp[position]=='b'){
				num.push(b);
				position++;
			}else if(exp[position]=='c'){
				num.push(c);
				position++;
			}else{
				if (ope.empty())
				{
					ope.push(exp[position]);
					position++;
				}else{
					if (judge(ope.top(),exp[position]))
					{


						while (!ope.empty()&&judge(ope.top(),exp[position]))
						{
							//cout<<"end"<<endl;
								if (exp[position]==')')
								{
									while(ope.top()!='(')
									{
									//	tmp[i++]=ope.top();
										operator1=ope.top();
										lastnum=num.top();
										num.pop();
										firstnum=num.top();
										num.pop();
										tmp3=count(firstnum,lastnum,operator1);
										ope.pop();


										num.push(tmp3);
									}
									ope.pop();
									//cout<<"end"<<endl;
									break;
								}else{
								//	tmp[i++]=ope.top();
									operator1=ope.top();
										lastnum=num.top();
										num.pop();
										firstnum=num.top();
										num.pop();
										tmp3=count(firstnum,lastnum,operator1);
										ope.pop();


										num.push(tmp3);
								}
							
						}
						  if (exp[position]!=')')
						  {
							  ope.push(exp[position]);
						  }
						  position++;
					}else{
						 
						ope.push(exp[position]);
						position++;
					}
					
				}
			}
			
		}
	}
	return sum;
}

以下是main函数： 



<span style="font-size:14px;">// Expression.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <cassert>
#include <math.h>
#include<stack>
using  namespace std;


 
float a,b,c;<span style="white-space:pre">				</span>//全局变量a,b,c
 


bool IsValid(char exp[],int& position){
	 
	bool flag=false;
	for(position;position<100;position++){
		if(exp[position]=='\0'){
			if(!(exp[0]=='(')&&!isdigit(exp[0])&&!(exp[0]=='a')&&!(exp[0]=='b')&&!(exp[0]=='c')){								//判断表达式是否以+，-，*，/等运算符开头，如是，则表达式不合格
				cout<<"the expression can not end of operator"<<endl;
				return false;
			}
			if(!(exp[position-1]==')')&&!isdigit(exp[position-1])&&!(exp[position-1]=='a')&&!(exp[position-1]=='c')&&!(exp[position-1]=='b')){
				cout<<"the expression can not end of operator"<<endl;			//判断表达式是否以+，-，*，/等运算符结尾，如是，则表达式不合格
				return false;
			}
			break;
		}else{
			if (!isdigit(exp[position]))
			{
				if (exp[position]=='(')
				{
					operatorstack.push(exp[position]);

				}else{
					if(exp[position]==')'){
						if (operatorstack.empty())
						{
							cout<<"the expression is unvalid!"<<endl;			//若表达式有多余的"(",")"，则不合格
							return false;
						}else{
							operatorstack.pop();
						}
					}else{
						if (exp[position]=='a'||exp[position]=='b'||exp[position]=='c')
						{
							continue;
						}
						if(exp[position-1]=='+'||exp[position-1]=='-'||exp[position-1]=='*'||exp[position-1]=='^'
							||exp[position-1]=='/'||exp[position-1]=='%'||exp[position-1]=='&'
							||exp[position-1]=='|'||exp[position-1]=='>'||exp[position-1]=='<'){
							cout<<"the expression can not contain two continuous operators"<<endl;			//若表达式中有两个以上的+，-，*，/等运算符出现，则不合格
							return false;
						}
						continue;
					}
				}
			}
		}
	}
	cout<<"the expression is valid!"<<endl;
	return true;
}

int judge(char op1,char op2){
	if (op2=='(')
	{
		return 0;
	}
	if (op2==')')
	{
		return 1;
	}
	if (op2=='+'||op2=='-')
	{
		switch (op1)
		{
		case '+':
		case '-':
		case '(':
			return 0;
			break;
		case '*':
		case '/':
		case '^':
			return 1;
			break;
		}
	}
	if (op2=='*'||op2=='/')
	{
		switch (op1)
		{
		case '+':
		case '-':
		case '(':
		case '*':
		case '/':
			return 0;
			break;
		
		case '^':
			return 1;
			break;
		}
	}
	if (op2=='^')
	{
		switch (op1)
		{
		case '+':
		case '-':
		case '(':
		case '*':
		case '/':
		case '^':
			return 0;
			break;
		}
	}
}

void In2Pos(char exp[],int& position ,char* tmp){
	 
	int i=0,j;
	for (j=0;j<100;j++)
	{
		tmp[j]='e';
	}
	stack<char> ope;
	for (position;position<100;position++)
	{
		if (exp[position]=='\0')
		{
			while (!ope.empty())
			{
				char exchange;
				exchange=ope.top();
				ope.pop();
				tmp[i++]=exchange;
			}
			
			return ;
		}else{
			if (isdigit(exp[position])||exp[position]=='.'||exp[position]=='a'||exp[position]=='b'||exp[position]=='c')
			{
				tmp[i++]=exp[position];
			}else{
				if (ope.empty())
				{
					ope.push(exp[position]);
				}else{
					if (judge(ope.top(),exp[position]))
					{

						while (!ope.empty()&&judge(ope.top(),exp[position]))
						{
							//cout<<"end"<<endl;
								if (exp[position]==')')
								{
									while(ope.top()!='(')
									{
										tmp[i++]=ope.top();
										ope.pop();
									}
									ope.pop();
									//cout<<"end"<<endl;
									break;
								}else{
									tmp[i++]=ope.top();
									ope.pop();
								}
							
							}
						  if (exp[position]!=')')
						  {
							  ope.push(exp[position]);
						  }
					}else{
						 
						ope.push(exp[position]);
						
					}
					
				}
			}
		}
	}
	return ;
}

float count(float first,float last,char ope){
	float cot;
	switch (ope)
	{
	case '+':
		cot=first+last;
		break;
	case '-':
		cot=first-last;
		break;
	case '*':
		cot=first*last;
		break;
	case '/':
		cot=first/last;
		break;
	case '^':
		cot=pow(first,last);
		break;
	}
	return cot;
}
float Evaluate(char exp[],int& position){
	int j;
	float sum=0,tmp1=0,tmp2=0,tmp3=0;
	float firstnum,lastnum;
	char operator1;
	stack<float> num;
	stack<char> ope;
	while(true){
		if (exp[position]=='\0')
		{
			while (!ope.empty())
			{
				operator1=ope.top();
				ope.pop();
				lastnum=num.top();
				num.pop();
				firstnum=num.top();
				num.pop();
				tmp3=count(firstnum,lastnum,operator1);
				num.push(tmp3);
			}
			sum=num.top();
			return sum;
		}else{
			if (isdigit(exp[position])||exp[position]=='.')
			{
				while (isdigit(exp[position])||exp[position]=='.')
				{
					if (exp[position]=='.')
					{
						position++;
						int point=0;
						float pnum=0;
						while(isdigit(exp[position])){
							point++;
							pnum=(float)(exp[position]-48);
							for (j=0;j<point;j++)
							{
								pnum=pnum/10;
							}
							tmp2+=pnum;
							position++;
						}
					}else{
						tmp1=tmp1*10+(int)(exp[position]-48);
						position++;
					}
				}
				tmp1=tmp1+tmp2;
				num.push(tmp1);
				tmp1=0;tmp2=0;
			}else if(exp[position]=='a'){
				num.push(a);
				position++;
			}else if(exp[position]=='b'){
				num.push(b);
				position++;
			}else if(exp[position]=='c'){
				num.push(c);
				position++;
			}else{
				if (ope.empty())
				{
					ope.push(exp[position]);
					position++;
				}else{
					if (judge(ope.top(),exp[position]))
					{

						while (!ope.empty()&&judge(ope.top(),exp[position]))
						{
							//cout<<"end"<<endl;
								if (exp[position]==')')
								{
									while(ope.top()!='(')
									{
									//	tmp[i++]=ope.top();
										operator1=ope.top();
										lastnum=num.top();
										num.pop();
										firstnum=num.top();
										num.pop();
										tmp3=count(firstnum,lastnum,operator1);
										ope.pop();

										num.push(tmp3);
									}
									ope.pop();
									//cout<<"end"<<endl;
									break;
								}else{
								//	tmp[i++]=ope.top();
									operator1=ope.top();
										lastnum=num.top();
										num.pop();
										firstnum=num.top();
										num.pop();
										tmp3=count(firstnum,lastnum,operator1);
										ope.pop();

										num.push(tmp3);
								}
							
						}
						  if (exp[position]!=')')
						  {
							  ope.push(exp[position]);
						  }
						  position++;
					}else{
						 
						ope.push(exp[position]);
						position++;
					}
					
				}
			}
			
		}
	}
	return sum;
}
 
int main(){
	cout<<"My procedure can calculate integer type and float-point type equation."<<endl;
	cout<<"welcome to operate my procedure."<<endl;
	cout<<"please input the value of a,b,c:"<<endl;
	cin>>a>>b>>c;
	cout<<"your input is \na="<<a<<"\nb="<<b<<"\nc="<<c<<endl;
	
	cin.ignore();
	int position=0;
	char expression[100];
	cout<<"please input your expression"<<endl;
	cin.getline(expression,100);
 
	IsValid(expression,position);
	cout<<endl;
 	position=0;
 	
	char t[100];
	
	In2Pos(expression,position,t);
	cout<<"the postfix expression of this expression is:"<<endl;
	int i=0;
	while(t[i]!='e'){
	
	cout<<(char)t[i];
		i++;
	}
	cout<<endl;
	cout<<endl;
	position=0;
	cout<<"the answer of the expression is :"<<endl;
	cout<<Evaluate(expression,position)<<endl;
	cout<<endl;
	cout<<"thanks for operating my procedure."<<endl;
	return 0;

}
</span>

我要天天向上
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构里的中缀转后缀，可以输出后缀表达式，如操作数是浮点数，可以计算表达式的值
12-20
数据结构里的中缀转后缀，可以输出后缀表达式，如操作数是浮点数，可以计算表达式的值
栈应用（中缀表达式转后缀表达式并计算后缀表达式的值）
PacosonSWJTU的博客
10-18 2369
【0】README0.1） 本文旨在总结 中缀表达式转后缀表达式并计算后缀表达式的值 的步骤，并给出源代码实现；【1】中缀到后缀的转换1.1）此方法需要遵循几个规则（Rule）： R1）如果读入操作数，则直接放入输出字符串； R2）如果读入一般运算符如+-*/，则放入堆栈，但是放入堆栈之前必须要检查栈顶，并确定栈顶运算符的优先级比放入的运算符的优先级低；如果放入的优先级较低或两者相等的话，则需要将栈
中缀表达式转换成后缀表达式，进行简单表达式的计算
LITTENg的博客
03-06 562
分析： 步骤一：中缀表达式转换为后缀表达式 设立一个操作符栈，用来临时存放操作符；设置一个队列用以存放后缀表达式序列。 从左至右遍历中缀表达式，如果遇到操作数（需要注意的是操作数可能不止一位，因此需要一位位的读入然后合并成整数）就将其加入到后缀序列中。 如果遇到操作符，如果是左括号‘（’就直接压入栈中，如果是右括号‘）’就依次弹出栈中元素直至左括号出现。否则将其与栈顶元素比较优先...
C/C++ 算法 中缀转后缀表达式实现3---实现加减乘除四则算数（包括浮点数运算，包括括号）
热门推荐
徐麻子的专栏
08-25 1万+
C/C++ 算法 中缀转后缀表达式实现3---实现浮点数加减乘除四则算数（包括括号） 如：输入：12.2/2+(10+4)/7+2.5*2.5-1，输出：13.35 代码如下： #include #include using namespace std; bool isoperator(char ch); int priority(char ch); void infix_to_postf
java 中缀表达式转后缀表达式并计算结果
dsczxcc的博客
07-25 229
实现代码如下，已有详细注释，后续再补概念。 package infix_to_suffix; import com.sun.istack.internal.NotNull; import com.sun.tools.javac.util.StringUtils; import java.util.ArrayList; import java.util.Iterator; import jav...
自定义栈中缀表达式转换为后缀表达式并求值
05-20
自定义栈，中缀表达式转换为后缀表达式并求值，三个抽象数据类型定义（1.class stack 2.class Middle_expressionToPost_expression 3.class Post_expression_value）
中缀表达式转换为后缀表达式（oj题库）
12-21
中缀表达式转换为后缀表达式是一种常见的编程问题，主要应用于计算机算法解析和计算领域。后缀表达式，也称为逆波兰表示法，是一种没有括号的表达方式，运算符位于其操作数之后，这使得计算过程更为简单，因为不需要...
中缀表达式转换为后缀表达式及逆波兰式求值
01-10
在这个程序中，还实现了前缀表达式转换为后缀表达式，前缀表达式与中缀表达式类似，只是运算符位于操作数之前，如 `+ 2 3`。转换过程与中缀转后缀类似，只是在比较运算符优先级时需反向处理。 此外，程序支持了加、...
C语言实现中缀表达式转换为后缀表达式
08-19
中缀表达式转换为后缀表达式是计算机科学中一个非常重要的概念，它是一种将中缀表达式转换为后缀表达式的算法。中缀表达式是一种常见的表达式形式，它的运算符位于操作数之间，而后缀表达式则是将运算符置于操作数...
将中缀表达式转换为后缀表达式并计算.doc
10-08
将中缀表达式转换为后缀表达式并计算 本文档主要讨论如何将中缀表达式转换为后缀表达式，并计算表达式的值。通过使用栈的操作，实现了中缀表达式到后缀表达式的转换，并计算表达式的值。 一、需求分析 在该实验中...
Java 中缀表达转后缀表达式（多位数，带计算）
05-23
中缀表达式转后缀表达式，java版本。可以进行多位数计算的
中缀表达式转成后缀表达式并输出计算结果
11-22
用户输入中缀表达式，程序输出后缀表达式并输出计算结果
求后缀表达式(可用于浮点型）
jxnczyp的专栏
06-02 631
#include#include#includetypedef struct stack_num{  double num;  struct stack_num *next;}stack_num_node,*stack_num_link;typedef struct stack_char{  char ch;  struct stack_char *next;}stack_char_node,*s
Java review(8) 进制和浮点数的后缀
衡与墨的博客
11-28 327
十六进制以0X开头，八进制以0开头，使用Integer对应的方法可以将数转换为不同进制的字符串输出 @Test public void test2() throws Exception { int i = 0x123; System.out.println("十六进制：" + i + "：" + Integer.toHexString(i)); ...
常浮点数赋值时加 “f” 后缀与不加的区别
qq_43499599的博客
07-15 8938
例： float a = 1.5; float b = 1.5f; 常浮点数默认是double型的，当1.5赋值给a时，存在（double）1.5 --> float a的强制转换，当数据较小时，结果一般不会出现错误，当数据较大时，若将右值赋值给左值时产生溢出，结果就会出现非预期值，所以在书写时，最好在常量的末尾加后缀进行严格的限制。 ...
解释C语言中 6.18f (浮点数常量后缀)
Han同学
09-29 698
解释C语言中浮点型常量后缀含义。
中缀表达式转后缀表达式_求表达式的值
gu_solo的博客
09-11 1169
中缀转后缀需要遵守以下规则 1、操作数：直接输出 2、“（”：直接入栈 3、“）”：”将“（”以前的直接输出，并将“)”出栈(不输出) 4、运算符+-*/：将优先级不小于该运算符的操作符出栈，最后将该运算符入栈 5、最后将栈中的元素依次弹出 6、优先级*/大于+-大于()class InToSuf { public List<String> solve(String[] op)/
数据结构预算法分析计算后缀表达式（可计算小数）
qq_28161649的博客
11-15 970
/*计算后缀表达式（加强版），可运算‘+ - * /’可以多位数并且可以带小数进行运算，两个运算数据之间用空格隔开，如：1.1 2.2+  遇到#符号，运算结束 打印运算结果*/ //头文件 #ifndef _Three19a_H typedef struct Node *PtrToNode; typedef PtrToNode Stack; typedef PtrToNode Posi
中缀表达式转后缀表达式 求值
zhougb3的博客
09-30 296
中缀表达式 后缀表达式
中缀表达式转换成后缀表达式
最新发布
11-03
中缀表达式转换成后缀表达式是一种将中缀表达式转换为后缀表达式的算法后缀表达式也称为逆波兰表达式，它是一种不含括号的表达式，操作符位于操作数之后。中缀表达式转换成后缀表达式的过程中，需要使用栈来保存操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值