栈：中缀表达式转换为后缀表达式

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

具体步骤如下：

1) 初始化两个栈：运算符栈s1和储存中间结果的栈s2；

2) 从左至右扫描中缀表达式；

3) 遇到操作数时，将其压s2；

4) 遇到运算符时，比较其与s1栈顶运算符的优先级：

　　(1). 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；

　　(2). 否则，若优先级比栈顶运算符的高，也将运算符压入s1；

　　(3). 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较；

5) 遇到括号时：
　　(1). 如果是左括号“(”，则直接压入s1
　　(2). 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号    为止，此时将这一对括号丢弃

6) 重复步骤2至5，直到表达式的最右边

7) 将s1中剩余的运算符依次弹出并压入s2

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

举例说明

将中缀表达式 1 + ( ( 2 + 3 )× 4) - 5 => 后缀表达式 过程如下：

结果为： 1 2 3 + 4 * + 5 -

 代码实现

package com.jyj.stack;

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

public class PolandNotation {
    public static void main(String[] args) {
        //完成一个中缀表达式转后缀表达式的功能
        //说明：
        //1. 1+((2+3)*4)-5 => 转成 1 2 3 + 4 * + 5 -
        //2. 因为直接对str 进行操作，不方便，因此先将"1+((2+3)*4)-5" => 中缀的表达式对应的List
        //   即"1+((2+3)×4)-5" => ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
        //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
        //   即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
        String expression = "1+((2+3)*4)-5";
        List<String> inffixExpressionList = toInffixExpressionList(expression);
        System.out.println("inffixExpressionList = "+inffixExpressionList);
        List<String> suffixExpressionList = parseSuffixExpressionList(inffixExpressionList);
        System.out.println("suffixExpressionList = " + suffixExpressionList);    
    }
    
    //将得到的中缀表达式对应的List => 后缀表达式对应的List
    //即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList[1,2,3,+,4,*,+,5,-]
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //定义两个栈
        Stack<String> s1 = new Stack<String>();//符号栈
        //说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不使用Stack<String> 直接使用 List<String> s2
        List<String> s2 = new ArrayList<String>();
        //遍历ls
        for(String item : ls) {
            //如果是一个数，加入s2
            if(item.matches("\d+")) {
                s2.add(item);
            }else if(item.equals("(")) {
                s1.push(item);
            }else if(item.equals(")")) {//如果是右括号“)”
                //依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while(!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//注意！！将“(”弹出s1，消除
            }else {
                //当item优先级小于等于s1栈顶运算符,将s1栈顶的运算符弹出并加入到s2中
                //问题：缺少比较优先级的方法
                while(s1.size() != 0 && !s1.peek().equals("(") && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                //item优先级比s1栈顶运算符的高，将运算符压入s1
                s1.push(item);
            }
        }
        
        while(s1.size() != 0) {
            //将s1中剩余的运算符依次弹出并压入s2
            s2.add(s1.pop());
        }
        return s2; //注意因为是存放到List，因此按顺序输出就是对应的后缀表达式
    }
    
    
    //将中缀表达式转成对应的List
    // s = "1+((2+3)×4)-5"
    public static List<String> toInffixExpressionList(String s) {
        //定义一个List，存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0; //指针，用于遍历 中缀表达式字符串
        String str; //对多位数的拼接
        char c; //每遍历到一个字符，就放入到c
        do{
            //如果c是一个非数字，需要加入ls
            if((c=s.charAt(i)) < 48 || (c=s.charAt(i)) > 57) {
                ls.add(""+c);
                i++;
            }else {
                str = ""; //先将str 置成""
                //'0'[48]->'9'[57]
                while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        }while(i < s.length());
        
        return ls;//返回
    }
}

//编写一个类 Operation 可以返回一个运算符对应的优先级
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 getValue(String operation) {
        int result = 0;
        switch(operation) {
        case "+":
            result = ADD;
            break;
        case "-":
            result = SUB;
            break;
        case "*":
            result = MUL;
            break;
        case "/":
            result = DIV;
            break;
        default:
//            throw new RuntimeException("运算符有误");
            System.out.println("运算符有误");
            break;
        }
        return result;
    }
}

结果例：

以上。