7. 逆波兰表达式，前缀，中缀，后缀之间如何表示，中缀如何使用代码转换为后缀

1. 如何快速的将中缀变为前缀和后缀

• 这里我给出一个中缀表达式
  a+b*c-(d+e)
• 第一步：

1. 按照运算符的优先级对所有的运算单位加括号 ，式子变成：((a+(b*c))-(d+e))

• 第二步：转换前缀与后缀表达式
  1. 前缀：把运算符号移动到对应的括号前面，则变成：-( +(a * (bc)) +(de))
  把括号去掉：- +a * bc+de 前缀式子出现
  2. 后缀：把运算符号移动到对应的括号后面，则变成：((a(bc)* )+ (de)+ )-
  把括号去掉：abc*+de+ - 后缀式子出现

2. 如何计算后缀表达式和中缀表达式呢

• 前缀：注意如果是减法，或者除法，那么出栈的第一个 - 出栈的第二个
  
• 中缀：也就是我们人，最熟悉的算法
  
• 后缀：注意如果是减法，或者除法，那么出栈的第二个 - 出栈的第一个
  

3. 如何使用代码来实现中缀转后缀呢？

思路：

代码：

package stack;

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

public class PolandNotation2 {

    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
        //3. 即  1+((2+3)*4)-5 => ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]

        String expression = "1+((2+3)*4)-5";
        List<String> list = toInfixExpressionList(expression);
        System.out.println("中缀表达式"+list);

        //将得到的中缀表达式转换为后缀表达式  1 2 3 + 4 * + 5 -
        List<String> list1 = parseSuffixExpressionList(list);
        System.out.println("后缀表达式"+list1);

        //计算后缀表达式
        int calculate = calculate(list1);
        System.out.println("计算结果="+calculate);


    }
    //将一个逆波兰表达式，依次将数据和运算符 放入到ArrayList中
    public static List<String> getLisString(String suffixExpression){
        //将suffixExpression分割,并返回一个数组
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String s : split) {
            list.add(s);
        }
        return list;
    }

    //完成对逆波兰表达式的一个运算
    public static int calculate(List<String> ls){
        //创建一个栈,只需要一个栈即可
        Stack<String> stack = new Stack<String>();
        //遍历list
        for (String item : ls) {
            //这里使用一个正则表达式来取出一个数
            if (item.matches("\\d+")){ //匹配的是多位数
                //入栈
                stack.push(item);
            }else {

                //pop出两个数，并运算，在入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")){
                    res = num1 + num2;
                }else if (item.equals("*")){
                    res = num1 * num2;
                }else if (item.equals("-")){
                    res = num1 - num2;
                }else if (item.equals("/")){
                    res = num1 / num2;
                }else {
                    throw new RuntimeException("运算符有误");
                }
                //把res入栈
                stack.push(res+""); //这是一个简单地把整数，转化为字符串的操作

            }
        }
        //最后留在stack的就是结果
        return Integer.parseInt(stack.pop());  //把字符串转化为整数

    }

    //将中缀表达式转换成对应的List
    public static List<String> toInfixExpressionList(String s){
        //定义一个List ,存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0 ; // 用于遍历s中缀表达式字符串
        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;
    }

    //中缀转后缀
    public static List<String> parseSuffixExpressionList(List<String> ls){

        //定义两个栈
        Stack<String> s1 = new Stack<String>();  //符号栈
        //因为Stack2 没有pop操作，而且后面我们还要逆序输出
        //因此比较麻烦，这里我们就不用stack了 ，所以我们直接使用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栈顶运算法弹出并压入到s2，然后在与新的运算符比较
                //问题 我们缺一个方法，比较运算符的优先级
                while (s1.size()!= 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){
                    //如果压入的符号优先级比栈顶的优先级低
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);

            }
        }

        //将s1中剩余的运算符弹出并要入s2
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2; //因为是存放到List，因此按顺序输出就是对应的逆波兰表达式

    }



}

//编写一个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:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }



}