go语言实现四则运算

最新推荐文章于 2024-01-24 16:32:48 发布
最新推荐文章于 2024-01-24 16:32:48 发布
阅读量2.7k 收藏 4
点赞数 2
分类专栏： Go 算法与数据结构 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_just_smile/article/details/103635660
版权

go语言实现四则运算

文章目录


 

一 将四则运算用中缀表达式表示

前缀表达式、中缀表达式、后缀表达式都是四则运算的表示方式。为了按照四则运算的运算顺序求值（比如乘法、括号比加减运算级高），可以将四则运算用前缀或者后缀表达式表示，方便求值。
 
比如四则运算：9+(3-1)*3+10/2
前缀表达式：+ + 9 * - 3 1 3 / 10 2
中缀表达式：9+(3-1)*3+10/2
后缀表达式：9 3 1 - 3 * 10 2 / + +
 
前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。
后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后。

二 前缀、后缀表达式求值

 

1 前缀表达式求值

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（ 栈顶元素 op 次栈顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

举例：

例如前缀表达式：+ + 9 * - 3 1 3 / 10 2
（1） 从右往左扫描到数字2，压栈
	stack: 2
（2） 扫描到数字10，压栈
	stack: 2 10
（3） 扫描到运算符/，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	10 / 2 = 5
	stack: 5
（4） 扫描到数字3，压栈
	stack: 5 3
（5） 扫描到数字1，压栈
	stack: 5 3 1
（6） 扫描到数字3，压栈
	stack: 5 3 1 3
（7） 扫描到运算符-，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	3 - 1 = 2
	stack: 5 3 2
（8） 扫描到运算符*，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	2 * 3 = 6
	stack: 5 6
（9） 扫描到数字9，压栈
	stack: 5 6 9
（10） 扫描到运算符+，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	9 + 6 = 15
	stack: 5 15
（11） 扫描到运算符+，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	15 + 5 = 20
	stack: 20
（12） 最后运算得出的值即为表达式的结果
	result = 20

 

2 后缀表达式求值

从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（ 次栈顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

举例：

例如后缀表达式：9 3 1 - 3 * 10 2 / + +
（1） 从左往右扫描到数字9，压栈
	stack: 9
（2） 扫描到数字3，压栈
	stack: 9 3
（3） 扫描到数字1，压栈
	stack: 9 3 1
（4） 扫描到运算符-，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	3 - 1 = 2
	stack: 9 2
（5） 扫描到数字3，压栈
	stack: 9 2 3
（6） 扫描到运算符*，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	2 * 3 = 6
	stack: 9 6
（7） 扫描到数字10，压栈
	stack: 9 6 10
（8） 扫描到数字2，压栈
	stack: 9 6 10 2
（9） 扫描到运算符/，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	10 / 2 = 5
	stack: 9 6 5
（10） 扫描到运算符+，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	6 + 5 = 11
	stack: 9 11
（11） 扫描到运算符+，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈
	9 + 11 = 20
	stack: 20
（12） 最后运算得出的值即为表达式的结果
	result = 20

 

三 中缀表达式转前、后缀表达式

 

1 中缀表达式转前缀表达式

这是从别人那拷贝哒~，就没有举例了。参考：前缀、中缀、后缀表达式(逆波兰表达式)

  1. 初始化两个栈:运算符栈s1，储存中间结果的栈s2
  2. 从右至左扫描中缀表达式
  3. 遇到操作数时，将其压入s2
  4. 遇到运算符时，比较其与s1栈顶运算符的优先级
    1. 如果s1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈
    2. 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入s1
    3. 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较
  5. 遇到括号时
    1. 如果是右括号“)”，则直接压入s1
    2. 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃
  6. 重复步骤2至5，直到表达式的最左边
  7. 将s1中剩余的运算符依次弹出并压入s2
  8. 依次弹出s2中的元素并输出，结果即为中缀表达式对应的前缀表达式

 

2 后缀表达式转前缀表达式

这是自己的。

从左至右扫描中缀表达式：

  1. 若读取的是操作数，则将该操作数存入后缀表达式。

  2. 若读取的是运算符：
    (1) 该运算符为左括号"(",则直接压入运算符堆栈。
    (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到后缀表达式，直到遇到左括号为止。
    (3) 该运算符为非括号运算符:
     (a)若运算符堆栈为空,则直接压入运算符堆栈。
     (b)若运算符堆栈栈顶的运算符为括号，则直接压入运算符堆栈。
     ©若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到后缀表达式,直接找到一个栈顶运算符的优先级大于当前运算符，或者栈为空。并将当前运算符压入运算符堆栈。
     (d)若比运算符堆栈栈顶的运算符优先级高，则直接压入运算符堆栈。

  3. 扫描结束，将运算符堆栈中的运算符依次弹出，存入后缀表达式。

举例：

例如中缀表达式：9+(3-1)*3+10/2
（1） 从左往右扫描到数字9，将该操作数存入后缀表达式
	postfixExpress(后缀表达式)：9
（2） 扫描到"+"，运算符堆栈为空，压入运算符堆栈
	postfixExpress：9	stack:+
（3） 扫描到左括号"("，压入运算符堆栈
	postfixExpress：9	stack:+ (
（4） 扫描到数字3，将该操作数存入后缀表达式
	postfixExpress：9 3 	stack:+ (
（5） 扫描到"-"，运算符堆栈栈顶的运算符为括号，压入运算符堆栈
	postfixExpress：9 3 	stack:+ ( -
（6） 扫描到数字1，将该操作数存入后缀表达式
	postfixExpress：9 3 1	stack:+ ( -
（7） 扫描到右括号")"，则输出运算符堆栈中的运算符到后缀表达式，直到遇到左括号为止
	postfixExpress：9 3 1 - 	stack:+
（8） 扫描到"*"，比运算符堆栈栈顶的运算符优先级高，压入运算符堆栈
	postfixExpress：9 3 1 - 	stack:+ *
（9） 扫描到数字3，将该操作数存入后缀表达式
	postfixExpress：9 3 1 - 3	stack:+ *
（10） 扫描到"+"，比运算符堆栈栈顶的运算符优先级低，输出栈顶运算符到后缀表达式,并将当前运算符压入运算符堆栈
	postfixExpress：9 3 1 - 3 *		stack:+ +
（11） 扫描到数字10，将该操作数存入后缀表达式
		postfixExpress：9 3 1 - 3 *	10		stack:+ +
（12） 扫描到"/"，比运算符堆栈栈顶的运算符优先级高，压入运算符堆栈
	postfixExpress：9 3 1 - 3 *	10		stack:+ + /
（13） 扫描到数字2，将该操作数存入后缀表达式
		postfixExpress：9 3 1 - 3 *	10 2	stack:+ + /
（14） 扫描结束，将运算符堆栈中的运算符依次弹出，存入后缀表达式
		postfixExpress：9 3 1 - 3 *	10 2 / + +

 

四 GO代码

main.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	process()
}

//	输入一个四则运算表达式（中缀表达式），求出其结果。如：9+(3-1)*3+10/2，结果为 20。
func process() (err error) {
	for {
		//	输入
		express,_ := getInput()
		if len(express) == 0 {
			continue
		}

		//	将中缀表达式转换成后缀表达式（逆波兰式），postfixExpress：后缀表达式
		express = strings.ReplaceAll(express, " ", "")
		postfixExpress,errRet := transPostfixExpress(express)
		if errRet != nil {
			err = errRet
			fmt.Println(errRet)
			return
		}
		//fmt.Println(postfixExpress)

		//	后缀表达式求值
		result,errRet := calc(postfixExpress)
		if errRet != nil {
			fmt.Println("error:",errRet)
			continue
		}
		fmt.Println(result)
	}
	return
}

func getInput() (string, error) {
	reader := bufio.NewReader(os.Stdin)
	return reader.ReadString('\n')
}

func priority(s byte) int {
	switch s {
	case '+':
		return 1
	case '-':
		return 1
	case '*':
		return 2
	case '/':
		return 2
	}
	return 0
}

//	将中缀表达式转换成后缀表达式（逆波兰式），postfixExpress：后缀表达式
func transPostfixExpress(express string) (postfixExpress []string, err error) {
	var (
		opStack Stack	//	运算符堆栈
		i int
	)

	LABEL:
		for i < len(express) {	//	从左至右扫描中缀表达式
			switch  {
			//	1. 若读取的是操作数，则将该操作数存入后缀表达式。
			case express[i] >= '0' && express[i] <= '9':
				var number []byte	//	如数字123，由'1'、'2'、'3'组成
				for ; i < len(express); i++ {
					if express[i] < '0' || express[i] > '9' {
						break
					}
					number = append(number, express[i])
				}
				postfixExpress = append(postfixExpress, string(number))

			//	2. 若读取的是运算符：
			//	(1) 该运算符为左括号"("，则直接压入运算符堆栈。
			case express[i] == '(':
				opStack.Push(fmt.Sprintf("%c", express[i]))
				i++

			//	(2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到后缀表达式，直到遇到左括号为止。
			case express[i] == ')':
				for !opStack.IsEmpty() {
					data, _ := opStack.Pop()
					if data[0] == '(' {
						break
					}
					postfixExpress = append(postfixExpress, data)
				}
				i++

			//	(3) 该运算符为非括号运算符:
			case express[i] == '+' || express[i] == '-' || express[i] == '*' || express[i] == '/':
				//	(a)若运算符堆栈为空,则直接压入运算符堆栈。
				if opStack.IsEmpty() {
					opStack.Push(fmt.Sprintf("%c", express[i]))
					i++
					continue LABEL
				}

				data, _ := opStack.Top()
				//	(b)若运算符堆栈栈顶的运算符为括号，则直接压入运算符堆栈。(只可能为左括号这种情况)
				if data[0] == '(' {
					opStack.Push(fmt.Sprintf("%c", express[i]))
					i++
					continue LABEL
				}
				//	(c)若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到后缀表达式,直到栈为空或者找到优先级高于当前运算符。并将当前运算符压入运算符堆栈。
				if priority(express[i]) <= priority(data[0]) {
				tmp := priority(express[i])
				for !opStack.IsEmpty() && tmp <= priority(data[0]) {
					postfixExpress = append(postfixExpress, data)
					opStack.Pop()
					data, _ = opStack.Top()
				}
				opStack.Push(fmt.Sprintf("%c", express[i]))
				i++
				continue LABEL
			}
				//	(d)若比运算符堆栈栈顶的运算符优先级高，则直接压入运算符堆栈。
				opStack.Push(fmt.Sprintf("%c", express[i]))
				i++

			default:
				err = fmt.Errorf("invalid express:%v", express[i])
				return
			}
		}

		//	3. 扫描结束，将运算符堆栈中的运算符依次弹出，存入后缀表达式。
		for !opStack.IsEmpty() {
			data, _ := opStack.Pop()
			if data[0] == '#' {
				break
			}
			postfixExpress = append(postfixExpress, data)
		}

		return
}

//	后缀表达式求值
func calc(postfixExpress []string) (result int64, err error) {
	var (
		num1 string
		num2 string
		s Stack		//	操作栈，用于存入操作数，运算符
	)

	//	从左至右扫描后缀表达式
	for i := 0; i < len(postfixExpress); i++ {
		var cur = postfixExpress[i]

		//	1. 若读取的是运算符
		if cur[0] == '+' || cur[0] == '-' || cur[0] == '*' || cur[0] == '/' {
			//	从操作栈中弹出两个数进行运算
			num1, err = s.Pop()
			if err != nil {
				return
			}
			num2, err = s.Pop()
			if err != nil {
				return
			}

			//	先弹出的数为B，后弹出的数为A
			B, _ := strconv.Atoi(num1)
			A, _ := strconv.Atoi(num2)
			var res int

			switch cur[0] {
			case '+':
				res = A + B
			case '-':
				res = A - B
			case '*':
				res = A * B
			case '/':
				res = A / B
			default:
				err = fmt.Errorf("invalid operation")
				return
			}

			//	将中间结果压栈
			s.Push(fmt.Sprintf("%d", res))
			//fmt.Println("mid value = ", res)
		} else {
			//	1. 若读取的是操作数，直接压栈
			s.Push(cur)
		}
	}

	//	计算结束，栈顶保存最后结果
	resultStr, err := s.Top()
	if err != nil {
		return
	}
	result, err = strconv.ParseInt(resultStr, 10, 64)
	return
}

stack.go

package main

import "fmt"

type Stack struct {
	data [1024]string
	top int
}

func (s *Stack) IsEmpty() bool {
	return s.top == 0
}

func (s *Stack) Top() (ret string, err error) {
	if s.top == 0 {
		err = fmt.Errorf("stack is empty")
		return
	}
	ret = s.data[s.top-1]
	return
}

func (s *Stack) Push(str string) {
	s.data[s.top] = str
	s.top++
}

func (s *Stack) Pop() (ret string, err error) {
	if s.top == 0 {
		err = fmt.Errorf("stack is empty")
		return
	}
	s.top--
	ret = s.data[s.top]
	return
}
baboon_chen
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
go_四则运算
wucong930313的博客
03-30 101
tip：整数在使用 / 时，结果会直接丢掉小数部分，要想得到小数，则需要有浮点数参与计算。乘、除、取余(模)（*、 / 、%） 大于 加、减(+、 -)
手撕Go语言v1.1.pdf
02-02
Go语言（又称Golang）是一种静态类型的编程语言，由Google工程师Robert Griesemer、Rob Pike及Ken Thompson在2007年开始设计并开发，于2009年正式发布。它被设计成一种简洁、高效且易于学习的语言，旨在解决现代软件...
GO语言实现简单整数四则运算器
ZYM66的博客
01-13 303
Judge函数实现了运算符优先级的判断,conver函数返回一个栈弹出后就是前缀表达式。Compute函数接收一个前缀表达式的栈,最后返回一个整数就是运算的结果。这个栈由一个链表实现,一并还实现了记录链表的长度。
Go程序：利用命令行参数做四则运算
howard2005的专栏
02-17 1147
利用命令参数进行加减乘除运算
【数据结构连载一栈】【四则运算--后缀表达式】golang
hbk5241的博客
05-14 272
package main import ( "fmt" "strconv" "strings" ) type Node struct { data interface{} next *Node } type LinkedStack struct { length int head *Node } func NewLinkedStack() LinkedStack { return LinkedStack{length: 0, head: nil} } func (s *Linke
4. golang之算术运算符
weixin_43893483的博客
07-19 311
1. 算术运算符 算术运算符是对数值类型的变量进行运算的，比如：加减乘除。 1） 算术运算符的一览表 2）案例演示 <1> 除号 “/” 使用的特点 <2> 当对一数
每周一道算法题002：四则运算
baoli1912的博客
07-15 423
问题： 求位于1000～9999，满足如下条件的数： 各位数字间加入四则运算符，也可省略，使得按四则运算计算的结果为原数字的各位数逆序排列。 例如：351 → 3×51 ＝ 153 思路： 遍历1000-9999所有的数字，切分并组合运算符，拼成四则运算的算式然后计算。4位数中最大的数是9999，他可以被拆成999+9=1008，逆排后不可能等于原数，减法和除法不可能计算出比原数更大的数，所以只需...
go语言语言语言语言语言
最新发布
06-25
1. **接口的实现**：在Go语言中，一个类型如果实现了接口中所有方法的签名，则称该类型实现了该接口。这种实现是隐式的，无需显式声明。 2. **局部变量**：局部变量是在函数内部定义的变量，其作用域仅限于该函数...
用面向对象的方式操作 JSON 甚至还能做四则运算 JSON 库.doc
07-11
在这个特定的文档中，提到的JSON库支持通过面向对象的方式直接获取JSON对象中的字段值，甚至进行四则运算。 首先，库的核心功能在于解析JSON字符串并提供一种简便的访问接口。例如，使用`gjson.Get()`函数可以直接...
Go-Golang验证码生成库
08-13
在IT行业中，Go语言（Golang）以其高效、简洁的语法和强大的并发处理能力而备受开发者喜爱。在构建Web应用程序时，验证码（CAPTCHA）是一个关键的安全组件，用于防止自动化的机器人程序进行恶意操作，例如垃圾邮件...
更换Django默认的模板引擎为jinja2的实现方法
12-25
使用中，大家会发现很多局限性，最明显的就是四则运算。就只能加减，乘除都不支持。另外还有判断相等，不能直接if，要用ifequal。确实不太方便。还有一点，DTL很慢，jinja2宣称比DTL快10-20倍。 jinja2 先来安装，...
位运算实现加减乘除(Go语言实现)
TNTNT_T的博客
04-01 423
【代码】位运算实现加减乘除(Go语言实现)
Go 加、减、乘、除基本运算
qq_35807303的博客
01-24 738
Go 语言的加、减、乘、除运算封装方法，支持内部自动转换类型，并支持多数字同时运算，且支持设置保留小数点的位数，支持所有数字类型和字符串数字类型运算等
【Go语言刷题篇】Go从0到入门2：类型转换、字符求和、运算符运算（加减乘除取余比较符）练习
热门推荐
06-17 4万+
【Go语言刷题篇】Go从0到入门2：类型转换、字符求和、运算符运算（加减乘除取余比较符）练习
《用Go语言自制解释器》之第3章 求值
yxqq378287007的博客
08-30 455
《用Go语言自制解释器》之第3章 求值
go02 做个计算器
Newin2020的博客
05-21 593
go02 做个计算器 算术运算符 Go 语言中提供了 +、-、*、/、% 来做加减乘除和取余的算术运算。 fmt.Print 和 fmt.Println 前者不会换行，后者会自动换行。 上述例子里使用了 Print，Println 函数。 可以传递若干个参数，之间用逗号分开。 参数可以是字符串、数字、数学表达式等等。 格式化打印 可以使用 Printf 来控制打印的输出结果。 与 Print 和 Println 不同，Printf 的第一个参数必须是字符串。 这个字符串里包含了像 %v 这
Go语言面向对象版计算器
Python私教
10-26 293
需求 定义一个类，有一个方法，可以实现任意两个整数的加减乘除四种运算 源码 package main import "fmt" /* 需求：定义一个类，有一个方法，可以实现任意两个整数的加减乘除四种运算 */ // 计算结构体 type Calculate struct { } // 方法 func (c *Calculate) Operate(a int, b int, opt string) int { var result int switch opt { case "+": res
7.栈的应用-四则运算算术表达式求解(算符优先法)
文洲的专栏
04-17 2万+
1.理论 表达式求解在程序编译器sheji
Golang 实现计算器
weixin_34297300的博客
02-04 2089
只进行基本的四则运算，利用栈结构和后缀表达式来计算数学表达式的值。本文代码：GitHub 原文：wuyin.io 转载请注明来源。运行效果： 问题 如果只能进行两个值的加减乘除，如何编程计算一个数学表达式的值？比如计算 1+2*3+(4*5+6)*7，我们知道优先级顺序 () 大于 * / 大于 + - ，直接计算得 1+6+26*7...
《深入解析Go》：探索Go语言内部实现
"《深入解析Go》是一本探讨Go语言内部实现的开源书籍，作者希望通过分享知识，让更多人了解Go语言的底层机制。本书涵盖了从基础到高级的各种主题，包括Go语言的安装、基本数据结构、类型、函数调用、并发机制、内存...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值