实现计算器

一、实现计算器

传入一个字符串，含多位数整数，不含有小数，含有加减乘除其中符号；

二、实现思路

1.中缀转后缀：一个符号栈和一个链表

1）当遇到符号时：若符号栈为空、栈顶符号为左括号＇(＇、栈顶符号优先级小于等于当前符号优先级时直接入栈；否则进行循环将符号栈的运算符压入链表，直到遇到上面三种情况的否定时停止；

2）遇到右括号时：将符号栈的符号从栈顶开始压入链表直到遇见左括号时停止，并且将左括号移除；

3）遇到数字时：往后进行判断是否为多位数进行拼接；

4）最后将符号栈里所有元素压入链表

例：（2－5）＋2＊3

① 符号栈：[(]，链表：[]

② 符号栈：[(]，链表：[2]

③ 符号栈：[(，-]，链表：[2]

④ 符号栈：[(，-]，链表：[2，5]

⑤ 符号栈：[]，链表：[2，5，-]

⑥ 符号栈：[+]，链表：[2，5，-]

⑦ 符号栈：[+]，链表：[2，5，-，2]

⑧ 符号栈：[+，*]，链表：[2，5，-，2]

⑨ 符号栈：[+，*]，链表：[2，5，-，2，3]

⑩ 符号栈：[]，链表：[2，5，-，2，3，*，+]

2.计算器的实现：一个栈一个链表

1）将链表进行循环，当遇到数字时将数字入栈；

2）当遇到符号时，从栈中压出两个数字进行运算，第一个出栈的数为num2，第二个出栈的数为num1，进行运算后将最后结果入栈，最终栈里面的唯一一个数即为结果。

三、代码实现

// 计算器
public static int calculator(String str) {
        ArrayList<String> list = change(str);
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < list.size(); i ++) {
            String s = list.get(i);
            if (s.equals("/") || s.equals("+") || s.equals("-") || s.equals("*")) {
                int num2 = stack.pop();
                int num1 = stack.pop();
                int sum = calculation(num1, num2, s);
                stack.push(sum);
            } else {
                stack.push(Integer.parseInt(s));
            }
        }
        return stack.peek();
    }

    private static int calculation(int num1, int num2, String s) { // 进行运算
        switch (s) {
            case "+" :
                return num1 + num2;
            case "-" :
                return num1 - num2;
            case "*" :
                return num1 * num2;
            case "/" :
                return num1 / num2;
            default:
                return 0;
        }
    }


    // 中缀转后缀
    public static ArrayList<String> change(String str) {
        ArrayList<String> mainStack = new ArrayList<>();
        Stack<Character> temStack = new Stack<>();
        int len = str.length();
        if (len == 0) {
            return mainStack;
        }
        char[] ch = str.toCharArray();
        for (int i = 0; i < len; ) {
            char c = ch[i];
            if (c == '(') {
                temStack.push(c);
                i ++;
            } else if (c == '+' || c == '-' || c == '*' || c == '/') { // 当遇到符号时进行的情况的判断
                // 当符号栈为空 或者符号栈栈顶为左括号 或者符号栈栈顶运算符优先级小于当前的符号时 直接入栈
                // 否则进行循环将符号栈的运算符压入主栈 直到遇到上面三种情况的否定时停止
                if (temStack.isEmpty() || temStack.peek() == '(' || judge(c) >= judge(temStack.peek())) {
                    temStack.push(c);
                } else {
                    while (!temStack.isEmpty() && temStack.peek() != '(' && judge(temStack.peek()) >= judge(c)) {
                        mainStack.add(temStack.pop() + "");
                    }
                    temStack.push(c);
                }
                i ++;
            } else if (c == ')') {
                while (temStack.peek() != '(') {
                    mainStack.add(temStack.pop()+"");
                }
                temStack.pop();
                i ++;
            } else { // 拼接多位数
                String s = "";
                while ( i < str.length()) {
                    if (ch[i] != '/' && ch[i] != '*' && ch[i] != '+' && ch[i] != '-' && ch[i] != ')') {
                        s = s + ch[i];
                        i ++;
                    } else {
                        break;
                    }
                }
                mainStack.add(s);
            }
        }
        while (!temStack.isEmpty()) {
            mainStack.add(temStack.pop()+"");
        }
        return mainStack;
    }

    public static int judge(char ch) { // 判断优先级
        if (ch == '/' || ch == '*') {
            return 1;
        } else return 0;
    }