逆波兰算法（后缀表达式）实现数学表达式计算_编程实现将正常的四则运算表达式转换成后缀表达式(逆波兰式),然后利用后缀表达式

什么是逆波兰表达式（后缀表达式）：

逆波兰算法（Reverse Polish Notation, RPN），也被称作后缀表达式，是一种没有括号，且任何运算符均放置于对应的操作数之后的算术表达式。这种表示方法避免了运算符优先级带来的歧义，使得算术表达式的解析更为简单。
后缀表达式（逆波兰表达式）的组成：
**操作数：**表达式中的数字和变量。
**运算符：**加、减、乘、除等算术运算符，以及比较运算符等。
后缀表达式的特点：

• 没有优先级，运算符按照出现的顺序执行。
• 任何运算符均出现在其相关操作数之后。
• 可以使用栈（stack）数据结构方便地进行计算。

将中缀表达式（如常见的数学表达式) 转换为逆波兰表达式)的过程通常涉及以下步骤：
1、 创建两个栈：一个用于操作数 (称为操作数栈或数组)，另一个用于运算符 (称为运算符栈)。
2、从左到右扫描中缀表达式。
3、如果遇到操作数，将其转换为逆波兰表达式，并在操作数栈中添加该操作数。
4、如果遇到运算符：
1）如果运算符栈为空或栈顶运算符为左括号(，或当前运算符优先级高于栈顶运算符，则将当前运算符压入运算符栈。
2） 否则，当栈顶运算符优先级大于或等于当前运算符优先级时，将栈顶运算符弹出并添加到操作数栈中，然后继续比较栈顶新的运算符与当前运算符的优先级。
5、如果遇到左括号 (，将其压入运算符栈。 如果遇到右括号 )，则将栈顶的运算符弹出并添加到操作数栈中，直到遇到左括号(。弹出左括号，但不用它表示任何运算。
6、表达式扫描完毕后，将操作数栈中的元素依次弹出并添加到运算符栈中，再运算符元素依次弹出组成字符串即为逆波兰表达式。

转换成逆波兰表达式详细步骤举例：

将 “3+4-(5*8)/7” 转换成逆波兰表达式为：”3 4 + 4 5 7 / + -“，步骤如下

simple:3+4-(5*8)/7
res: 3 4 + 4 5 7 / + -
step1: 从simple从左向右扫描，遇到操作数压入数字栈numStack中，遇到操作符压入符号栈operStack
      numStack:3 4     
      operStack:+    
step2:  遇到-操作符与+优先级一致，将+从符号栈弹出放入数字栈，再将-放入符号栈
	numStack:3 4 +  
	operStack:-
step3: numStack:3 4 + 4  
	operStack:- ( 
step4: 遇到+操作符比符号栈(优先小，将（从符号栈弹出放入数字栈，再将+放入符号栈
	numStack:3 4 + 4 (  
	operStack:- +
step5: 
	numStack:3 4 + 4 ( 5  
	operStack:- + )
step6: 
	numStack:3 4 + 4 ( 5  ) 7  
	operStack:- + /
step7:
	numStack->operStack:- + / 7 ) 5 ( 4 + 4 3
step8:
	operStack依次pop(省略“(”，“)”)最终结果为:3 4 + 4 5 7 / + -
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

逆波兰表达式计算

假设有一个逆波兰表达式 3 4 + 2 *。
1、初始化一个空栈。
2、从左至右扫描表达式：
	遇到数字 3，将其入栈。
	遇到数字 4，将其也入栈。
	遇到 + 运算符，由于栈顶是 3 和 4（操作数），满足执行条件，所以弹出栈顶的两个操作数（3 和 4），执行 3 + 4，将结果 7 入栈。
	遇到数字 2，入栈。
	遇到 * 运算符，栈顶是 7 和 2（操作数），满足执行条件，弹出栈顶的两个操作数（7 和 2），执行 7 * 2，将结果 14 入栈。
3、表达式扫描完毕，栈中只有一个元素 14，这就是表达式的计算结果。
1
2
3
4
5
6
7
8
9

具体代码实现如下：

package com.data;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Stack_infixToSuffix {

    public static void main(String[] args) {
//        String s = infixToSuffix("30+ 50 - (4 * ( 4 + 50 )) ");
//        String s = infixToSuffix("3 + 4 - ( 5 * 8 ) / 7");
        String s = infixToSuffix("3+4-(5*8)/7");

        System.out.println("后缀表达式：" + s);

        int calculate = calculate(s);
        System.out.println("运算结果：" + calculate);
    }

    /**
     *
     * @param s
     * @return 返回一个包含s中所有数字与操作符的List
     */
    public static List<String> getList(String s) {
        List<String> list = new ArrayList<>();

        s = s.replace(" ", "");
        String s1 = "";
        for (int i = 0; i < s.length(); i++) {
            String t = String.valueOf(s.charAt(i));
            if (getPriority(t) == 0) {//多位数拼接
                s1 = s1 + t;
            } else {//当前字符不为数字时
                if (!s1.equals("")) {
                    s1 = s1.trim();
                    list.add(s1);
                    s1 = "";
                }
                list.add(t.trim());
            }

        }
        list.add(s1);
        return list;
    }

    /**
    *         simple:3+4-(5*8)/7
    *         res: 3 4 + 4 5 7 / + -
    *         step1: numStack:3 4     operStack:+    遇到-操作符与+优先级一致，将+从符号栈弹出放入数字栈，再将-放入符号栈
    *         step2: numStack:3 4 +   operStack:-
    *         step3: numStack:3 4 + 4  operStack:- ( 遇到+操作符比符号栈(优先小，将（从符号栈弹出放入数字栈，再将+放入符号栈
    *         step4: numStack:3 4 + 4 (  operStack:- +
    *         step5: numStack:3 4 + 4 ( 5  operStack:- + )
    *         step6: numStack:3 4 + 4 ( 5  ) 7  operStack:- + /
    *         step7: numStack->operStack:- + / 7 ) 5 ( 4 + 4 3
    *         step8:operStack依次pop(省略“(”，“)”):3 4 + 4 5 7 / + -
     *
     *
     * @param s
     * @return 后缀表达式（逆波兰表达式）
     */
    public static String infixToSuffix(String s) {
        List<String> list = getList(s);
        System.out.println("=====" + list);
        String result = "";

        Stack<String> numStack = new Stack<>();
        Stack<String> operStack = new Stack<>();
        for (String s1 : list) {
            if (s1.matches("\\d+")) {
                //将数字压入数字栈
                numStack.push(s1);
            } else {
                if (operStack.isEmpty()) {
                    operStack.push(s1);
                } else {
                    String peek = operStack.peek();
                    //比较符号栈中首个符号的优先级与即将压入符号栈中的元素的优先级，peek优先级<s1，就直接放入符号栈
                    if (getPriority(peek) < getPriority(s1)) {
                        operStack.push(s1);
                    } else {
                        //否则，将符号栈栈顶元素放入数字栈，再将s1放入符号栈
                        String t = operStack.pop();
                        numStack.push(t);
                        operStack.push(s1);
                    }
                }
            }
        }
        while (!numStack.isEmpty()) {
            String pop = numStack.pop();
            operStack.push(pop);
        }
        while (!operStack.isEmpty()) {
            String s2 = operStack.pop();
            if (s2.equals("(") || s2.equals(")")) {
                continue;
            }
            result = result + s2 + " ";
        }
        return result;
    }

    /**
     * @param s 操作符
     * @return 返回每种操作符的优先级 +，-为1，*，/为2，（，）为3
     */
    static int getPriority(String s) {
        int p = 0;
        if (s.equals("+") || s.equals("-")) {
            p = 1;
        } else if (s.equals("*") || s.equals("/")) {
            p = 2;
        } else if (s.equals("(") || s.equals(")")) {
            p = 3;
        }
        return p;
    }


    /**
     * 根据 suffix 逆波兰表达式计算表达式的值
     * 计算后缀表达式的过程非常简单，只需要一个栈：
     * 遍历后缀表达式的每个字符。
     * 遇到操作数，将其压入栈中。
     * 遇到运算符，弹出栈顶的两个操作数，进行运算，将结果压回栈中。
     * 重复上述步骤，直到表达式计算完成。
     * 栈中剩余的一个元素即为最终结果
     * @param suffix
     * @return
     */
    public static int calculate(String suffix) {
        String[] se = suffix.split(" ");

        Stack<String> stack = new Stack<>();
        for (String s : se) {
            if (s.matches("\\d+")) {//匹配到数字入栈
                stack.push(s);
            } else {
                //匹配到了操作符 进行计算
                int n1 = Integer.parseInt(stack.pop());
                int n2 = Integer.parseInt(stack.pop());
                int res = 0;
                if (s.equals("+")) {
                    res = n1 + n2;
                    stack.push(String.valueOf(res));
                } else if (s.equals("-")) {
                    res = n2 - n1;
                    stack.push(String.valueOf(res));
                } else if (s.equals("*")) {
                    res = n1 * n2;
                    stack.push(String.valueOf(res));
                } else if (s.equals("/")) {
                    res = n2 / n1;
                    stack.push(String.valueOf(res));
                } else {
                    throw new RuntimeException("运算符异常");
                }
            }
        }
        int res = Integer.parseInt(stack.pop());
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166