中缀表达式转后缀表达式与计算

中缀表达式转后缀表达式与计算

1.创建两个栈，一个存储数字和后缀表达式s1，一个存储符号栈s2
2.存储流程
（1）如果符号栈s2为空，直接存入符号。
（2）如果不为空，当前符号优先级等于或者大于栈的符号，直接存入。
（3）如果不为空，当前符号优先级雄小于栈的符号，先弹出一个符号栈顶的元素，再比较，然后再存入
（4）如果遇到（直接存入。
（5）如果遇到）把符号栈遇到（之前的符号全部弹出存进去s1，最后再弹出这个括号。

具体实现如下：

//将中缀表达式转换为后缀表达式
    public static List<String>parseSuffixExpreesionList(List<String> ls){


        Stack<String> s1=new Stack<>();//符号栈

        List<String> s2=new ArrayList<>(); //后缀表达式栈

        for (String item:ls)
        {
            //判断是否为数字
            if (item.matches("\\d+"))
            {
                s2.add(item);
            }else if (item.equals("(")) //是否为左括号
            {
                s1.add(item);
            }else if (item.equals(")")) //是否为右括号
            {
                //取出遇到做括号之前的所右运算符存进s2
                while (!s1.peek().equals("("))
                {
                    s2.add(s1.pop());
                }
                s1.pop();
            }
            else{
                while(s1.size()!=0&&operation.getOp(s1.peek())>=operation.getOp(item))
                {
                        s2.add(s1.pop());
                }
                //把运算符存进去
                s1.add(item);



            }
        }
        //把剩下的符号存进去
        while (s1.size()!=0)
        {
            s2.add(s1.pop());
        }

        return s2;
    }

      //把字符串准换为list集合
    public static List<String>toInfixExpressionList(String s)
    {
        //创建一个集合
        List<String> list=new ArrayList<>();
        char c;
        String str;
        int  i=0;

        do{
            //不是数字
            if ((c=s.charAt(i))<48||(c=s.charAt(i))>57)
            {
                //直接存入
                list.add(c+"");
                i++;
            }

            else{
                str="";
                //数字
                while(i<s.length()&&(c=s.charAt(i))>=48&&(c=s.charAt(i))<=57)

                {
                    //拼接数字
                   str+=c;
                   i++;
                }
                list.add(str);
            }

        }while (i<s.length());

        return list;
    }


    //计算逆波兰表达式
    public static int ca(List<String> list)
    {
        //定义一个集合存储数据
        Stack<String> stack=new Stack<>();
        //遍历集合
        for (String item:list)
        {
            //判断是否为数字，是放进去
            if (item.matches("\\d+")){
                stack.push(item);
                //否则丛stack弹出两个数据进行运算
            }else
            {
                //第二个数据
                int num2=Integer.parseInt(stack.pop());
                //第一个数
                int num1=Integer.parseInt(stack.pop());
                int res=0;
                switch (item){
                    case "+":
                        res=num1+num2;
                        break;
                    case "-":res=num1-num2;
                        break;
                    case "*":res=num1*num2;
                        break;
                    case "/": res=num1/num2;
                        break;
                    default:
                        System.out.println("有误/为括号");;
                }
                //最后的后果
                stack.push(res+"");
            }
        }
        return Integer.parseInt(stack.pop());
    }

//操作符优先级
public class operation {

    private static int add=1;
    private static int jian=1;
    private static int mul=2;
    private static int div=2;


    public  static int getOp(String op)
    {

        int result=0;
        switch (op){
            case "+":
                result= add;
            break;
            case "-": result= jian;
            break;
            case "*":result= mul;
            break;
            case "/":result= div;
            default:
                System.out.println("操作符有误/为括号");
        }

        return result;
    }
}