java 两栈计算算式,使用栈计算多项表达式的简单实现--java

正则表达式用来指定字符串模式。当你需要定位匹配某种模式的字符串时就可以使用正则表达式。例如，我们下面的一个例程就是在一个HTML文件中通过查找字符串模式来定位所有的超链接。     当然，为了指定一种模式，使用...这种记号是不够精确

这是使用栈直接计算多项表达式的java简单实现。

算法原理：

1、定义两个栈：操作数栈od，操作符栈op

2、逐个字符扫描多项表达式：

-------a)如果是操作数，将数字转换为double类型push进od栈

-------b)如果是‘(’，直接push进op栈

-------c)如果是操作符，比较当前操作符”op“和op栈栈顶操作符的优先级：当前操作符优先级高时，操作符直接入栈，进行下一步；否则，使用当前操作符”op“，从od栈pop两个操作数”odNum1“和”odNum2“，进行计算odMum2 op odNum1(注意操作数的先后顺序)，结果push进od栈。例如将“3/2”结果1.5 push进od栈，重新执行c步骤。

-------d)如果是‘)’，从op栈pop一个操作符”op“：如果是‘(’，进行下一步；否则，使用当前操作符”op“，从od栈pop两个操作数”odNum1“和”odNum2“，进行计算odMum2 op odNum1(注意操作数的先后顺序)，结果push进od栈，重新执行d步骤。如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。 如果你不熟悉这个术语，那么“正则表达式”(Regular Expression)就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。 许多语言，

3、如果op栈不为空，从op栈pop一个操作符”op“，从od栈pop两个操作数”odNum1“和”odNum2“，进行计算odMum2 op odNum1(注意操作数的先后顺序)，结果push进od栈，重新执行3步骤。

4、此时op栈为空，od栈剩下一个操作数，这个操作数就是结果。从od栈pop这个操作数，返回结果。

代码实现:

MyStack.java

package jsj.lgl;

import java.util.ArrayList;

import java.util.List;

public class MyStack {

List list;

public MyStack()

{

list = new ArrayList();

}

public void push(Object obj)

{

list.add(obj);

}

public Object pop()

{

if(!list.isEmpty())

{

return list.remove(list.size()-1);

}

return null;

}

public Object get()

{

if(!list.isEmpty())

{

return list.get(list.size()-1);

}

return null;

}

} DuoXiangShi.java

package jsj.lgl;

public class DuoXiangShi {

public static void main(String[] args)

{

DuoXiangShi dxs = new DuoXiangShi();

System.out.println(dxs.calculateDirectly("(1.123+22.22*3)/(3%1)*1234.567"));

}

public static int getOpLevel(char op)

{

switch(op)

{

case '(':return 0;

case '+':

case '-':return 1;

case '*':

case '/':

case '%':return 2;

case ')':return 3;

default:return 0;

}

}

public static double caculateResult(char op,double od1,double od2)

{

switch(op)

{

case '*':return od1*od2;

case '/':return od1/od2;

case '+':return od1+od2;

case '-':return od1-od2;

case '%':return ((int)od1)%((int)od2);

}

return 0;

}

/**

* 计算多项式

*/

public double calculateDirectly(String equation)

{

/**操作数栈*/

MyStack odStack = new MyStack();

/**操作符栈*/

MyStack opStack = new MyStack();

int index = 0;

int length = equation.length();

while(index < length)

{

char c = equation.charAt(index);

if(c == '(')

{

opStack.push(c);

}

else if(c == '+' || c == '-' || c == '*' || c == '/' || c=='%')

{

int currOpLevel = getOpLevel(c);

while(true)

{

int stackOpLevel = 0;

Object obj = opStack.get();

if(obj != null)

{

stackOpLevel = getOpLevel((char)obj);

}

//可以入栈

if(currOpLevel > stackOpLevel)

{

opStack.push(c);

break;

}

else

{

try{

char optemp = (char) opStack.pop();

double odNum1 = (double) odStack.pop();

double odNum2 = (double) odStack.pop();

/*if((optemp=='/'||optemp=='%')&&(odNum2 == 0.0))

{

System.out.println("除操作或者取余操作非法");

return Integer.MAX_VALUE;

}*/

odStack.push(caculateResult(optemp, odNum2, odNum1));

}

catch(Exception e){

System.out.println("多项式不正确："+equation);

e.printStackTrace();

}

}

}

}

else if(c == ')')

{

while(true)

{

char op = (char) opStack.pop();

if(op == '(')

{

break;

}

else

{

try{

//char optemp = (char) opStack.pop();

double odNum1 = (double) odStack.pop();

double odNum2 = (double) odStack.pop();

odStack.push(caculateResult(op, odNum2, odNum1));

}

catch(Exception e){

System.out.println("多项式不正确："+equation);

e.printStackTrace();

}

}

}

}

else if(c >= '0' && c <= '9' || c == '.')

{

int tempindex = index+1;

while(tempindex < length)

{

char tempc = equation.charAt(tempindex);

if(tempc >= '0' && tempc <= '9' || tempc == '.')

{

tempindex++;

}

else

{

break;

}

}

String odStr = equation.substring(index, tempindex);

try {

double odNum = Double.parseDouble(odStr);

odStack.push(odNum);

index = tempindex - 1;

} catch (Exception e) {

System.out.println("多项式不正确："+equation);

e.printStackTrace();

}

}

index++;

}

//开始看op栈是否为空

while(true)

{

Object obj = opStack.pop();

if(obj == null)

{

break;

}

else

{

char optemp = (char) obj;

double odNum1 = (double) odStack.pop();

double odNum2 = (double) odStack.pop();

odStack.push(caculateResult(optemp, odNum2, odNum1));

}

}

double result = 0.0;

try {

result = (double) odStack.pop();

} catch (Exception e) {

System.out.println("多项式不正确："+equation);

e.printStackTrace();

}

return result;

}

}