[Swift]LeetCode150. 逆波兰表达式求值 | Evaluate Reverse Polish Notation

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10049039.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Note:

• Division between two integers should truncate toward zero.
• The given RPN expression is always valid. That means the expression would always evaluate to a result and there won't be any divide by zero operation.

Example 1:

Input: ["2", "1", "+", "3", "*"]
Output: 9
Explanation: ((2 + 1) * 3) = 9

Example 2:

Input: ["4", "13", "5", "/", "+"]
Output: 6
Explanation: (4 + (13 / 5)) = 6

Example 3:

Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
Output: 22
Explanation: 
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

---

根据逆波兰表示法，求表达式的值。

有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

• 整数除法只保留整数部分。
• 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入: ["2", "1", "+", "3", "*"]
输出: 9
解释: ((2 + 1) * 3) = 9

示例 2：

输入: ["4", "13", "5", "/", "+"]
输出: 6
解释: (4 + (13 / 5)) = 6

示例 3：

输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
输出: 22
解释: 
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

---

52ms

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {
        var intStack = [Int]()
        for t in tokens {
            switch t {
                case "+":
                    guard let a = intStack.popLast(), let b = intStack.popLast() else {return -1}
                    intStack.append(a+b)
                case "-":
                    guard let a = intStack.popLast(), let b = intStack.popLast() else {return -1}
                    intStack.append(b-a)
                case "*":
                    guard let a = intStack.popLast(), let b = intStack.popLast() else {return -1}
                    intStack.append(b*a)
                case "/":
                    guard let a = intStack.popLast(), let b = intStack.popLast() else {return -1}
                    intStack.append(b/a)
                default:
                    guard let n = Int(t) else {return -1}
                    intStack.append(n)
            }
        }
        return intStack.last!
    }
}

---

60ms

class Stack<T> {
    var arr = [T]()

    func insert(_ v: T) {
        arr.append(v)
    }

    func dequeue() -> T? {
        if arr.count == 0 { return nil }
        return arr.removeLast()
    }
}

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {
        let stack = Stack<Int>()
        for item in tokens {
            if let numericItem = Int(item) {
                stack.insert(numericItem)
            } else {
                if let rhs = stack.dequeue(), let lhs = stack.dequeue() {
                    switch item {
                    case "+":
                        stack.insert(lhs + rhs)
                    case "-":
                        stack.insert(lhs - rhs)
                    case "*":
                        stack.insert(lhs * rhs)
                    case "/":
                        stack.insert(lhs / rhs)
                    default:
                        break
                    }
                } else {
                    fatalError("wrong rpn")
                }
            }
        }
        return stack.dequeue()!
    }
}

---

64ms

class Solution {
    private struct Stack<Type> {
        var arr = [Type]()
        mutating func push(_ e: Type) {
            arr.insert(e, at: arr.count)
        }
        mutating func pop() -> Type? {
            if arr.count > 0 {
                return arr.remove(at: arr.count-1)
            }
            return nil
        }
        
        var isEmpty: Bool {
            return arr.count <= 0
        }
    }
    
    func evalRPN(_ tokens: [String]) -> Int {
        var stack = Stack<Int>()
        for str in tokens {
            if let num = Int(str) {
                stack.push(num)
            } else {
                let op2 = stack.pop()!
                let op1 = stack.pop()!
                var ret = 0
                switch str {
                case "+":
                    ret = op1 + op2
                case "-":
                    ret = op1 - op2
                case "*":
                    ret = op1 * op2
                case "/":
                    ret = op1 / op2
                default:
                    break
                }
                stack.push(ret)
            }
        }
        return stack.pop()!
    }
}

---

100ms

class Solution {
    enum Operation: String {
        case plus = "+"
        case minus = "-"
        case divive = "/"
        case mutiple = "*"
        
        func comput(_ num1: Int, _ num2: Int) -> Int {
            switch self {
            case .plus:
                return num1 + num2
            case .minus:
                return num1 - num2
            case .divive:
                return num1 / num2
            case .mutiple:
                return num1 * num2
            }
        }
    }
    
    func evalRPN(_ tokens: [String]) -> Int {
        var opertationNumer: [Int] = []
        
        tokens.forEach { (token) in
            if let num = Int(token) {
                opertationNumer.append(num)
            } else if let operation = Operation(rawValue: token) {
                if let num2 = opertationNumer.popLast(),
                    let num1 = opertationNumer.popLast() {
                    let res = operation.comput(num1, num2)
                    opertationNumer.append(res)
                }
            }
        }
        return opertationNumer.popLast()!
    }
}

---

116ms

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {
        var stack = [Int]()
        
        for char in tokens {
            switch char {
                case "+":
                    stack.append(stack.remove(at: stack.count - 2) + stack.removeLast())
                case "-":
                    stack.append(stack.remove(at: stack.count - 2) - stack.removeLast())
                case "*":
                    stack.append(stack.remove(at: stack.count - 2) * stack.removeLast())
                case "/":
                    stack.append(stack.remove(at: stack.count - 2) / stack.removeLast())
                default:
                    stack.append(Int(String(char))!)
            }
        }
        
        return stack.first!
    }
}

---

120ms

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {
        var stack = [Int]()
        
        for token in tokens {
            if let num = Int(token) {
                stack.append(num)
            } else {
                let post = stack.removeLast()
                let prev = stack.removeLast()
                
                stack.append(operate(prev, post, token))
            }
        }
        
        return stack.first ?? 0
    }
    
    func operate(_ prev: Int, _ post: Int, _ token: String) -> Int{
        switch token {
            case "+":
                return prev + post
            case "-":
                return prev - post
            case "*":
                return prev * post
            default:
                return prev / post
       }
    }
}

---

124ms

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {

        var stack = [String]()
        
        for (_ , str) in tokens.enumerated() {
            if str != "+" && str != "-" && str != "*" && str != "/" {
                stack.append(str)
            } else {
                let postStr = stack.removeLast()
                let preStr = stack.removeLast()
                
                var res = 0
                if str == "+" {
                    res = Int(preStr)! + Int(postStr)!
                } else if str == "-" {
                    res = Int(preStr)! - Int(postStr)!
                } else if str == "*" {
                    res = Int(preStr)! * Int(postStr)!
                } else {
                    res = Int(preStr)! / Int(postStr)!
                }

                stack.append(String(res))
            }
        }
        
        let val = stack.removeLast()
        return Int(val)!
    }
}

---

132ms

class Solution {
    func evalRPN(_ tokens: [String]) -> Int {
        guard tokens.count > 0 else { return 0 }
        let operators = Set<String>(["+", "-", "*", "/"])
        var stack = [String]()
        for token in tokens {
            if operators.contains(token) {
                let b = Int(stack.removeLast())!
                let a = Int(stack.removeLast())!
                var res = 0
                switch token {
                case "+":
                    res = a + b
                    break
                case "-":
                    res = a - b
                    break
                case "*":
                    res = a * b
                    break
                case "/":
                    res = a / b
                    break
                default:
                    break
                }
                stack.append(String(res))
            } else {
                stack.append(token)
            }
        }
        return Int(stack[0])!
    }
}

---

148ms

class Solution {
    enum Operator: String {
        case plus = "+"
        case minus = "-"
        case multiplication = "*"
        case division = "/"

        func evaluate(_ num1: Int, _ num2: Int) -> Int {
            let expression = self.expression()
            return expression(num1, num2)
        }

        func expression() -> ((Int, Int) -> Int) {
            switch self {
                case .plus:
                    return { (a, b) in return (a + b) }
                case .minus:
                    return { (a, b) in return (a - b) }
                case .multiplication:
                    return { (a, b) in return (a * b) }
                case .division:
                    return { (a, b) in return (a / b) }
            }
        }
    }

    func evalRPN(_ tokens: [String]) -> Int {
        let resultStack = Stack<Int>()

        for token in tokens {
            if let operatorValue = makeOperator(token) {
                if let num1 = resultStack.pop(), let num2 = resultStack.pop() {
                    let result = operatorValue.evaluate(num2, num1)
                    resultStack.push(result)
                } else {
                    assertionFailure("input tokens are not valid")
                    return 0
                }
            } else if let integerValue = makeInteger(token) {
                resultStack.push(integerValue)
            } else {
                assertionFailure("input token is not valid")
                return 0
            }
        }

        if let result = resultStack.pop() {
            return result
        } else {
            assertionFailure("input tokens are not in correct format")
            return 0
        }
    }

    func makeInteger(_ str: String) -> Int? {
        return Int(str)
    }

    func makeOperator(_ str: String) -> Operator? {
        return Operator(rawValue: str)
    }
}

public class Stack<T> {

    class Node {
        let value: T
        var next: Node?

        init(value: T, next: Node? = nil) {
            self.value = value
            self.next = next
        }
    }

    private var top: Node? = nil
    public private(set) var count: Int = 0

    public func push(_ value: T) {
        let node = Node(value: value)
        node.next = top
        top = node
        count += 1
    }

    @discardableResult
    public func pop() -> T? {
        let value = top?.value
        top = top?.next
        count -= 1
        return value
    }

    func printDescription() {
        var currentNode = top
        while let node = currentNode {
            print("[(node.value)]", terminator: "->")
            currentNode = currentNode?.next
        }
        print("[]")
    }
}