Golang实现简单的计算器功能

最新推荐文章于 2024-06-12 09:31:30 发布
最新推荐文章于 2024-06-12 09:31:30 发布
阅读量812 收藏 18
点赞数 28
文章标签： 数据结构 开发语言 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61453210/article/details/139227827
版权

目录

介绍

算法思路

算法实现

判断一个字符是不是运算符

运算的方法

运算符的优先级

核心算法

核心算法的整体代码

整体代码

运行结果

介绍

本文通过栈来进行实现综合的计算器，在控制台输入要进行运算的表达式，通过计算将结果输出。

算法思路

  1. 创建两个栈，numStack栈用于存放表达式中的数字，简称数栈。operStack栈用于存放表达式中的运算符，简称符号栈。
  2. exp：存储控制台输入的表达式；index：帮助扫描exp表达式。
  3. 通过扫描exp发现是数字，则直接入数栈numStack
  4. 如果发现是一个运算符。（1）如果operStack是一个空栈，直接入栈。（2）如果operStack不是一个空栈：1）如果发现operStack栈顶运算符的优先级大于等于当前准备入栈的运算符的优先级，就从符号栈Pop出，并从数栈也Pop两个数进行运算，运算后的结果重新入栈到数栈，符号再入符号栈。2）否则，运算符直接入栈
  5. 如果扫描表达式完毕，依次从符号栈取出符号，然后从数栈取出两个数，运算后的结果，入数栈，直到符号栈为空。

算法实现

本文运用的栈为：Golang实现数组模拟栈和队列-CSDN博客，并在此基础栈中添加一些计算器相关的方法。

判断一个字符是不是运算符

" * "的ASCII码为42；" + "的ASCII码为43； " - "的ASCII码为45； " / "的ASCII码为47； 

func (s *Stack) IsOper(val int) bool {
	if val == 42 || val == 43 || val == 45 || val == 47 {
		return true
	} else {
		return false
	}
}

运算的方法

参数为数栈的两个元素，符号栈对应的ASCII码的符号

func (s *Stack) Cal(num1, num2, oper int) int {
	res := 0
	switch oper {
	case 42:
		res = num2 * num1
	case 43:
		res = num2 + num1
	case 45:
		res = num2 - num1
	case 47:
		res = num2 / num1
	default:
		fmt.Println("运算符错误！")
	}
	return res
}

运算符的优先级

返回运算符的优先级： * / 优先级为 1； + - 优先级为 0
func (s *Stack) Priority(oper int) int {
	if oper == 42 || oper == 47 {
		return 1
	} else if oper == 43 || oper == 45 {
		return 0
	}
	return 0
}

核心算法

创建数栈和符号栈，定义exp存储表达式。

	numStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	operStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	var exp string
	fmt.Println("请输入一个只包含（+，-，*，/）的表达式")
	fmt.Scanln(&exp)

定义num1，num2为数栈要计算的两个数，oper为符号栈的运算符的ASCII码，result为运算结果；keepNum为处理多位数。

	//	定义一个index，帮助扫描exp
	index := 0
	//为了配合运算，我们定义需要的变量
	num1 := 0
	num2 := 0
	oper := 0
	result := 0
	keepNum := ""

定义ch用于接收exp的字符，temp将字符装换为ASCII码

ch := exp[index : index+1]
temp := int([]byte(ch)[0]) //就是字符对应的ASCII码

判断temp是运算符还是数字

这里判断是运算符的情况：首先判断符号栈是不是空栈如果是直接入栈，如果不是，就将要入栈的运算符与符号栈的栈顶运算符进行比较，如果要入栈的运算符的优先级小就直接入栈，否则从数栈中弹出两个数，从符号栈弹出运算符进行运算。

if operStack.IsOper(temp) {
			//	说明是符号
			//	如果operStack 是一个空栈，直接入栈
			if operStack.Top == -1 {
				operStack.Push(temp)
			} else {
				//	如果发现operStack栈顶的运算符的优先级大于等于当前准备入栈的运算符的优先级，就从符号栈Pop出，并从数栈中也Pop两个数，进行运算
				//	运算后的结果再重新入栈到数栈，当前符号再入符号栈
				if operStack.Priority(operStack.arr[operStack.Top]) >= operStack.Priority(temp) {
					num1 = numStack.Pop()
					num2 = numStack.Pop()
					oper = operStack.Pop()
					result = operStack.Cal(num1, num2, oper)
					//	将计算结果重新入栈
					numStack.Push(result)
					//	当前的符号压入栈
					operStack.Push(temp)
				} else {
					//否则直接将符号入栈
					operStack.Push(temp)
				}
			}
		}

这里判断是数字的情况，并且包含多位数的情况。定义变量keepNum进行拼接多位数，然后每次要向index的前面字符测试一下，是不是运算符，然后处理。如果已经到表达式最后，直接keepNum

else {
			keepNum += ch
			if index == len(exp)-1 {
				val, _ := strconv.ParseInt(keepNum, 10, 64)
				numStack.Push(int(val))
			} else {
				if operStack.IsOper(int([]byte(exp[index+1 : index+2])[0])) {
					val, _ := strconv.ParseInt(keepNum, 10, 64)
					numStack.Push(int(val))
					keepNum = ""
				}
			}
		}

判断index 是不是扫描到表达式的最后

if index+1 == len(exp) {
			break
		}
index++

如果扫描表达式 完毕 ，依次从符号栈取出符号，然后从数栈取出两个数，运算后的结果，入数栈，直到符号栈为空

	for {
		if operStack.Top == -1 {
			break
		}
		num1 = numStack.Pop()
		num2 = numStack.Pop()
		oper = operStack.Pop()
		result = operStack.Cal(num1, num2, oper)
		//	将计算结果重新入栈
		numStack.Push(result)
	}

	//	如果算法没有问题，表达式也正确，则结果就是numStack最后数
	res := numStack.Pop()
	fmt.Printf("表达式%s=%v", exp, res)

核心算法的整体代码

//	数栈
	numStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	operStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	var exp string
	fmt.Println("请输入一个只包含（+，-，*，/）的表达式")
	fmt.Scanln(&exp)
	//	定义一个index，帮助扫描exp
	index := 0
	//为了配合运算，我们定义需要的变量
	num1 := 0
	num2 := 0
	oper := 0
	result := 0
	keepNum := ""
	for {
		//增加一个逻辑，处理多位数的问题

		ch := exp[index : index+1]
		temp := int([]byte(ch)[0]) //就是字符对应的ASCII码
		if operStack.IsOper(temp) {
			//	说明是符号
			//	如果operStack 是一个空栈，直接入栈
			if operStack.Top == -1 {
				operStack.Push(temp)
			} else {
				//	如果发现operStack栈顶的运算符的优先级大于等于当前准备入栈的运算符的优先级，就从符号栈Pop出，并从数栈中也Pop两个数，进行运算
				//	运算后的结果再重新入栈到数栈，当前符号再入符号栈
				if operStack.Priority(operStack.arr[operStack.Top]) >= operStack.Priority(temp) {
					num1 = numStack.Pop()
					num2 = numStack.Pop()
					oper = operStack.Pop()
					result = operStack.Cal(num1, num2, oper)
					//	将计算结果重新入栈
					numStack.Push(result)
					//	当前的符号压入栈
					operStack.Push(temp)
				} else {
					//否则直接将符号入栈
					operStack.Push(temp)
				}
			}
		} else {
			//	说明是数字
			//处理多位数的思路
			//1.定义一个变量 keepNum string ,做拼接
			keepNum += ch

			//2.每次要向index的前面字符测试一下，是不是运算符，然后处理

			//如果已经到表达式最后，直接keepNum
			if index == len(exp)-1 {
				val, _ := strconv.ParseInt(keepNum, 10, 64)
				numStack.Push(int(val))
			} else {
				//	向index后面测试一下看看是不是运算符
				if operStack.IsOper(int([]byte(exp[index+1 : index+2])[0])) {
					val, _ := strconv.ParseInt(keepNum, 10, 64)
					numStack.Push(int(val))
					keepNum = ""
				}
			}
		}

		//继续扫描
		//先判断index 是否扫描到计算表达式的最后
		if index+1 == len(exp) {
			break
		}
		index++
	}
	//	如果扫描表达式 完毕 ，依次从符号栈取出符号，然后从数栈取出两个数
	//运算后的结果，入数栈，直到符号栈为空
	for {
		if operStack.Top == -1 {
			break
		}
		num1 = numStack.Pop()
		num2 = numStack.Pop()
		oper = operStack.Pop()
		result = operStack.Cal(num1, num2, oper)
		//	将计算结果重新入栈
		numStack.Push(result)
	}

	//	如果算法没有问题，表达式也正确，则结果就是numStack最后数
	res := numStack.Pop()
	fmt.Printf("表达式%s=%v", exp, res)

整体代码

package main

import (
	"fmt"
	"strconv"
)

type Stack struct {
	MaxTop int //表示栈中能存放的最多的元素
	Top    int // 表示栈顶元素
	arr    [20]int
}

// Push 入栈
func (s *Stack) Push(val int) {
	if s.Top+1 == s.MaxTop {
		fmt.Println("栈满了")
		return
	}
	s.Top++
	s.arr[s.Top] = val
}

// Push2 一次性添加多个元素
func (s *Stack) Push2(v ...int) {
	if s.Top+1 == s.MaxTop {
		fmt.Println("栈满了")
		return
	}
	for _, val := range v {
		s.Push(val)
	}
}

// Pop 出栈
func (s *Stack) Pop() int {
	if s.Top == -1 {
		fmt.Println("空栈")
		return 0
	}
	v := s.arr[s.Top]
	s.Top--
	return v
}

// Peek 显示栈中元素
func (s *Stack) Peek() {
	if s.Top == -1 {
		fmt.Println("空栈")
		return
	}
	fmt.Println("栈中元素为：")
	for i := s.Top; i >= 0; i-- {
		fmt.Printf("arr[%d]=%d\n", i, s.arr[i])
	}
}

// IsOper 判断一个字符是不是一个运算符[+,-,*,/]
func (s *Stack) IsOper(val int) bool {
	if val == 42 || val == 43 || val == 45 || val == 47 {
		return true
	} else {
		return false
	}
}

// Cal 运算的方法
func (s *Stack) Cal(num1, num2, oper int) int {
	res := 0
	switch oper {
	case 42:
		res = num2 * num1
	case 43:
		res = num2 + num1
	case 45:
		res = num2 - num1
	case 47:
		res = num2 / num1
	default:
		fmt.Println("运算符错误！")
	}
	return res
}

// Priority 编写一个方法，返回某个运算符的优先级
// * / 优先级 1
// + - 优先级 0
func (s *Stack) Priority(oper int) int {
	if oper == 42 || oper == 47 {
		return 1
	} else if oper == 43 || oper == 45 {
		return 0
	}
	return 0
}

func main() {
	//	数栈
	numStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	operStack := &Stack{
		MaxTop: 20,
		Top:    -1,
	}
	var exp string
	fmt.Println("请输入一个只包含（+，-，*，/）的表达式")
	fmt.Scanln(&exp)"
	//	定义一个index，帮助扫描exp
	index := 0
	//为了配合运算，我们定义需要的变量
	num1 := 0
	num2 := 0
	oper := 0
	result := 0
	keepNum := ""
	for {
		//增加一个逻辑，处理多位数的问题

		ch := exp[index : index+1]
		temp := int([]byte(ch)[0]) //就是字符对应的ASCII码
		if operStack.IsOper(temp) {
			//	说明是符号
			//	如果operStack 是一个空栈，直接入栈
			if operStack.Top == -1 {
				operStack.Push(temp)
			} else {
				//	如果发现operStack栈顶的运算符的优先级大于等于当前准备入栈的运算符的优先级，就从符号栈Pop出，并从数栈中也Pop两个数，进行运算
				//	运算后的结果再重新入栈到数栈，当前符号再入符号栈
				if operStack.Priority(operStack.arr[operStack.Top]) >= operStack.Priority(temp) {
					num1 = numStack.Pop()
					num2 = numStack.Pop()
					oper = operStack.Pop()
					result = operStack.Cal(num1, num2, oper)
					//	将计算结果重新入栈
					numStack.Push(result)
					//	当前的符号压入栈
					operStack.Push(temp)
				} else {
					//否则直接将符号入栈
					operStack.Push(temp)
				}
			}
		} else {
			//	说明是数字
			//处理多位数的思路
			//1.定义一个变量 keepNum string ,做拼接
			keepNum += ch

			//2.每次要向index的前面字符测试一下，是不是运算符，然后处理

			//如果已经到表达式最后，直接keepNum
			if index == len(exp)-1 {
				val, _ := strconv.ParseInt(keepNum, 10, 64)
				numStack.Push(int(val))
			} else {
				//	向index后面测试一下看看是不是运算符
				if operStack.IsOper(int([]byte(exp[index+1 : index+2])[0])) {
					val, _ := strconv.ParseInt(keepNum, 10, 64)
					numStack.Push(int(val))
					keepNum = ""
				}
			}
		}

		//继续扫描
		//先判断index 是否扫描到计算表达式的最后
		if index+1 == len(exp) {
			break
		}
		index++
	}
	//	如果扫描表达式 完毕 ，依次从符号栈取出符号，然后从数栈取出两个数
	//运算后的结果，入数栈，直到符号栈为空
	for {
		if operStack.Top == -1 {
			break
		}
		num1 = numStack.Pop()
		num2 = numStack.Pop()
		oper = operStack.Pop()
		result = operStack.Cal(num1, num2, oper)
		//	将计算结果重新入栈
		numStack.Push(result)
	}

	//	如果算法没有问题，表达式也正确，则结果就是numStack最后数
	res := numStack.Pop()
	fmt.Printf("表达式%s=%v", exp, res)
}

运行结果

不会前端的小李
关注
  • 28
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang单文件实现简单计算器
afei001
10-29 650
golang没有接触过，因为想编写漏洞利用工具，所以不得不来学习。单个文件实现了计算器加、减、乘、除、开方、取模运算功能。
循环鼠标自动点击功能- Golang实现
04-10
循环鼠标自动点击功能--- Golang实现 有代码和可执行程序。
golang实现栈
李三思的博客
08-07 1048
golang实现栈
Golang 编译原理 计算器(通俗易懂)
wanghao3616的专栏
07-14 730
本文不需要你掌握任何编译原理的知识。 只需要看懂简单的golang语言即可， 完整的代码示例在GIT, 代码是从writing an interpreter in go这本书抽取了简单的部分出来, 如果需要进一步了解,请详阅此书. 听到编译原理，就觉得很高大上。记得上大学时，这门课要记忆一些BNF,LEX,AST,CFG这些有的没的。一个听不懂，二个没兴趣。随着使用了几门语言之后，也尝试用编译原理的基本知识写过一个sql转es的工具之后。发现其实了解一点点编译原理的知识，能够提高我们的生产效率，做出一些很
Golang实现逻辑编排解释引擎
ZhongAnTech的博客
10-20 584
逻辑编排提供一站式集成平台，简化了在集成接口、应用和服务时，所涉及的业务逻辑和流程。本文会介绍如何通过ChatGPT学习Golang、以及表达式解释器的实现和Golang解析引擎的基本设计架构。
go ast语义分析实现指标计算器
wujiesunlirong的博客
05-23 614
首先我们要知道AST是什么（Abstract Syntax Tree，AST），简称为语法树，是go语言源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。
Go: 用go编写一个简易版计算器
qq_42696078的博客
09-06 1112
用go语言实现一个简易版的计算器
golang与手机如何实现一些自动化操作？
soEase
10-26 5278
所有指令控制： http://adbshell.com/ golang与手机如何实现一些自动化操作？虽然不太会把电脑开起来操作手机，不过pi也应该可以与手机互动吧。 比如说来个无人值守功能啥的，语音信箱啥的....任凭想像。 第一步是实现手机与linux的连接，这里使用华为安卓手机，并没有root，反正试过几次都没成功。 ubuntu安装adb sudo add-apt-reposit...
深入理解Golang Map原理
剑心！的博客
06-11 1901
哈希表 是一种古老的数据结构，在 1953 年就有人使用拉链法实现了哈希表，它能够根据键（Key）直接访问内存中的存储位置，也就是说我们能够直接通过键找到该键对应的一个值，哈希表名称的来源是因为它使用了哈希函数将一个键映射到一个桶中，这个桶中就可能包含该键对应的值。哈希函数（常被称为散列函数）是可以用于将任意大小的数据映射到固定大小值的函数，常见的包括MD5、SHA系列等。 一个设计优秀的哈希函数应该包含以下特性：哈希函数在实际中遇到的最常见的问题就是哈希碰撞, 即不同的键通过哈希函数可能产生相同的哈希值
golang php服务器,golang,server_golang 并发的http服务器，golang,server - phpStudy
weixin_33042645的博客
03-21 127
golang 并发的http服务器首先，我使用了github.com/ant0ine/go-json-rest/rest 这个包直接贴代码func Start(){NeptuneLog := logs.New()api := rest.NewApi()api.Use(rest.DefaultDevStack...)router, err := rest.MakeRouter(rest.Get("...
golang实现简易的分布式系统方法
09-20
主要介绍了golang实现简易的分布式系统方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
golang 进度条功能实现示例
12-17
最近在做一个需求，功能很简单，就是开发一个轻量级客户端，将一个指定文件中的内容通过 TCP 发送到服务器。由于该文件特别大，有可能到达100G的数量级，因此处理起来会比较慢，为了给用户提供比较友好的展示界面，...
golang实现http server提供文件下载功能
09-17
主要介绍了golang实现http server提供文件下载功能，本文给大家简单介绍了Golang的相关知识，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
go-age:Golang的年龄计算器
05-09
适龄 Go-Age是一个用于go的小实用程序库，它可以轻松计算实体的年龄，并解决leap年等难题。
《征服数据结构》栈
最新发布
数据结构和算法
06-12 213
摘要：1，栈的介绍2，栈的链表实现3，栈的数组实现1，栈的介绍栈(stack)又称堆栈，是一种特殊的线性表，只能对栈顶添加和删除元素，它是一种后进先出(LIFO, Last In First Out)的数据结构。栈的两种基本操作：压栈(push)和出栈(pop)。压栈：将数据放入堆栈顶端。出栈：将堆栈顶端数据移除。堆栈只能操作一端，我们前面讲过双端队列，就是两端都可以添加和删除元素，如果把双端队列...
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1209
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
数据结构(4):串
qq_64279967的博客
06-10 498
字符串数据结构三要数：逻辑结构、存储结构、运算子串必须是连续的！空格也是一个字符！每个空格字符占1B。
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 878
二叉树顺序结构——堆的结构与源代码实现
golang实现简单密码功能
05-28
可以使用golang的crypto包来实现简单密码功能，下面是一个示例代码： ```go package main import ( "crypto/md5" "fmt" ) func main() { password := "123456" salt := "salt" hashed := md5.Sum([]byte...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值