演算法（3）簡單四則運算

hard_man發表於2019-04-08
演算法

1.0 問題描述

實現10以內四則運算（只包含數字，+-*/和小括號）

2.0 問題分析

  1. 四則運算使用“字尾表示式”演算法來計算，字尾表示式可以無需考慮運算子優先順序，直接從左至右依次計算。
  2. 問題分解成2部分，一是將“中綴表示式”（我們正常寫的四則運算字串樣式，即我們的輸入表示式）轉為“字尾表示式”；二是使用“字尾表示式”求值。
  3. “中綴表示式”轉“字尾表示式”流程：
    • 首先建立一個棧和一個佇列，分別為“符號棧”和“結果佇列”：“符號棧”用於儲存符號，處理符號優先順序；“結果佇列”用於儲存“字尾表示式”
    • 依次遍歷“中綴表示式”的字元。
      • 若是數字直接進結果佇列。
      • 若是運算子，則需檢視符號棧頂元素。
        • 如果棧為空或棧頂元素為“(”則直接進符號棧。
        • 否則，需要將符號棧頂部所有優先順序低於當前運算子的所有符號依次出棧，進入結果佇列。
      • 若是“)”，重複彈出棧頂運算子，進入結果佇列，直到遇到“(”，將其丟棄。
    • 遍歷完成後，即生成了“字尾表示式”，求值過程如下：
      • 建立一個“數字棧”，用於儲存計算結果。
      • 結果佇列依次出佇列。
        • 若是數字直接進“數字棧”。
        • 若是運算子，則從“數字棧”彈出2個數值，與此運算子計算後，再進“數字棧”。
        • 重複上面的過程，直到“數字棧”剩餘1個數字。這個數字即為計算結果。

3.0 程式碼實現

3.1使用swift實現

/**
 * 把Character轉換成Doublec
 * @param {Character} c - 需要轉換的字元
 * @return {Double} 返回c對應的數字
 */
func _c2n(_ c: Character) throws -> Double{
    guard case "0" ... "9" = c else {
        throw AlgorithmError.msg("符號範圍錯誤");
    }
    let zero = "0".unicodeScalars.first!.value;
    return Double(c.unicodeScalars.first!.value - zero);
}

/**
 * 最小單元計算 {n1}{mark}{n2}
 * @param {Double} n1 - 數字1
 * @param {Double} n2 - 數字2
 * @param {Character} mark - 符號
 * @return {Double} 返回 {n1}{mark}{n2} 的結果
 */
func _eval(_ n1: Double, _ n2: Double, _ mark: Character) throws -> Double{
    switch mark {
    case "+":
        return n1 + n2;
    case "-":
        return n1 - n2;
    case "*":
        return n1 * n2;
    case "/":
        if n2 == 0 {
            throw AlgorithmError.msg("除0錯誤");
        }
        return n1 / n2;
    default:
        throw AlgorithmError.msg("符號錯誤");
    }
}

/**
 * 比較符號
 * @param {String} a - 符號a
 * @param {String} b - 符號b
 * @return {Bool} 如果a的優先順序<=b的優先順序返回true，否則返回false
 */
func _arithmeticCompare(_ a: Character, _ b: Character) throws -> Bool {
    switch b {
    case "+", "-":
        return a == "+" || a == "-";
    case "*", "/":
        return true;
    case "(":
        return false;
    default:
        throw AlgorithmError.msg("非法符號");
    }
}


/**
 * 計算10以內的四則運算
 * @param {String} str - 輸入中綴表示式
 * @return {Double} - 返回計算結果
 */
func arithmetic(_ str: String) throws -> Double{
    //結果棧
    let retStack = Stack<Character>();
    //符號棧
    let markStack = Stack<Character>();
    var lastC: Character? = nil;
    for c in str{
        switch c{
        case "(":
            if let lc = lastC, case "0"..."9" = lc{
                throw AlgorithmError.msg("發現錯誤");
            }
            //直接進符號
            markStack.push(c);
            break
        case ")":
            //依次出棧直到括號結束
            while markStack.top() != "(" && markStack.count() > 0 {
                if let m = markStack.pop(){
                    retStack.push(m);
                }
            }
            if markStack.count() > 0 {
                markStack.pop();
            }else{
                throw AlgorithmError.msg("發現錯誤");
            }
            break
        case "+", "-", "*", "/":
            //比c優先順序高的都進結果棧
            if let t = markStack.top(){
                while true {
                    if let c = try? _arithmeticCompare(c, t), c{
                        markStack.pop();
                        retStack.push(t);
                        if markStack.count() == 0{
                            break;
                        }
                    }else{
                        break;
                    }
                }
            }
            markStack.push(c);
            break;
        case "0"..."9":
            if let lc = lastC , case "0"..."9" = lc {
                throw AlgorithmError.msg("發現錯誤");
            }
            //直接進結果
            retStack.push(c);
            break;
        default:
            throw AlgorithmError.msg("發現錯誤");
        }
        lastC = c;
    }
    
    //符號棧可能不空
    while markStack.count() > 0 {
        retStack.push(markStack.pop()!);
    }
    
    //計算結果
    let numStack = Stack<Double>();
    while retStack.count() > 0 {
        if let c = retStack.shift(){
            if case "0"..."9" = c {//數字
                numStack.push(try _c2n(c));
            }else{//符號
                if numStack.count() >= 2{
                    if let n1 = numStack.pop(), let n2 = numStack.pop() {
                        numStack.push(try _eval(n2, n1, c));
                    }
                }else{
                    throw AlgorithmError.msg("發現錯誤");
                }
            }
        }
    }
    
    if numStack.count() != 1{
        throw AlgorithmError.msg("發現錯誤");
    }
    
    return numStack.pop()!;
}
複製程式碼

3.2使用js實現

function size(inputArr){
    let stack1 = [];
    let stack2 = [];

    let validMark = (m) => {
        return ['+', '-', '*', '/', '(', ')'].includes(m);
    }

    let compareDict = {
        '+': 0,
        '-': 0,
        '*': 1,
        '/': 1
    }

    let compare = (a, b) => {
        if(!compareDict.hasOwnProperty(a) || !compareDict.hasOwnProperty(b)){
            throw `錯誤符號 a=${a} b=${b}`;
        }
        return compareDict[a] < compareDict[b];
    }

    //中綴轉字尾
    //數字直接入棧2，符號如果優先順序低於棧頂，依次出棧1，入棧2.
    for (const e of inputArr) {
        let num = Number.parseInt(e);
        //數字直接入棧2
        if(!Number.isNaN(num)){
            stack2.push(num);
        }else{//非數字，2種情況，可能是括號，可能是非括號
            if(!validMark(e)){
                throw `非法符號${e}`;
            }
            if(e == '('){//左括號直接入棧1
                stack1.push(e);
            }else if(e == ')'){//右括號依次出棧
                let mark = null;
                let valid = false;
                while(stack1.length > 0 && mark != '('){//複雜度O(1)
                    mark = stack1.pop();
                    if(mark != '('){
                        stack2.push(mark);
                    }else{
                        valid = true;
                    }
                }
                if(!valid){
                    throw '非法表示式';
                }
            }else{//如果是正常運算子，則依次與棧1頂元素比較，若棧頂元素優先順序高，則出棧
                let mark = null;
                let handled = false;
                while(stack1.length > 0 && mark != '('){//複雜度O(1)
                    mark = stack1.pop();
                    //只有棧頂元素優先順序 < e時才結束迴圈，否則棧頂元素優先順序 >= e時，就不停出棧
                    if(mark == '(' || compare(mark, e)){
                        stack1.push(mark);
                        stack1.push(e);
                        handled = true;
                        break;
                    }else{
                        stack2.push(mark);
                    }
                }
                //所有符號都出棧了或者遇到了'('
                if(!handled){
                    stack1.push(e);
                }
            }
        }
    }

    while(stack1.length > 0){
        stack2.push(stack1.pop());
    }

    if(stack1.length != 0){
        throw '表示式錯誤';
    }

    while(stack2.length > 0){//O(n)
        let mark = stack2.shift();
        let num = Number.parseInt(mark);
        if(!Number.isNaN(num)){//數字
            stack1.push(num);
        }else{//符號
            let n1 = stack1.pop();
            let n2 = stack1.pop();
            if(!n1 || !n2){
                throw '表示式錯誤';
            }
            let v = eval(`${n2}${mark}${n1}`);
            stack1.push(v);
        }
    }
    console.log(`stack1=${stack1}`);
    return stack1.pop();
}
複製程式碼

4.0 複雜度分析

上述2個過程複雜度都比較低，如果遇到數字都是直接儲存，遇到符號會進行一次比較或計算，時間複雜度為O(n)。 上述演算法中使用了3個棧或佇列，其中2個棧能夠重複使用，空間複雜度為O(2n)。

5.0 注意

上面的演算法只是關注演算法本身邏輯，健壯性及通用性比較差，如果用於正式的程式，還需要增加很多驗證邏輯及更多運算子的支援。

相關文章