表达式计算 java 后缀表达式

题目:

问题描述
  输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。
输入格式
  输入一行,包含一个表达式。
输出格式
  输出这个表达式的值。
样例输入
1-2+3*(4-5)
样例输出
-4
数据规模和约定
  表达式长度不超过100,表达式运算合法且运算过程都在int内进行。
 
 

初看此题,从人的直观角度来说很简单,先遍历括号内的运算完再重新遍历,但是很麻烦。

回忆起了后缀表达式的知识

 

中缀表达式转后缀表达式的方法:
1.遇到操作数:直接输出(添加到后缀表达式中)
2.栈为空时,遇到运算符,直接入栈
3.遇到左括号:将其入栈
4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。
5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
6.最终将栈中的元素依次出栈,输出。

后缀表达式的计算机求值:
与前缀表达式类似,只是顺序是从左至右:
从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 op 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果。
例如后缀表达式“3 4 + 5 × 6 -”:
(1) 从左至右扫描,将3和4压入堆栈;
(2) 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素,注意与前缀表达式做比较),计算出3+4的值,得7,再将7入栈;
(3) 将5入栈;
(4) 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
(5) 将6入栈;
(6) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。

 

一开始,我先把中缀表达式转换为后缀表达式,再对后缀表达式求值。

有一个很大的问题,数字的保存,转化为后缀表达式时保存为char字符,对于大于9的数字保存很麻烦。

后来想了想,可以直接借用后缀表达式的计算方法。

代码如下

 1 public class Main {
 2     public static void main(String[] args) {
 3         // TODO Auto-generated method stub
 4         Scanner scanner = new Scanner(System.in);
 5         Stack<Integer> nums = new Stack<Integer>(); // 保存数字
 6         Stack<Character> opes = new Stack<Character>(); // 保存操作符
 7         String string = scanner.nextLine();
 8         int n = 0; // 保存每一个数字
 9         char[] cs = string.toCharArray();
10         for (int i = 0; i < cs.length; i++) {
11             char temp = cs[i];
12             if (Character.isDigit(cs[i])) {
13                 n = 10 * n + Integer.parseInt(String.valueOf(cs[i])); // 大于10的数字保存
14             } else {
15                 if (n != 0) {
16                     nums.push(n);
17                     n = 0;
18                 }
19                 if (temp == '(') {
20                     opes.push(temp);
21                 } else if (temp == ')') {
22                     while (opes.peek() != '(') { // 括号里面运算完
23                         int t = cal(nums.pop(), nums.pop(), opes.pop());
24                         nums.push(t);
25                     }
26                     opes.pop();
27                 } else if (isType(temp) > 0) {
28                     if (opes.isEmpty()) { // 栈为空直接入栈
29                         opes.push(temp);
30                     } else {
31                         // 若栈顶元素优先级大于或等于要入栈的元素,将栈顶元素弹出并计算,然后入栈
32                         if (isType(opes.peek()) >= isType(temp)) {
33                             int t = cal(nums.pop(), nums.pop(), opes.pop());
34                             nums.push(t);
35                         }
36                         opes.push(temp);
37                     }
38                 }
39             }
40         }
41         // 最后一个字符若是数字,未入栈
42         if (n != 0) {
43             nums.push(n);
44         }
45         while (!opes.isEmpty()) {
46             int t = cal(nums.pop(), nums.pop(), opes.pop());
47             nums.push(t);
48         }
49         System.out.println(nums.pop());
50     }
51 
52     // 返回的是运算符的优先级,数字和()不需要考虑
53     public static int isType(char c) {
54         if (c == '+' || c == '-') {
55             return 1;
56         } else if (c == '*' || c == '/') {
57             return 2;
58         } else {
59             return 0;
60         }
61     }
62 
63     // 运算次序是反的,跟入栈出栈次序有关
64     public static int cal(int m, int n, char c) {
65         int sum = -987654321;
66         if (c == '+') {
67             sum = n + m;
68         } else if (c == '-') {
69             sum = n - m;
70         } else if (c == '*') {
71             sum = n * m;
72         } else if (c == '/') {
73             sum = n / m;
74         }
75         return sum;
76     }
77 }

 

posted @ 2017-03-13 21:21  十六梦魇  阅读(7158)  评论(0编辑  收藏  举报