Converting Infix Expressions to Postfix and Evaluating Them in Swift

Background : While developing a "24‑point challenge" app the author needed to compute the result of arbitrary arithmetic strings like 8 - (6 + 4 / 2 - 1) * 2 and show the whole calculation process.

Infix vs. Postfix : An infix expression places operators between operands, which is natural for humans but difficult for computers. Converting it to postfix (Reverse Polish) puts the operator after its operands, making evaluation straightforward.

Conversion algorithm : The algorithm uses two arrays to simulate a stack (one for numbers, one for operators). It scans the expression from left to right, handling parentheses, operator precedence, and finally outputs the postfix array.

Swift implementation – conversion :

func converExpressionToSuffixExpression(_ expressionStr: String) -> [String] {
    var suffixExpressionList: [String] = []
    var operatorExpressionList: [String] = []
    for item in expressionStr {
        let itemStr = String(item)
        if itemStr == " " { continue }
        if item.isNumber {
            suffixExpressionList.append(itemStr)
        } else {
            if operatorExpressionList.isEmpty {
                operatorExpressionList.append(itemStr)
            } else {
                if itemStr == ")" {
                    let temp = handleAppendExpressionList(operatorExpressionList, suffixList: suffixExpressionList, isRightBracket: true)
                    operatorExpressionList = temp.l1
                    suffixExpressionList = temp.l2
                } else {
                    let lastStr = operatorExpressionList.last!
                    let isItemPriorityHigh = isFirstOperatorPriorityHigh(first: itemStr, second: lastStr)
                    if isItemPriorityHigh || itemStr == "(" || lastStr == "(" {
                        operatorExpressionList.append(itemStr)
                    } else {
                        let temp = handleAppendExpressionList(operatorExpressionList, suffixList: suffixExpressionList, isRightBracket: false)
                        operatorExpressionList = temp.l1
                        suffixExpressionList = temp.l2
                        operatorExpressionList.append(itemStr)
                    }
                }
            }
        }
    }
    while !operatorExpressionList.isEmpty {
        if let last = operatorExpressionList.popLast() {
            suffixExpressionList.append(last)
        }
    }
    return suffixExpressionList
}

func handleAppendExpressionList(_ operatorList: [String], suffixList: [String], isRightBracket: Bool) -> ([String], [String]) {
    var operatorExpressionList = operatorList
    var suffixExpressionList = suffixList
    var lastStr = operatorExpressionList.last
    repeat {
        guard let tempLastStr = operatorExpressionList.popLast() else { break }
        lastStr = tempLastStr
        if tempLastStr != "(" {
            suffixExpressionList.append(tempLastStr)
        } else if isRightBracket {
            operatorExpressionList.append("(")
        }
    } while lastStr != "(" && lastStr != ""
    return (operatorExpressionList, suffixExpressionList)
}

func isFirstOperatorPriorityHigh(first: String, second: String) -> Bool {
    let isFirst = isMultiplyOrDivideOperator(itemStr: first)
    let isSecond = isMultiplyOrDivideOperator(itemStr: second)
    return isFirst && !isSecond
}

func isMultiplyOrDivideOperator(itemStr: String) -> Bool {
    return ["*", "x", "×", "X", "/", "÷"].contains(itemStr)
}

Postfix evaluation principle : Scan the postfix array from left to right; when an operator is encountered, take the two preceding numbers, compute a op b, replace the three elements with the result, and continue until a single element remains.

Swift implementation – evaluation :

func calculatorExpressionList(_ expressionList: [String]) -> Double {
    if expressionList.count == 1 {
        return (expressionList.first as NSString?)?.doubleValue ?? 0.0
    }
    var targetList = expressionList
    for (index, item) in expressionList.enumerated() {
        if isOperator(item) {
            let a = expressionList[index - 2]
            let b = expressionList[index - 1]
            let r = calculator(a, item, b)
            targetList[index - 2] = r
            targetList.removeSubrange(Range(NSRange(location: index - 1, length: 2))!)
            break
        }
    }
    return calculatorExpressionList(targetList)
}

func calculator(_ a: String, _ op: String, _ b: String) -> String {
    let aValue = (a as NSString).doubleValue
    let bValue = (b as NSString).doubleValue
    var result: Double = 0.0
    switch op {
    case "+": result = aValue + bValue
    case "-": result = aValue - bValue
    case "*", "×", "x", "X": result = aValue * bValue
    case "/", "÷": if bValue != 0 { result = aValue / bValue }
    default: break
    }
    return String(format: "%f", result)
}

func isOperator(_ str: String) -> Bool {
    if isMultiplyOrDivideOperator(itemStr: str) { return true }
    return str == "+" || str == "-"
}

Shortcut with NSExpression : For simple calculations the built‑in NSExpression class can evaluate a formatted string directly.

let expressionStr = "2 + 3 * (5 - 1)"
let formatted = expressionStr.replacingOccurrences(of: " ", with: "")
let expression = NSExpression(format: formatted)
if let result = expression.expressionValue(with: nil, context: nil) as? NSNumber {
    print(result)
}

Summary : The article provides a complete Swift solution for converting infix arithmetic strings to postfix notation, evaluating the postfix expression, and an alternative using NSExpression. The full source code is available at GitHub .