Solución:
Es una cuestión de estilo y gusto personal, tu código está bien (además de no ser seguro para subprocesos y entrar en pánico si sale de una pila vacía). Para simplificarlo un poco, puede trabajar con métodos de valor y devolver la pila en sí, es un poco más elegante para algunos gustos. es decir
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)
}
Otro enfoque es envolverlo en una estructura, por lo que también puede agregar fácilmente un mutex para evitar condiciones de carrera, etc., algo como:
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())
}
Aquí hay una implementación de LIFO usando una estructura de datos vinculada
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
}
Creo que sería bueno si pudiéramos aprovechar las bibliotecas estándar de Go en lugar de crear una estructura de datos autodefinida como lo hizo @guy_fawkes. Aunque hizo un gran trabajo, no es una forma estándar de usar una lista enlazada individualmente.
Para obtener la cola de la lista en complejidad de tiempo O (1), usaría una lista doblemente enlazada. Cambio espacio por tiempo.
También sigo el consejo de @ Not_a_Golfer de agregar un candado a la pila.
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
}
Haga clic en este campo de juegos para obtener una vista previa del resultado.