中缀表达式转后缀表达式

    /**
     * 依次扫描中缀表达式，并加入字符串列表中
     * @param infixExpression
     * @return
     */
    public static List<String> convertList(String infixExpression) {
        List<String> list = new ArrayList<>();
        int i = 0;
        String numSeq = "";
        while (i < infixExpression.length()){
            char ch = infixExpression.charAt(i);
            // 如果扫描到的不是数字并且不是空格，直接加入到列表
            if ((ch <= 47 || ch >= 58) && (ch != 32)) {
                list.add(ch + "");
            } else {
                // 如果未扫描到末尾，且扫描到的元素为数字，循环拼接成字符串
                while (i < infixExpression.length() && (ch = infixExpression.charAt(i)) > 47 && (ch = infixExpression.charAt(i)) < 58) {
                    numSeq += ch;
                    int j = i + 1;
                    // 判断当前数字的下一个字符是否为数字，否则直接跳出循环
                    if (j < infixExpression.length() && (ch = infixExpression.charAt(j)) > 47 && (ch = infixExpression.charAt(j)) < 58) {
                        i++;
                    } else {
                        break;
                    }
                }
                // 仅当拼接的字符串不为空时，加入列表中并再次置为空串
                if (!numSeq.equals("")) {
                    list.add(numSeq);
                    numSeq = "";
                }
            }
            i ++;
        }
        return list;
    }

    /**
     * 中缀表达式转后缀表达式的步骤
     *
     * 1、 定义两个栈，一个用于存放运算符的S1栈，一个用于存放中间结果的S2栈
     * 2、从左到右依次扫描中缀表达式：
     *   2.1、如果扫描到'('左括号，直接压入S1栈中
     *   2.2、如果扫描到数字，直接压入到S2栈中
     *   2.3、如果扫描到运算符，做以下步骤：
     *           2.3.1 如果S1为空栈或S1栈顶元素为'('左括号，直接压入S1栈中
     *           2.3.2 否则取出S1栈顶元素与扫描到的运算符比较
     *                      如果扫描到的运算符大于S1栈顶元素，直接把扫描到的运算符压入到S1栈中
     *                      如果扫描到的运算符小于或等于S1栈顶元素，取出S1栈顶元素加入到S2栈中，重复执行2.3
     *   2.4、如果扫描到')'右括号，循环取出S1栈顶元素加入到S2栈中，直至在S1栈中遇到'('左括号并丢弃
     *   2.5、把S1栈中的元素依次添加到S2栈中
     *
     * @param items
     * @return
     */
    public static String InfixToSuffix(List<String> items) {
        Stack<String> s1 = new Stack<>();
        Stack<String> s2 = new Stack<>();

        for (String item : items) {
            if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                while (!s1.peek().equals("(")) {
                    s2.push(s1.pop());
                }
                s1.pop();
            } else if (item.matches("\\d+")) {
                s2.push(item);
            } else if (Operator.isOperator(item)) {
                while (!s1.isEmpty() && !s1.peek().equals("(") && Operator.determinePriority(item, s1.peek()) <= 0) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        }

        // 把S1栈中剩余的元素依次加入到S2栈中
        while (!s1.isEmpty()) {
            s2.push(s1.pop());
        }

        // 把S2栈中的元素依次弹出就是后缀表达式
        StringBuffer stringBuffer = new StringBuffer();
        while (!s2.isEmpty()) {
            stringBuffer.append(s2.pop() + " ");
        }

        return stringBuffer.toString();
    }