题解 | #四则运算#

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    private static String s = "";
    private static Node1 root = new Node1();
    private static Set<Character> nextTypes = new HashSet<>();
    private static Set<Character> brother = new HashSet<>();

    private static boolean isNextNode = false;
    private static boolean isBrother = false;


    private static void setBrother() {
        brother.add('+');
        brother.add('-');
    }

    private static void setNextTypes() {
        nextTypes.add('*');
        nextTypes.add('/');
    }

    private static void initFlag() {
        isNextNode = false;
        isBrother = false;
    }

    private static void change2nd() {
        s = s.replace("\\[", "(");
        s = s.replace("\\]", ")");
    }
    private static void change3rd() {
        s = s.replace("\\{", "(");
        s = s.replace("\\}", ")");
    }


    private static void spilt1st() {
        int start = -1;//s.replaceFirst("\\(", "a").indexOf("a");
        int end = s.replaceFirst("\\)", "b").indexOf("b");
        if (end == -1) {
            return;
        }
        for (int i = end; i >= 0; i--) {
            char c = s.charAt(i);
            if (c == '(') {
                start = i;
                break;
            }
        }

        if (start < 0) {
            return;
        }
        String s1 = s.substring(start + 1, end);
        int sum = doResult(s1);
        String replace = s.replace("(" + s1 + ")", "" + sum);
        s = replace;
        spilt1st();
    }

    private static int doResult(String s1) {

        Node1 temp = new Node1();
        temp.preNode = root;
        root.eqLevel.add(temp);
        int len = s1.length();
        for (int i = 0; i < len; i++) {

            char c = s1.charAt(i);
            if (c >= '0' && c <= '9') {
                int ci = (int)c - 48;
                temp.data = 10 * temp.data + (temp.dataFlag ? ci : -ci);
                initFlag();
            } else {
                if (isNextNode && c == '-') {
                    temp.dataFlag = false;
                    continue;
                }
                temp = setNextNode(s1, temp, i);
            }
        }

        int sum = root.getSum();
        //System.out.println(sum);
        root = new Node1();
        return sum;
    }

    public static void main(String[] args) {

        setNextTypes();
        setBrother();

        int result = 0;
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            s = in.next();
        }

        spilt1st();
        change2nd();
        spilt1st();
        change3rd();
        spilt1st();
        int sum = doResult(s);
        System.out.print(sum);
    }



    private static Node1 setNextNode(String s1, Node1 node1, int index) {

        initFlag();
        if (index + 1 >= s1.length()) {
            node1.end = true;
            return node1;
        }
        Node1 next = isNextNode(s1, node1, index);
        if (isNextNode) {
            return next;
        }
        next = isBrother(s1, node1, index);
        if (isBrother) {
            return next;
        }

        throw new RuntimeException("运算符号不符合");
    }


    private static Node1 isNextNode(String s1, Node1 node1, int index) {
        char c = s1.charAt(index);
        if (nextTypes.contains(c)) {
            node1.nextNodeType = c;
            Node1 nextNode = new Node1();
            node1.nextNode = nextNode;
            nextNode.preNode = node1;
            isNextNode = true;
            return nextNode;
        }
        return node1;
    }

    private static Node1 isBrother(String s1, Node1 node1, int index) {
        char c = s1.charAt(index);
        if (brother.contains(c)) {
            Node1 eqNode = new Node1();
            if ('-' == c) {
                eqNode.dataFlag = false;
            }
            eqNode.preNode = root;
            root.eqLevel.add(eqNode);
            isBrother = true;
            return eqNode;
        }
        return node1;
    }

    static class Node1 {
        public Integer data = 0;
        public boolean dataFlag = true;
        public boolean end = false;
        public List<Node1> eqLevel = new LinkedList<>();
        public Node1 nextNode = null;
        public char nextNodeType = '+';
        public Node1 preNode = null;

        public Integer getSum() {
            Integer sum = 0;
            if (eqLevel != null) {
                for (Node1 i : eqLevel) {
                    sum += i.result();
                }
            }
            return sum;
        }

        public Integer getNextNodeResult() {
            Integer nextNodeResult = 0;
            if (nextNode != null) {

                if (nextNodeType == '*') {
                    nextNodeResult = data * nextNode.getNextNodeResult();
                } else if (nextNodeType == '/') {
                    nextNodeResult = data / nextNode.getNextNodeResult();
                }
            } else {
                nextNodeResult = data;
            }
            return nextNodeResult;
        }

        public Integer result() {

            Integer result = getNextNodeResult() + getSum();
            return result;
        }
    }
}

换了几种思路，这个不错