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

Introducción: Por qué los algoritmos y las estructuras de datos son importantes en Go

Go (Golang) es un lenguaje compilado moderno, creado en Google para sistemas de alto rendimiento. Su simplicidad y el soporte integrado para la concurrencia lo hacen ideal para el desarrollo backend, microservicios y aplicaciones en la nube. Sin embargo, como en cualquier otro lenguaje, la eficiencia del código en Go depende directamente de la comprensión de algoritmos y estructuras de datos. Sin ellos, incluso el lenguaje más rápido puede convertirse en un cuello de botella.

En este artículo, analizaremos las estructuras de datos y algoritmos clave que todo desarrollador Go debe conocer: desde arrays hasta la búsqueda binaria. Verá ejemplos de código, aprenderá cómo funcionan "bajo el capó" y obtendrá consejos prácticos para la optimización.

1. Estructuras de datos básicas en Go

Go proporciona estructuras de datos integradas, pero su uso correcto es la clave del rendimiento. Consideremos tres principales: arrays, slices y tablas hash.

1.1 Arrays y Slices

Un array en Go es una secuencia fija de elementos del mismo tipo. Un slice es un envoltorio dinámico sobre un array que permite cambiar su tamaño.

package main

import "fmt"

func main() {    // Array de longitud fija    var arr [5]int = [5]int{1, 2, 3, 4, 5}    fmt.Println("Array:", arr)

    // Slice — estructura dinámica    slice := []int{10, 20, 30}    slice = append(slice, 40) // Añadir elemento    fmt.Println("Slice:", slice)

    // Slice a partir de un array    subSlice := arr[1:4] // [2, 3, 4]    fmt.Println("Subslice:", subSlice)}

Consejo: Use siempre slices en lugar de arrays para mayor flexibilidad, pero recuerde que append puede provocar reasignación de memoria. Predefina la capacidad con make([]int, 0, capacity).

1.2 Tablas hash (Map)

Un map es una colección no ordenada de pares clave-valor. En Go, el map se implementa como una tabla hash, que proporciona un tiempo de acceso promedio de O(1).

package main

import "fmt"

func main() {    // Crear un map    scores := make(map[string]int)    scores["Alice"] = 95    scores["Bob"] = 87

    // Lectura con verificación    if val, ok := scores["Alice"]; ok {        fmt.Println("Puntuación de Alice:", val)    }

    // Eliminación    delete(scores, "Bob")    fmt.Println("Después de eliminar:", scores)}

Importante: El map no admite acceso concurrente sin sincronización. Para escenarios multihilo, use sync.Map o mutex.

2. Implementación de una lista enlazada en Go

Las listas enlazadas rara vez se encuentran en Go debido a la existencia de slices, pero son útiles para comprender los punteros y las estructuras dinámicas. Consideremos una lista simplemente enlazada.

2.1 Estructura del nodo y operaciones básicas

package main

import "fmt"

// Nodo de la listatype Node struct {    Value int    Next  *Node}

// Listatype LinkedList struct {    Head *Node}

// Añadir al iniciofunc (ll *LinkedList) Prepend(value int) {    newNode := &Node{Value: value, Next: ll.Head}    ll.Head = newNode}

// Buscar elementofunc (ll *LinkedList) Search(value int) bool {    current := ll.Head    for current != nil {        if current.Value == value {            return true        }        current = current.Next    }    return false}

// Imprimir listafunc (ll *LinkedList) Print() {    current := ll.Head    for current != nil {        fmt.Printf("%d -> ", current.Value)        current = current.Next    }    fmt.Println("nil")}

func main() {    list := LinkedList{}    list.Prepend(10)    list.Prepend(20)    list.Prepend(30)    list.Print() // 30 -> 20 -> 10 -> nil    fmt.Println("Encontrado 20:", list.Search(20)) // true}

Rendimiento: La inserción al inicio es O(1), la búsqueda es O(n). Para acceso frecuente por índice