java 逆波兰表达式 （后缀表达式） 计算器

   在写计算器应用程序时，我们需要通过四则运算表达式构造逆波兰表达式，通过逆波兰表达式进行求值。

   <注：逆波兰表达式，也称后缀表达式>

  

  算法：需要构造运算符栈，通过进栈、出栈将愿表达式转换成为所需的逆波兰表达式。

              转换过程：

                           （1）从左到右，依次读入，若读入字符是数字，则将其输出到逆波兰表达式列表。

                            （2）若读入字符是  '(' , 直接入栈；

                                      若是 ‘）’，则采取出栈操作并顺序输出，直到 遇到第一个‘（‘ ， ’（‘出栈不输出；

                              （3）若为其他运算符，则比较 栈顶元素 与 该优先符 优先级；

                                                    当栈顶元素优先级 >= 当前元素优先级，出栈并顺序输出栈内运算符，直到栈顶元素优先 

                                                     级 <  当前元素优先级，将当前的运算符入栈。

                                        若当前运算符优先级 >  栈顶运算符优先级， 直接入栈即可。

                               （4）扫描结束，顺序输出栈内元素，添至逆波兰表达式列表尾处即可。

 附带实现代码：

                基本定义：

	private final static String OPER1 = "+";
	private final static String OPER2 = "-";
	private final static String OPER3 = "*";
	private final static String OPER4 = "/";        
	private final static String OPERLEF = "(";
	private final static String OPERRIGHT = ")";
	private String exp; 
	private int precision = 4;             // 精度计算
	private RoundingMode roundingmode = RoundingMode.HALF_UP;
	private List<String> expList = new ArrayList<String>(); 
	private List<String> postfixList = new ArrayList<String>();

  

               栈的定义，不解释，见代码；

               

        private class Stack
	{
		LinkedList<String> stackList = new LinkedList<String>();
		public Stack()
		{}
			
		public boolean isEmpty()
		{
			return stackList.isEmpty();
		}
		public void push(String expession)
		{
			stackList.addLast(expession);
		}
		
		public String pop()
		{
			return stackList.removeLast();
		}	
		
		public String top()
		{
			return stackList.getLast();
		}
	}

                依次为判断是否是 ’）‘ ，’（‘，数字，以及优先级高低：

            

public boolean isNum(String str)
	{
		return str.startsWith("0")||
				str.startsWith("1")||
				str.startsWith("2")||
				str.startsWith("3")||
				str.startsWith("4")||
				str.startsWith("5")||
				str.startsWith("6")||
				str.startsWith("7")||
				str.startsWith("8")||
				str.startsWith("9")||
				str.startsWith(".");
	}
	
	/**The method using for judge whether 
	 * a char is a 'x' or a '/'
	 * */
	
	private boolean isHigher(String str)
	{
		if(str.equals(OPER3)||str.equals(OPER4))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	/** The method using for judge whether the 
	 * priority if str1 is higher than the str2
	 * */
	
	private boolean compare(String str1, String str2)
	{
		if(str1.equals(OPERLEF))
		{
			return false;
		}
		if((!isHigher(str1))&&(isHigher(str2)))
		{
			return false;
		}
		else
		{
			if(isHigher(str1))
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	
	/** The method using for judge the 
	 * '('*/
	
	private boolean isLeft(String str)
	{
		return str.equals(OPERLEF);
	}
	
	/**The method using for judge the 
	 * ')'*/
	private boolean isRight(String str)
	{
		return str.equals(OPERRIGHT);
	}

  

                实现 四则运算的数字与运算符的分离，放入字符串内，后转换成后缀表达式，之后对后缀表达式进行计算。

     

private void seperate()
	{
		int length = exp.length();
		String tempStr = "";
		for(int i = 0; i < length; i++)
		{
			String tempChar = exp.substring(i,i+1);
			if(isNum(tempChar))
			{
				tempStr += tempChar;
			}
			else
			{
				if(!tempStr.equals(""))
				{
					expList.add(tempStr);
				}
				expList.add(tempChar);
				tempStr = "";
			}
		}
		if(!tempStr.equals(""))
		{
			expList.add(tempStr);
		}
	}
	
	/** The method using the expression list to 
	 * convert a poxfixExpression
	 * return a poxfixList
	 * */
	
	private void convertPoxfix()
	{
		Stack stack = new Stack();
		int length = expList.size();
		for(int i= 0; i < length; i++)
		{
			String ch = expList.get(i);
			if(isNum(ch))
			{
				postfixList.add(ch);
			}
			else
			{
				if(isLeft(ch))
				{
					stack.push(ch);
				}
				else 
					if(isRight(ch))
					{
						while(!stack.isEmpty())
						{
							String tempChar = stack.pop();
							if(!tempChar.equals(OPERLEF))
							{
								postfixList.add(tempChar);
							}
							else
							{
								break;
							}
						}
					}
					else
					{
						if(stack.isEmpty())
						{
							stack.push(ch);
						}
						else
						{
							if(compare(stack.top(),ch))
							{
								while(!stack.isEmpty() && compare(stack.top(),ch))
							     	{
									postfixList.add(stack.pop());
									}
							}
							stack.push(ch);
						}
						
					}
			}		
		}
		while(!stack.isEmpty())
		{
			postfixList.add(stack.pop());
		}
	}
	
	/**The method using for the calculation on the decimal precision
	 * */
	public static BigDecimal getBigDecimal(String numString, int precision, RoundingMode roundingmode)
	{
		String precisionFlag = "0";
		if(numString == null || numString.equals(""))
		{
			precisionFlag = "0.00";
		}
		else
		{
			precisionFlag = numString;
		}
		
		BigDecimal bigdecimal = new BigDecimal(precisionFlag);
		bigdecimal.setScale(precision, roundingmode);
		return bigdecimal;
	}
	
	/**the method which uses the postifixExpression to calculate
	 * the expression 
	 * return the answer which is on the top of the stack
	 * */
	
	public String calculation() throws ArithmeticException
	{
		Stack numStack = new Stack();
		int length = postfixList.size();
		for(int i = 0; i < length; i++)
		{
			String tempC = postfixList.get(i);
			
			if(isNum(tempC))
			{
				numStack.push(tempC);
			}
			else
			{
				BigDecimal tempNum1 = getBigDecimal(numStack.pop(),precision,roundingmode);
				BigDecimal tempNum2 = getBigDecimal(numStack.pop(),precision,roundingmode);
				BigDecimal tempNum = getBigDecimal("",precision,roundingmode);
				
				if(tempC.equals(OPER1))
				{
					tempNum = tempNum2.add(tempNum1);
				}
				else
					if(tempC.equals(OPER2))
					{
						tempNum = tempNum2.subtract(tempNum1);
					}
					else
						if(tempC.equals(OPER3))
						{
							tempNum = tempNum2.multiply(tempNum1);
						}
						else
							if(tempC.equals(OPER4))
							{
								tempNum = tempNum2.divide(tempNum1, precision, roundingmode);
							}
				numStack.push(tempNum.toString());
			}
		}
		return numStack.pop();
	}

              类的构造：

public PostfixExp(String exp, int precision, RoundingMode roundingmode)
	{
		this.exp = exp;
		this.precision = precision;
		this.roundingmode = roundingmode;
		seperate();
		convertPoxfix();
		
	}

          测试代码：

public String getPostfix()
	{
		String post = "";
		int length = postfixList.size();
		for(int i = 0; i < length; i++)
		{
			post += postfixList.get(i)+" ";
		}
		return post;
	}

public static void main(String[] args)
	{
		String str = "1+4/2*3+5+(3+1)+2/2";
		System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
		PostfixExp postfixexp = new PostfixExp(str,10,RoundingMode.HALF_UP);
		String post = postfixexp.getPostfix();
		System.out.println("PostFix Expression: "+ post);
		System.out.println("Answer : "+ postfixexp.calculation());
	}

     至此  所有源代码已经给出，欢迎批评指正！！

      部分思想源于网上大牛！ 多谢各位大牛指导！！！