中缀表达式转后缀表达式及其计算

中缀表达式->后缀表达式

算法：

1.循环读取输入的字符串
2.读取到操作数：输出
3.读取到’+’, ‘-’ : 弹出栈的内容到输出流直到遇到’(‘，最后将’+’或’-‘入栈
4.读取到’*’, ‘/’ : 弹出栈的内容到输出流直到遇到’(‘, 最后将’*’或’/’入栈
5.读取到’(‘，入栈
6.读取到’)’, 弹出栈的内容到输出流直到遇到’(‘， 圆括号不输出。

个人实现的代码如下:

public static String midToPost(String s) {
        int n = s.length();
        StringBuilder str = new StringBuilder();
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            Character temp;
            switch (ch) {
            case ' ':
                break;
            case '('://遇到'('压栈
                stack.push(ch);
                break;
            case '+'://遇到'+'或者'-'一直弹出栈的内容到输出直到遇到'(',然后将'+'或者'-'压栈
            case '-':
                while(!stack.isEmpty()) {
                    temp = stack.peek();
                    if (temp == '(') {
                        break;
                    } else {
                        str.append(stack.pop());
                    }
                }
                stack.push(ch);
                break;
            case '*'://遇到'*'或者'/'一直弹出栈的内容到输出直到遇见'(','+','-'，最后压栈'*'或者'/'
            case '/':
                while (!stack.isEmpty()) {
                    temp = stack.peek();
                    if (temp == '(' || temp == '+' || temp == '-') {
                        break;
                    } else {
                        str.append(stack.pop());
                    }
                }
                stack.push(ch);
                break;
            case ')'://遇到')'一直弹出栈的内容到输出直到遇见'(',弹出'('，不输出不压栈
                while (!stack.isEmpty()) {
                    temp = stack.peek();
                    if (temp == '(') {
                        stack.pop();
                        break;
                    } else {
                        str.append(stack.pop());
                    }
                }
                break;
            default:
                str.append(ch);
                break;
            }

测试如下：

输入1：a+b*c+(d*e+f)*g

输出2：abc*+de*f+g*+

输入2：5+((1+2)*4)-3

输出2：512+4*+3-

---

后缀表达式的计算

算法：

循环读取输入流

读取到数字时压栈

读取到操作符时，对栈做两次弹出，对这两个弹出的数字错对应操作，如果是减法和除法注意区分减数和被减数，除数和被除数。

个人实现的代码如下:

private static int postFixCal(String input) {
        Stack<Integer> stack = new Stack<Integer>();
        int n = input.length();
        int a,b;
        for(int i = 0; i < n; i++) {
            char tmp = input.charAt(i);
            if(tmp>='A' && tmp<='F') {
                stack.push((int)(tmp-'A')+10);
            } else if(tmp>='1' && tmp<='9'){
                stack.push(tmp - 48);
            } 
            switch(tmp) {
            case '+':
                a = stack.pop();
                b = stack.pop();
                stack.push(b+a);
                break;
            case '-':
                a = stack.pop();
                b = stack.pop();
                stack.push(b-a);
                break;
            case '*':
                a = stack.pop();
                b = stack.pop();
                stack.push(b*a);
                break;
            case '/':
                a = stack.pop();
                b = stack.pop();
                stack.push(b/a);
                break;
            default:
                break;

            }
        }
        return stack.pop();
    }

有了后缀表达式的计算，就不用管中缀表达式的那些括号匹配啦，超麻烦。

所以现在可以将一个中缀表达式的输入转为后缀表达式，然后再进行计算。

输入：512+4*+3- （上文的输入2）

输出：14

在本人机器eclipse调试通过，读者可以自行测试。

以上。