数据结构+算法--中缀表达式 转 后缀表达式

思路

代码实现

import java.util.*;


public class PolandNotation {
    public static void main(String[] args) {

        //完成将一个 中缀表达式 转换成 后缀表达式 的功能
        //说明
        //1. 表达式str="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,-]
        //4. 再调用calculate方法进行计算表达式的值
        String expression = "1+((2+3)*4)-5";

        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList);  // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]

        List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("中缀表达式对应的List=" + suffixExpressionList);  //  ArrayList [1,2,3,+,4,*,+,5,-]

        System.out.printf("表达式 %s = %d \n", expression, calculate(suffixExpressionList));  //等于16



    }

    //将中缀表达式 转成对应的List
    //infixExpr = "1+((2+3)*4)-5"
    public static List<String> toInfixExpressionList(String infixExpr){

        //定义一个List,存放 中缀表达式 对应的内容
        List<String> ls = new ArrayList<>();
        int i = 0;  //这是一个指针，用于遍历 中缀表达式 字符串
        String str;  //用于对多位数的拼接
        char c;  // 每遍历到一个字符，就放入到c
        do {
            //如果c是一个非数字，直接加入到ls
            if((c = infixExpr.charAt(i)) < 48 || (c = infixExpr.charAt(i)) > 57){  //'0'[48]->'9'[57]
                ls.add(""+c);
                i++; //i需要后移
            }else{  //如果是一个数，需要考虑多位数
                str = ""; //先将str置成""，
                while(i < infixExpr.length() && (c = infixExpr.charAt(i)) >= 48 && (c = infixExpr.charAt(i)) <= 57 ){
                    str += c;  //拼接
                    i++;
                }
                ls.add(str);
            }

        }while(i < infixExpr.length());
        return ls;
    }



    //即ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] => ArrayList [1,2,3,+,4,*,+,5,-]
    //方法：将得到的 中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpressionList(List<String> infixExprList){
        //定义两个栈
        Stack<String> s1 = new Stack<>();  //符号栈
        //说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //因此比较麻烦，这里我们就不用Stack<String>,直接用List<String> s2
        // Stack<String> s2 = new Stack<>();  // 储存中间结果的栈s2
        List<String> s2 = new ArrayList<>();  // 储存中间结果的List s2

        //遍历infixExprList
        for(String item : infixExprList){
            //如果是一个数，加入s2
            if(item.matches("\\d+")){
                s2.add(item);
            }else if (item.equals("(")){
                s1.push(item);
            }else if (item.equals(")")){
                //如果是右括号")",则依次弹出 栈operStack 栈顶的运算符，并压入saveStack，直到遇到左括号为止，此时将这一对括号丢弃
                while(!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();  // 注意：将左括号（ 弹出s1栈，消除小括号
            }else{
                //当item的优先级小于等于s1栈顶运算符时，将s1栈顶的运算符弹出并加入到s2中，再次转到（4.1）与 栈s1中新的栈顶运算符进行比较
                while(s1.size() != 0 && priority(item.charAt(0)) <= priority(s1.peek().charAt(0))){
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }

        //将 栈s1 中剩余的运算符依次弹出并压入 栈saveStack
        while(!s1.isEmpty()){
            s2.add(s1.pop());
        }

        return s2;  //  注意：因为是存放到List,因此按顺序输出就是对应的后缀表达式对应的List

    }






    //完成对逆波兰表达式的计算
    /*表达式suffixExpression = "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，因此得出最终结果（注意：这里是 35-6 而不是 6-35 是拿栈的 次顶元素-栈顶元素）
     */
    public static int calculate(List<String> sufExprList){
        //创建一个栈，只需要一个栈即可
        Stack<String> stack = new Stack<>();
        //遍历ls
        for(String item: sufExprList){

            //这里使用正则表达式来取出数
            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());
    }


    //返回运算符的优先级，优先级是由程序员来确定，优先级使用数字来表示
    //数字越大，则优先级就越高
    public static int priority(int oper) {

        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;  //假定目前的表达式只有+，-，*，/
        }
    }
}

结果截图：