Sebastian Gomez

Jan 05, 2023

Updated: Jun 24, 2026

Estructuras de datos en Go: Pilas

Las estructuras de datos son una colección organizada de datos para almacenar, recuperar y manipular información de manera eficiente. Estas estructuras incluyen listas enlazadas, pilas, colas, árboles, matrices, grafos y tablas de hash. Cada estructura de datos tiene sus propias características y usos, lo que permite a los programadores elegir la estructura adecuada para cada situación. Estas estructuras también se pueden combinar para producir soluciones de programación más complejas.

Pilas (Stack)

Una pila o Stack es una estructura de datos basada en la idea de LIFO (Last In, First Out). Esto significa que el elemento que fue agregado más recientemente es el primero en ser retirado. Esta estructura se usa comúnmente para almacenar y manipular datos de forma ordenada y eficiente. Por ejemplo, se pueden usar para deshacer operaciones, almacenar llamadas a funciones y guardar datos en un orden específico.

Algunas características de una pila son:

• Es una estructura de datos LIFO (Last In, First Out).
• Solo permite el acceso a un elemento: el elemento superior.
• Solo se pueden realizar dos operaciones principales: push (agregar un elemento) y pop (eliminar un elemento).

Un Stack está diseñado para ser una estructura de datos eficiente. Los stacks se usan comúnmente para implementar recursividad y para almacenar datos en un orden específico.

Métodos principales que debemos implementar

Cuando implementamos un stack, estos son los métodos principales:

• Push: agregar un elemento al stack.
• Pop: eliminar el elemento superior.
• Peek (también conocido como top): obtener el elemento superior sin eliminarlo.
• Empty (también conocido como isEmpty): verificar si el stack está vacío o no.
• Size: obtener el tamaño del stack.

Imagina un stack de 4 elementos, donde el elemento superior (A) es el primero en ser eliminado.

Aquí tienes un ejemplo de código de una pila escrita en Go. Recuerda que la traducción de pila es stack:

package main

import (
	"fmt"
)

// Libro es una estructura para almacenar información de libros
type Libro struct {
	Título  string
	Autor   string
	Páginas int
}

// StackLibros es una estructura de datos que permite la inserción y eliminación de libros
// utilizando el principio LIFO (Last In First Out).
type StackLibros struct {
	data []Libro
}

// Push agrega un libro al stack
func (s *StackLibros) Push(value Libro) {
	s.data = append(s.data, value)
}

// Pop elimina el elemento superior del stack
func (s *StackLibros) Pop() Libro {
	if len(s.data) == 0 {
		return Libro{}
	}

	value := s.data[len(s.data)-1]
	s.data = s.data[:len(s.data)-1]
	return value
}

// Peek obtiene el elemento superior del stack sin eliminarlo
func (s *StackLibros) Peek() Libro {
	if len(s.data) == 0 {
		return Libro{}
	}
	return s.data[len(s.data)-1]
}

// Empty verifica si el stack está vacío o no
func (s *StackLibros) Empty() bool {
	return len(s.data) == 0
}

// Size obtiene el tamaño del stack
func (s *StackLibros) Size() int {
	return len(s.data)
}

func main() {
	s := StackLibros{}
	s.Push(Libro{"Cien años de soledad", "Gabriel García Márquez", 417})
	s.Push(Libro{"El principito", "Antoine de Saint-Exupéry", 77})
	s.Push(Libro{"El alquimista", "Paulo Coelho", 163})

	fmt.Println("Tamaño del stack:", s.Size())
	fmt.Println("Elemento superior:", s.Peek().Título)

	for !s.Empty() {
		libro := s.Pop()
		fmt.Printf("Título: %s, Autor: %s, Páginas: %d\n", libro.Título, libro.Autor, libro.Páginas)
	}
}

Este código compila y se ejecuta sin problemas en versiones actuales de Go: el patrón de pila respaldada por un slice (append para insertar y s.data[:len(s.data)-1] para eliminar) es atemporal y no depende de ninguna API que vaya a quedar obsoleta.

¿Por qué un Stack es la base de otras estructuras de datos más complejas?

Un stack es una estructura de datos muy simple que puede servir como base para construir estructuras más complejas como los árboles, grafos y colas. Esto se debe a que el stack ofrece una forma eficiente de almacenar y manipular datos. Además, los stacks se usan comúnmente para implementar recursividad, lo que los convierte en una herramienta útil para crear estructuras de datos más complejas.

Un poco de historia

El Stack se remonta a los primeros días de la informática, cuando los programadores buscaban la mejor forma de almacenar y manipular datos de manera eficiente. El principio LIFO (Last In, First Out) suele atribuirse comúnmente a Alan Turing (alrededor de 1946) y, de forma independiente, a Friedrich L. Bauer y Klaus Samelson, quienes patentaron el principio a finales de la década de 1950. La idea era crear una estructura de datos eficiente en la que el último elemento agregado fuera el primero en ser eliminado. Con el tiempo, el stack se ha convertido en una herramienta básica para construir estructuras de datos más complejas como los árboles, grafos y colas. Se usa comúnmente para implementar recursividad y para almacenar datos en un orden específico. En la actualidad, el stack sigue siendo una de las estructuras de datos más utilizadas en la ingeniería de software.

Conclusiones

En conclusión, la estructura Stack es una estructura de datos muy útil y ampliamente utilizada para almacenar y organizar información. Ofrece una forma fácil de guardar y recuperar datos de manera eficiente. Esta estructura es esencial para la programación, ya que permite a los programadores implementar una gran variedad de soluciones. Además, la estructura Stack es una herramienta indispensable para la implementación de algoritmos recursivos.

Ejercicios para practicar

A continuación te dejo un ejercicio para que practiques la estructura "Stack" en Go y envíes la solución como un Pull request a este repositorio: Go Para Principiantes.

Ejercicio: Crea una estructura Stack en Go para almacenar los nombres de los animales y agrega los elementos 'Perro', 'Gato', 'Conejo' y 'Loro' a la pila.

Resumen

• Las Pilas o Stacks son estructuras de datos basadas en la idea de LIFO (Last In, First Out) y son ampliamente utilizadas en programación.
• Los Stacks permiten realizar operaciones de push (agregar un elemento) y pop (eliminar un elemento), además de otras funciones como peek (obtener el elemento superior sin eliminarlo), empty (verificar si el stack está vacío) y size (obtener el tamaño del stack).
• Los Stacks son esenciales en la implementación de algoritmos recursivos y sirven como base para estructuras de datos más complejas como árboles, grafos y colas.

Ahora que conoces las bases de las pilas y cómo implementarlas en Go, puedes explorar cómo aplicarlas en diferentes problemas y situaciones en tus proyectos de programación. Espero que este post te sea de utilidad y lo puedas aplicar a algún proyecto que tengas en mente. Déjame un comentario si te sirvió, y recuerda que si te gustó también puedes compartirlo usando los links a las redes sociales aquí abajo. ¡Buena suerte y feliz codificación!