逆波兰算法介绍
假定给定一个只 包含 加、减、乘、除，和括号的算术表达式，你怎么编写程序计算出其结果？
问题是：在表达式中，括号，以及括号的多层嵌套 的使用，运算符的优先级不同等因素，使得一个算术表达式在计算时，运算顺序往往因表达式的内容而定，不具规律性。 这样很难编写出统一的计算指令。
使用逆波兰算法可以轻松解决这个问题。他的核心思想是将普通的中缀表达式转换为后缀表达式。
什么是中缀表达式？例如a+b，运算符在两个操作数的中间。这是我们从小学开始学习数学就一直使用的表达式形式。
什么是后缀表达式？例如a b + ，运算符在两个操作数的后面。后缀表达式虽然看起来奇怪，不利于人阅读，但利于计算机处理。
转换为后缀表达式的好处是：
1、去除原来表达式中的括号，因为括号只指示运算顺序，不是实际参与计算的元素。
2、使得运算顺序有规律可寻，计算机能编写出代码完成计算。
算术表达式的组成部分
一个表达式有如下及部分元素组成
- 操作数：可以是任何数值：1，89 ， 3.14159 ...
- 运算符：
分为单目运算符 如 sin , cos ， 双目运算符 如 加、减、乘、除 。
运算符还会分为左结合性和右结合性。同级的左结合性的运算符从左往右依次计算。同级的右结合性的运算符从右往左依次计算。
如: 7-6+1 等价于 (7-6) + 1 ，因为普通加减运算符是左结合性的。
如：C语言中的组合赋值语句： a = b = 1 等价于 a = (b=1) ，因为赋值运算符在C中是右结合性的。
对于单目运算符，还分为前缀运算符和后缀运算符，如 sin(x) 是前缀运算符，而 阶乘运算符 ： n ! 就是后缀运算符。
- 分界符：一般是圆括号 ( ) ， 用于指示运算的先后顺序。
在本文中，只会考虑算术表达式 有 加、减、乘、除 运算符， 左右圆括号 ( ， ) ，以及合法的数字简单的情况。对于更加复杂的运算符，只要对这个算法轻微修改，就可以支持。
逆波兰算法的原理
逆波兰算法的核心步骤就2个：
1、将中缀表达式转换为后缀表达式，例如输入的原始表达式是 3*（5+7） ，转换得到 3 5 7 + *
2、根据后缀表达式，按照特定的计算规则得到最终计算结果
下面详细介绍这个2步的操作。
中缀表达式转换为后缀表达式
你需要设定一个栈SOP,和一个线性表 L 。SOP用于临时存储运算符和左括号分界符( ，L用于存储后缀表达式。
遍历原始表达式中的每一个表达式元素
（1）如果是操作数，则直接追加到 L中。只有 运算符 或者 分界符（ 才可以存放到 栈SOP中
（2）如果是分界符
Ⅰ 如果是左括号 ( ， 则 直接压入SOP，等待下一个最近的 右括号 与之配对。
Ⅱ 如果是右括号），则说明有一对括号已经配对(在表达式输入无误的情况下)。不将它压栈，丢弃它，然后从SOP中出栈，得到元素e，将e依次追加到L里。一直循环，直到出栈元素e 是 左括号 ( ，同样丢弃他。
（3）如果是运算符（用op1表示）
Ⅰ如果SOP栈顶元素（用op2表示） 不是运算符，则二者没有可比性，则直接将此运算符op1压栈。 例如栈顶是左括号 ( ，或者栈为空。
Ⅱ 如果SOP栈顶元素（用op2表示） 是运算符 ，则比较op1和 op2的优先级。如果op1 > op2 ，则直接将此运算符op1压栈。
如果不满足op1 > op2，则将op2出栈，并追加到L，再试图将op1压栈，如果如果依然不满足 op1>新的栈顶op2，继续将新的op2弹出追加到L ，直到op1可以压入栈中为止。
也就是说，如果在SOP栈中，有2个相邻的元素都是运算符，则他们必须满足：下层运算符的优先级一定小于上层元素的优先级，才能相邻。
最后，如果SOP中还有元素，则依次弹出追加到L后，就得到了后缀表达式。
伪代码
#将参数中缀表达式expression转为后缀表达式存放在L中，返回L function infixToSuffix(expression): { for each element in expression #对表达式中的每一个元素 { if (element 是一个操作数) { L.append(element) #将这个元素追加到线性表L后 } else if (element 是 一个运算符) { While (sop栈 不为空 && sop栈顶元素 是一个运算符 && element的优先级 <= sop栈顶运算符元素的优先级 ) { L.append(sop.pop()) } sop.push(element); } else if(element 是 一个分界符) { if (element is '(' ) { sop.push(element) } else if( element is ')' ) { While (sop栈不为空 && sop栈顶元素 不是 '(' ) #将匹配的2个括号之间的栈元素弹出，追加到L { L.append( sop.pop() ); } if(sop栈不为空 ) { sop.pop() #将匹配到的 '(' 弹出丢弃 } } } } While (sop 栈 不为空) #将sop栈中剩余的所有元素弹出，追加到L后 { L.append(sop.pop()) } return L }
示例图
根据后缀表达式计算得到最终结果
执行这步操作时，也需要一个栈scalc，用于存放计算中的操作数。
伪代码
function suffixToResult(suffix_expression) { for each element in suffix_expression { if(element 是 操作数) { scalc.push(element) } else if(element 是运算符) { #从栈中弹出2个操作数 num1 和 num2 。注意：后弹出的num2是第一操作数，num1是第二操作数 。 #因为这里考虑的都是二元运算符，因此需要弹2个元素出来进行运算。 num1 = scalc.pop() num2 = scalc.pop() #使用element代表的运算符完成 num2 和 num1 的计算，产生临时结果 temp_value temp_value = num2 【element的运算符: + ,- ,* , / 】 num1 #将temp_value压栈 scalc.push(temp_value) } #如果一切正常，最后栈scalc中仅仅只有一个元素，这个元素就是最终的结果 return sclac.pop() } }
示例图
代码实现（Java）
1、核心算法实现是 InfixExpression类中的 public SuffixExpression toSuffixExpression() 和 SuffixExpression 类中的 double getResultValue() throws Exception 。
2、并没有实现解析输入的代码，因此算术表达式只能通过硬编码构造。涉及到编译原理的知识，书到用时方恨少，哎。
3、所有的操作数内部使用double存储。
package com. lulix86 .calc ; import java. util .ArrayList ; import java. util .Deque ; import java. util .HashMap ; import java. util .Iterator ; import java. util .LinkedList ; import java. util .List ; import java. util .Map ; import java. util .regex . Matcher; import java. util .regex . Pattern; public class App { public static void main (String [] args ) { InfixExpression expression = new InfixExpression () ; // (1+8)-(3*(4-1)) = 0 expression .append ( "(") ; expression .append ( "1") ; expression .append ( "+") ; expression .append ( "8") ; expression .append ( ")") ; expression .append ( "-") ; expression .append ( "(") ; expression .append ( "3") ; expression .append ( "*") ; expression .append ( "(") ; expression .append ( "4") ; expression .append ( "-") ; expression .append ( "1") ; expression .append ( ")") ; expression .append ( ")") ; System . out. println( "原始表达式:" + expression ); try { System . out. println( "计算结果是:" + expression. getResultValue () ) ; } catch (Exception e) { System . out. println( "一定是表达式输入的有问题，请检查后重试" ) ; } } } /** * 表达式元素的公父类。表达式元素具体分为：运算符类，操作数类，分界符类。因此这个类有3个子类。 这是一个抽象类。 这个类的作用如下： * 1、定义了表达式元素的共同属性：String content，用来存储元素的字符串形式的内容。 * 2、限定了分界符元素和运算符元素的相关性质：如可取的content值，运算符的优先级等。 * 2、这个类提供了一些供子类使用的工具函数：isLegalXXXX。 * * * @see ExpressionDelimeter * @see ExpressionOperator * @see ExpressionOperand * */ abstract class ExpressionElement { // -----------------------------分界符----------------------------------- // 表达式中的分界符：左右圆括号 public static final String LEFT_PARENTHESES = "(" ; public static final String RIGHT_PARENTHESES = ")" ; protected static boolean isLegalDelimeter (String content) { if ( LEFT_PARENTHESES .equals ( content) || RIGHT_PARENTHESES . equals( content )) return true ; return false ; } // -----------------------------运算符----------------------------------- // 运算符:这里只用到了常见的这4个运算符 public static final String PLUS = "+" ; public static final String MINUS = "-" ; public static final String MULTIPLE = "*" ; public static final String DIVIDE = "/" ; // 将运算符 和 他的 优先级 通过 k-v 对存放到 Map中：运算符的优先级分为2个等级，用数字1 和2代表，数值越大，优先级越高 protected static final Map <String , Integer> operatorPiority = new HashMap <> (); static { operatorPiority .put ( PLUS, 1) ; operatorPiority .put ( MINUS, 1) ; operatorPiority .put ( MULTIPLE, 2) ; operatorPiority .put ( DIVIDE, 2) ; } protected static boolean isLegalOperator (String content) { if ( ! operatorPiority. containsKey (content )) return false ; return true ; } // -----------------------------操作数----------------------------------- // 通过正则表达式校验一个字符串是否是合法的数字 。 protected static boolean isLegalOperand (String content) { Pattern numberPat = Pattern .compile ( "(\+|-)?(\d+\.)?\d+" ); Matcher mat = numberPat .matcher ( content) ; if ( ! mat. matches ()) return false ; return true ; } protected final String content ; protected ExpressionElement ( String content ) { this .content = content ; } public String getContent() { return content ; } @Override public String toString() { return content . toString() ; } } /** * 表达式运算符类。 构造函数私有，不可以自己创建实例，只能用类中预定义的4个静态类对象，分别代表了加减乘除4个运算符。 类对象不可变。 * 实现了Comparable接口，compareTo方法用来比较2个运算符的优先级。 * */ class ExpressionOperator extends ExpressionElement implements Comparable <ExpressionOperator > { public static final ExpressionOperator OP_MINUS = new ExpressionOperator (ExpressionElement . MINUS) ; public static final ExpressionOperator OP_PLUS = new ExpressionOperator (ExpressionElement . PLUS) ; public static final ExpressionOperator OP_MULTIPLE = new ExpressionOperator (ExpressionElement . MULTIPLE) ; public static final ExpressionOperator OP_DEVIDE = new ExpressionOperator (ExpressionElement . DIVIDE) ; // ----------------------------------------------------- private final int priority ; // 运算符的优先级 // 不可以在类外实例化运算符，不允许创建其它的新的运算符 private ExpressionOperator ( String content ) { super (content ) ; if ( ! isLegalOperator( content )) throw new IllegalArgumentException( "运算符 " + content + " 不是合法的" ); this .priority = operatorPiority .get ( content) ; } public int getPriority() { return priority ; } @Override public int compareTo( ExpressionOperator other ) { return this . priority - other . priority; } @Override public boolean equals( Object obj ) { if ( obj == null) return false ; if ( obj == this) return true ; if ( obj .getClass () != this. getClass ()) return false ; ExpressionOperator other = ( ExpressionOperator) obj; return this . getContent() . equals( other .getContent ()) ; } } /** * 表达式操作数类。 * * 使用double作为数字的存储类型。 不可变类型。 实现了Comparable接口，compareTo方法用来比较2个操作数的大小。 * * 因为操作数是不可枚举的，因此这个类可以创建实例。 */ class ExpressionOperand extends ExpressionElement implements Comparable <ExpressionOperand > { private final double value ; public ExpressionOperand ( String content ) { super (content ) ; try { value = Double. parseDouble (content ) ; } catch (NumberFormatException e) { throw new IllegalArgumentException( content + " 不是一个合法的数字" ); } } public ExpressionOperand ( double value ) { super (Double . toString( value )); this .value = value ; } public double getValue() { return value ; } @Override public int compareTo( ExpressionOperand other ) { return Double . compare( this .value , other . value) ; } @Override public String toString() { return Double . toString( this .value ) ; } } /** * 表达式分界符类。 不可变类型。 构造函数私有，不可以自己创建实例，只能用类中预定义的2个静态类对象，分别代表左，右括号。 * */ class ExpressionDelimeter extends ExpressionElement { public static final ExpressionDelimeter DM_LEFT_PARENTHESES = new ExpressionDelimeter ( ExpressionElement . LEFT_PARENTHESES) ; public static final ExpressionDelimeter DM_RIGHT_PARENTHESES = new ExpressionDelimeter ( ExpressionElement . RIGHT_PARENTHESES) ; private ExpressionDelimeter ( String content ) { super (content ) ; if ( ! isLegalDelimeter( content )) throw new IllegalArgumentException( "分界符 " + content + " 不是合法的" ); } @Override public boolean equals( Object obj ) { if ( obj == null) return false ; if ( obj == this) return true ; if ( obj .getClass () != this. getClass ()) return false ; ExpressionDelimeter other = ( ExpressionDelimeter) obj ; return content . equals( other .content ) ; } } /** * 表达式类。 你可以把这个类看做是一个存储表达式元素的线性表，因此可以使用appendXXX方法来构造一个表达式。 * * 封装了工具函数 infixToSuffix，用于将中缀表达式转换为后缀表达式。 * 实现了 Iterable接口，可以迭代ExpressionElement元素对象。 */ abstract class Expression implements Iterable< ExpressionElement > { // --------------------------------------------------------------------------- // 使用ArrayList存储表达式元素 protected final List< ExpressionElement > expression = new ArrayList <>() ; // 追加一个表达式元素对象，不可以追加空元素。 public boolean append( ExpressionElement e ) { if ( e == null) return false ; expression .add ( e) ; return true ; } public boolean append( String content ) { switch ( content ) { case ExpressionElement . LEFT_PARENTHESES: expression .add ( ExpressionDelimeter. DM_LEFT_PARENTHESES ) ; break ; case ExpressionElement . RIGHT_PARENTHESES: expression .add ( ExpressionDelimeter. DM_RIGHT_PARENTHESES ) ; break ; case ExpressionElement . PLUS: expression .add ( ExpressionOperator. OP_PLUS ); break ; case ExpressionElement . MINUS: expression .add ( ExpressionOperator. OP_MINUS ); break ; case ExpressionElement . MULTIPLE: expression .add ( ExpressionOperator. OP_MULTIPLE ); break ; case ExpressionElement . DIVIDE: expression .add ( ExpressionOperator. OP_DEVIDE ); break ; default : try { ExpressionOperand operand = new ExpressionOperand (content ) ; // 构造时使用了parseDouble expression .add ( operand) ; } catch (Exception e) { return false ; } } return true ; } @Override public String toString() { boolean firstAdd = true ; StringBuilder sb = new StringBuilder () ; for ( ExpressionElement e : expression ) { if ( ! firstAdd) { sb .append ( " ") ; } else { firstAdd = false; } sb .append ( e. toString ()); } return sb . toString() ; } @Override public Iterator < ExpressionElement> iterator() { return expression . iterator() ; } public void clear() { this .expression . clear() ; } // 获取表达式最终的运算的结果 public abstract double getResultValue() throws Exception ; } class SuffixExpression extends Expression { private double doPlus( ExpressionOperand a , ExpressionOperand b ) { return a . getValue() + b .getValue () ; } private double doMinus( ExpressionOperand a , ExpressionOperand b ) { return a . getValue() - b .getValue () ; } private double doMultiple( ExpressionOperand a , ExpressionOperand b ) { return a . getValue() * b .getValue () ; } private double doDevide( ExpressionOperand a , ExpressionOperand b ) { return a . getValue() / b .getValue () ; } // SuffixExpression 本身已经是一个后缀表达了。getResultValue计算出结果就OK了 @Override public double getResultValue () throws Exception { SimpleStack <ExpressionOperand > scalc = new SimpleStack <>() ; for ( ExpressionElement e : expression ) { if ( e instanceof ExpressionOperand) { scalc .push (( ExpressionOperand) e) ; } else if ( e instanceof ExpressionOperator ) { ExpressionOperator operator = ( ExpressionOperator) e; // 获取这个运算符 ExpressionOperand opf = scalc .pop () ; // 弹出二元运算符的第二个操作数 ExpressionOperand ops = scalc .pop () ; // 弹出二元运算符的第一个操作数 ExpressionOperand temp = null ; // 存储临时运算结果 if ( opf == null || ops == null ) throw new Exception( "表达式不合法，不能完成计算" ) ; if ( operator. equals (ExpressionOperator . OP_PLUS)) { temp = new ExpressionOperand (doPlus ( ops, opf)) ; } else if ( operator. equals (ExpressionOperator . OP_MINUS)) { temp = new ExpressionOperand (doMinus ( ops, opf)) ; } else if ( operator. equals (ExpressionOperator . OP_MULTIPLE)) { temp = new ExpressionOperand (doMultiple ( ops, opf)) ; } else if ( operator. equals (ExpressionOperator . OP_DEVIDE)) { temp = new ExpressionOperand (doDevide ( ops, opf)) ; } scalc .push ( temp) ; } // else if } // end foreach if ( scalc .size () != 1) throw new Exception( "表达式不合法，不能完成计算" ) ; // 从 scalc栈中取出最后一个元素就是结果 return scalc . pop() . getValue() ; } } class InfixExpression extends Expression { public SuffixExpression toSuffixExpression() { SuffixExpression suffix = new SuffixExpression () ; // suffix是一个用来存储表达式元素的线性表对象，对应算法中的L SimpleStack <ExpressionElement > sop = new SimpleStack <>() ; // sop 栈 // 遍历原始表达式中的每一个元素 for ( ExpressionElement e : expression ) { if ( e instanceof ExpressionOperand) // 如果是操作数，则直接追加到后缀表达式suffix中 { suffix .append ( e) ; } else if ( e instanceof ExpressionDelimeter ) // 如果是分界符 { if ( e. equals (ExpressionDelimeter . DM_LEFT_PARENTHESES )) // 是 左括号,则直接压栈 { sop .push ( e) ; } else if ( e. equals (ExpressionDelimeter . DM_RIGHT_PARENTHESES )) // 是 右括号，则从 sop中弹出与这个括号配对的中间的所有元素， { // 并追加到后缀表达式中 while ( ! sop. isEmpty () && ! sop. peek (). equals (ExpressionDelimeter . DM_LEFT_PARENTHESES )) { suffix .append ( sop. pop ()); // 将元素出栈，追加到 suffix 表中去 } if ( ! sop. isEmpty ()) { sop .pop () ; // 将栈顶的( 出栈，丢弃。 } } } else if ( e instanceof ExpressionOperator ) // 如果是运算符 { while ( ! sop. isEmpty () && sop . peek() instanceof ExpressionOperator && 0 >= (( ExpressionOperator) e ). compareTo ((ExpressionOperator ) sop . peek())) { suffix .append ( sop. pop ()); } sop .push ( e) ; } } // end of foreach // 将 sop栈中剩余的元素全部追加到suffix后 while ( ! sop. isEmpty ()) { suffix .append ( sop. pop ()); } return suffix ; } @Override public double getResultValue () throws Exception { return toSuffixExpression () .getResultValue () ; } } /** * * 因为Java集合框架中的Stack类是线程安全的， 但是这里不需要这种特性，为了提高效率，使用双端队列作为内部实现，自己封装成为一个栈数据结构。 * * @see java.util.Stack <E> * @see java.util.Deque <E> * @see java.util.LinkedList <E> */ class SimpleStack < E> { private final Deque< E > deque = new LinkedList < E> (); public E pop() { return deque . pop() ; // 双端队列的第一个元素，也就是栈的栈顶 } public E peek() { return deque . peek() ; } public void push( E e ) { deque .push ( e) ; // 压栈 } public int size() { return deque . size() ; } public boolean isEmpty() { return 0 == deque .size () ; } @Override public String toString() { StringBuilder sb = new StringBuilder () ; sb .append ( "栈顶[") ; for ( E e : deque) { sb .append ( e. toString () + "," ) ; } sb .append ( "]栈底") ; return sb. toString (); } }