表达式求值

使用后缀表达式对于表达式进行求值

1. 求后缀表达式

后缀表达式求取：后缀表达式结果使用队列 tmp 进行存储

1. 遇到数字字符，截取相连的数字字符为一组，加入 tmp 中
2. 设置符号优先级，入栈时 (、*、/ 大于 +、- 大于 )， 出栈时 *、/ 大于 +、- 大于 (，并构建存储符号的栈 charStack
3. 当遍历到符号时，如果 charStack 的长度为 0，直接加入栈中
4. 如果为 )，则将 charStack 中的符号出栈，只至遇到 (
5. 如果为 (、*、\，则直接入栈
6. 如果为 +、-，则将优先级不小于它们的符号全部出栈，直到遇到 ( 或栈空为止

charStack := make([]byte,0)
    tmp := make([]string,0)
    for i:=0;i<len(s);{
        if s[i] >= '0' && s[i] <= '9'{
            t := ""
            j := i
            for ;j<len(s);j++{
                if s[j] >= '0' && s[j] <= '9'{
                    t+= string(s[j])

                }else{
                    break
                }
            }
            tmp = append(tmp,string(t))
            i = j
        }else{
            if len(charStack) == 0{
                charStack = append(charStack, s[i])
            }else{
                if s[i] == ')'{
                    t := 0
                    for j:=len(charStack)-1;j>=0;j--{
                        if charStack[j] == '('{
                            break
                        }else{
                            tmp = append(tmp, string(charStack[j]))
                            t++
                        }

                    }
                    charStack = charStack[:len(charStack)-t-1]
                }else if s[i] == '+' || s[i] == '-'{
                    t :=0
                    for j:=len(charStack)-1;j>=0;j--{
                        if charStack[j] == '(' {
                            break
                        }else{
                            tmp = append(tmp, string(charStack[j]))
                            t++
                        }
                    }
                    charStack = charStack[:len(charStack)-t]
                    charStack = append(charStack, s[i])
                }else{
                    charStack = append(charStack, s[i])
                }
            }
            i++
        }
    }
    for i:=len(charStack)-1;i>=0;i--{
        tmp = append(tmp,string(charStack[i]))
    }

2. 通过后缀表达式求值

1. 遍历后缀表达式队列 tmp，构建存储结果的栈 numStack
2. 遇到数字，将其入栈
3. 遇到运算符，从 numStack 中使顶部两个数字出栈，先出的位于运算符右边，后出的位于左边。例如减号中，后面为被减数，前面为减数
4. 循环2-3 步，直至遍历完成，输出 numStack 元素即为最终结果。

numStack:=make([]int,0)
    for  i:=0;i<len(tmp);i++{
        t,err := strconv.Atoi(tmp[i])
        if err != nil{
            if len(numStack) < 2{
                continue
            }
            a,b := numStack[len(numStack)-2],numStack[len(numStack)-1]
            numStack = numStack[:len(numStack)-2]
            res := 0
            switch tmp[i]{
                case "+":
                res = a+b 
                case "-":
                res = a-b 
                case "*":
                res = a*b 
                case "/":
                res = a/b
            }
            numStack = append(numStack, res)
        }else{
            numStack =append(numStack, t)
        }


    }
    return numStack[0]