编辑代码

import Foundation

// 定义一个函数，用于计算表达式的值  
func evaluate(_ expression: String) throws -> Double {  
    enum EvaluationError: Error {  
        case unbalancedParentheses  
        case invalidToken(String)  
        case divisionByZero  
    }  
  
    // 去除空格并将字符串分解为标记  
    let separator = CharacterSet.whitespaces.union(.newlines)  
    let tokens = expression.components(separatedBy: separator).filter { !$0.isEmpty }
    //let tokens = expression.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }  
      
    var values = [Double]()  // 数值栈  
    var ops = [Character]()  // 运算符栈  
      
    // 运算符优先级  
    let precedence: [Character: Int] = ["+": 1, "-": 1, "*": 2, "/": 2 , "^": 3]  
      
    // 应用运算符函数  
    func applyOp(_ op: Character, rhs: Double, lhs: Double) throws  -> Double {  
        switch op {  
        case "+": return lhs + rhs  
        case "-": return lhs - rhs  
        case "*": return lhs * rhs  
        case "/":  
            guard rhs != 0 else { throw EvaluationError.divisionByZero }  
            return lhs / rhs  
        case "^": return pows(lhs, rhs) // 使用pows函数进行乘方运算      
        default: fatalError("Unsupported operation")  
        }  
    }  
    func pows(_ base: Double, _ exponent: Double) -> Double {  
        let intPart = Int(exponent)  
 
        
        var result = 1.0  
        for _ in 0..<intPart {  
            result *= base  
        }    
        return result  
    }
    // 检查运算符的优先级  
    func hasPrecedence(op1: Character, over op2: Character) -> Bool {  
        guard let prec1 = precedence[op1], let prec2 = precedence[op2] else { return false }  
        return prec1 >= prec2  
    }  
      
    for token in tokens {
        if let value = Double(token) {  
            values.append(value)  
        } else if token == "(" {  
            ops.append("(")  
        } else if token == ")" {  
            while !ops.isEmpty && ops.last != "(" {  
                let op = ops.removeLast()  
                let rhs = values.removeLast()  
                let lhs = values.removeLast()
                do{
                    values.append(try applyOp(op, rhs: rhs, lhs: lhs))
                }  catch{
                    print("error:\(error)")
                }
                //values.append(try! applyOp(op, rhs: rhs, lhs: lhs))  
            }  
            if !ops.isEmpty && ops.last == "(" {  
                ops.removeLast()  
            } else {  
                throw EvaluationError.unbalancedParentheses  
            }  
        } else if let firstChar = token.first, precedence[firstChar] != nil {  
            // 运算符  
            while !ops.isEmpty && ops.last != "(" && hasPrecedence(op1:ops.last!, over: firstChar) {  
                let op = ops.removeLast()  
                let rhs = values.removeLast()  
                let lhs = values.removeLast()  
                do{
                    values.append(try applyOp(op, rhs: rhs, lhs: lhs))
                }  catch{
                    print("error:\(error)")
                }  
            }  
            ops.append(firstChar)  
        } else {  
            throw EvaluationError.invalidToken(token)  
        }  
    }  
      
    // 处理剩余的运算符  
    while !ops.isEmpty {  
        if ops.last == "(" {  
            throw EvaluationError.unbalancedParentheses  
        }  
        let op = ops.removeLast()  
        let rhs = values.removeLast()  
        let lhs = values.removeLast()  
        do{
            values.append(try applyOp(op, rhs: rhs, lhs: lhs))
        }catch{
           print("error:\(error)") 
        }
        //values.append(try! applyOp(op, rhs: rhs, lhs: lhs))  
    }  
      
    guard values.count == 1 else { throw EvaluationError.unbalancedParentheses }  
    return values.first!  
}  
  
// 示例使用  
do {  
    print("请输入一个数学表达式：")  
    if let input = readLine()?.trimmingCharacters(in: .whitespacesAndNewlines) {  
        let result = try evaluate(input)  
        print("Result: \(result)")  
    } else {  
        print("未输入有效的表达式。")  
    }  
} catch {  
    print("Error: \(error)")  
}