Algoritmos y estructuras de datos en Go: guía para principiantes

Introducción a los algoritmos y estructuras de datos en Go

Go (Golang) es un lenguaje de programación compilado moderno, desarrollado en Google. Combina el rendimiento de C++ con la simplicidad de Python, lo que lo convierte en una opción ideal para aprender algoritmos y estructuras de datos. En este artículo, exploraremos conceptos fundamentales que te ayudarán a empezar a escribir código eficiente en Go.

Comprender las estructuras de datos y los algoritmos es una habilidad clave para cualquier desarrollador. Permiten organizar datos de manera eficiente y resolver problemas de forma óptima. Go proporciona tipos integrados potentes, como slices y map, pero conocer las estructuras básicas te ayudará a crear soluciones más complejas.

Estructuras de datos principales en Go

Arrays y Slices

En Go, los arrays tienen una longitud fija, mientras que los slices son dinámicos. Los slices son una herramienta más flexible y se usan con mayor frecuencia.

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 — array dinámico    slice := []int{10, 20, 30, 40, 50}    fmt.Println("Slice:", slice)

    // Agregar un elemento al slice    slice = append(slice, 60)    fmt.Println("Slice después de append:", slice)

    // Slice de una parte del array    subSlice := arr[1:4]    fmt.Println("Subslice:", subSlice)}

Los slices en Go son una referencia a un array subyacente. Contienen un puntero al primer elemento, la longitud y la capacidad. Esto los hace muy eficientes para trabajar con secuencias de datos.

Pila (Stack) en Go

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

package main

import (    "fmt"    "errors")

type Stack []int

func (s *Stack) Push(v int) {    *s = append(*s, v)}

func (s *Stack) Pop() (int, error) {    if len(*s) == 0 {        return 0, errors.New("la pila está vacía")    }    index := len(*s) - 1    element := (*s)[index]    *s = (*s)[:index]    return element, nil}

func main() {    var stack Stack        stack.Push(1)    stack.Push(2)    stack.Push(3)        for len(stack) > 0 {        val, err := stack.Pop()        if err == nil {            fmt.Println("Extraído:", val)        }    }}

Las pilas se utilizan en algoritmos de recorrido de árboles, verificación de paréntesis, deshacer acciones (undo) y análisis de expresiones.

Cola (Queue) en Go

La cola funciona bajo el principio FIFO (First In, First Out). En Go, se puede implementar usando un slice o una lista doblemente enlazada.

package main

import "fmt"

type Queue []int

func (q *Queue) Enqueue(v int) {    *q = append(*q, v)}

func (q *Queue) Dequeue() (int, bool) {    if len(*q) == 0 {        return 0, false    }    element := (*q)[0]    *q = (*q)[1:]    return element, true}

func main() {    queue := Queue{}        queue.Enqueue(10)    queue.Enqueue(20)    queue.Enqueue(30)        for len(queue) > 0 {        val, ok := queue.Dequeue()        if ok {            fmt.Println("Extraído:", val)        }    }}

Las colas se aplican en sistemas de gestión de tareas, almacenamiento en búfer de datos y algoritmos de búsqueda en anchura (BFS).

Algoritmos básicos de ordenamiento y búsqueda

Ordenamiento Burbuja (Bubble Sort)

Un algoritmo de ordenamiento simple que recorre repetidamente el array, comparando elementos adyacentes e intercambiándolos si están en el orden incorrecto.

package main

import "fmt"

func bubbleSort(arr []int) {    n := len(arr)    for i := 0; i < n-1; i++ {        for j := 0; j < n-i-1; j++ {            if arr[j] > arr[j+1] {                arr[j], arr[j+1] = arr[j+1], arr[j]            }        }    }}

func main() {    data