使用栈计算多项表达式的简单实现--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;
	}
}