逆波兰表达式(中缀表达式转换为后缀表达式)

后缀表达式

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

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

代码实现

package com.data.PolandNotation;

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

//将中缀表达式转换为后缀表达式
public class PolamdNotaion {
    public static void main(String[] args) {
       String s = "1+((2+3)*4)-5";
       List<String> list = chage(s);
        List<String> list1 = houzhui(list);
        System.out.println(cal(list1));
    }
     //首先将中缀表达式放在list集合中
    public static List<String> chage(String s){
        List<String> list=new ArrayList<>();
        int index=0;
        String str="";
        while (index<s.length()){
            if (s.charAt(index)<=48||s.charAt(index)>=57){
                //如果为符号直接加到集合中
                list.add(s.charAt(index)+"");
                index++;
            }else {
                str="";
                while (index<s.length()&&s.charAt(index)>48&&s.charAt(index)<57){
                    str=str+s.charAt(index);
                    index++;
                }
                list.add(str);
            }
        }
        return list;
    }

    //将中缀表达式转换为后缀表达式
    public static List<String> houzhui(List<String> list){
        Stack<String > stack=new Stack<>();
        List llll=new ArrayList();
        int index=0;
        while (index<list.size()){
            String s = list.get(index);
            if (s.matches("\\d+")){
                llll.add(s);//如果是数字直接加入到集合中
                index++;
            }else if (s.equals("(")){
                stack.add(s);
                index++;
            }else if (s.equals(")")){
                while (!stack.peek().equals("(")){
                    llll.add(stack.pop());
                }
                stack.pop();
                index++;
            }else  {
                while (stack.size()!=0&&youxiaoji(stack.peek())>=youxiaoji(s)){
                    llll.add(stack.pop());
                }
                stack.push(s);
                index++;
            }
            }
        while (stack.size()!=0){
            llll.add(stack.pop());
        }
        return llll;
        }


    public static int youxiaoji(String s){
        if (s.equals("+")|s.equals("-")){
            return 1;
        }else if (s.equals("*")|s.equals("/")){
            return 2;
        }else {
            return 0;
        }
    }

    public static boolean isfuhao(String s){
        if (s=="+"|s=="-"|s=="*"|s=="/"){
            return true;
        }else {
            return false;
        }
    }

    //cal
    public static int cal(List<String> list){
        Stack<String> stack=new Stack();
        int num1=0;
        int num2=0;
        int sum=0;
        for (String s:
             list) {
            if (s.matches("\\d+")){
                //如果是数字直接入栈
                stack.push(s);
            }else {
                //如果是符号,取出
                num2 =Integer.parseInt( stack.pop());
                num1=Integer.parseInt(stack.pop());
                if (s.equals("+")){
                    sum=num1+num2;
                }else if (s.equals("-")){
                    sum=num1-num2;
                }else if (s.equals("*")){
                    sum=num1*num2;
                }else if (s.equals("/")){
                    sum=num1/num2;
                }
                stack.push(sum+"");
            }
        }
        return Integer.parseInt(stack.pop());
    }
}