计算四则表达式值 Golang

思路：
先转逆波兰，再求值
逆波兰求值的思路是，碰到数字入栈，碰到运算符则取栈顶两元素运算后入栈，最终栈内数字即为答案。
中缀表达式转为后缀表达式，即逆波兰表达式方法：对于中缀表达式的每个元素，遇到数字则直接加到结果上面，遇到操作符，若栈空或者当前操作符不小于栈顶操作符优先级（乘除大于加减），则入栈，否则将栈弹空依次加到结果上，再把当前元素入栈。遍历完毕后，最后再将栈内元素依次弹到结果上即可。

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func mid2fix(s string) []string {
	res := []string{}
	exp := strings.Fields(s)
	ss := []string{}
	fmt.Println(exp)

	for _, c := range exp {
		_, err := strconv.Atoi(c)
		// 是数字 结果直接加
		if err == nil {
			res = append(res, c)
		} else {
			// 不是数字 
			if len(ss) == 0 {
				// 栈空直接入
				ss = append(ss, c)
			} else {
				// 判断优先级是否低于栈顶
				lst := ss[len(ss)-1]
				if low_prio(c, lst) {
					for len(ss) > 0 {
						res = append(res, ss[len(ss)-1])
						ss = ss[:len(ss)-1]
					}
				}
				ss = append(ss, c)
			}
		}
	}
	for len(ss) > 0 {
		res = append(res, ss[len(ss)-1])
		ss = ss[:len(ss)-1]
	}
	return res
}

func low_prio(a, b string) bool {
	if a == "*" || a == "/" {
		return false
	} else {
		if b == "*" || b == "/" {
			return true
		} else {
			return false
		}
	}
}

func calc_res(exp []string) int {
	s := []int{}
	for _, ex := range exp {
		num, err := strconv.Atoi(ex)
		if err == nil {
			s = append(s, num)
		} else {
			a, b := s[len(s)-2], s[len(s)-1]
			s = s[:len(s)-2]
			s = append(s, op(a, b, ex))
		}
	}
	return s[0]
}

func op(a, b int, c string) int {
	if c == "*" {
		return a * b
	} else if c == "/" {
		return a / b
	} else if c == "+" {
		return a + b
	} else {
		return a - b
	}

}
func main() {
	tt := "2 + 3 * 4 - 5 / 6"
	exp := mid2fix(tt)
	fmt.Println(exp)
	res := calc_res(exp)
	fmt.Println(res)
}