Golang每日一练(leetDay0081) 基本计算器I\II Basic Calculator

224. 基本计算器 Basic Calculator

给你一个字符串表达式

，请你实现一个基本计算器来计算并返回它的值。

注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如

eval()

。

示例 1：

**输入：**s = "1 + 1"
**输出：**2

示例 2：

**输入：**s = " 2-1 + 2 "
**输出：**3

示例 3：

**输入：**s = "(1+(4+5+2)-3)+(6+8)"
**输出：**23

提示：

1 <= s.length <= 3 * 10^5
s 由数字、'+'、'-'、'('、')'、和 ' ' 组成
s 表示一个有效的表达式
'+' 不能用作一元运算(例如， "+1" 和 "+(2 + 3)" 无效)
'-' 可以用作一元运算(即 "-1" 和 "-(2 + 3)" 是有效的)
输入中不存在两个连续的操作符
每个数字和运行的计算将适合于一个有符号的 32位整数

代码： 只有+-没有*/，但有括号

package main

import "fmt"

func calculate(s string) int {
    stack := make([]int, 0)
    num := 0
    sign := '+'
    for i := 0; i < len(s); i++ {
        c := s[i]
        if isDigit(c) {
            num = num*10 + int(c-'0')
        }
        if c == '(' {
            left := 1
            j := i + 1
            for left > 0 {
                if s[j] == '(' {
                    left++
                } else if s[j] == ')' {
                    left--
                }
                j++
            }
            num = calculate(s[i+1 : j])
            i = j - 1
        }
        if c != ' ' && !isDigit(c) || i == len(s)-1 {
            if sign == '-' {
                num = -num
            }
            stack = append(stack, num)
            sign = rune(c)
            num = 0
        }
    }
    sum := 0
    for _, num := range stack {
        sum += num
    }
    return sum
}

func isDigit(c byte) bool {
    return c >= '0' && c <= '9'
}

func main() {
    s := "1 + 1"
    fmt.Println(calculate(s))
    s = " 2-1 + 2 "
    fmt.Println(calculate(s))
    s = "(1+(4+5+2)-3)+(6+8)"
    fmt.Println(calculate(s))
}

输出：

2
3
23

227. 基本计算器 II Basic Calculator

给你一个字符串表达式

，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

你可以假设给定的表达式总是有效的。所有中间结果将在

[-2^31, 2^31 - 1]

的范围内。

注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如

eval()

。

示例 1：

**输入：**s = "3+2*2"
**输出：**7

示例 2：

**输入：**s = " 3/2 "
**输出：**1

示例 3：

**输入：**s = " 3+5 / 2 "
**输出：**5

提示：

1 <= s.length <= 3 * 10^5
s 由整数和算符 ('+', '-', '*', '/') 组成，中间由一些空格隔开
s 表示一个 有效表达式
表达式中的所有整数都是非负整数，且在范围 [0, 2^31 - 1] 内
题目数据保证答案是一个 32-bit 整数

代码： 只有+-*/，没有括号

package main

import "fmt"

func calculate(s string) int {
    stack := make([]int, 0)
    num := 0
    sign := '+'
    for i := 0; i < len(s); i++ {
        c := s[i]
        if isDigit(c) {
            num = num*10 + int(c-'0')
        }
        if c != ' ' && !isDigit(c) || i == len(s)-1 {
            if sign == '+' {
                stack = append(stack, num)
            } else if sign == '-' {
                stack = append(stack, -num)
            } else if sign == '*' {
                stack[len(stack)-1] *= num
            } else if sign == '/' {
                stack[len(stack)-1] /= num
            }
            sign = rune(c)
            num = 0
        }
    }
    sum := 0
    for _, num := range stack {
        sum += num
    }
    return sum
}

func isDigit(c byte) bool {
    return c >= '0' && c <= '9'
}

func main() {
    s := "3+2*2"
    fmt.Println(calculate(s))
    s = " 3/2 "
    fmt.Println(calculate(s))
    s = " 3+5 / 2"
    fmt.Println(calculate(s))
}

输出：

7
1
5

Stack和Queue

都是一种线性数据结构，其主要区别在于数据的操作方式。

Stack

是一种后进先出（Last In First Out，LIFO）的数据结构，即最后一个入栈的元素最先出栈，其操作包括压栈（push）和弹栈（pop）。

Queue

是一种先进先出（First In First Out，FIFO）的数据结构，即最先入队的元素最先出队，其操作包括入队（enqueue）和出队（dequeue）。

相同点

在于都可以使用数组或链表来实现，同时都是基于线性结构的数据类型。

不同点

在于其数据操作的方式不同，Stack的操作方式是LIFO，而Queue的操作方式是FIFO。

两种数据结构在不同的场景下有不同的应用，比如在计算机中的函数调用中常用Stack来实现函数调用栈，而在消息队列中则常用Queue来实现消息的异步处理。

🌟 每日一练刷题专栏 🌟

✨持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！

🌟 收藏，你的青睐是我努力的方向！

✎ 评论，你的意见是我进步的财富！

☸ 主页：https://hannyang.blog.csdn.net/

Rust每日一练专栏

（2023.5.16~）更新中...

Golang每日一练专栏

（2023.3.11~）更新中...

Python每日一练专栏

（2023.2.18~2023.5.18）暂停更

C/C++每日一练专栏