中缀表达式转后缀表达式

中缀表达式简单的讲就是我们平时看到的混合运算式，比如1+((2+3)x 4)-5，但是计算机运算这样的式子并不方便，我们就需要将中缀表达式进行转换，转换成适合计算机计算的式子称为后缀表达式，转换后的式子叫做后缀表达式。

转换的过程有些复杂，我们来看一下大牛们发明的算法思路。

中缀表达式转后缀表达式思路：

 我们还是以1+((2+3)x 4)-5为例来理解这个思路的具体工作流程：

• 开始第一次扫描：
• 遇到1直接压入s2，
• 遇到+号，观察s1栈为空，直接压入s1，
• 遇到(，左括号直接压入s1，
• 遇到2，数字直接压入s2，
• 遇到+，运算符观察栈顶优先级，s1栈顶元素为(,直接压入s1，
• 遇到3，数字直接压入s2，
• 遇到)，右括号不要压入s1，依次弹出s1的栈顶元素，如果弹出的元素为左括号，停止弹出元素，抛弃这一对括号，
• 遇到x，此时s1栈顶为(,将x直接压入s1，
• 遇到4，数字直接压入s2，
• 遇到)，右括号不入s1，依次弹出s1的栈顶元素，遇到左括号停止弹出，抛弃这一对括号，
• 遇到-，减号优先级不比加号高，弹出s1的栈顶元素，s1这时候为空，压入-，
• 遇到5，直接压入s2，
• 将s1中剩余的元素都压入s2，
• 逆序输出s2:1 2 3 + 4 x + 5 -

 代码实现：

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


public class PolandNotation {
    public static void main(String[] args) {
        // 中缀表达式
        String infixExpression = "1+((2+3)*4)-5";
        // 将中缀表达式转成集合
        List<String> iel = infixExpressionList(infixExpression);
        System.out.println("中缀表达式:"+iel);
        // 将中缀表达式转成后缀表达式
        List<String> suffixExpression = parseSuffixExpression(iel);
        System.out.println("后缀表达式:"+suffixExpression);

    }

    // 中缀表达式转成以多位数字、运算符为个体的运算符 如[10,+,(,(,2,+,3,),*,4,),-,5]
    public static List<String> infixExpressionList(String s){
        // 存放中缀表达式
        List<String> ls = new ArrayList<String>();
        // 字符串转成当个字符
        char[] chars = s.toCharArray();
        // 拼接多位数
        String morenum = "";
        int j = 0;
        for (int i = 0; i < chars.length;   ) {
            // 非数字
            if (chars[i]<48 || chars[i]>57){ //ASCII码中非数字的判断条件
                ls.add("" + chars[i]); // 采用拼接，将字符转为字符串
                i++;
            }else {  //数字，考虑是否为多位数
                while (i<chars.length && chars[i]>=48 && chars[i]<=57){
                    morenum += chars[i];
                    i++;
                }
                ls.add(morenum);
                morenum = "";
            }
        }

        return ls;

    }

    // 中缀表达式转为后缀表达式
    public static List<String> parseSuffixExpression(List<String> ls){
        // 1.创建s1栈和s2
        Stack<String> s1 = new Stack<String>(); //符号栈
        // Stack<String> s2 = new Stack<String>(); //中间栈
        // 我们由上面算法可以发现，s2栈在整个转换过程中，没有pop操作，最后还要逆序输出，在这里就不使用栈
        List<String> s2 = new ArrayList<String>();
        // 2.遍历表达式
        for (String item : ls){
            //3.遇到数字，直接压入s2
            if (item.matches("\\d+")){
                s2.add(item);
            }else if ("(".equals(item)){ // 5.1遇到左括号，压入s1
                s1.push(item);
            }else if (")".equals(item)){ // 5.2遇到右括号
                while (!"(".equals(s1.peek())){ // peek查看当前栈顶元素
                    s2.add(s1.pop()); // 5.2弹出左括号之前的所有元素到s2中
                }
                // 5.2 抛弃这一对括号，右括号未入栈，只抛弃左括号
                s1.pop();
            }else { // 4 遇到运算符,比较运算符的优先级
                // 4.1 当前item优先级比s1栈顶元素优先级低,压入s1
                while (s1.size() != 0 && Operation.getPriority(item)<=Operation.getPriority(s1.peek())){ //自定义比较运算符方法
                    s2.add(s1.pop());// 4.3将s1栈顶元素弹出到s2，再循环比较优先级
                }
                // 4.2 经过循环后，item优先级比栈顶元素高(或者空栈),将item压入s1栈内
                s1.push(item);
            }
        }
        // 7 将剩余s1元素pop到s2中
        while (s1.size() != 0){
            s2.add(s1.pop());
        }
        // 8.逆序s2，由于我们使用的不是栈，因此不需要逆序,直接返回s2
        return s2;

    }
}

class Operation{
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    public static int getPriority(String oper){ //不用new就可以调用该方法
        int result = 0;
        switch (oper){
            case "+":result = ADD;break;
            case "-":result = SUB;break;
            case "*":result = MUL;break;
            case "/":result = DIV;break;
            default: /*System.out.println("不是合法的运算符");*/break;
        }
        return result;
    }
}