數據結構與算法 | LeetCode 224. Basic Calculator

時間 2019-12-07

標籤數據結構算法 leetcode basic calculator 简体版

原文原文鏈接

原文連接：wangwei.one/posts/algoD…html

前面，咱們學習了有關的棧的實現及其應用，今天咱們基於棧，來實現一個簡單的計算器功能。java

簡單計算器實現

Leetcode 224. Basic Calculatorgit

實現一個可以對簡單的表達式進行計算的基礎計算器。github

表達式字符串包含括號 ( 、)，加號(+)，減號(-)，非負整數以及空格(' ')。算法

Example 1:express

Input: "1 + 1"
Output: 2
複製代碼

Example 2:bash

Input: " 2-1 + 2 "
Output: 3
複製代碼

Example 3:數據結構

Input: "(1+(4+5+2)-3)+(6+8)"
Output: 23
複製代碼

使用兩個棧來實現

根據棧的實現及其應用中學到的表達式求值的解法：post

編譯器會使用兩個棧來實現，一個棧用來保存操做數，另外一個棧用來保存運算符。從左向右遍歷表達式，遇到數字直接壓入操做數棧，遇到操做符，就與運算符棧頂元素進行比較。學習

若是比運算符棧頂元素的優先級高，就將當前運算符壓入棧；若是比運算符棧頂元素的優先級低或者相同，從運算符棧中取棧頂運算符，從操做數棧的棧頂取 2 個操做數，而後進行計算，再把計算完的結果壓入操做數棧，繼續比較。

下面是我根據上面思路，寫出來的初版實現，相比於網上巧妙的解題方法，確實複雜不少，在LeetCode的運行時間爲 195 ms ，只超過了 8.14% 的提交記錄 😅 。

思路

先對錶達式進行校驗，去除空格，並轉化爲ArrayList，若是按照一個字符一個字符去遍歷的到，要是表達式中存在多位的整數，就行不通了。
對轉化後的 ArrayList 進行遍歷，遇到數字，直接壓入操做數棧。
遇到操做符，則進行須要進行一系列的判斷，特別是遇到括號的處理：
1. 操做符棧爲空的狀況下，直接入棧；
2. 比較 新的操做符 與 操做符棧頂元素 的優先級，優先級高，則直接入棧。若是它們有一個或都是左括號，則直接入棧；
3. 若是優先級低或相同，則對前面的表達式進行遞歸計算，將最後的結果壓入操做數棧。以後，在遞歸調用自身，壓入新的操做符。
遍歷結束後，在對操做數站進行最後一次遞歸計算；
去除操做數棧的棧頂元素。

代碼以下

裏面用到的 LinkedStack 是咱們前面本身實現的鏈表棧，固然使用 ArrayStack 也能夠。

package one.wangwei.leetcode.stack;

import one.wangwei.algorithms.datastructures.stack.IStack;
import one.wangwei.algorithms.datastructures.stack.impl.LinkedStack;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

/** * 簡單計算器實現 * * @author https://wangwei.one * @date 2019/1/18 */
public class MyBasicCalculator {

    private IStack<Integer> operand;
    private IStack<String> operator;
    private Set<String> highOperator;
    private Set<String> lowOperator;
    private Set<String> parentheses;
    private Set<String> operatorSet;

    public MyBasicCalculator() {
        this.operand = new LinkedStack<>();
        this.operator = new LinkedStack<>();

        this.parentheses = new HashSet<>();
        this.parentheses.add("(");
        this.parentheses.add(")");

        this.highOperator = new HashSet<>();
        this.highOperator.add("*");
        this.highOperator.add("/");

        this.lowOperator = new HashSet<>();
        this.lowOperator.add("+");
        this.lowOperator.add("-");

        this.operatorSet = new HashSet<>();
        this.operatorSet.addAll(highOperator);
        this.operatorSet.addAll(lowOperator);
        this.operatorSet.addAll(parentheses);
    }

    /** * 運算表達式 * * @param s * @return */
    public int calculate(String s) {
        if (s == null || s.isEmpty()) {
            throw new RuntimeException("Expression Invalid! expr=" + s);
        }

        ArrayList<String> express = convertExpr(s);
        for (String str : express) {
            if (!operatorSet.contains(str)) {
                operand.push(Integer.valueOf(str));
            } else {
                pushOperator(str);
            }
        }

        // 對餘下的操做數進行計算，獲得最後的結果
        operandCalcu();

        return operand.pop();
    }

    /** * 轉換表達式 * <p> * 1. 去除空格 * 2. 拆分出有效的數字 * * @param expr * @return */
    private ArrayList<String> convertExpr(String expr) {
        ArrayList<String> result = new ArrayList<>();
        // remove empty spaces
        String trimExpr = expr.replaceAll("\\s+", "");

        String tmpIntStr = "";
        for (Character ch : trimExpr.toCharArray()) {
            String str = ch.toString();
            if (operatorSet.contains(str)) {
                if (!tmpIntStr.isEmpty()) {
                    result.add(tmpIntStr);
                    tmpIntStr = "";
                }
                result.add(str);
            } else {
                tmpIntStr = tmpIntStr + str;
            }
        }
        if (!tmpIntStr.isEmpty()) {
            result.add(tmpIntStr);
        }
        return result;
    }

    /** * 運算符入棧 * * @param operatorSign */
    private void pushOperator(String operatorSign) {
        String prevOperator = null;
        if (!operator.empty()) {
            prevOperator = operator.peek();
        }
        // 第一次入棧
        if (prevOperator == null) {
            operator.push(operatorSign);
        } else {
            if (")".equals(operatorSign) && "(".equals(prevOperator)) {
                operator.pop();
                return;
            }
            // 第一次之後入棧，先比較優先級，高優先級，則入棧
            if (priority(operatorSign, prevOperator)) {
                operator.push(operatorSign);
            } else {
                // 不然先對前面的表達式進行計算
                operandCalcu();
                pushOperator(operatorSign);
            }
        }
    }

    /** * 從操做數棧取出兩個操做數進行計算 */
    private void operandCalcu() {
        if (operator.empty()) {
            return;
        }
        String sign = operator.peek();
        if ("(".equals(sign)) {
            return;
        }

        sign = operator.pop();
        int after = operand.pop();
        int front = operand.pop();

        int value = calcIntegers(front, after, sign);
        operand.push(value);
        operandCalcu();
    }

    /** * 比較優先級 * * @param next * @param prev * @return */
    private boolean priority(String next, String prev) {
        return (highOperator.contains(next)
                && lowOperator.contains(prev))
                || "(".equals(prev)
                || "(".equals(next);
    }

    /** * 對兩個數字進行計算 * * @param front * @param after * @param sign * @return */
    private int calcIntegers(int front, int after, String sign) {
        switch (sign) {
            case "+":
                return front + after;
            case "-":
                return front - after;
            case "*":
                return front * after;
            case "/":
                return front / after;
            default:
                throw new RuntimeException("Sign Invalid! sign=" + sign);
        }
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        MyBasicCalculator solution = new MyBasicCalculator();
        System.out.println(solution.calculate("1 + 1 - 3 + 4 - (8 + 2) - 4 + 3 - 1 - 4 + 6 - 9 + 1"));
        System.out.println(solution.calculate("(1+(4+5+2)-3)+(6+8)"));
        System.out.println(solution.calculate("1-(5)"));
        System.out.println(solution.calculate("2-4-(8+2-6+(8+4-(1)+8-10))"));
        System.out.println(System.currentTimeMillis() - startTime);
    }
}
複製代碼

源碼

巧妙的解法

下面咱們來看看網上比較好的解法，相比於個人代碼，簡直不要爽太多，膜拜…… LeetCode上運行只須要耗時 27 ms.

思路

處理多位整數。好比解析123，第一次循環爲 1 * 10 + 2 = 12，第二次循環爲 12 * 10 + 3 = 123；
處理加減號。不是存儲入到操做符棧，而是轉爲正負號，待到下一次循環時，與前面的累計結果進行相加；
處理括號。若是遇到 左括號 (，就將前面累計的結果與正負存儲操做數棧，並將累計結果清空，正負號標記爲正。等到遇到右括號 )時，就將這一次累計的結果與操做數棧頂存儲的累計結果進行累加，獲得一個最終結果；

代碼

package one.wangwei.leetcode.stack;

import java.util.Stack;

/** * 簡單計算器實現 * * @author https://wangwei.one * @date 2019/1/18 */
public class BasicCalculator {

    /** * 運算表達式 * * @param s * @return */
    public int calculate(String s) {
        // 操做數棧
        Stack<Integer> stack = new Stack<>();
        // 正負號
        int sign = 1;
        // 累計結果
        int result = 0;
        for (int i = 0; i < s.length(); i++) {
            if (Character.isDigit(s.charAt(i))) {
                // 字符轉換
                int num = s.charAt(i) - '0';
                // 處理多位整數
                while (i + 1 < s.length() && Character.isDigit(s.charAt(i + 1))) {
                    num = num * 10 + s.charAt(i + 1) - '0';
                    i++;
                }
                result += num * sign;
            } else if (s.charAt(i) == '+') {
                sign = 1;
            } else if (s.charAt(i) == '-') {
                sign = -1;
            } else if (s.charAt(i) == '(') {
                stack.push(result);
                stack.push(sign);
                result = 0;
                sign = 1;
            } else if (s.charAt(i) == ')') {
                result = result * stack.pop() + stack.pop();
            }
        }
        return result;
    }

    public static void main(String[] args) {
        BasicCalculator calculator = new BasicCalculator();
        System.out.println(calculator.calculate("2-4-(8+2-6 + (8 +4 -(1)+8-10))"));
    }

}

複製代碼