手写计算器

---

一、中缀表达式

（或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。
与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。
与前缀或后缀记法不同的是，中缀记法中括号是必需的。计算过程中必须用括号将操作符和对应的操作数括起来，用于指示运算的次序。
例：
（1）8+4-62用后缀表达式表示为：
8 4+6 2-
（2）2*（3+5）+7/1-4用后缀表达式表示为：
235+*71/+4-

二、后缀表达式

一个表达式E的后缀形式可以如下定义：
（1）如果E是一个变量或常量，则E的后缀式是E本身。
（2）如果E是E1 op E2形式的表达式，这里op是任何二元操作符，则E的后缀式为E1’E2’ op，这里E1’和E2’分别为E1和E2的后缀式。
（3)如果E是（E1）形式的表达式，则E1的后缀式就是E的后缀式。
如：我们平时写a+b，这是中缀表达式，写成后缀表达式就是：ab+
(a+b)c-(a+b)/e的后缀表达式为：
(a+b)c-(a+b)/e
→((a+b)c)((a+b)/e)-
→((a+b)c)((a+b)e/)-
→(ab+c)(ab+e/)-
→ab+cab+e/-

三、中缀表达式转后缀表达式

1. 初始化一个栈和一个集合：运算符栈s1和集合list1
2. 从左向右扫描中缀表达式
3. 遇到数字时，将该字符加入到list1中
4. 遇到运算符时，比较s1栈顶中的运算符：
   1. 如果s1为空，或者该字符为“（”，则直接加入到集合list1中；
   2. 否则，如果该字符优先级比栈顶元素高，也直接加入到list1中；
   3. 否则，如果该字符优先级小于等于栈顶元素优先级，将s1中运算符弹出并且加入到list1中，并且继续4.1比较剩下栈顶元素。
5. 遇到括号时：
   1. 如果时左括号“（”，则直接压入s1
   2. 如果时右括号“）”，则一次弹出s1栈顶的运算符，并加入到list1中，直到遇到左括号为止，此时将这一对括号丢弃；
6. 重复步骤2-5，直至元素判断完
7. 最后将s1栈中元素依次弹出加入到list1中
8. list1输出的数据即为后缀表达

	/**
     * 中缀表达式转后缀表达式
     * @param list
     * @return
     */
    public List<String> ParseInfixToPostfix(List<String> list) {
        if(list.size() == 0) {
            return null;
        }

        Stack<String> stack = new Stack<>();
        List<String> result = new ArrayList<>();

        for (String str : list) {
            // 如果是数字
            if (str.matches("\\d+")) {
                result.add(str);
            } else if (str.equals("(")) {
                stack.push(str);
            } else if (str.equals(")")) {
                // 如果是右括号，需要将栈中数据依次弹出，加入到集合中，直至遇到左括号，同时将这一对括号舍弃
                while (!"(".equals(stack.peek())) {
                    result.add(stack.pop());
                }
                stack.pop(); //舍弃左括号；
            }
            // 处理运算符的情况
            else {
                // 当str的优先级小于等于栈顶的优先级时，需要栈顶的运算符弹出加入到集合中，然后再次与栈顶的运算符进行比较
                while(!stack.isEmpty() && Operation.getVal(str) <= Operation.getVal(stack.peek())) {
                    result.add(stack.pop());
                }
                stack.push(str);
            }
        }

        // 最终将栈中数据依次加入到集合中
        while (!stack.isEmpty()) {
            result.add(stack.pop());
        }
        return result;
    }

四、字符串转集合

/**
     * 字符串转List集合
     * @param str
     * @return
     */
    private List<String> ParseStringToList(String str){
        if (str.length() == 0) {
            return null;
        }

        List<String> list = new LinkedList<>();
        int i = 0;
        while (i<str.length()) {
            // 如果这个字符时空字符
            if ( str.charAt(i) ==  ' ') {
                i++;
                continue;
            }
            // 如果这个字符不是数字，直接加入到集合中
            if (!Character.isDigit(str.charAt(i))) {
                list.add(Character.toString(str.charAt(i)));
                i++;
                continue;
            }
            if (Character.isDigit(str.charAt(i))) {
                String number = Character.toString(str.charAt(i));
                while (++i < str.length() ){
                    if (Character.isDigit(str.charAt(i))) {
                        number = number + str.charAt(i);
                    }else{
                        break;
                    }
                }
                list.add(number);
                continue;
            }
        }
        return list;
    }

五、后缀表达式计算

1. 判断该list集合是否为空，如果为空直接返回null;
2. 初始化一个栈，该栈用来存储数值
3. 循环遍历该集合，遇到数值就压入栈中，如果遇到运算符，就去除栈顶两个元素，运算完之后压入栈中。
4. 最后栈中元素即为结果。

public Integer Rnp(List<String> list) {
        if (list.size() == 0) {
            return null;
        }
        Stack<String> stringStack = new Stack<>();
        int a,b;
        for (String str : list) {
            if (str.matches("\\d+")) {
                stringStack.push(str);
            } else {
                a = Integer.parseInt(stringStack.pop());
                b = Integer.parseInt(stringStack.pop());
                switch (str) {
                    case "+" :
                        stringStack.push(String.valueOf(a+b));
                        break;
                    case "-" :
                        stringStack.push(String.valueOf(a-b));
                        break;
                    case "*" :
                        stringStack.push(String.valueOf(a*b));
                        break;
                    case "/" :
                        stringStack.push(String.valueOf(b/a));
                        break;
                    default:
                        break;
                }
            }
        }
        return Integer.valueOf(stringStack.pop());
    }