golang数据结构之利用栈求计算表达式加减乘除

例如：3+2*6-2

先定义两个栈，一个为数值栈，一个为运算符栈；

stack.go

package stack

import (
    "errors"
    fmt"
)

type Stack struct {
    MaxTop int     //栈最大可以存放的数量
    Top    栈顶
    Arr    [20]int 模拟栈
}

func (s *Stack) Push(val int) (err error) {
    先判断栈是否满了
    if s.Top == s.MaxTop-1 {
        fmt.Println(栈满了)
        return errors.New()
    }
    s.Top++
    s.Arr[s.Top] = val
    return
}

func (s *Stack) Pop() (val ,err error) {
    if s.Top == -栈已空return -1,errors.New()
    }
    val = s.Arr[s.Top]
    s.Arr[s.Top] = 0
    s.Top--
     val,nil

}

func (s *Stack) Show() {
    栈为空
    }
    tmp := s
    for i := tmp.Top; i >= 0; i-- {
        fmt.Printf(Arr[%d]=%v\n
}

判断一个字符是数字还是加减乘除
func (s *Stack) IsOper(val int) bool {
    if val == 42 || val == 43 || val == 45 || val == 47 {
        return true
    } elsefalse
    }
}

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

定义优先级
func (s *Stack) Priority(oper if oper == 42 || oper ==  {
        res = else 43 || oper == 
    }
     res
}

main.go

package main

import (
    go_code/data_structure/stackstrconv
)

func main() {

    str := 30+2*6-600/2
    n := len(str)
    numStack := &stack.Stack{
        MaxTop: n,Top:    -= 
    num1 := 
    num2 := 
    oper := 
    result := 
    keepNum := ""
    for {
        ch := str[index : index+]
        字符对应的ASCII码值
        tmp := int([]byte(ch)[])
        if operStack.IsOper(tmp) {
            if operStack.Top == - {
                operStack.Push(tmp)
            }  {
                判断栈顶的优先级
                if operStack.Priority(operStack.Arr[operStack.Top]) >=
                    operStack.Priority(tmp) {
                    num1,_ = numStack.Pop()
                    num2,1)"> numStack.Pop()
                    oper,1)"> operStack.Pop()
                    result = operStack.Cal(num1,num2,oper)
                    将计算的结果重新入栈
                    numStack.Push(result)
                    当前符号重新入栈
                    operStack.Push(tmp)
                }  {
                    operStack.Push(tmp)
                }
            }

        }  {
            判断型如30等数字
            keepNum += ch

            if index == n- {
                val,_ := strconv.ParseInt(keepNum,10,1)">64)
                numStack.Push((val))
            } 向index后面探以位
                if operStack.IsOper(byte(str[index+1 : index+2])[])) {
                    val,1)">)
                    numStack.Push((val))
                    keepNum = ""
                }
            }
            入栈的数要是int型
             numStack.Push(int(val))
        }
        break
        }
        继续扫描
        index++
    }

    如果表达式扫描完毕，依次取出符号和两位数进行运算
    
        }
        num1,1)"> numStack.Pop()
        num2,1)"> numStack.Pop()
        oper,1)"> operStack.Pop()
        result =        numStack.Push(result)
    }

    res,_ := numStack.Pop()
    fmt.Printf(计算表达式 %v 的值是：%v\n

                
                                 
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [e-mail] 举报，一经查实，本站将立刻删除。
                            

• 上一篇：golang数据结构之单链表下一篇：golang数据结构之总结