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

这是使用栈直接计算多项表达式的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步骤。

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<Object> list;

public MyStack()
{
list = new ArrayList<Object>();
}

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;
}
}