Question

到目前为止，我的天真方法是

type stack []int

func (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

这是一个风格和个人品味的问题，你的代码很好（除了不是线程安全和恐慌，如果你从空堆栈弹出）。为了简化它，您可以使用值方法并返回堆栈本身，它稍微优雅到某些品味。即。

type stack []int

func (s stack) Push(v int) stack {
    return append(s, v)
}

func (s stack) Pop() (stack, int) {
    // FIXME: What do we do if the stack is empty, though?

    l := len(s)
    return  s[:l-1], s[l-1]
}


func main(){
    s := make(stack,0)
    s = s.Push(1)
    s = s.Push(2)
    s = s.Push(3)

    s, p := s.Pop()
    fmt.Println(p)

}

另一种方法是将它包装在一个结构中，这样你也可以轻松地添加一个互斥体以避免竞争条件，例如：

type stack struct {
     lock sync.Mutex // you don't have to do this if you don't want thread safety
     s []int
}

func NewStack() *stack {
    return &stack {sync.Mutex{}, make([]int,0), }
}

func (s *stack) Push(v int) {
    s.lock.Lock()
    defer s.lock.Unlock()

    s.s = append(s.s, v)
}

func (s *stack) Pop() (int, error) {
    s.lock.Lock()
    defer s.lock.Unlock()


    l := len(s.s)
    if l == 0 {
        return 0, errors.New("Empty Stack")
    }

    res := s.s[l-1]
    s.s = s.s[:l-1]
    return res, nil
}


func main(){
    s := NewStack()
    s.Push(1)
    s.Push(2)
    s.Push(3)
    fmt.Println(s.Pop())
    fmt.Println(s.Pop())
    fmt.Println(s.Pop())
}

Answer 2

以下是使用链接数据结构的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
}

Answer 3

我相信，如果我们可以利用Go的标准库而不是像@guy_fawkes那样创建自定义数据结构，那将是很好的。尽管他做得很好，但这不是使用单链表的标准方法。

要获得O（1）时间复杂度的列表尾巴，我将使用双向链接列表。我用时间来换空间。

我也接受@Not_a_Golfer的建议，将一个锁添加到堆栈中。

import (
    "container/list"
    "sync"
)

type Stack struct {
    dll   *list.List
    mutex sync.Mutex
}

func NewStack() *Stack {
    return &Stack{dll: list.New()}
}

func (s *Stack) Push(x interface{}) {
    s.mutex.Lock()
    defer s.mutex.Unlock()

    s.dll.PushBack(x)
}

func (s *Stack) Pop() interface{} {
    s.mutex.Lock()
    defer s.mutex.Unlock()

    if s.dll.Len() == 0 {
        return nil
    }
    tail := s.dll.Back()
    val := tail.Value
    s.dll.Remove(tail)
    return val
}

点击this playground预览结果。

Answer 4

使用https://github.com/emirpasic/gods

package main

import lls "github.com/emirpasic/gods/stacks/linkedliststack"

func main() {
    stack := lls.New()  // empty
    stack.Push(1)       // 1
    stack.Push(2)       // 1, 2
    stack.Values()      // 2, 1 (LIFO order)
    _, _ = stack.Peek() // 2,true
    _, _ = stack.Pop()  // 2, true
    _, _ = stack.Pop()  // 1, true
    _, _ = stack.Pop()  // nil, false (nothing to pop)
    stack.Push(1)       // 1
    stack.Clear()       // empty
    stack.Empty()       // true
    stack.Size()        // 0
}

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

4 个答案: