golang实现中缀表达式转换成后缀表达式(逆波兰)

已于 2022-08-16 16:03:58 修改
阅读量655 收藏 1
点赞数 2
文章标签： golang 开发语言 后端
于 2021-11-02 01:06:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42474185/article/details/121092431
版权

NifixToRPN函数只能转换无括号的中缀表达式，遇到括号则调用barket函数，如果括号中嵌套括号则形成了递归。

支持含 + - * / ( ) 与 整数 组合的中缀表达式转换（ 可以支持负数如(-2) ）。

函数预览：

func NifixToRPN(nifix []byte) []string

Go语言实现:

package main

import "fmt"

//与NifixToRPN 递归消除括号,返回对应后括号的位置
func barket(a []byte, first int) ([]string, int) {
	last := 0  //对应后括号的位置
	count := 0 //计数左括号
	for i := first; i < len(a)-1; i++ {
		if a[i+1] == '(' {
			count++
		}
		if a[i+1] == ')' {
			if count == 0 {
				last = i + 1
                break
			} else {
				count--
			}
		}
	}
	NewA := a[first+1 : last]
	return NifixToRPN(NewA), last //递归
}

//中缀表达式转后缀表达式
//仅仅支持含 + - * / ( ) 与 整数 组合的表达式(可以支持负数如(-2))
func NifixToRPN(nifix []byte) []string {
	operatorStack := make([]byte, 0, 20) //存放运算符的栈(切片模拟栈)
	ret := make([]string, 0, len(nifix)) //返回的逆波兰表达式
	//把'+' '-'看成一类，优先级低于 '*' '/'
	priority := map[byte]int{
		'+': 0,
		'-': 0,
		'*': 1,
		'/': 1,
	}
	i := 0
	//处理第一个数为负数的情况
	if nifix[0] == '-' {
		i = 1
		tempI := i
		//处理'-'后的数字加入ret
		for tempI+1 < len(nifix) && nifix[tempI+1] >= '0' && nifix[tempI+1] <= '9' {
			tempI++
		}
		ret = append(ret, "-"+string(nifix[i:tempI+1]))
		i = tempI + 1
	}
	for ; i < len(nifix); i++ {
		//将连续的数字写入ret
		if nifix[i] >= '0' && nifix[i] <= '9' {
			tempI := i
			for tempI+1 < len(nifix) && nifix[tempI+1] >= '0' && nifix[tempI+1] <= '9' {
				tempI++
			}
			ret = append(ret, string(nifix[i:tempI+1]))
			i = tempI
			continue
		}
		//把括号里面的内容当成一个数字，将得到的逆波兰表达式直接写入ret
		if nifix[i] == '(' {
			//调用barket消除括号
			newNifix, last := barket(nifix, i)
			ret = append(ret, newNifix...)
			i = last
			continue
		}
		//栈中没有运算符，直接将当前运算符入栈
		if len(operatorStack) == 0 {
			operatorStack = append(operatorStack, nifix[i])
			continue
		}
		//如果当前符号的优先级 小于 上一个未出栈符号优先级，则将栈清空，当前符号入栈
		if priority[nifix[i]] < priority[operatorStack[len(operatorStack)-1]] {
			//将栈清空，写入ret
			for len(operatorStack) != 0 {
				ret = append(ret, string(operatorStack[len(operatorStack)-1]))
				operatorStack = operatorStack[0 : len(operatorStack)-1]
			}
			//当前符号入栈
			operatorStack = append(operatorStack, nifix[i])
			continue
		}
		//如果当前符号的优先级 等于 上一个未出栈符号优先级，栈中优先级相同的连续符号全部出栈，当前符号入栈
		if priority[nifix[i]] == priority[operatorStack[len(operatorStack)-1]] {
			for len(operatorStack) != 0 && priority[nifix[i]] == priority[operatorStack[len(operatorStack)-1]] {
				ret = append(ret, string(operatorStack[len(operatorStack)-1]))
				operatorStack = operatorStack[0 : len(operatorStack)-1]
			}
			//当前符号入栈
			operatorStack = append(operatorStack, nifix[i])
			continue
		}
		//此时栈中还有符号，且当前符号优先级高于栈中符号,将当前符号入栈
		operatorStack = append(operatorStack, nifix[i])
	}
	//还有未出栈的符号，依次出栈
	if len(operatorStack) != 0 {
		if len(operatorStack) == 2 {
			ret = append(ret, string(operatorStack[1]))
		}
		ret = append(ret, string(operatorStack[0]))
	}
	return ret
}


func main() {
	//test case
	//s1:="1+2*6-3"
	//s1 := "1+(2-3)*4+10/5"
	//s1 := "1+((2+3)*4)-5"
	//s1 := "15*90+2*1/6-3"
	//s1 := "2*4/7-3/6+9"
	s1 := "15*90+2*1/6-3-1+((2+3)*4)-9+(2-3)*4"
	ss := NifixToRPN([]byte(s1))
	fmt.Println(s1)
	fmt.Println(ss)
}

test case输出

15*90+2*1/6-3-1+((2+3)*4)-9+(2-3)*4
[15 90 * 2 1 * 6 / + 3 - 1 - 2 3 + 4 * + 9 - 2 3 - 4 * +]

golang测试代码：

package main

import (
	"reflect"
	"testing"
)

type testcase struct {
	Nifix string
	RPN   []string
}

func TestNifixToRPN(t *testing.T) {
	tests := []testcase{
		{"1+2*6*4-3", []string{"1", "2", "6", "*", "4", "*", "+", "3", "-"}},
		{"-366/3+9", []string{"-366", "3", "/", "9", "+"}},
		{"(-366/3+9)", []string{"-366", "3", "/", "9", "+"}},
		{"-3/3+9", []string{"-3", "3", "/", "9", "+"}},
		{"-3", []string{"-3"}},
		{"(-3)", []string{"-3"}},
		{"(-366)", []string{"-366"}},
		{"1+2+6-3*9", []string{"1", "2", "+", "6", "+", "3", "9", "*", "-"}},
		{"1*8*9+2*6-3+5", []string{"1", "8", "*", "9", "*", "2", "6", "*", "+", "3", "-", "5", "+"}},
		{"1*8*9*7/2+2/3*6-3+5", []string{"1", "8", "*", "9", "*", "7", "*", "2", "/", "2", "3", "/",
			"6", "*", "+", "3", "-", "5", "+"}},
		{"1/8*9+2+6-3*5", []string{"1", "8", "/", "9", "*", "2", "+", "6", "+", "3", "5", "*", "-"}},
		{"2*6-3", []string{"2", "6", "*", "3", "-"}},
		{"1+(2-3)*4+10/5", []string{"1", "2", "3", "-", "4", "*", "+", "10", "5", "/", "+"}},
		{"1+2*3-4-5/6", []string{"1", "2", "3", "*", "+", "4", "-", "5", "6", "/", "-"}},
		{"1+((2+3)*4)-5", []string{"1", "2", "3", "+", "4", "*", "+", "5", "-"}},
		{"1+(-9*(2+3)*4)-5", []string{"1", "-9", "2", "3", "+", "*", "4", "*", "+", "5", "-"}},
		{"1+(-99*(2+3)*4+5)-5", []string{"1", "-99", "2", "3", "+", "*", "4", "*", "5", "+", "+", "5", "-"}},
		{"15*90+2*1/6-3", []string{"15", "90", "*", "2", "1", "*", "6", "/", "+", "3", "-"}},
		{"15*90+4*(2-(6+9)*3)", []string{"15", "90", "*", "4", "2", "6", "9", "+", "3", "*", "-", "*", "+"}},
		{"15*90+4*(-2-(6+9)*3)", []string{"15", "90", "*", "4", "-2", "6", "9", "+", "3", "*", "-", "*", "+"}},
		{"15*(100-90)+2", []string{"15", "100", "90", "-", "*", "2", "+"}},
		{"2*4/7-3/6+9", []string{"2", "4", "*", "7", "/", "3", "6", "/", "-", "9", "+"}},
		{"15*90+2*1/6-3-1+((2+3)*4)-9+(2-3)*4", []string{"15", "90", "*", "2", "1", "*", "6", "/", "+", "3", "-", "1",
			"-", "2", "3", "+", "4", "*", "+", "9", "-", "2", "3", "-", "4", "*", "+"}},
		{"15*90+2*1/6-3-1+((2+3)*4)-9+99*(2-3)*4", []string{"15", "90", "*", "2", "1", "*", "6", "/", "+", "3", "-", "1",
			"-", "2", "3", "+", "4", "*", "+", "9", "-", "99", "2", "3", "-", "*", "4", "*", "+"}},
		{"3*75+4-8+((10*(6/((9+3)*(0-11))))+17)+5", []string{"3", "75", "*", "4", "+", "8", "-", "10", "6", "9", "3", "+", "0", "11",
			"-", "*", "/", "*", "17", "+", "+", "5", "+"}},
		{"3*75+4-8+((10*(6/((9+3)*(0-11))))*99+17)*99+5", []string{"3", "75", "*", "4", "+", "8", "-", "10", "6", "9", "3", "+", "0", "11",
			"-", "*", "/", "*", "99", "*", "17", "+", "99", "*", "+", "5", "+"}},
		{"(3*75+4-8+((10*(6/((9+3)*(0-11))))*99+17)*99+5)", []string{"3", "75", "*", "4", "+", "8", "-", "10", "6", "9", "3", "+", "0", "11",
			"-", "*", "/", "*", "99", "*", "17", "+", "99", "*", "+", "5", "+"}},
		{"3*75+4-8+((10*(-6/((9+3)*(0-11))))*99+17)*99+5", []string{"3", "75", "*", "4", "+", "8", "-", "10", "-6", "9", "3", "+", "0", "11",
			"-", "*", "/", "*", "99", "*", "17", "+", "99", "*", "+", "5", "+"}},
	}
	for _, v := range tests {
		if !reflect.DeepEqual(NifixToRPN([]byte(v.Nifix)), v.RPN) {
			t.Errorf("input:%s\n", v.Nifix)
			t.Errorf("want:%v\n", v.RPN)
			t.Errorf("get:%v\n", NifixToRPN([]byte(v.Nifix)))
		}
	}
}

测试用例全部通过：

=== RUN   TestNifixToRPN
--- PASS: TestNifixToRPN (0.00s)
PASS
ok      2       0.054s

Doratmon
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
中缀表达式转后缀表达式（又称逆波兰式）
Build
09-03 776
对于常见的 1+3*5-4/2 这种我们常用的表达式我们称为中缀表达式 而还有一种是将运算符放在后面的表达式称为后缀表达式
逆波兰计算器(中缀表达式转后缀表达式)
Shaunan的博客
10-23 562
1.输入一个逆波兰表达式（后缀表达式），使用栈（Stack),计算其结果 2.支持小括号和多位数整数。 3.思路分析 （3+4）5 -6对应的后缀表达式就是 3 4 + 5 * 6 - 1）从左至右扫描，将3和4压入堆栈 2）遇到+运算符，因此弹出4和3 ，计算出3+4的值，得到7，再将7入栈 3）遇到5入栈； 4）接下来是运算符，因此弹出5和7，计算出7* 5 = 35，将35入栈 5）将6入栈...
《数据结构》：中缀表达式转后缀表达式 + 后缀表达式的计算
热门推荐
Amentos的博客
10-07 7万+
《数据结构》实验报告：中缀/后缀/前缀表达式基本概念 + 前缀转后缀 + 后缀表达式的计算 + 完整算法实现
中缀表达式 转 后缀表达式(逆波兰表达式) 及计算
推土机
08-17 1936
中缀表达式转换后缀表达式： 正常表达式（中缀表达式）3+4*5-6 对应的后缀表达式(逆波兰表达式)：3 4 + 5 × 6 - 【利用栈的方法 】 中缀表达式看成一个字符串，从左到右开始扫描中缀表达式： 遇到操作数：直接输出（添加到后缀表达式中） 栈为空时，遇到运算符，直接入栈 遇到左括号：将其入栈 遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，括号不...
表达式转换（中缀表达式转后缀表达式） 递归算法
m0_59048867的博客
10-10 1018
圆括号可以嵌套，左圆括号后面又是表达式，形成表达式的递归定义。 圆括号具有最高优先级，其次是乘除，最后是加减。 最外层看成操作数1和操作数2及操作符+或-的组合表达式；第二层看成操作数1和操作数2及操作符*或/的组合表达式，最内层为圆括号括起来的表达式。 最内层返回第二层，第二层返回第一层，与计算逻辑相符。 后缀表达式为操作数+操作数+操作符，操作数可以是后缀表达式。 如有问题请指出，谢谢~ bool IsOpOrNum(string str) { char c = str[0]; if
Golang通过栈实现表达式运算(中缀表达式转后缀表达式解析语法)
u013071014的博客
08-07 631
需求背景：将string表达式数组 [title==AUSU && ( header==Wecome || brand!=AC68U )] 解析并使用ES查询得到运算结果。 分析：带有括号的表达式，需要根据优先级解析，可将中缀表达式转换为后缀表达式，去除括号
【数据结构连载一栈】【四则运算--后缀表达式】golang
hbk5241的博客
05-14 271
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
golang使用正则表达式解析网页
10-24
主要介绍了golang使用正则表达式解析网页,需要的朋友可以参考下
浅析golang 正则表达式
10-14
Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。这篇文章给大家介绍golang 正则表达式的相关知识，感兴趣的朋友跟随小编一起看看吧
gval：golang中的表达式求值
02-04
Gval（Go eVALuate）提供了对评估任意表达式（特别是类似Go的表达式）的支持。 评估 Gval可以使用参数，算术，逻辑和字符串运算来计算表达式： 基本表达式： 参数化表达式： 嵌套的参数化表达式： 算术表达式：...
go专业数据结构与算法
12-05
本节为go专业数据结构与算法，主要讲解go中的数据结构以及相关的算法，如排序算法等。
前缀中缀后缀表达式
weixin_33766168的博客
07-30 76
它们都是对表达式的记法，它们之间的区别在于运算符相对于操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。 将中缀表达式转换为前缀表达式 (1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2； (2) 从右至左扫描中缀表达式； (3) 遇到操作数时，将其压入S2； (4) 遇到运算符时，比较其...
栈_逆波兰表达式_计算器实现_Golang版本
u012807459的专栏
02-01 1790
逆波兰表达式可以讲复杂的计算过程转化为简单的操作过程，进而得出答案。 比如 (a+b)*(b-c) 按照逆波兰表达式的规则得到 ：ab+bc-*   将该表达式的字符以及符号，按照从左到右的顺序，依次入栈，一碰到符号则将栈顶前两个元素取出，做运算然后放入栈内，重复该操作，直到表达式结束。 下面将结合栈与逆波兰表达式写一个简易计算器。 运行命令如下 go run counter.go --
150. 逆波兰表达式求值
jiangdongxiaobawang的博客
09-23 524
根据逆波兰表示法，求表达式的值。 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 1.整数除法只保留整数部分。 2.给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 示例 2： 示例 3： 逆波兰表达式： 逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。 1.平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。 2.该算式的逆波兰表达式写法为 ( ( 1
Go语言了解
blll0的博客
05-28 581
Go了解 Go程序开发和基本结构说明 //go文件后缀：.go //表示该文件所在包是main，在go中，每个文件都必须属于一个包 package main //引入一个包fmt，引入后可以使用该包里面函数 import "fmt" //func是一个关键字，表示函数 //main是函数名，为主函数，即程序入口 func main(){ //表示调用fmt中函数Println fmt.Println("helloworld!") } 通过go build对该go文件进行编译，生成.exe
Golang对逆波兰表示法的简单实现
weixin_30795127的博客
08-09 136
1 package main 2 import ( 3 "bufio" 4 "fmt" 5 "os" 6 "strconv" 7 ) 8 type Stack struct { 9 i int 10 data [10]int 11 } 12 func (s *Stack) Push(a int) { 13...
golang力扣leetcode 150.逆波兰表达式求值
清风
12-04 465
150.逆波兰表达式求值150.逆波兰表达式求值题解代码 150.逆波兰表达式求值 150.逆波兰表达式求值 题解 逆波兰表达式是一种后缀表达式，遇到运算符就弹出两个进行运算即可，大水题 代码 package main import "strconv" func evalRPN(tokens []string) int { if len(tokens) == 0 { return 0 } stack := make([]int, 0, len(tokens)) for i := 0; i &
逆波兰实现计算器
huruzun的专栏
03-22 1046
#include #include #include using namespace std; bool isopretor(char ch) { switch(ch) { case '+' : case '-': case '*': case '/': case '%': return 1; default: return -1
算法学习——栈的应用之逆波兰（后缀）表达式转换
学不可以已
01-22 633
已知一组中缀表达式，求其后主表达式 例：      中缀表达式：(1+2)*3+(4+6)*(5*6)+7      后缀表达式：1 2+3*4 6+5 6** +7+ 求解此问题通常有两种方法： 1. 利用栈来存储运算符，通过比较优先级进行出入栈操作。 2. 将中缀表达式转换为二叉树，对二叉树进行后序遍历。 本文着重分析并实现方法1. 对于栈解法，应遵循以下原则： 1.  数字直
golang 正则表达式
最新发布
09-09
Golang 中正则表达式的使用非常方便。你可以使用内置的 `regexp` 包来进行正则表达式的匹配和操作。下面是一个简单的示例代码，展示了如何使用正则表达式在字符串中查找匹配的内容： ```go package main import ( ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值