栈之中缀表达式转后缀表达式（计算器问题）

1.栈是我们已经我们已经很少熟悉的数据结构，它遵循”先进后出，后进先出“原则，底层一般由数组或者单向链表实现的，接下来介绍一下栈应该场景，用栈实现中缀表达式转后缀表达式（逆波兰表达式）和实现简单计算器计算。

2.中缀表达式转后缀表达式：中缀表达式是我们人类比较容易识别的表达式，比如 1 + ( ( 2 + 3 )× 4) - 5，但是计算不认识中缀表达式，计算机只识别后缀表达式，所以在计算的时候要把中缀表达式转化为后缀表达式，比如 - 5 + * 4 + 3 2 1  =>  1 2 3 + 4 * + 5 -。

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

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中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达

代码实现：

public class PolandNotation {
    public static void main(String[] args) {
        String s="1+((2+3)*4)-5";
        List<String> strings = toInfixExpressionList(s);
        System.out.println(strings);
        List<String> strings1 = parseSuffixExpreesionList(strings);
        System.out.println(strings1);
       

    }
}
 //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpreesionList(List<String> ls) {
        // 定于一个stack，用来存放符号的
        Stack<String> s1=new Stack<>();
        //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
        //Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
        List<String> s2 = new ArrayList<>(); // 储存中间结果的Lists2
        for(String st:ls){
            if(st.matches("\\d+")){
                s2.add(st);
            }else if("(".equals(st)){
                s1.push(st);
            }else if(")".equals(st)){
                while (!"(".equals(s1.peek())){
                    s2.add(s1.pop());
                }
                s1.pop();
            }else {
                while(s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(st)){
                    s2.add(s1.pop());
                }
                s1.push(st);
            }

        }
        //将s1中剩余的运算符依次弹出并加入s2
        while(s1.size()!=0){
            s2.add(s1.pop());
        }

        return s2;// 注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
    }
    //方法：将 中缀表达式转成对应的List
    public static List<String> toInfixExpressionList(String s) {
        List<String>ls=new ArrayList<>();
        char ch;// 用来保存遍历的每个字符；
        String st;// 用来拼接多位数的。
        int i=0;
        do {
            if(s.charAt(i)<48||s.charAt(i)>57){
                ls.add(""+s.charAt(i));
                i++;
            }else {
                st="";
                while(i<s.length()&&(ch=s.charAt(i))>=48&&(ch=s.charAt(i))<=57){
                    st+=ch;
                    i++;
                }
                ls.add(st);
            }
        }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 res=0;
            switch (operation){
                case "+":
                    res=ADD;
                    break;
                case "-":
                    res=SUB;
                    break;
                case "*":
                    res=MUL;
                    break;
                case "/":
                    res=DIV;
                    break;
                default:
                    System.out.printf("该运算符不存在",operation);
                    break;
            }
            return res;

    }

}

3.计算器问题：利用后缀表达式实现计算器计算，下面对后缀表达式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，由此得出最终结果
代码实现：

 public static int calculate(List<String> ls) {
        Stack<String> stack=new Stack<>();
        for(String ss:ls){
            if(ss.matches("\\d+")){
                stack.push(ss);
            }else {
                int num1=Integer.parseInt(stack.pop());
                int num2=Integer.parseInt(stack.pop());
                int res=0;
                if("+".equals(ss)){
                    res=num2*num1;
                }else if("-".equals(ss)){
                    res=num2-num1;
                }else if ("*".equals(ss)){
                    res=num2*num1;
                }else if ("/".equals(ss)){
                    res=num2/num1;
                }else {
                    throw new RuntimeException("运算符有误");
                }
                stack.push(""+res);

            }
        }
        return Integer.parseInt(stack.pop());
    }

4.中缀表达式计算器的思路:
1. 通过一个 index  值（索引），来遍历我们的表达式
2. 如果我们发现是一个数字, 就直接入数栈
3. 如果发现扫描到是一个符号,  就分如下情况
3.1 如果发现当前的符号栈为 空，就直接入栈
3.2 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
4. 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
5. 最后在数栈只有一个数字，就是表达式的结果。