栈_逆波兰表达式_计算器实现_Golang版本

借助栈与逆波兰表达式 实现一个计算器，编程语言用的是Golang。

逆波兰表达式可以讲复杂的计算过程转化为简单的操作过程，进而得出答案。 比如 (a+b)*(b-c) 按照逆波兰表达式的规则得到 ：ab+bc-*  

然后将该表达式的字符以及符号，按照从左到右的顺序，依次入栈，一碰到符号则将栈顶前两个元素取出，做运算然后放入栈内，重复该操作，直到表达式结束。

下面将结合栈与逆波兰表达式写一个简易计算器。

运行命令如下

go run counter.go --expression=\(3-5\)*4-\(5*8\)/3+78*9

代码示例：

package main

import (
	"fmt"
	"strconv"
	"flag"
)

type StackNode struct {
	Data interface{}
	next *StackNode
}

type LinkStack struct {
	top *StackNode
	Count int
}

func (this *LinkStack) Init() {
	this.top = nil
	this.Count = 0
}

func (this *LinkStack) Push(data interface{}) {
	var node *StackNode = new(StackNode)
	node.Data = data
	node.next = this.top
	this.top = node
	this.Count++
}

func (this *LinkStack) Pop() interface{} {
	if this.top == nil {
		return nil
	}
	returnData := this.top.Data
	this.top = this.top.next
	this.Count--
	return returnData
}

//Look up the top element in the stack, but not pop.
func (this *LinkStack) LookTop() interface{} {
	if this.top == nil {
		return nil
	}
	return this.top.Data
}

var str *string = flag.String("expression", "", "")

func main() {
	flag.Parse()
	fmt.Println(*str)
	fmt.Println(Count(*str))
}

func Count(data string) float64 {
	//TODO 检查字符串输入
	var arr []string = generateRPN(data)
	return calculateRPN(arr)
}

func calculateRPN(datas []string) float64 {
	var stack LinkStack
	stack.Init()
	for i := 0; i < len(datas); i++ {
		if isNumberString(datas[i]) {
			if f, err := strconv.ParseFloat(datas[i], 64); err != nil {
				panic("operatin process go wrong.")
			} else {
				stack.Push(f)
			}
		} else {
			p1 := stack.Pop().(float64)
			p2 := stack.Pop().(float64)
			p3 := normalCalculate(p2, p1, datas[i])
			stack.Push(p3)
		}
	}
	res := stack.Pop().(float64)
	return res
}

func normalCalculate(a,b float64, operation string) float64 {
	switch operation{
	case "*":
		return a * b
	case "-":
		return a - b
	case "+":
		return a + b
	case "/":
		return a / b
	default:
		panic("invalid operator")
	}
}

func generateRPN(exp string) []string {

	var stack LinkStack
	stack.Init()

	var spiltedStr []string = convertToStrings(exp)
	var datas []string

	for i := 0; i < len(spiltedStr); i++ { // 遍历每一个字符
		tmp := spiltedStr[i] //当前字符

		if !isNumberString(tmp) { //是否是数字
			// 四种情况入栈
			// 1 左括号直接入栈
			// 2 栈内为空直接入栈
			// 3 栈顶为左括号，直接入栈
			// 4 当前元素不为右括号时，在比较栈顶元素与当前元素，如果当前元素大，直接入栈。
			if tmp == "(" ||
				stack.LookTop() == nil || stack.LookTop().(string) == "(" ||
				( compareOperator(tmp, stack.LookTop().(string)) == 1 && tmp != ")" ) {
				stack.Push(tmp)
			} else { // ) priority
				if tmp == ")" { //当前元素为右括号时，提取操作符，直到碰见左括号
					for {
						if pop := stack.Pop().(string); pop == "(" {
							break
						} else {
							datas = append(datas, pop)
						}
					}
				} else { //当前元素为操作符时，不断地与栈顶元素比较直到遇到比自己小的（或者栈空了），然后入栈。
					for {
						pop := stack.LookTop()
						if pop != nil && compareOperator(tmp, pop.(string)) != 1 {
							datas = append(datas, stack.Pop().(string))
						} else {
							stack.Push(tmp)
							break
						}
					}
				}
			}

		} else {
			datas = append(datas, tmp)
		}
	}

	//将栈内剩余的操作符全部弹出。
	for {
		if pop := stack.Pop(); pop != nil {
			datas = append(datas, pop.(string))
		} else {
			break
		}
	}
	return datas
}

// if return 1, o1 > o2.
// if return 0, o1 = 02
// if return -1, o1 < o2
func compareOperator(o1, o2 string) int {
	// + - * /
	var o1Priority int
	if o1 == "+" || o1 == "-" {
		o1Priority = 1
	} else {
		o1Priority = 2
	}
	var o2Priority int
	if o2 == "+" || o2 == "-" {
		o2Priority = 1
	} else {
		o2Priority = 2
	}
	if o1Priority > o2Priority {
		return 1
	} else if o1Priority == o2Priority {
		return 0
	} else {
		return -1
	}
}

func isNumberString(o1 string) bool {
	if o1 == "+" || o1 == "-" || o1 == "*" || o1 == "/" || o1 == "(" || o1 == ")" {
		return false
	} else {
		return true
	}
}

func convertToStrings(s string) []string {
	var strs []string
	bys := []byte(s)
	var tmp string
	for i := 0; i < len(bys); i++ {
		if !isNumber(bys[i]) {
			if tmp != "" {
				strs = append(strs, tmp)
				tmp = ""
			}
			strs = append(strs, string(bys[i]))
		} else {
			tmp = tmp+string(bys[i])
		}
	}
	strs = append(strs, tmp)
	return strs
}

func isNumber(o1 byte) bool {
	if o1 == '+' || o1 == '-' || o1 == '*' || o1 == '/' || o1 == '(' || o1 == ')' {
		return false
	} else {
		return true
	}
}