在 golang 中寻找合理的堆栈实现？

Question

到目前为止，我天真的方法是type stack []intfunc (s *stack) Push(v int) {    *s = append(*s, v)}func (s *stack) Pop() int {    res:=(*s)[len(*s)-1]    *s=(*s)[:len(*s)-1]    return res}它有效 - playground，但看起来很丑并且有太多的取消引用。我能做得更好吗？

Answer 1

这是使用链接数据结构的 LIFO 实现

package stack

import "sync"

type element struct {

    data interface{}

    next *element

}

type stack struct {

    lock *sync.Mutex

    head *element

    Size int

}

func (stk *stack) Push(data interface{}) {

    stk.lock.Lock()

    element := new(element)

    element.data = data

    temp := stk.head

    element.next = temp

    stk.head = element

    stk.Size++

    stk.lock.Unlock()

}

func (stk *stack) Pop() interface{} {

    if stk.head == nil {

        return nil

    }

    stk.lock.Lock()

    r := stk.head.data

    stk.head = stk.head.next

    stk.Size--

    stk.lock.Unlock()

    return r

}

func New() *stack {

    stk := new(stack)

    stk.lock = &sync.Mutex{}

    return stk

}