前中后缀表达式

前缀、中缀、后缀表达式

前缀表达式

前缀表达式的运算符位于操作数之前

前缀表达式计算方法

1. 将前缀表达式按从右往左的顺序将数字压住栈中
2. 如遇到计算符，将栈顶两个数弹出进行相应的操作，得到的数压入栈中。（计算减法时用先弹出的数减去后弹出的数）最后得到的数就是表达式的计算值。

中缀表达式

中缀表达式就是平常手工计算时使用的表达式。
中缀表达式的求值过程可以参考上一篇博客
https://blog.youkuaiyun.com/LEverything/article/details/105743542

后缀表达式（逆波兰表达式）

后缀表达式的运算符位于操作数之后

利用后缀表达式计算

1. 将后缀表达式的数字从左至右压入栈中。
2. 遇到计算符时将栈顶的两个元素弹出，并通过运算符计算，得到的数压入栈中。（计算减法时用后弹出的减去先弹出的）最后得到的数就是表达式的值。

中缀表达式转换成后缀表达式

1. 初始化两个栈，stack1存计算符，stack2存结果
2. 从左至右扫描中缀表达式
3. 遇到操作数时，将其压栈stack2中
4. 遇到运算符时，比较其与stack1栈顶运算符的优先级：
   a）若stack1为空，或栈顶运算符为 左括号( 则直接将该运算符压入stack1中.
   b)若该运算符优先级比栈顶运算符优先级高，直接将该运算符压入stack1中。
   c）否则就将stack1栈顶运算符弹出并压入栈stack2中，再将当前运算符与新的stack1栈顶运算符比较，重复**a),b),c)**直到将当前操作符压入栈中。
5. 遇到括号时：
   a）若时 左括号( 则直接将左括号压入stack1中
   b）若是 右括号) 则将stack1栈中的计算符依次弹出并压入stack2中，直到遇到 左括号( 将这对括号丢弃。
6. 重复3-5的操作，直到中缀表达式结束
7. 最后将stack1中剩余的计算符依次弹出并压入stack2中。
8. 最后将stack2中的元素依次弹出，其逆序就是后缀表达式。

//将一个中缀表达式的每个元素存入List中方便后续操作
    public static List<String> toMidexpression(String str){
        List<String> list = new ArrayList<>();
        for(int i=0;i<str.length();){
            char c = str.charAt(i);
            String s = c+"";
            if(c>'9' || c<'0'){
                list.add(s);
                i++;
            }else if(c>='0' && c<='9'){
                while (true){
                    if(i==str.length()-1 || str.charAt(i+1)>'9' || str.charAt(i+1)<'0'){
                        i++;
                        break;
                    }else if(str.charAt(i+1)>='0'&&str.charAt(i+1)<='9'&&i<str.length()-1){
                        s+=str.charAt(i+1);
                        i++;
                    }
                }
                list.add(s);
            }
        }
        return list;
    }
    //将中缀表达式装换成后缀表达式
    public static List<String> MidToBackexpression(List<String> list){
        Stack<String> s1 = new Stack<>();
        List<String>  s2 = new ArrayList<>(); //s2使用List 就不需要逆序输出。

        for(String item: list){
            if(item.matches("\\d+")){   //遇到数直接加入s2中
                s2.add(item);
            }else if(item.equals("(")){    //遇到左括号直接压入s1中
                s1.push(item);
            }else if(item.equals(")")){    //遇到右括号 ，将s1中的计算符弹出加入s2中
                //直到遇到左括号为止，并将括号弹出丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();    // 弹出左括号
            }else {
                //遇到操作符，S1不为空 且栈顶优先级大于当前优先级，将栈顶操作符弹出加入S2
                while (s1.size()!=0 && Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        }
        //将剩余的S1操作符加入S2中
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;
    }

}
// 操作符优先级
class Operation{
    public static int getValue(String operation){
        if(operation.equals("+") ||operation.equals("-")){
            return 1;
        }else if(operation.equals("*")||operation.equals("/")){
            return 2;
        }
        return 0;
    }
}