参考博客：前缀、中缀、后缀表达式
一、表达式的三种表示法
1. 中缀表示法
运算符放在两个运算对象中间，这是我们书写的时候最熟悉的一种形式，如：（2 + 3）* 7
2. 前缀表示法
前缀是附加在表达式前面的内容。又称为波兰前缀表示法，因为他是由波兰数学家Jan Lukasiewicz发明的。使用前缀表示法后，就完全不需要括号了。例如，表达式（2
+ 3）* 7以波兰前缀表示法可以写成： * + 2 3 7
计算方法：
算波兰表达式时，无需记住运算的层次，只需要直接寻找第一个运算的操作符。以二元运算为例，从左至右读入表达式，遇到一个操作符后跟随两个操作数时，则计算之，然后将结果作为操作数替换这个操作符和两个操作数；重复此步骤，直至所有操作符处理完毕。因为在正确的前缀表达式中，操作数必然比操作符多一个，所以必然能找到一个操作符符合运算条件；而替换时，两个操作数和一个操作符替换为一个操作数，所以减少了各一个操作符和操作数，仍然可以迭代运算直至计算整个式子。多元运算也类似，遇到足够的操作数即产生运算，迭代直至完成。迭代结束的条件由表达式的正确性来保证。下面是一个例子，演示了每一步的运算顺序：
− × ÷ 15 − 7 + 1 1 3 + 2 + 1 1 =
− × ÷ 15 − 7 2 3 + 2 + 1 1 =
− × ÷ 15 5 3 + 2 + 1 1 =
− × 3 3 + 2 + 1 1 =
− 9 + 2 + 1 1 =
− 9 + 2 2 =
− 9 4 =
5
− × ÷ 15 − 7 2 3 + 2 + 1 1 =
− × ÷ 15 5 3 + 2 + 1 1 =
− × 3 3 + 2 + 1 1 =
− 9 + 2 + 1 1 =
− 9 + 2 2 =
− 9 4 =
5
等价的中缀表达式: ((15 ÷ (7 − (1 + 1))) × 3) − (2 + (1 + 1)) = 5
3.后缀表达式
后缀表达式与前缀表达式类似，只是运算符位于操作数之后。
他和前缀表示法都对计算机比较友好，但他很容易用堆栈解析，所以在计算机中用的很多。他的解释过程一般是：操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。因此逆波兰表达式的求值使用堆栈结构很容易实现，和能很快求值。
注意：逆波兰记法并不是简单的波兰表达式的反转。因为对于不满足交换律的操作符，它的操作数写法仍然是常规顺序，如，波兰记法“/ 6 3”的逆波兰记法是“6 3 /”而不是“3 6 /”；数字的数位写法也是常规顺序。 为了更好的了解前缀表达式的计算过程，举个例子：5 3 2 * + 4 - 5 +，计算过程如下：
| 扫描到的元素 | 栈（栈底到栈顶） | 说明 |
| 5 | 5 | 操作数直接入栈 |
| 3 | 5 3 | 操作数直接入栈 |
| 2 | 5 3 2 | 操作数直接入栈 |
| * | 5 6 | 遇到操作符，弹出两个实数，求值，压栈 |
| + | 11 | 遇到操作符，弹出两个实数，求值，压栈 |
| 4 | 11 4 | 操作数直接入栈 |
| - | 7 | 遇到操作符，弹出两个实数，求值，压栈 |
| 5 | 7 5 | 操作数直接入栈 |
| + | 12 | 计算结果为12 |
二 、 算法实现
public static final Pattern UNSIGNED_DOUBLE =
Pattern.compile("((\\d+\\.?\\d*)|(\\.\\d+))([Ee][-+]?\\d+)?.*?");
public static final Pattern CHARACTER =
Pattern.compile("\\S.*?");1. 后缀表达式求值
伪代码：
a. 初始化生成了一个由双精度实数构成的栈。
b. do
if（下一个输入元素为数值）
读取下一个元素并压到栈中。
else
{
读取下一个字符，该字符是一个运算符。
从栈中弹出两个实数
将两个数用运算符组合（第二个弹出的数值为左操作数）
然后将结果压入栈中。
}
while (表达式中有更多的输入)。
c. 到此为止，栈中仅包含一个数值，该数值就是表达式的值。
/**
* 后缀表达式的求值算法
* @param expression
* @return
*/
public static double evaluateReversePolishNotation(String expression)
{
// 使用一个栈来保存表达式中的数值
Stack<Double> numbers = new Stack<Double>();
// 将表达式转换成一个Scanner类的对象，以便更易于处理
Scanner input = new Scanner(expression);
// next存储的是表达式的下一个片段：数值、运算符或括号
String next;
while (input.hasNext())
{
if (input.hasNext(UNSIGNED_DOUBLE))
{
next = input.findInLine(UNSIGNED_DOUBLE);
numbers.push(new Double(next));
} else {
next = input.findInLine(CHARACTER);
double operand1, operand2;
if (numbers.size() < 2)
{
throw new IllegalArgumentException("Illegal expression.");
}
switch (next.charAt(0))
{
case '+':
operand2 = numbers.pop();
operand1 = numbers.pop();
numbers.push(operand1 + operand2);
break;
case '-':
operand2 = numbers.pop();
operand1 = numbers.pop();
numbers.push(operand1 - operand2);
break;
case '*':
operand2 = numbers.pop();
operand1 = numbers.pop();
numbers.push(operand1 * operand2);
break;
case '/':
operand2 = numbers.pop();
operand1 = numbers.pop();
numbers.push(operand1 / operand2);
break;
default:
throw new IllegalArgumentException("Illegal input expression.");
}
}
}
if (numbers.size() != 1)
{
throw new IllegalArgumentException("Illegal input expression.");
}
return numbers.pop();
} String s3 = "5 3 2 *+4-5+";
double value3 = CalculateUtils.evaluateReversePolishNotation(s3);
System.out.println(value3);5 3 2 *+4-5+的计算结果为：12.02. 中缀表达式求值
由于后缀表达式非常易于求值，所以计算普通的中缀表达式的一种策略是先将它转载成后缀表达式，然后在计算对应的后最表达式。
伪代码：
a. 初始化一个字符栈用于存储运算符和括号。
b. do
if (下一个输入时左括号）
读取左括号并将它压到栈中。
else if (下一个输入时数值或其他操作数)
读取操作数并将它输出
else if (下一个输入是运算符)
{
出栈并打印运算符，直到下列三种情况中的一种发生:（1） 栈为空；（2）栈中的下一个符号是左括号；（3）栈中的下一个符号是优 先级比下一个输入中的运算符更低的运算符。当发生三种情况中的某种时，停止出栈，读取下一个输入符号，并将该符号压入栈中。
}
else
{
读取并放弃下一个输入符号（它应该是一个右括号）。出栈并打印输出从栈中弹出的运算符，直到栈中的下一个符号是左括号位置。 （如果没有出现左括号，打印出出错信 息表明括号不平衡，终止程序。）最后，出栈并丢弃左括号。
}
while （表达式中有更多信息读入）
c. 出栈并打印输出栈中所有属于的运算符。（不应该是左括号，否则输入表达式的括号是不平衡的。）
// 中缀表达式转换为波兰后缀表达式的算法
public static String infixToReversePolishNotation(String expression)
{
StringBuffer outStrBuffer = new StringBuffer();
// 使用一个栈来存储运算符和括号
Stack<Character> operations = new Stack<Character>();
// 将表达式转换成一个Scanner类的对象，以便更易于处理
Scanner input = new Scanner(expression);
// next存储的是表达式的下一个片段：数值、运算符或括号
String next;
while (input.hasNext())
{
// 如果输入为数值或其他操作数，读取操作数并将它
if (input.hasNext(UNSIGNED_DOUBLE))
{
next = input.findInLine(UNSIGNED_DOUBLE);
outStrBuffer.append(next);
outStrBuffer.append(" ");
} else {
next = input.findInLine(CHARACTER);
switch (next.charAt(0))
{
case '(':
operations.push(next.charAt(0));
break;
case '+':
case '-':
case '*':
case '/':
while (true)
{
if (operations.empty() || operations.peek().equals('(') ||
priorityCompare(operations.peek(), next.charAt(0)) == -1)
{
operations.push(next.charAt(0));
break;
}
else {
outStrBuffer.append(operations.pop());
outStrBuffer.append(" ");
}
}
break;
case ')':
while (true)
{
if (!operations.peek().equals('('))
{
outStrBuffer.append(operations.pop());
outStrBuffer.append(" ");
} else {
operations.pop();
break;
}
}
break;
default:
throw new IllegalArgumentException("Illegal input expression.");
}
}
} String s4 = "5*(9.1+3.2)/(1-5+4.88)";
String outStr = infixToReversePolishNotation(s4);
System.out.println(outStr);
double value4 = CalculateUtils.evaluateReversePolishNotation(outStr);
System.out.println(value4);5 9.1 3.2 + * 1 5 - 4.88 + /
69.88636363636364