Stack 表达式计算

package com.citi.ww03140.ds.exp;

import java.util.HashMap;
import java.util.Stack;

/*
3. 后缀表达式
后缀表达式也称为逆波兰式（Reverse Polish Notation, RPN），更加广为人知一些，和前缀表达式刚好相反，是将操作符号放置于操作数之后，比如2 + 3 * (5 - 1)用逆波兰式来表示则是：2 3 5 1 - * +。

逆波兰式的计算也是从左往右依次读取，当读到操作符时，将之前的两个操作数做计算，然后替换这两个操作数和操作符，接着读取，重复此步骤。对于这个表达式，读到5 1 -，得到4，然后读取乘号，取出前面的3和上一步的计算结果4，并计算，到12，接着读取加号+，计算2 12 +得到14，计算结束。

上面这个步骤可以很容易的用栈来实现：

从左往右依次读取表达式，如果是数字则将该数字压栈，如果是符号，则将之前的两个数字出栈，做计算后，将计算结果压栈，直到表达式读取结束。栈中剩下的一个数就是计算结果。

逆波兰式看起来像波兰式反过来，比如5 + 1的波兰式是+ 5 1，逆波兰式为5 1 +或者1 5 +。也很明显，逆波兰式并不是简单的将波兰式反过来，因为，减法和除法中减数和被减数、除数与被除数是不能交换的，即- 10 5和- 5 10就完全不一样。

4. 中缀表达式到后缀表达式的转换
因为通过后缀表达式来进行计算只需要一个栈即可，从硬件和软件上实现都是极为便利的，因此逆波兰式在计算机领域的应用更加广泛，因此将中缀表达式转换为逆波兰式非常重要。

依然仅仅使用栈就可以将中缀表达式转换成逆波兰式，转换过程如下：

从左往右遍历中缀表达式中的每个数字和符号，弱是数字就输出，成为逆波兰式的一部分； 如果是右括号，或者是其他符号并且比当前栈顶符号的优先级低，则栈顶元素依次出栈并输出； 然后将当前符号进栈，重复以上操作直到结束。

还是以2 + 3 * (5 - 1)为例：

首先读入数字2，直接将其输出，输出为2，栈为空
接着读入加号+，由于栈为空，因此将其进栈，输出为2，栈为+
接着读入数字3，直接将其输出，输出为2 3，栈为+
接着读入乘号*，比栈顶元素优先级高，进栈，输出为2 3，栈为+ *
读入左括号(，直接进栈，输出2 3，栈为+ * (
读入数字5，直接将其输出，输出为2 3 5，栈为+ * (
读入减号-，栈顶元素为左括号，进栈，输出为2 3 5，栈为+ * ( -
读入数字1，直接将其输出，输出为2 3 5 1，栈为+ * ( -
读入右括号，依次输出栈顶元素，直到左括号，括号不输出，输出2 3 5 1 -，栈为+ *
已经无元素可读，依次输出栈顶元素，直到栈为空，输出2 3 5 1 - * +，栈为空
这样可以仅仅使用栈，首先将中缀表达式转换为逆波兰式，然后用本文第3节中的方法对后缀表达式进行求值，整个过程使用栈来完成即可。

5. 表达式树与逆波兰式
还可以通过另外一种方法来将一个表达式转换成波兰式和逆波兰式，这种方法依赖与树，首先需要根据表达式构建成树，仍然以2 + 3 * (5 - 1)为例，下图是其表达式树。

6. 后缀表达式计算
将表达式，依次取出来，存入Stack，遇到运算符, 依次取2个stack top element 进行运算，并结果压stack，直到中只有最后一个元素


*/
public class StackExp {

private final Stack<String> exps=new Stack<String>();

private final Stack<String> oper=new Stack<String>();

private final HashMap<String,Integer> mapping=new HashMap<String,Integer>();

public StackExp(){
mapping.put("+", 1);
mapping.put("-", 1);
mapping.put("*", 2);
mapping.put("%", 2);
mapping.put("/", 2);
mapping.put("^", 3);
mapping.put("(", 0);
mapping.put(")", 0);
mapping.put("|", -1);
}

public void transform(String expStr){
char[] chs=expStr.toCharArray();
for(int i=0;i<chs.length;i++){
String s=String.valueOf(chs[i]);
if(!mapping.containsKey(s)){
exps.add(s);
}else{
if("(".equals(s)){
oper.add(s);
}else if(")".equals(s)){
while(oper.size()>0 && !oper.peek().equals("(")){
exps.add(oper.pop());
}
oper.pop();
}else{
if(oper.isEmpty()){
oper.add(s);
}else{
int curOp=mapping.get(s);
int topOp=mapping.get(oper.peek());
if(curOp>topOp){
oper.add(s);
}else{
do{
exps.add(oper.pop());
}while(oper.size()>0 && (curOp<=mapping.get(oper.peek())));
oper.add(s);
}
}
}
}
}
while(oper.size()>0){
exps.add(oper.pop());
}

while(exps.size()>0){
oper.add(exps.pop());
}
printExp();
calculate();
System.out.println(exps.toString());
}

private void calculate(){
while(oper.size()>0){
String op=oper.pop();
if(mapping.containsKey(op)){
double d=calculate(op,Double.parseDouble(exps.pop()),Double.parseDouble(exps.pop()));
System.out.println(d);
exps.push(String.valueOf(d));
}else{
exps.push(op);
}
}
}

private void printExp(){
System.out.println(exps.toString());
}

private double calculate(String op,double d1, double d2){
if(op.equals("+")){
return d1+d2;
}
if(op.equals("-")){
return d1-d2;
}
if(op.equals("*")){
return d1*d2;
}
if(op.equals("/")){
return d1/d2;
}
if(op.equals("%")){
return d1%d2;
}
if(op.equals("^")){
return Math.pow(d1, d2);
}
return 0;
}

public static void main(String[] args) {
StackExp exp=new StackExp();
exp.transform("(1+2)*3-5+8+(1+2)*3-5+8");
}

}