数据结构和算法练习---中缀表达式转后缀表达式以及逆波兰计算器的实现代码（不含小数的计算）

package easynotation;

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

public class PolandNonation_V1 {

    public static void main(String[] args) {
        //中缀表达式   目标 将其转为后缀表达式  1，2，3，+，4,*,+,5，-
        //先将其转为list集合中的元素方便遍历
        String infixExpression = "10+((2+3)*4)-5";
        List<String> strListByString = getStrListByString(infixExpression);
        System.out.println(strListByString);
        List<String> sufixExpression = getSufixExpression(strListByString);
        System.out.println(sufixExpression);
        int result = PolandNotation.getCalcluationResult(sufixExpression);
        System.out.println(result);
    }

    /**
     * 方法一  将字符串表达式转为list集合中的表达式
     * @param str
     * @return
     */
    public static List<String> getStrListByString(String str){
        List<String> list = new ArrayList<>(); //
        int i = 0; //作为索引遍历字符串
        String tempStr = new String(); //一个临时字符串用来拼接多位数
        char c; //用来判断是数字还是其他字符
        do{
            //若符合该条件，则该字符不是数字，直接加入集合中
            if((c = str.charAt(i)) < 48 || (c = str.charAt(i)) > 57){
                list.add("" + c);
                i++; //迭代索引
            }else{
                //先置空字符串
                tempStr = "";
                //若到此分支，则当前字符为数字，需要判断是否为多位数
                while (i < str.length() && (c = str.charAt(i)) >= 48 && (c = str.charAt(i)) <= 57){
                    tempStr += c; //拼接字符串
                    i++;  //迭代索引
                }
                list.add(tempStr);
            }
        }while (i < str.length());
        return list;
    }

    /**
     * 将中缀表达式转为后缀表达式
     * @param inFixExpression
     * @return
     */
    public static List<String> getSufixExpression(List<String> inFixExpression){
        //用于储存运算符的栈s1
        Stack<String> s1 = new Stack<>();
        //用于储存中间量的集合s2，因为s2只有入栈操作，无出战操作所以可以使用集合代替
        List<String> s2 = new ArrayList<>();
        //遍历中缀表达式集合
        for (String item : inFixExpression) {
            //若当前元素为数字，则直接如s2栈
            if(item.matches("\\d+")){
               s2.add(item);
               //若当前元素为左括号，则直接如s1栈
            } else if(item.equals("(")){
                s1.push(item);
                //若当前元素为右括号，则将s1中的元素在左括号之前的元素全部弹出，并放入s2中，最后弹出左括号，则解决掉一对小括号
            }else if(item.equals(")")){
                while (!s1.peek().equals("(") && s1.size() > 0){
                    s2.add(s1.pop());
                }
                s1.pop();
                //若当前元素为运算符，则先与s1的栈顶元素比较优先级，若栈顶元素的优先级大于等于当前元素，则将栈顶元素加入s2中
                //然后依次进行下一轮比较,若栈顶元素的优先级小于当前元素则当前元素直接如s1栈
            }else{

                while (s1.size() != 0 && !s1.peek().equals("(") &&
                        Operation.getOperationPriority(s1.peek()) >= Operation.getOperationPriority(item)){
                    s2.add(s1.pop());
                }
                //当前元素入s1栈(若s1栈顶元素为左括号，则不用判断优先级，当前元素直接如s1栈)
                s1.push(item);
            }
        }
        //最后将s1中的元素，全部依次放入s2中，并返回s2
        while (s1.size() != 0){
            s2.add(s1.pop());
        }
        return s2;
    }




}

/**
 * 运算符类，提供判断运算符优先级的方法，并返回数字
 */
class Operation{

    public static final int ADD = 1;
    public static final int SUB = 1;
    public static final int MUL = 2;
    public static final int DIV = 2;

    public static int getOperationPriority(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("输入的运算符有误！");
        }
        return result;
    }



}