中缀表达式转后缀表达式

1 . 初 始 化 俩 个 栈 ：运算符栈s1和储存中间结果栈；
2 . 从左到右依次扫描中缀表达式
3.遇到操作数时，将其压入s2
4）.遇到运算符时，比较其与s1栈顶运算符的优先级：
1.如果s1为空，或栈顶运算符’ ( ’ 直接将此运算符压入栈；
2.否则，如优先级比栈顶运算符的高，也将此运算符压入s1
3.否则，将s1栈顶的运算符弹出并压入s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
5）.遇到括号时:
(1) 如果是左括号’ ( ‘直接压入栈
(2) 如果是右括号’ ）’ ，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
将剩余的s1的运算符依次压入s2

package com.asia.DataStructures;

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

/**
 * @author asia
 * @Title:
 * @Package
 * @Description:
 * @date 2019/8/2115:56
 */
public class PolandNotation {
    public static void main(String[] args) {
   /*     String  suffixExpression="30 4 + 5 * 6 -";
        List<String> list = getListString(suffixExpression);
        System.out.println(list);
        int calculate = calculate(list);
        System.out.println(calculate);*/
   String suffixExpression="1+((2+3)*4)-5";
        List<String> list = toInfixExpressionList(suffixExpression);
        System.out.println(list);
        List<String> list1 = parseSuffixExpressionlist(list);
        System.out.println(list1);
        int calculate = calculate(list1);
        System.out.println(calculate);

    }






    public  static List<String>  getListString(String  suffixExpression){
        String[] strings = suffixExpression.split(" ");
        List<String>   list=new ArrayList<>();
        for (String suffix:strings) {
            list.add(suffix);
        }
        return list;
    }
    public  static   List<String>  toInfixExpressionList(String s){

        List<String>   ls=new ArrayList<>();
        int   i=0;//这是一个指针，用于扫描中缀表达式中的字符串
        String  str;//对多位数的拼接
        char c;//每遍历到一个字符，就放入到c
        do {
            //如果是一个非数字，需要加入到ls
            if ((c=s.charAt(i))<48||(c=s.charAt(i))>57){
                ls.add(""+c);
                i++;
            }else {
                str="";
                while (i<s.length()&&((c=s.charAt(i))>=48&&(c=s.charAt(i))<=57)){
                        str+=c;
                        i++;
                }
                ls.add(str);
            }

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

        return  ls;
    }
    public  static List<String> parseSuffixExpressionlist(List<String> ls){
         //定义两个栈
        Stack<String>   s1=new Stack<String>();
        //因为整个环节没有s2输出，可以换成ArrayList
//        Stack<String>   s2=new Stack<String>();
          List<String>   s2=new ArrayList<>();
//      遍历ls
        for (String  item:ls) {
           //如果是一个数就加入s2,
            if (item.matches("\\d+")){
                s2.add(item);
            }else if (item.equals("(")){
                s1.push(item);
            }else if (item.equals(")")){
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();
            }else {
                while (s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                s1.push(item);
            }

        }
        while (s1.size()!=0){
            s2.add(s1.pop());
        }

       return s2;


    }


    public  static   int   calculate(List<String>  ls){
        Stack<String> stack = new Stack<>();
        for (String  items:ls) {
            if (items.matches("\\d+")){
                stack.push(items);
            }else {
                int   num2=Integer.parseInt(stack.pop());
                int   num1=Integer.parseInt(stack.pop());
                int  res=0;
                if (items.equals("+")){
                    res=num1+num2;
                }else if (items.equals("-")){
                    res=num1-num2;
                }else if (items.equals("*")){
                    res=num1*num2;
                }else if (items.equals("/")){
                    res=num1/num2;
                }else {
                    throw  new   RuntimeException("符号有问题");
                }
                stack.push(""+res);
            }
        }
        return  Integer.parseInt(stack.pop());
    }
}
class Operation{
    private  static  int  ADD=1;
    private  static  int  SUB=1;
    private  static  int  MUL=2;
    private  static  int  DIV=2;
   public  static  int   getValue(String  operation){
      int  result=0;
      switch (operation){
          case "+":
              result=ADD;
              break;
          case "-":
              result=SUB;
              break;
          case "*":
              result=MUL;
              break;
          case "/":
              result=DIV;
              break;
          default:
              System.out.println("不存在该运算符");
              break;
      }
      return  result;
   }


}