后缀表达式转为中缀表达式

后缀表达式转为后缀表达式

1.简介

将形如1 + ( ( 2 + 3 ) $\times$ 4 ) -5 的后缀表达式转换成为形如1 2 3 + 4 $\times$ + 5 - 的后缀表达式

jdk 1.8

这个只支持个位数以及整数的运算及转换

2.代码实现

import com.ethan.shangguigu.stack.suffixCalculator.SuffixCalculator;

import java.util.Stack;

public class MediumOrderCalculator {
    public static void main(String[] args) {
        //operatorStack用于存放运算符以及括号
        Stack<Character> operatorStack=new Stack<>();
        //NumberStack用于存放操作数以及运算符，最终的后缀表达式就是该栈的倒序
        Stack<Character> NumberStack=new Stack<>();
        //MediumExpression代表一个中缀的表达式
        String MediumExpression = "1+((2+3)*4)-5";
        for (int i = 0; i < MediumExpression.length(); i++) {
            //从左到右一次取出给ch
            char ch=MediumExpression.charAt(i);
            //判断是否为数字
            if(isNumber(ch)){
                //是数字直接放入数字栈
               NumberStack.push(ch);
            }else {
                if(isOperator(ch)){
                    //如果是操作符，则执行相应操作
                    operator(ch,operatorStack,NumberStack);
                }else {
                    if (isOpParen(ch)){
                        //为‘(’时，直接压入operatorStack
                        operatorStack.push(ch);
                    }else if(isOutParen(ch)){
                        //如果是‘)’，则执行相应操作
                        OutParen(operatorStack,NumberStack);
                    }
                }
            }
        }
        //将operatorStack中剩余的操作符存放到NumberStack中
        for(Character value: operatorStack){
            NumberStack.push(value);
        }
        //因为最终的后缀表达式为NumberStack的倒序，所以直接将其取出重新放入一个新栈当中
        String suffixExpression="";
        for(Character value: NumberStack){
           suffixExpression=suffixExpression+value+" ";
        }
        //打印输出
        System.out.println(MediumExpression+"="+SuffixCalculator.main(suffixExpression));
    }
    //当ch为‘)’时的处理方法
    public static void OutParen(Stack operatorStack,Stack NumberStack){
        //将operatorStack栈顶的存入NumberStack中，直到operatorStack当前栈顶为‘(’,则直接将其弹出栈
        if(isOpParen((char)operatorStack.peek())){
            operatorStack.pop();
        }else {
                NumberStack.push(operatorStack.pop());
                OutParen(operatorStack,NumberStack);
        }
    }
    //当ch为操作符时的处理
    public static void operator(char ch, Stack operatorStack,Stack NumberStack){
        //当operatorStack为空或者operatorStack栈顶为‘(’时，直接将ch存入operatorStack
        if(operatorStack.isEmpty()||isOpParen((char)operatorStack.peek())){
            operatorStack.push(ch);
        }else {
            //当ch的优先级比operatorStack栈顶运算符优先级高时，直接将ch入operatorStack
            if(Priority(ch)>Priority((char)operatorStack.peek())){
                operatorStack.push(ch);
            }else {
                //当ch的优先级比operatorStack栈顶运算符的优先级低时，将栈顶的操作符取出放入NumberStack当中
                //并一直循环，直到operatorStack为空或者operatorStack栈顶为‘(’再或者ch的优先级比operatorStack栈顶运算符优先级高
                NumberStack.push(operatorStack.pop());
                //递归调用
                operator(ch,operatorStack,NumberStack);
            }
        }
    }
    //判断是否为数字
    public static Boolean isNumber(char ch){
        if(ch>='0' && ch <='9'){
            return true;
        }else {
            return false;
        }
    }
    //判断是否为前括号
    public static Boolean isOpParen(char ch){
        if(ch=='('){
            return true;
        }else {
            return false;
        }
    }
    //判断是否为后括号
    public static Boolean isOutParen(char ch){
        if(ch==')'){
            return true;
        }else {
            return false;
        }
    }
    //判断是否为运算符
    public static Boolean isOperator(char ch){
        if(ch=='+'||ch=='-'||ch=='*'||ch=='/'){
            return true;
        }else {
            return false;
        }
    }
    //判断是否为运算符
    public static int Priority(char ch){
        int result=0;
       switch (ch){
           case '+':
           case '-': result=1;break;
           case '*':
           case '/':result=2;break;
       }
       return result;
    }
}

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

public class SuffixCalculator {
    public static int main(String suffixExpression) {
        //suffixExpression表示一个后缀表达式的字符串
        //将suffixExpression转化成为suffixArrayList，以方便后续进行操作
        List<String> suffixArrayList=getSuffixArrayList(suffixExpression);
        int results = calculator(suffixArrayList);
        return results;
    }
    //将suffixExpression转换成为suffixArrayList
    public static List<String> getSuffixArrayList(String sue){
        String[] split = sue.split(" ");
        List<String> suffixArrayList = new ArrayList<>();
        for(String value : split){
            suffixArrayList.add(value);
        }
        return suffixArrayList;
    }
   //进行后缀表达式的运算
    public static int calculator(List<String> suffixArrayList){
        //创建一个栈，利用栈来实现后缀的表达式的运算，栈中只存贮操作数，最终栈中会保留一个数，该数为最终结果
        Stack<Integer> suffixStack=new Stack<>();
        for(String value : suffixArrayList){
            //判断是否为操作符，是则从栈中取出两个操作数，根据本value的值进行运算
            //               不是则直接入栈
            if(isOperator(value)){
                //从栈中取出第一个操作数
               Integer s1 = suffixStack.pop();
                //从栈中取出第二个操作数
               Integer s2 = suffixStack.pop();
                //对操作数进行相应的运算
               Integer results = compute(s1,s2,value);
               //将两数运算的结果入栈
               suffixStack.add(results);
            }else {
                //入栈
                suffixStack.add(Integer.parseInt(value));
            }
        }
        return suffixStack.pop();
    }
    //判断字符串是否为操作符
    public static Boolean isOperator(String value){
        if(value.equals("+") || value.equals("-") ||value.equals("*") ||value.equals("/")){
            return true;
        }else {
            return false;
        }
    }
    //按照操作符进行相应的运算
    public static Integer compute(Integer s1, Integer s2 , String operator){
        Integer results=0;
        switch (operator){
            case "+": return s1+s2;
            case "-": return s2-s1;
            case "*": return s1*s2;
            case "/": return s2/s1;
        }
        return results;
    }
}

3.运行结果

1+((2+3)*4)-5=16