练手系列(3) 中缀表达式转后缀表达式

　　最近在看数据结构和算法时，看到了中缀表达式和后缀表达式，感觉蛮有意思的，于是自己实现了一下，算是一种锻炼。

①首先，中缀表达式就是我们平时见惯了的算术式，比如：5+3这样的就是中缀表达式，而后缀表达式呢，就是53+这样的。因为转为后缀表达式后，算术式的计算会相对简单一些，可以用栈来实现。

分析图如下：

这种后缀表达式计算的最大的优点就是不用知道什么优先级。

②好，下面我们来看一下怎么从中缀表达式（5+3）变为后缀表达式（53+）：

好了，以上两张图片就是后缀表达式的相关分析。

下面上具体代码：

import java.util.Stack;

public class Calculate {
    // 定义操作符号
    private static final char PLUS = '+';
    private static final char MINUS = '-';
    private static final char MULTIPLY = '*';
    private static final char DIVIDE = '/';
    private static final char LEFT_PARENTHESIS = '(';
    private static final char RIGHT_PARENTHESIS = ')';

    public static void main(String[] args) {
        String infix = "(3+(2-1))*5";
        String postfix = convert(infix);
        System.out.println(postfix);
        analysePostfix(postfix);
    }

    // 计算后缀表达式
    public static void analysePostfix(String postfix) {
        Stack<Double> stack = new Stack<Double>();
        char[] chs = postfix.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            if (chs[i] != PLUS && chs[i] != MINUS && chs[i] != MULTIPLY
                    && chs[i] != DIVIDE) {
                // 如果读取到的是数字，则加到栈中
                stack.push(Double.valueOf(String.valueOf(chs[i])));
            } else {
                // 如果读取到的是操作符，则从栈中弹出两个数字，并执行运算
                double b = (double) stack.pop();
                double a = (double) stack.pop();
                char operator = chs[i];
                double result = calculate(a, b, operator);
                stack.push(result);
            }
        }
        System.out.println("result is : " + stack.pop());
    }

    public static double calculate(double a, double b, char operator) {
        switch (operator) {
        case PLUS:
            return a + b;
        case MINUS:
            return a - b;
        case MULTIPLY:
            return a * b;
        case DIVIDE:
            return a / b;
        }
        return 0;
    }

    // 中缀到后缀的转换
    public static String convert(String infix) {
        Stack<Character> vector = new Stack<Character>();
        char[] chs = infix.toCharArray();
        StringBuffer postfix = new StringBuffer();
        for (int i = 0; i < chs.length; i++) {
            // 如果是数字，直接插入表达式中
            if (chs[i] != PLUS && chs[i] != MINUS && chs[i] != MULTIPLY
                    && chs[i] != DIVIDE && chs[i] != LEFT_PARENTHESIS
                    && chs[i] != RIGHT_PARENTHESIS) {
                postfix.append(String.valueOf(chs[i]));
            } else {
                // 如果是左括号，直接压入栈中
                if (LEFT_PARENTHESIS == chs[i]) {
                    vector.push(chs[i]);
                    continue;
                }
                // 如果是右括號，則去除棧裏面的左括號之上的所有操作符號
                if (RIGHT_PARENTHESIS == chs[i]) {
                    while (LEFT_PARENTHESIS != vector.peek()) {
                        postfix.append(vector.pop());
                    }
                    vector.pop();
                }
                // 如果当前读到的操作符和栈里面的操作符一样，那么直接加到后缀表达式中
                if (vector.size() > 0 && chs[i] == vector.peek()) {
                    postfix.append(String.valueOf(chs[i]));
                } else if (vector.size() == 0 || chs[i] != vector.peek()) {
                    // 如果是乘号或者除号，直接压入栈中
                    if (MULTIPLY == chs[i] || DIVIDE == chs[i]) {
                        vector.push(chs[i]);
                    }
                    if (PLUS == chs[i] || MINUS == chs[i]) {
                        if (vector.size() > 0
                                && (vector.peek() == MULTIPLY || vector.peek() == DIVIDE)) {
                            postfix.append(vector.pop().toString());
                            vector.push(chs[i]);
                        } else {
                            vector.push(chs[i]);
                        }
                    }
                }
            }
            // 如果已经读完了中缀表达式，则弹出栈中所有操作符并加入到后缀表达式中
            if (i == chs.length - 1) {
                for (int j = vector.size(); j > 0; j--) {
                    postfix.append(vector.pop().toString());
                }
            }
        }
        return postfix.toString();
    }
}