Java 四则运算表达式求解
2014-05-08 09:06
369 查看
说明:次函数传入参数只有一个就是expression——你要计算的表达式,返回类型为String,有两种情况,一是返回正确结果,二是返回错误信息。此函数只能处理普通的四则运算表达式,含有平方,开方或者其他运算符本函数处理不了。
例如:10+2*5,2.5*4+(3+2)等等都可以处理
全部代码如下:(没有封装成类了,要用的可以直接将此段代码拷贝至自己的代码中,然后调用suffix_expression函数即可)
[java] view
plaincopy
private String suffix_expression(String expression)//中缀表达式转换后缀表达式(逆波兰式)
{
//Stack<Double> s2=new Stack<Double>();//存放数字栈
Stack<Object> s3=new Stack<Object>();//存放结果栈
Stack<Character> s4=new Stack<Character>();//存放操作符栈
int len=expression.length();//
char c1;
double number;
int m,n=-1;
for(int i=0;i<len;i++)
{
c1=expression.charAt(i);
if(isOprator(c1)||(i==len-1))//如果是运算符,将前面的数数字入s3栈,操作符入s4栈
{
if(i==len-1&&(!isOprator(c1)))//当最后一位且不是操作符时,将前面的数压栈
m=i+1;
else
m=i;
//操作数入栈,向前遍历到下一个运算符,将中间的字符串转化为double
for(int j=i-1;j>=0;j--)
{
if(isOprator(expression.charAt(j)))
{
n=j;
break;
}
n=j-1;
}
if(m!=n+1)//只有当这两个值不等时中间才会有操作数
{
number=Double.parseDouble(expression.substring(n+1,m));
s3.push(number);
}
//运算符入栈
if(i==0&&(c1!='('))//当表达式第一个字符就为运算符且不是左括号时,返回表达式错误
{
return "表达式错误!";
}
else if(isOprator(c1))//且是操作符时
{
while(true)
{
if(s4.isEmpty()||s4.peek()=='('||c1=='(')//如果栈为空或者栈顶元素为(或者c1为(时,则直接将运算符压入栈内
{
s4.push(c1);
break;
}
else if(c1==')')//当c1为)时,依次弹出s4中的运算符并压入s3,直到(,舍弃这一对括号
{
while(s4.peek()!='(')
{
s3.push(s4.pop());
if(s4.isEmpty())//弹出所有不为左括号之后堆栈为空,则表达式不合法
{
return "缺少左括号";
}
}
s4.pop();//弹出(
break;
}
else
{
if(priorityCompare(c1,s4.peek())==1)//判断优先级,优先级高入栈,优先级低将栈顶运算符压入s3
{
s4.push(c1);
break;
}
else
{
s3.push(s4.pop());
}
}
}
}
}
else
continue;
}
while(!s4.isEmpty())//表达式结束后,依次将s4剩下的运算符压入s3
{
if((char)s4.peek()=='(')
return "缺少右括号";
s3.push(s4.pop());
}
return count_result(s3);
}
private int priorityCompare(char c1,char c2)
{
switch(c1)
{
case '+':
case '-':
return (c2 == '*' || c2 == '/' ? -1 : 0);
case '*':
case '/':
return (c2 == '+' || c2 == '-' ? 1 : 0);
}
return 1;
}
//判断字符是否为运算符,是为真,不是为假
private boolean isOprator(Object c) {
// TODO Auto-generated method stub
try
{
char c1=(char)c;
if(c1=='+'||c1=='-'||c1=='*'||c1=='/'||c1=='('||c1==')')
return true;
}
catch (Exception e) {
// TODO: handle exception
return false;
}
return false;
}
private String count_result(Stack<Object> ob) {
// TODO Auto-generated method stub
Stack<Object> s1=new Stack<Object>();//后缀表达式栈
Stack<Double> s2=new Stack<Double>();//操作数栈
//char c1;
// Stack<Character> s3=new Stack<Character>();//操作符栈
while(!ob.isEmpty())//将传入的栈逆序压入
{
s1.push(ob.pop());
}
while(!s1.isEmpty())
{
if(!isOprator(s1.peek()))//遇到非操作符,压入s2栈
{
s2.push((Double)s1.pop());
}
else
{
s2.push(cout(s2.pop(),s2.pop(),(char)s1.pop()));
}
}
return Double.toString(s2.peek());
}
private Double cout(double s1,double s2,char s3)
{
double result=0;
switch(s3)
{
case '+':
result=s1+s2;
break;
case '-':
result=s1-s2;
break;
case '*':
result=s1*s2;
break;
case '/':
result=s1/s2;
break;
}
return result;
}
代码全部在上面,只有一个Public函数够调用者访问,其余函数全为Private。
1.中缀表达式转化为后缀表达式
(1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2;
(2) 从左至右扫描中缀表达式;
(3) 遇到操作数时,将其压入S2;
(4) 遇到运算符时,比较其与S1栈顶运算符的优先级:
(4-1) 如果S1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
(4-2) 否则,若优先级比栈顶运算符的高,也将运算符压入S1(注意转换为前缀表达式时是优先级较高或相同,而这里则不包括相同的情况);
(4-3) 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较;
(5) 遇到括号时:
(5-1) 如果是左括号“(”,则直接压入S1;
(5-2) 如果是右括号“)”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到左括号为止,此时将这一对括号丢弃;
(6) 重复步骤(2)至(5),直到表达式的最右边;
(7) 将S1中剩余的运算符依次弹出并压入S2;
(8) 依次弹出S2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式(转换为前缀表达式时不用逆序)。
例如,将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下:
因此结果为“1 2 3 + 4 × + 5 -”(注意需要逆序输出)。
2.计算后缀表达式
从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 op 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果。
例如后缀表达式“3 4 + 5 × 6 -”:
(1) 从左至右扫描,将3和4压入堆栈;
(2) 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素,注意与前缀表达式做比较),计算出3+4的值,得7,再将7入栈;
(3) 将5入栈;
(4) 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
(5) 将6入栈;
(6) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。
备注:
本博文代码基本参考如上算法所写,大家当作学习下吧,因为还未测试完全,大家在调用时如果发现Bug,请留言告知,不胜感激。
例如:10+2*5,2.5*4+(3+2)等等都可以处理
全部代码如下:(没有封装成类了,要用的可以直接将此段代码拷贝至自己的代码中,然后调用suffix_expression函数即可)
[java] view
plaincopy
private String suffix_expression(String expression)//中缀表达式转换后缀表达式(逆波兰式)
{
//Stack<Double> s2=new Stack<Double>();//存放数字栈
Stack<Object> s3=new Stack<Object>();//存放结果栈
Stack<Character> s4=new Stack<Character>();//存放操作符栈
int len=expression.length();//
char c1;
double number;
int m,n=-1;
for(int i=0;i<len;i++)
{
c1=expression.charAt(i);
if(isOprator(c1)||(i==len-1))//如果是运算符,将前面的数数字入s3栈,操作符入s4栈
{
if(i==len-1&&(!isOprator(c1)))//当最后一位且不是操作符时,将前面的数压栈
m=i+1;
else
m=i;
//操作数入栈,向前遍历到下一个运算符,将中间的字符串转化为double
for(int j=i-1;j>=0;j--)
{
if(isOprator(expression.charAt(j)))
{
n=j;
break;
}
n=j-1;
}
if(m!=n+1)//只有当这两个值不等时中间才会有操作数
{
number=Double.parseDouble(expression.substring(n+1,m));
s3.push(number);
}
//运算符入栈
if(i==0&&(c1!='('))//当表达式第一个字符就为运算符且不是左括号时,返回表达式错误
{
return "表达式错误!";
}
else if(isOprator(c1))//且是操作符时
{
while(true)
{
if(s4.isEmpty()||s4.peek()=='('||c1=='(')//如果栈为空或者栈顶元素为(或者c1为(时,则直接将运算符压入栈内
{
s4.push(c1);
break;
}
else if(c1==')')//当c1为)时,依次弹出s4中的运算符并压入s3,直到(,舍弃这一对括号
{
while(s4.peek()!='(')
{
s3.push(s4.pop());
if(s4.isEmpty())//弹出所有不为左括号之后堆栈为空,则表达式不合法
{
return "缺少左括号";
}
}
s4.pop();//弹出(
break;
}
else
{
if(priorityCompare(c1,s4.peek())==1)//判断优先级,优先级高入栈,优先级低将栈顶运算符压入s3
{
s4.push(c1);
break;
}
else
{
s3.push(s4.pop());
}
}
}
}
}
else
continue;
}
while(!s4.isEmpty())//表达式结束后,依次将s4剩下的运算符压入s3
{
if((char)s4.peek()=='(')
return "缺少右括号";
s3.push(s4.pop());
}
return count_result(s3);
}
private int priorityCompare(char c1,char c2)
{
switch(c1)
{
case '+':
case '-':
return (c2 == '*' || c2 == '/' ? -1 : 0);
case '*':
case '/':
return (c2 == '+' || c2 == '-' ? 1 : 0);
}
return 1;
}
//判断字符是否为运算符,是为真,不是为假
private boolean isOprator(Object c) {
// TODO Auto-generated method stub
try
{
char c1=(char)c;
if(c1=='+'||c1=='-'||c1=='*'||c1=='/'||c1=='('||c1==')')
return true;
}
catch (Exception e) {
// TODO: handle exception
return false;
}
return false;
}
private String count_result(Stack<Object> ob) {
// TODO Auto-generated method stub
Stack<Object> s1=new Stack<Object>();//后缀表达式栈
Stack<Double> s2=new Stack<Double>();//操作数栈
//char c1;
// Stack<Character> s3=new Stack<Character>();//操作符栈
while(!ob.isEmpty())//将传入的栈逆序压入
{
s1.push(ob.pop());
}
while(!s1.isEmpty())
{
if(!isOprator(s1.peek()))//遇到非操作符,压入s2栈
{
s2.push((Double)s1.pop());
}
else
{
s2.push(cout(s2.pop(),s2.pop(),(char)s1.pop()));
}
}
return Double.toString(s2.peek());
}
private Double cout(double s1,double s2,char s3)
{
double result=0;
switch(s3)
{
case '+':
result=s1+s2;
break;
case '-':
result=s1-s2;
break;
case '*':
result=s1*s2;
break;
case '/':
result=s1/s2;
break;
}
return result;
}
代码全部在上面,只有一个Public函数够调用者访问,其余函数全为Private。
实现思路
采用将中缀表达式先转换成后缀表达式,然后再用基本的表达式求法对简化后的表达式求解(具体中缀表达式和后缀表达式的区别请参见博客http://blog.csdn.net/antineutrino/article/details/6763722,在此要感谢该博客博主。)1.中缀表达式转化为后缀表达式
(1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2;
(2) 从左至右扫描中缀表达式;
(3) 遇到操作数时,将其压入S2;
(4) 遇到运算符时,比较其与S1栈顶运算符的优先级:
(4-1) 如果S1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
(4-2) 否则,若优先级比栈顶运算符的高,也将运算符压入S1(注意转换为前缀表达式时是优先级较高或相同,而这里则不包括相同的情况);
(4-3) 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较;
(5) 遇到括号时:
(5-1) 如果是左括号“(”,则直接压入S1;
(5-2) 如果是右括号“)”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到左括号为止,此时将这一对括号丢弃;
(6) 重复步骤(2)至(5),直到表达式的最右边;
(7) 将S1中剩余的运算符依次弹出并压入S2;
(8) 依次弹出S2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式(转换为前缀表达式时不用逆序)。
例如,将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下:
扫描到的元素 | S2(栈底->栈顶) | S1 (栈底->栈顶) | 说明 |
1 | 1 | 空 | 数字,直接入栈 |
+ | 1 | + | S1为空,运算符直接入栈 |
( | 1 | + ( | 左括号,直接入栈 |
( | 1 | + ( ( | 同上 |
2 | 1 2 | + ( ( | 数字 |
+ | 1 2 | + ( ( + | S1栈顶为左括号,运算符直接入栈 |
3 | 1 2 3 | + ( ( + | 数字 |
) | 1 2 3 + | + ( | 右括号,弹出运算符直至遇到左括号 |
× | 1 2 3 + | + ( × | S1栈顶为左括号,运算符直接入栈 |
4 | 1 2 3 + 4 | + ( × | 数字 |
) | 1 2 3 + 4 × | + | 右括号,弹出运算符直至遇到左括号 |
- | 1 2 3 + 4 × + | - | -与+优先级相同,因此弹出+,再压入- |
5 | 1 2 3 + 4 × + 5 | - | 数字 |
到达最右端 | 1 2 3 + 4 × + 5 - | 空 | S1中剩余的运算符 |
2.计算后缀表达式
从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 op 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果。
例如后缀表达式“3 4 + 5 × 6 -”:
(1) 从左至右扫描,将3和4压入堆栈;
(2) 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素,注意与前缀表达式做比较),计算出3+4的值,得7,再将7入栈;
(3) 将5入栈;
(4) 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
(5) 将6入栈;
(6) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。
备注:
本博文代码基本参考如上算法所写,大家当作学习下吧,因为还未测试完全,大家在调用时如果发现Bug,请留言告知,不胜感激。
相关文章推荐
- Java 四则运算表达式求解
- Java四则运算表达式求解
- java实现任意四则运算表达式求值算法
- java 解析四则混合运算表达式并计算结果
- Java实现四则运算表达式计算
- java中正则表达式用Pattern计算字符串的结果(四则运算);分成有括号和没括号;当然也可以采用逆波兰式
- 输入四则运算的表达式,求解结果算法
- 栈的应用--四则运算表达式求值(java代码)
- 8.栈的应用-四则运算算术表达式求解(后序表达式法)
- 栈的应用--四则运算表达式求值(java语言)
- java四则运算表达式不包含括号
- 字符串四则运算表达式的求解(中缀表达式实现,模拟笔算的方法)
- 在Java中计算四则运算表达式字符串的值
- 7.栈的应用-四则运算算术表达式求解(算符优先法)
- java 四则运算,并可完成 自定义函数 表达式 功能
- JAVA实现简单四则混合运算
- java调用matlab实例(以四则运算为例)
- hdu 3000 A Simple Language (逆波兰式计算四则运算表达式数值)
- 简单四则运算表达式的java实现(2)
- IDG | 四则运算表达式计算