目录

224. 基本计算器 Basic Calculator  🌟🌟🌟

227. 基本计算器 II Basic Calculator  🌟🌟

🌟 每日一练刷题专栏 🌟

Rust每日一练 专栏

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

224. 基本计算器 Basic Calculator

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 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

  给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

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

  你可以假设给定的表达式总是有效的。所有中间结果将在 [-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++每日一练 专栏 （2023.2.18~2023.5.18）暂停更
    	Java每日一练 专栏 （2023.3.11~2023.5.18）暂停更