数据结构与算法之栈

中缀表达式转后缀表达式

需求

大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将 中缀表达式转成后缀表达式。

算法思路分析
1、初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2、从左至右扫描中缀表达式；
3、遇到操作数时，将其压s2；
4、遇到运算符时，比较其与s1栈顶运算符的优先级：
(1).如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
(2).否则，若优先级比栈顶运算符的高，也将运算符压入s1；
(3).否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)
5、与s1中新的栈顶运算符相比较；
遇到括号时：
(1) 如果是左括号“(”，则直接压入s1
(2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6、重复步骤2至5，直到表达式的最右边
7、将s1中剩余的运算符依次弹出并压入s2
8、依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

代码实现

public class Center_Back_Calculatordemo {
    public static void main(String[] args) {
        String expression="1+((2+3)*4)-5";
        //将中缀表达式入数组
        List<String> infieExpressionList=toinfixExpression(expression);
        System.out.println("中缀表达式对应的List="+infieExpressionList);
        List<String> suffixExpression=parseSuffixExpressionList(infieExpressionList);
        System.out.println("后缀表达式"+suffixExpression);



    }
    //把中缀表达式转换为后缀表达式
    private static List<String> parseSuffixExpressionList(List<String> infieExpressionList) {
        //运算符栈
        Stack<String> s1 = new Stack<>();
        //存储中间结果的数组
        List<String> list = new ArrayList<String>();
        for (String ls:infieExpressionList){
            //如果是数字直接加入数组中
            if (ls.matches("\\d+")){
                list.add(ls);
                //（着直接入栈
            }else if (ls.equals("(")){
                s1.push(ls);
            }else if (ls.equals(")")){
                while(!s1.peek().equals("(")){
                    list.add(s1.pop());
                }
                s1.pop();
                //遇到运算符时
            }else {
                while (s1.size()!=0&&ArrayStack3.priority(s1.peek())>=ArrayStack3.priority(ls)){
                    list.add(s1.pop());
                }
               s1.push(ls);
            }
        }
        //将s1中剩余的运算符依次弹出并压入list
        while (s1.size()!=0){
            list.add(s1.pop());
        }
        return list;
    }

    public static List<String> toinfixExpression(String expression){
        List<String> list=new ArrayList<String>();
       int i=0;
       String str="";
       while (i<expression.length()){
           //如果不是一个数字
           if (expression.charAt(i)<48||expression.charAt(i)>57){
               list.add(expression.charAt(i)+"");
           }else {
               //如果是一个数字
               while (i<expression.length()&&(expression.charAt(i)>=48&&expression.charAt(i)<=57)){
                   str+=expression.charAt(i);
                   i++;
               }
               list.add(str);
               str="";
           }
           i++;
       }
        return list;
    }

}

class ArrayStack3{
    private int Maxsize;
    private int[] stack;
    private int top;

    public ArrayStack3(int Maxsize){
        this.Maxsize=Maxsize;
        stack=new int[Maxsize];
        top=-1;
    }
    //判断是否为空
    public boolean isEmpty(){
        return top==-1;
    }
    //判断栈是否以满
    public boolean isFull(){
        return top==Maxsize-1;
    }
    //返回栈顶元素
    public int show(){
        return stack[top];
    }
    //入栈
    public void push(int value){
        if (top==Maxsize-1){
            System.out.println("栈已经满了");
        }
        top++;
        stack[top]=value;
    }
    //出栈
    public int pop(){
        if (top==-1){
            System.out.println("栈已空");
        }
        int value=stack[top];
        top--;
        return value;
    }
    public void showList(){
        while (true){
            if (top==-1){
                break;
            }
            System.out.println(stack[top]);
            top--;
        }
    }
    //获取符号优先级
    public static int priority(String oper){
        if (oper=="*"||oper=="/"){
            return 1;
        }else if (oper=="+"||oper=="-"){
            return 0;
        }
        else {
            return -1;
        }
    }
    //判断是不是一个符号
    public static boolean isOper(char val){
        return val=='+'||val=='-'||val=='*'||val=='/';
    }
    //计算方法
    public static int cal(int num1,int num2,char oper){
        int res=0;
        switch (oper){
            case '+':
                res=num1+num2;
                break;
            //注意应该用后出来的减去前面出来的数字
            case '-':
                res=num2-num1;
                break;
            case '*':
                res=num1*num2;
                break;
            case '/':
                res=num1/num2;
                break;
            default:
                throw  new RuntimeException("异常");
        }
        return res;
    }
}