Algoritmos y estructuras de datos en Go: guía práctica

Algoritmos y estructuras de datos en Go: guía práctica

Go (Golang) es un lenguaje compilado y estáticamente tipado creado en Google. Su simplicidad, alto rendimiento y soporte integrado para concurrencia lo convierten en una excelente opción para desarrollo backend, microservicios y programación de sistemas. Sin embargo, para escribir código eficiente en Go, no basta con conocer la sintaxis: es necesario comprender cómo funcionan los algoritmos y las estructuras de datos. En este artículo, analizaremos las estructuras de datos y algoritmos clave en Go, acompañando cada sección con ejemplos prácticos.

1. Pila (Stack) en Go

La pila es una estructura de datos que funciona bajo el principio LIFO (Last In, First Out). En Go no existe un tipo "pila" incorporado, pero es fácil de implementar usando un slice.

Ejemplo de implementación de una pila:

package main\n\nimport "fmt"\n\ntype Stack struct {\n    items []int\n}\n\n// Push agrega un elemento a la cima de la pila\nfunc (s *Stack) Push(item int) {\n    s.items = append(s.items, item)\n}\n\n// Pop elimina y devuelve el elemento de la cima de la pila\nfunc (s *Stack) Pop() (int, bool) {\n    if len(s.items) == 0 {\n        return 0, false\n    }\n    lastIndex := len(s.items) - 1\n    item := s.items[lastIndex]\n    s.items = s.items[:lastIndex]\n    return item, true\n}\n\n// Peek devuelve el elemento de la cima sin eliminarlo\nfunc (s *Stack) Peek() (int, bool) {\n    if len(s.items) == 0 {\n        return 0, false\n    }\n    return s.items[len(s.items)-1], true\n}\n\nfunc main() {\n    stack := Stack{}\n    stack.Push(10)\n    stack.Push(20)\n    stack.Push(30)\n\n    item, ok := stack.Pop()\n    if ok {\n        fmt.Println("Extraído:", item) // 30\n    }\n    fmt.Println("Cima de la pila:", stack.Peek()) // 20\n}

La pila en Go es eficiente gracias a su complejidad amortizada O(1) para las operaciones Push y Pop. Úsala para tareas como verificar secuencias de paréntesis o deshacer acciones (undo).

2. Cola (Queue) en Go

La cola funciona bajo el principio FIFO (First In, First Out). La implementaremos usando un slice con punteros al inicio y al final.

Ejemplo de implementación de una cola:

package main\n\nimport "fmt"\n\ntype Queue struct {\n    items []int\n}\n\n// Enqueue agrega un elemento al final de la cola\nfunc (q *Queue) Enqueue(item int) {\n    q.items = append(q.items, item)\n}\n\n// Dequeue elimina y devuelve el elemento del inicio de la cola\nfunc (q *Queue) Dequeue() (int, bool) {\n    if len(q.items) == 0 {\n        return 0, false\n    }\n    item := q.items[0]\n    q.items = q.items[1:]\n    return item, true\n}\n\n// Front devuelve el primer elemento sin eliminarlo\nfunc (q *Queue) Front() (int, bool) {\n    if len(q.items) == 0 {\n        return 0, false\n    }\n    return q.items[0], true\n}\n\nfunc main() {\n    queue := Queue{}\n    queue.Enqueue(1)\n    queue.Enqueue(2)\n    queue.Enqueue(3)\n\n    item, ok := queue.Dequeue()\n    if ok {\n        fmt.Println("Extraído:", item) // 1\n    }\n    fmt.Println("Primero en la cola:", queue.Front()) // 2\n}

Atención: la operación Dequeue en esta implementación tiene complejidad O(n), ya que eliminar el primer elemento desplaza todo el slice. Para código en producción, usa un búfer circular (ring buffer) o una lista doblemente enlazada (container/list).

3. Ordenamiento de burbuja (Bubble Sort) en Go

El ordenamiento de burbuja es uno de los algoritmos más simples, aunque ineficientes. Sin embargo, es excelente para aprender. Complejidad: O(n²).

package main\n\nimport "fmt"\n\nfunc bubbleSort(arr []int) {\n    n := len(arr)\n    for i := 0; i < n-1; i++ {\n        swapped := false\n        for j := 0; j < n-i-1; j++ {\n            if arr[j] > arr[j+1] {\n                arr[j], arr[j+1] = arr[j+1], arr[j]\n                swapped = true\n            }\n        }\n        // Si no hubo intercambios, el array ya está ordenado\n        if !swap