原文地址：http://smiky.iteye.com/blog/718598
逆波兰表达式是一种十分有用的表达式，它将复杂表达式转换为可以依靠简单的操作得到计算结果的表达式。例如(a+b)*(c+d)转换为ab+cd+*d+。
它的优势在于只用两种简单操作，入栈和出栈就可以搞定任何普通表达式的运算。其运算方式如下：
如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。
将一个普通的中序表达式转换为逆波兰表达式的一般算法是：
(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号"#"。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。倘若不是的话，则将栈顶的运算符从栈中弹出，直到栈顶运算符的优先级低于当前运算符，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。其中运算符优先级如下：
*/:4
+-:3
(:2
):1
中缀表达式到后缀表达式的转换
要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。如果所有操作符优先级一样，那么求值顺序就取决于它们的结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。
转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：
1. 初始化一个空堆栈，将结果字符串变量置空。
2. 从左到右读入中缀表达式，每次一个字符。
3. 如果字符是操作数，将它添加到结果字符串。
4. 如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
5. 如果字符是个开括号，把它压入堆栈。
6. 如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
7. 如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。
逆波兰表达式又称后缀式，是波兰逻辑学家J.Lukasiewicz于1929提出的一种后缀表达运算式的方法。区别于我们所熟悉的中缀式，后缀式的特点就是运算量在前，运算符在后，如a+b表达为ab+。这种后缀表达式非常方便去掉运算符优先级的影响与括号，甚至是单目运算符：
1. a*b+c*(d+e) => ab*cde+*+
2. -a+-b*+c => a!b!c#*+ （注：为区别与减法运算与加法运算，这里用!表示负号，#表示正号）
那么计算机怎样通过后缀式来进行运算呢？这里首先假设读取分析表达式的准备工作都已经做好了，那么首先需要做的是把表达式转换成后缀式，也就是逆波兰表达式的构建过程。
构建器由两个主要组件组成，一个是目标表达式的存储器，另一个是一个符号栈。与源表达式的扫描顺序一样，存储器是从左向右储存数据的，而符号栈则遵守后进先出的原则：
* 读入一个数据
1. 如果是单目运算符，直接入符号栈；
2. 如果是运输量，则直接写入存储器；检查符号栈顶是否有单目运算符，有的话则全部出栈，并写入存储器；
3. 如果是左括号"("，则直接入符号栈；
4. 如果是右括号")"，则弹出符号栈数据，写入存储器，直到左括号弹出；
5. 如果是普通运算符，则与栈顶符号比较优先级，若大于栈顶优先级，则入栈；否则弹出栈顶符号并写入存储器，直到栈顶符号的运算优先级较小为止；
6. 如果是结束符（表示表达式已全部读完），则符号栈全部弹出并写入存储器，否则读取数据进入下个过程。
此外还有一些处理的技巧，比如定义一个优先级最低的运算符作为表达式结束的标志，在符号栈里首先加入一个结束标志，那么表达式读完时则自动弹出栈中所有符号，并写入存储器结尾表示成功。
下面用一个表格表示构建的过程：
Token
Expression
Dest Data
LIFO stack
Description
a*b+c*(d+-e)#
#
# is Ending Sign
a
*b+c*(d+-e)#
a
#
Value -> Data
*
b+c*(d+-e)#
a
#*
* > #
b
+c*(d+-e)#
ab
#*
Value -> Data
+
c*(d+-e)#
ab*
#
+ < *
c*(d+-e)#
ab*
#+
+ > #
c
*(d+-e)#
ab*c
#+
Value -> Data
*
(d+-e)#
ab*c
#+*
* > +
(
d+-e)#
ab*c
#+*
LPar( -> Stack
d
+-e)#
ab*cd
#+*(
Value -> Data
+
-e)#
ab*cd
#+*(+
</td>
+ > (
!
e)#
ab*cd
#+*(+!
! -> Stack
e
)#
ab*cde!
#+*(+
Value -> Data, Pop !
)
#
ab*cde!+
#+*
RPar) -> Pop Until (
#
ab*cde!+*+#
# -> Pop Until #
接下来是计算的过程。计算的时候除了刚才构建的数据外，还需要另外一个数据栈。首先是从左至右扫描数据段，如果读出的是数据则压入数据栈，遇到符号时从数据栈中弹出相应的数据进行运算，再把结果压回数据栈。依然拿上面的结果做表格列示：
Token
Expression
Data Stack
Compute
Description
ab*cde!+*+#
a
b*cde!+*+#
a
Value -> Stack
b
*cde!+*+#
ab
Value -> Stack
*
cde!+*+#
a*b
Pop a, b
cde!+*+#
m
set m = a*b
c
de!+*+#
mc
Value -> Stack
d
e!+*+#
mcd
Value -> Stack
e
!+*+#
mcde
Value -> Stack
!
+*+#
mcd
!e
Pop e
+*+#
mcdn
set n = !e
+
*+#
mc
d+n
Pop d, n
*+#
mco
set o = c+n
*
+#
m
c*o
Pop c, o
+#
mp
set p = c*o
+
#
m+p
Pop m, p
#
r
set r = m+p
#
r
check
Accept!
这样，返回结果就是栈中唯一的数据，我们完成了逆波兰表达式的全部计算过程。
感觉对于做计算器的话,这个东西很有用啊
下面是我的实现:
首先实现一个栈
Java代码
1. package myPolishNotation;
2.
3. public class Stack<T> {
4.
5. private StackNode<T> top;
6. private int index = -1;
7. public void push(T content){
8. StackNode<T> node = new StackNode<T>();
9. node.setContent(content);
10. node.setLink(top);
11. top = node;
12. index++;
13. }
14.
15. public StackNode<T> pop(){
16. if(index==-1){
17. System.out.println("stack hasn't content");
18. return null;
19. }
20. StackNode<T> node = this.getTop();
21. top = node.getLink();
22. index--;
23. return node;
24. }
25.
26. public StackNode<T> getTop() {
27. return top;
28. }
29.
30. public int getIndex() {
31. return index;
32. }
33.
34.
35.}
栈的节点:
Java代码
1. package myPolishNotation;
2.
3. public class StackNode<T> {
4.
5. private T content;
6. private StackNode<T> link;
7.
8. public T getContent() {
9. return content;
10. }
11. public void setContent(T content) {
12. this.content = content;
13. }
14.
15. public StackNode<T> getLink() {
16. return link;
17. }
18. public void setLink(StackNode<T> link) {
19. this.link = link;
20. }
21.
22.}
最后实现
Java代码
1. package myPolishNotation;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.StringTokenizer;
6.
7. public class PolishNotation {
8.
9. public List<String> parseExpression(String expression){
10. //先将表达式分割成操作符与数字并放入temp列表
11. StringTokenizer st = new StringTokenizer(expression,"+-*/()",true);
12. List<String> temp = new ArrayList<String>();
13. while(st.hasMoreElements()){
14. temp.add((String)st.nextElement());
15. }
16. List<String> polisthNotationlist = new ArrayList<String>();
17. Stack<String> stack = new Stack<String>();
18. for(String temp_ch : temp){
19. if(isOperator(temp_ch)){
20. //栈为空或操作符为(就入栈
21. if(stack.getIndex()==-1||"(".equals(temp_ch)){
22. stack.push(temp_ch);
23. }else{
24. //如果操作符为)就将栈内)之前(之后的操作符弹出并放入逆波兰列表,最后弹出(
25. if(")".equals(temp_ch)){
26. while(!stack.getTop().getContent().equals("(")){
27. String operator = stack.getTop().getContent();
28. polisthNotationlist.add(operator);
29. stack.pop();
30. }
31. stack.pop();
32. }else{
33. //如果栈顶元素为(,操作符入栈
34. if(stack.getTop().getContent().equals("(")){
35. stack.push(temp_ch);
36. }else{
37. //当栈不为空,且栈顶元素不为(时,比较操作符的优先级,如果栈顶元素优于当前操作符,那么弹出栈顶元素,直到栈为空或栈顶元素优先级低于当前操作符,
38. //则将当前操作符压入栈
39. while(stack.getIndex()!=-1&&!stack.getTop().getContent().equals("(")){
40. if(isPriority(operatorPriority(stack.getTop().getContent()),operatorPriority(temp_ch))){
41. String operator = stack.getTop().getContent();
42. polisthNotationlist.add(operator);
43. stack.pop();
44. if(stack.getIndex()==-1||!isPriority(operatorPriority(stack.getTop().getContent()),operatorPriority(temp_ch))){
45. stack.push(temp_ch);
46. break;
47. }
48. }else{
49. stack.push(temp_ch);
50. break;
51. }
52. }
53. }
54. }
55. }
56. }else{
57. //非操作符直接入栈
58. polisthNotationlist.add(temp_ch);
59. }
60. }
61. while(stack.getIndex()!=-1){
62. //栈中余下的操作符弹出
63. polisthNotationlist.add(stack.pop().getContent());
64. }
65. return polisthNotationlist;
66. }
67.
68. //计算逆波兰表达式的值
69. public double calculatePolishNotation(List<String> polishNotation){
70. Stack<String> stack = new Stack<String>();
71. for(String str : polishNotation){
72. if(!this.isOperator(str)){
73. stack.push(str);
74. }else{
75. String number1 = stack.pop().getContent();
76. String number2 = stack.pop().getContent();
77. stack.push(String.valueOf(calculate(str, number2, number1)));
78. }
79. }
80. return Double.parseDouble(stack.pop().getContent());
81. }
82.
83. //普通表达式计算
84. public double calculate(String operator,String number1,String number2){
85. char opt = operator.charAt(0);
86. double double1 = Double.parseDouble(number1);
87. double double2 = Double.parseDouble(number2);
88. switch(opt){
89. case '+':
90. return double1+double2;
91. case '-':
92. return double1-double2;
93. case '*':
94. return double1*double2;
95. case '/':
96. return double1/double2;
97. }
98. return 0;
99. }
100.
101. //设置操作符优先级,()设不设无所谓
102. public int operatorPriority(String operator){
103. if("(".equals(operator)){
104. return 1;
105. }
106. if(")".equals(operator)){
107. return 2;
108. }
109. if("+".equals(operator)||"-".equals(operator)){
110. return 3;
111. }
112. if("*".equals(operator)||"/".equals(operator)){
113. return 4;
114. }
115. return 0;
116. }
117.
118. //栈顶操作符与列表中操作符比较优先级
119. public boolean isPriority(int topOperator,int listOperator){
120. if(topOperator>=listOperator){
121. return true;
122. }
123. return false;
124. }
125.
126. //判断是否为操作符
127. public boolean isOperator(String arg){
128. if("+-*/()".indexOf(arg)!=-1){
129. return true;
130. }
131. return false;
132. }
133.
134. public static void main(String[] args) {
135. PolishNotation pn = new PolishNotation();
136. List<String> list = pn.parseExpression("4-(4-3*5+(2*4)+100)/10");
137. for(String str:list){
138. System.out.print(str+"/t");
139. }
140. System.out.println(pn.calculatePolishNotation(pn.parseExpression("4-(4-3*5+(2*4)+100)/10")));
141. }
142.
143. }
