計算公式 - 四則運算實作

要對公式進行運算，首先需要實作基礎的四則運算（包含符號()+-*/），用于決議一個字串的計算式子（如：'(6+2)/4-2'），演算法思路如下：

第一步：中綴運算式轉后綴運算式

中綴運算式是利于人理解的表達方式，而后綴運算式更方便計算機的運算，

<section>
  （或中綴記法）是一個通用的算識訓邏輯公式表示方法， 運算子是以中綴形式處于運算元的中間（例：3 + 4），中綴運算式是人們常用的算術表示方法，
	與前綴運算式（例：+ 3 4）或后綴運算式（例：3 4 +）相比，中綴運算式不容易被計算機決議，但仍被許多程式語言使用，因為它符合人們的普遍用法，
與前綴或后綴記法不同的是，中綴記法中括號是必需的，計算程序中必須用括號將運算子和對應的運算元括起來，用于指示運算的次序，
例：
（1）8+4-6*2用后綴運算式表示為：8 4+6 2*-
（2）2*（3+5）+7/1-4用后綴運算式表示為：235+*71/+4-
</section>

所以首先將中綴運算式轉換成后綴運算式，這個程序需要一個輔助處理的堆疊，從左到右掃描運算式里的每一個字符，執行以下操作：

• 為數字，直接添加到后綴運算式末尾
• 為 +-*/ 運算子，彈出所有優先級大于或者等于該運算子的輔助堆疊頂元素到后綴運算式中，然后將該運算子入堆疊
• 為左括號(，直接入堆疊
• 為右括號)，彈出堆疊頂元素到后綴運算式中，直到匹配到第一個左括號，括號不輸出到后綴運算式

遍歷完成后，將輔助堆疊中的元素輸出，則得到后綴運算式，

說明：運算子優先級為： () < +- < */

以A*(B-C)/D為例，處理程序如下：

   function infixToPostfix(infix, postfix) {
            let postfixHelper = Stack();
            for (let i = 0; i < infix.length; i++) {
                let c = infix[i]
                if (!isOper(c)) { // 處理運算元
                    let operands = ""
                    while (i < infix.length && !isOper(infix[i])) {
                        operands += infix[i++]
                    }
                    postfix.push(operands)
                    i--;
                } else { // 處理運算子做出處理
                    handlerSymbol(c, postfixHelper, postfix)
                }
            }
            console.log(postfixHelper)
            // 如果輸入結束，將堆疊內元素全部彈出，加入后綴運算式中
            while (!postfixHelper.empty()) {
                let c = postfixHelper.top()
                postfix.push(c)
                postfixHelper.pop()
            }
        }

第二步：計算后綴運算式

計算后綴運算式，同樣需要一個輔助處理的堆疊，從左到右遍歷字符，遇到運算元壓入輔助堆疊中；遇到運算子則從堆疊頂取出兩個元素，第一個為右運算元，第二個為左運算元（注意這個順序在除法中是結果相關的），運算后的結果入堆疊，遍歷完成后，輔助堆疊頂的元素則為所求，

 // 計算后綴運算式
        function calcPostFix(postfix, data) {
            let helperStack = Stack()
            for (let i = 0; i < postfix.length; i++) {
                let c = postfix[i]

                // 如果是運算元，壓入堆疊中
                if (!isOper(c)) {
                    let op = Number(c); // 數值
                    helperStack.push(op)
                } else {
                    // 如果是運算子，從堆疊中彈出元素進行計算
                    let op1 = helperStack.top()
                    helperStack.pop()
                    let op2 = helperStack.top()
                    helperStack.pop()
                    if (op1 === null || op2 === null) {
                        helperStack.push(null)
                    } else {

                        switch (c) {
                            case "+":
                                helperStack.push(op2 + op1)
                                break
                            case "-":
                                helperStack.push(op2 - op1)
                                break
                            case "*":
                                helperStack.push(op2 * op1)
                                break
                            case "/":
                                helperStack.push(op2 / op1) // 注意是op2(op)op1而不是op1(op)op2
                                break
                        }
                    }
                }
            }
            return helperStack.top()
        }