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

Algoritmos y estructuras de datos en Java: de la teoría a la práctica

La comprensión de los algoritmos y las estructuras de datos es la base sobre la que se construye la carrera de cualquier desarrollador Java. Sin este conocimiento, es difícil escribir código eficiente, escalable y mantenible. En este artículo, analizaremos las estructuras de datos y algoritmos clave que utilizará a diario y mostraremos su implementación en Java con ejemplos prácticos.

1. Estructuras de datos básicas en Java Collections Framework

Java ofrece un potente framework de colecciones que incluye las estructuras de datos principales. Veamos las tres más populares.

ArrayList — arreglo dinámico

ArrayList es una implementación de arreglo dinámico. Se expande automáticamente al agregar nuevos elementos, lo que lo convierte en una excelente opción para listas con tamaño desconocido de antemano.

import java.util.ArrayList;

public class ArrayListExample {    public static void main(String[] args) {        ArrayList<String> fruits = new ArrayList<>();        fruits.add("Manzana");        fruits.add("Plátano");        fruits.add("Naranja");

        System.out.println("Segundo elemento: " + fruits.get(1)); // Plátano        fruits.remove(0);        System.out.println("Tamaño después de eliminar: " + fruits.size()); // 2                for (String fruit : fruits) {            System.out.println(fruit);        }    }}

Complejidad de las operaciones: acceso por índice — O(1), inserción/eliminación en medio — O(n).

HashMap — tabla hash

HashMap almacena pares «clave-valor» y proporciona acceso casi instantáneo a los datos por clave.

import java.util.HashMap;

public class HashMapExample {    public static void main(String[] args) {        HashMap<String, Integer> ages = new HashMap<>();        ages.put("Ana", 25);        ages.put("Iván", 30);        ages.put("María", 28);

        System.out.println("Edad de Ana: " + ages.get("Ana")); // 25                // Verificar existencia de clave        if (ages.containsKey("Iván")) {            System.out.println("¡Iván encontrado!");        }                // Recorrer todas las entradas        for (String name : ages.keySet()) {            System.out.println(name + ": " + ages.get(name) + " años");        }    }}

Complejidad de las operaciones: inserción, búsqueda, eliminación — en promedio O(1).

LinkedList — lista doblemente enlazada

LinkedList está compuesta por nodos, cada uno de los cuales almacena referencias al elemento anterior y siguiente. Ideal para inserciones y eliminaciones frecuentes al inicio o final de la lista.

import java.util.LinkedList;

public class LinkedListExample {    public static void main(String[] args) {        LinkedList<Integer> queue = new LinkedList<>();                // Usar como cola (FIFO)        queue.addLast(1);        queue.addLast(2);        queue.addLast(3);                System.out.println("Primero en la cola: " + queue.getFirst()); // 1        queue.removeFirst();        System.out.println("Después de eliminar: " + queue); // [2, 3]                // Usar como pila (LIFO)        queue.push(10); // agregar al inicio        queue.push(20);        System.out.println("Tope de la pila: " + queue.pop()); // 20    }}

Complejidad de las operaciones: inserción/eliminación al inicio/final — O(1), acceso por índice — O(n).

2. Algoritmos de ordenamiento en Java

El ordenamiento es una de las tareas más comunes. Veamos dos implementaciones clásicas.

Ordenamiento burbuja (Bubble Sort)

Algoritmo simple pero lento. Se utiliza con fines educativos.

public class BubbleSort {    public static void bubbleSort(int[] arr) {        int n = arr.length;        boolean swapped;                for (i