逆波兰式计算器 java,09 - 逆波兰计算器(示例代码)

1. 前缀表达式 (波兰表达式)

前缀表达式的运算符位于操作数之前

【举例说明】 (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6

前缀表达式的计算机求值

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈顶元素 和 次顶元素)，并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果

【举例说明】针对上例的前缀表达式求值步骤如下(栈顶 ? 次顶):

从右至左扫描，将6、5、4、3压入堆栈

遇到 + 运算符，因此弹出3和4(3为栈顶元素，4为次顶元素)，计算出3+4的值，得7，再将7入栈

接下来是 × 运算符，因此弹出7和5，计算出7×5=35，将35入栈

最后是 - 运算符，计算出 35-6 的值，即29，由此得出最终结果

2. 中缀表达式

中缀表达式就是常见的运算表达式，如(3+4)×5-6

中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(08-案例就能看的这个问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

3. 后缀表达式 (逆波兰表达式)

后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后

【举例说明】 (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

后缀表达式的计算机求值

从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(次顶元素 和 栈顶元素)，并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

【举例说明】针对上例的前缀表达式求值步骤如下(次顶 ? 栈顶):

从左至右扫描，将3和4压入堆栈

遇到+运算符，因此弹出4和3(4为栈顶元素，3为次顶元素)，计算出3+4的值，得7，再将7入栈

将 5 入栈；

接下来是 × 运算符，因此弹出5和7，计算出7×5=35，将35入栈

将 6 入栈

最后是 - 运算符，计算出35-6的值，即29，由此得出最终结果

4. 中缀表达式 → 后缀表达式

后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下。因此在开发中，我们需要将 中缀表达式 → 后缀表达式

4.1 具体步骤

4.2 举例

5. 逆波兰计算器

要求

输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果

支持小括号和多位数整数(仅支持对整数的计算)

思路

从左到右遍历逆波兰表达式。遇到数字就入栈；遇到运算符就出栈 [栈顶元素] 和 [次顶元素]，用该运算符对其进行运算，之后再将计算结果压栈

遍历结束后，[栈顶元素] 即为 最终表达式结果

6. 代码实现(综合 4, 5)

public class PolandNotaion {

public static void main(String[] args) {

String suffixExpression = "(30+4)*5-6";

List list = parseSuffixExpression(suffixExpression);

System.out.println("算式结果：" + calculate(list));

}

// 将 中缀表达式(算式) 由 String → List

public static List toInfixExpressionList(String str) {

char[] arr = str.toCharArray();

// 定义List

List list = new ArrayList<>();

// 用于遍历str

int i = 0;

// 用于对多位数的拼接

String temp = "";

char c;

while (i < arr.length) {

if((c=arr[i]) < 48 || (c=arr[i]) > 57) { // c不是数字

list.add("" + c);

i++;

} else { // c是数字

while(i < arr.length && (c=arr[i]) >= 48 && (c=arr[i]) <= 57) {

temp += c;

i++;

}

list.add(temp);

temp = "";

}

/*

c = arr[i];

if(c < 48 || c > 57) { // c不是数字

list.add("" + c);

} else { // c是数字

temp += c;

if((i+1 != arr.length) && (arr[i+1] < 48 || arr[i+1] > 57)) {

list.add(temp);

temp = "";

}

}

i++;

*/

}

return list;

}

// 中缀表达式List → 后缀表达式List

public static List parseSuffixExpression(String infixExpression) {

// 中缀表达式的字符串 → List

List infixExpressionList = toInfixExpressionList(infixExpression);

// 定义 [运算符栈s1]

Stack s1 = new Stack<>();

/*

* 定义 [存储中间结果的栈s2]

* 解释：s2这个栈, 在整个过程中没有pop操作, 而且在末尾还需要逆序输出

* 不如 直接使用一个List来替代s2的栈结构

*/

List s2 = new ArrayList<>();

// 遍历infixExpressionList

for(String item : infixExpressionList) {

if(item.matches("d+")) { // 是数, 加入s2

s2.add(item);

} else if(s1.isEmpty() || item.equals("(")) {

s1.push(item);

} else if(item.equals(")")) {

// 依次弹出 s1 栈顶的运算符，并压入 s2

while(!s1.peek().equals("(")) { // 直到遇到 " ( " 为止

s2.add(s1.pop());

}

s1.pop(); // 将 "(" 弹出, 即将这对括号丢弃

} else {

// 运算符优先级 ≤ 栈顶运算符优先级

while(s1.size() > 0 && getPriority(item) <= getPriority(s1.peek())) {

// 将 {栈顶运算符} 弹出并压入 s2 中

s2.add(s1.pop());

}

s1.push(item);

}

}

// 将 s1 中剩余的运算符 依次弹出 并加入 s2

while(s1.size() != 0)

s2.add(s1.pop());

// 依次弹出 s2 中的元素并输出，结果的逆序即为 中缀表达式对应的后缀表达式

// 因为 s2 是List, 所以存放的顺序就是最终后缀表达式的顺序

return s2;

}

// 返回运算符优先级(拟定为：优先级使用数字表示, 数字越大, 则优先级越高)

public static int getPriority(String operation) {

int val = 0;

switch (operation) {

case "+":

val = 1;

break;

case "-":

val = 1;

break;

case "*":

val = 2;

break;

case "/":

val = 2;

break;

default:

System.out.println("不存在该运算符" + operation);

break;

}

return val;

}

// 完成对逆波兰表达式的计算

public static int calculate(List list) {

// 创建栈(仅需1个栈即可)

Stack stack = new Stack();

// 遍历list

for(String item : list)

// 这里使用 [正则表达式] 来取数

if(item.matches("d+")) { // --> 匹配 多位数

// 入栈

stack.push(item);

} else { // --> 匹配 运算符

// 弹出 栈顶元素 和 次顶元素, 并通过此次扫描到的运算符进行运算

int topNum = Integer.parseInt(stack.pop());

int nextTopNum = Integer.parseInt(stack.pop());

// 解析运算符 (次顶 ___ 栈顶)

int result;

if(item.equals("+"))

result = nextTopNum + topNum;

else if(item.equals("-"))

result = nextTopNum - topNum;

else if(item.equals("*"))

result = nextTopNum * topNum;

else if(item.equals("/"))

result = nextTopNum / topNum;

else

throw new RuntimeException("运算符有误");

// 将结果再次入栈

stack.push(result + "");

}

return Integer.parseInt(stack.pop());

}

}