Las estructuras de datos son los cimientos de la ingeniería de software, pero en la universidad (o en los bootcamps) suelen quedarse en diapositivas teóricas. La realidad es que la teoría aguanta todo, pero el compilador no.
Saber qué es un Array is easy, young man. Saber cuándo usar un Heap en lugar de un Array ordenado is harder. Esto es lo que diferencia a un Junior de un Senior.
Si quieres dejar de memorizar conceptos para entrevistas y empezar a entenderlos de verdad, necesitas construir.
En este post, exploraremos 5 proyectos prácticos que te permitirán dominar las estructuras de datos más importantes. Cada proyecto está diseñado para enseñarte conceptos específicos mientras construyes algo tangible y útil.
Lo que aprenderás:
- Cómo elegir la estructura de datos correcta para cada problema
- Implementación práctica de heaps, grafos, pilas y más
- Optimización de rendimiento y análisis de complejidad
- Proyectos que puedes agregar a tu portafolio
- Por qué construir es mejor que memorizar
- Proyecto 1: Sistema de Gestión de Tareas (Priority Queue)
- Proyecto 2: Red Social Simplificada (Grafos)
- Proyecto 3: Editor de Texto con "Deshacer" (Stacks)
- Proyecto 4: Sistema de Caché LRU (La pregunta de Google)
- Proyecto 5: Clon de Google Maps (Grafos Ponderados)
- Tabla Comparativa de Complejidad
- Tips para Maximizar tu Aprendizaje
- Recursos Adicionales para Profundizar
- Conclusión: El Código Habla
Por qué construir es mejor que memorizar
Muchos caen en el «Tutorial Hell»: ver vídeos sin escribir código. Eso es entretenimiento, no aprendizaje.
Al implementar estas estructuras de datos desde cero te enfrentarás a:
- Trade-offs reales: ¿Por qué elegir un Grafo sobre una Hash Table?
- Gestión de Memoria: Entenderás qué es un Memory Leak.
- Complejidad Temporal: Verás la diferencia entre una operación $O(1)$ y una $O(n)$ cuando tu app se congele.
💡 TipPro: Antes de empezar, asegúrate de tener claros los conceptos básicos. Si te sientes perdido, revisa nuestro Roadmap de Aprendizaje para Programadores para ver la ruta teórica antes de la práctica.
Proyecto 1: Sistema de Gestión de Tareas (Priority Queue)
¿Qué aprenderás?
Este proyecto te enseñará a implementar y trabajar con heaps (montículos), específicamente una cola de prioridad. Es perfecto para entender cómo optimizar operaciones que requieren acceso constante al elemento de mayor o menor prioridad.
Descripción del Proyecto
Desarrolla una aplicación de gestión de tareas donde las tareas se ordenan automáticamente según su prioridad. A diferencia de una lista simple, tu sistema debe permitir:
- Agregar nuevas tareas con diferentes niveles de prioridad (alta, media, baja)
- Obtener siempre la tarea de mayor prioridad en O(1)
- Eliminar la tarea más prioritaria en O(log n)
- Actualizar la prioridad de una tarea existente
Estructuras de Datos Clave
Heap (Min-Heap o Max-Heap): Esta estructura de datos te permite mantener las tareas ordenadas por prioridad de manera eficiente. Las operaciones de inserción y eliminación se realizan en tiempo logarítmico O(log n).
Implementación Paso a Paso
- Define la estructura de una tarea: Crea una clase Task con propiedades como id, título, descripción y prioridad (valor numérico).
- Implementa el heap: Puedes usar un array para representar el heap, donde para cada elemento en el índice i, sus hijos están en 2i+1 y 2i+2.
- Operaciones principales:
insert(task): Agrega la tarea al final y «sube» (heapify up) hasta su posición correctaextractMax(): Devuelve la tarea de mayor prioridad, reemplázala con la última y «baja» (heapify down)updatePriority(taskId, newPriority): Encuentra la tarea y ajusta su posición
- Interfaz de usuario: Crea una interfaz simple (CLI o web) para agregar, ver y completar tareas.
Lógica de Código Sugerida
class TaskManager {
constructor() {
this.heap = [];
}
// Insertar tarea y "burbujear" hacia arriba (Heapify Up)
insert(task, priority) {
const node = { task, priority };
this.heap.push(node);
this.siftUp(this.heap.length - 1);
}
// Extraer la tarea más urgente (O(log n))
extractMax() {
const max = this.heap[0];
const end = this.heap.pop();
if (this.heap.length > 0) {
this.heap[0] = end;
this.siftDown(0); // Reordenar hacia abajo
}
return max;
}
}Conceptos a Reforzar
- Complejidad temporal: O(log n) para inserción y eliminación, O(1) para peek
- Propiedad del heap: cada nodo padre tiene prioridad mayor (o menor) que sus hijos
- Diferencia entre min-heap y max-heap
Desafíos Adicionales
- Implementa fechas de vencimiento y combínalas con la prioridad
- Agrega categorías o etiquetas a las tareas
- Implementa persistencia guardando el heap en un archivo JSON
Proyecto 2: Red Social Simplificada (Grafos)
¿Qué aprenderás?
Los grafos son fundamentales para modelar relaciones entre entidades. Este proyecto te enseñará a implementar grafos y aplicar algoritmos de recorrido como BFS (Breadth-First Search) y DFS (Depth-First Search).
Descripción del Proyecto
Crea una mini red social donde los usuarios pueden conectarse entre sí. Tu sistema debe permitir:
- Agregar usuarios (nodos)
- Crear conexiones de amistad (aristas)
- Encontrar el camino más corto entre dos usuarios
- Sugerir amigos (amigos de amigos)
- Detectar comunidades o grupos conectados
Estructuras de Datos Clave
Grafo (Graph): Usa una lista de adyacencia para representar las conexiones. Cada usuario es un nodo y cada amistad es una arista no dirigida.
Implementación Paso a Paso
- Representación del grafo: Usa un HashMap/Dictionary donde la clave es el ID del usuario y el valor es una lista de amigos.
- Agregar usuarios y conexiones:
addUser(userId, name)addFriendship(userId1, userId2): Agrega la conexión en ambas direcciones
- Implementa BFS para el camino más corto:
- Usa una cola para explorar nivel por nivel
- Mantén un registro de nodos visitados y el camino
- Retorna el camino más corto entre dos usuarios
- Implementa DFS para exploración:
- Usa una pila (o recursión) para explorar en profundidad
- Útil para detectar componentes conectados
- Sugerencias de amistad: Encuentra amigos de amigos que no sean amigos directos del usuario.
Lógica de Código Sugerida
// Representación de Lista de Adyacencia
{
"Darkus": ["Ana", "Pedro"],
"Ana": ["Darkus", "Maria"],
"Pedro": ["Darkus", "Juan"]
}Conceptos a Reforzar
- Diferencia entre grafos dirigidos y no dirigidos
- BFS encuentra el camino más corto en grafos no ponderados
- DFS es útil para detección de ciclos y componentes conectados
- Complejidad: O(V + E) donde V es vertices y E es aristas
Desafíos Adicionales
- Implementa grados de separación (6 grados de Kevin Bacon)
- Agrega pesos a las conexiones (nivel de amistad)
- Detecta influencers (usuarios con más conexiones)
- Implementa un feed de noticias basado en las conexiones
Proyecto 3: Editor de Texto con «Deshacer» (Stacks)
¿Qué aprenderás?
Las pilas (stacks) son perfectas para operaciones LIFO (Last In, First Out). Este proyecto te mostrará cómo usar pilas para implementar funcionalidades de deshacer y rehacer.
Descripción del Proyecto
Construye un editor de texto simple donde cada cambio se puede deshacer (Ctrl+Z) o rehacer (Ctrl+Y). Tu editor debe:
- Permitir escribir, eliminar y modificar texto
- Guardar cada acción en una pila de deshacer
- Implementar deshacer (undo) y rehacer (redo)
- Manejar un límite de historial (por ejemplo, últimas 50 acciones)
Estructuras de Datos Clave
Stack (Pila): Necesitarás dos pilas: una para el historial de deshacer y otra para el historial de rehacer.
Implementación Paso a Paso
- Define las acciones: Crea una clase Action que represente cada cambio (tipo de acción, texto modificado, posición).
- Implementa las dos pilas:
undoStack: Guarda todas las acciones realizadasredoStack: Guarda las acciones deshechas
- Operaciones principales:
executeAction(action): Aplica la acción, agrégala a undoStack y limpia redoStackundo(): Saca la última acción de undoStack, reviértela y agrégala a redoStackredo(): Saca la última acción de redoStack, aplícala y agrégala a undoStack
- Tipos de acciones: Inserta texto, elimina texto, reemplaza texto.
- Interfaz: Crea una interfaz simple (web o desktop) con un área de texto y botones para undo/redo.
Lógica de Código Sugerida
class TextEditor {
constructor() {
this.text = "";
this.undoStack = [];
this.redoStack = [];
}
write(newText) {
this.undoStack.push(this.text); // Guardamos "snapshot"
this.text += newText;
this.redoStack = []; // Al escribir nuevo, rompemos el futuro (redo)
}
undo() {
if (this.undoStack.length > 0) {
this.redoStack.push(this.text); // Guardamos para poder rehacer
this.text = this.undoStack.pop();
}
}
}Conceptos a Reforzar
- LIFO (Last In, First Out): La última acción añadida es la primera en deshacerse
- Operaciones en O(1): push, pop y peek son constantes
- Patron Command: Cada acción encapsula toda la información necesaria para deshacerse
Desafíos Adicionales
- Agrupa múltiples cambios pequeños en una sola acción (typing burst)
- Implementa guardado automático del historial
- Agrega formato de texto (negrita, cursiva) y hazlo deshacible
- Implementa un límite de memoria para el historial
Proyecto 4: Sistema de Caché LRU (La pregunta de Google)
¿Qué aprenderás?
Este proyecto combina HashMap y Doubly Linked List para crear una estructura híbrida altamente eficiente. Es una pregunta clásica en entrevistas técnicas de empresas como Google, Facebook y Amazon.
Descripción del Proyecto
Implementa un caché LRU (Least Recently Used) que automáticamente elimina el elemento menos usado recientemente cuando alcanza su capacidad máxima. Tu caché debe:
- Almacenar pares clave-valor con capacidad limitada
- Permitir operaciones get y put en O(1)
- Eliminar automáticamente el elemento menos usado cuando está lleno
- Actualizar el «uso reciente» cada vez que se accede a un elemento
Estructuras de Datos Clave
HashMap + Doubly Linked List: El HashMap permite acceso O(1) a los nodos, mientras que la lista doblemente enlazada mantiene el orden de uso.
Este es uno de los ejercicios más comunes en entrevistas de nivel FAANG. Si logras implementarlo sin mirar la solución, estás en otro nivel.
Implementación Paso a Paso
- Diseña el nodo: Cada nodo debe tener key, value, prev y next.
- Estructura del caché:
- Un HashMap que mapea claves a nodos
- Una lista doblemente enlazada donde la cabeza es el más reciente y la cola el menos reciente
- Una variable de capacidad máxima
- Operación get(key):
- Si la clave existe, mueve el nodo al frente (más reciente)
- Retorna el valor o -1 si no existe
- Operación put(key, value):
- Si la clave existe, actualiza el valor y mueve al frente
- Si no existe y hay espacio, crea un nuevo nodo al frente
- Si no hay espacio, elimina el nodo de la cola y crea uno nuevo al frente
- Métodos auxiliares:
moveToHead(node): Remueve el nodo de su posición y lo coloca al inicioremoveTail(): Elimina y retorna el último nodo
Conceptos a Reforzar
- Complejidad O(1) para get y put gracias a la combinación de estructuras
- Listas doblemente enlazadas permiten eliminación e inserción en O(1)
- HashMap proporciona búsqueda en O(1)
- Política de reemplazo LRU: elimina lo menos usado recientemente
Desafíos Adicionales
- Implementa estadísticas: tasa de aciertos (hit rate) y fallos (miss rate)
- Agrega una política de expiración basada en tiempo (TTL)
- Implementa otras políticas: LFU (Least Frequently Used) o FIFO
- Hazlo thread-safe para uso concurrente
Proyecto 5: Clon de Google Maps (Grafos Ponderados)
¿Qué aprenderás?
Este proyecto combina grafos ponderados y colas de prioridad para implementar el famoso algoritmo de Dijkstra. Aprenderás cómo encontrar el camino más corto en grafos con pesos.
Descripción del Proyecto
Crea tu propia versión simplificada de Google Maps. Tu sistema debe:
- Representar un mapa como un grafo ponderado (distancias entre puntos)
- Encontrar la ruta más corta entre dos ubicaciones
- Calcular la distancia total del camino
- Mostrar la ruta paso a paso
- Manejar casos donde no existe un camino
Estructuras de Datos Clave
Grafo Ponderado + Priority Queue (Min-Heap): Los nodos representan ubicaciones y las aristas tienen pesos (distancias). La cola de prioridad ayuda a explorar siempre el camino más prometedor.
Implementación Paso a Paso
- Representación del grafo: Usa una lista de adyacencia donde cada arista incluye el nodo destino y el peso (distancia).
- Algoritmo de Dijkstra:
- Inicializa las distancias de todos los nodos como infinito, excepto el origen (0)
- Usa un min-heap para obtener siempre el nodo con menor distancia acumulada
- Para cada nodo, explora sus vecinos y actualiza las distancias si encuentras un camino más corto
- Mantén un registro del nodo previo para reconstruir el camino
- Reconstrucción del camino: Una vez que llegas al destino, retrocede usando el registro de nodos previos.
- Visualización: Muestra el mapa con los nodos y aristas, y resalta la ruta más corta.
Conceptos a Reforzar
- Algoritmo de Dijkstra encuentra el camino más corto en grafos con pesos positivos
- Complejidad: O((V + E) log V) usando min-heap
- Greedy approach: siempre explora el camino más prometedor primero
- Diferencia con BFS: Dijkstra maneja pesos, BFS asume aristas de peso 1
Desafíos Adicionales
- Implementa el algoritmo A* para búsquedas más eficientes con heurísticas
- Agrega restricciones: evitar ciertas rutas o tipos de caminos
- Calcula rutas alternativas (segunda y tercera ruta más corta)
- Integra con una API real de mapas para datos del mundo real
- Añade tráfico como factor dinámico de peso
Tabla Comparativa de Complejidad
| Proyecto | Estructura Principal | Complejidad Clave | Caso de Uso Real |
|---|---|---|---|
| Task Manager | Min/Max Heap | Insertar: O(log n) | Colas de impresión, Triaje médico |
| Red Social | Grafos (Adjacency List) | Búsqueda: O(V + E) | Recomendación de amigos, Rutas |
| Editor Texto | Stacks (Pilas) | Deshacer: O(1) | Editores de código, Navegadores (Atrás) |
| Caché LRU | HashMap + Linked List | Acceso: O(1) | Memoria RAM, Caché de navegador |
| Mapas | Grafos Ponderados | Dijkstra: O(E log V) | GPS, Logística, Redes IP |
Tips para Maximizar tu Aprendizaje
No intentes hacer los 5 en un fin de semana. Trátalo como un proyecto serio:
- Estudia: Usa técnicas de Active Recall para entender la lógica del algoritmo antes de escribir una sola línea de código.
- Elige uno: Empieza por el Editor de Texto (es el más visual). Es mi recomendación para iniciar
- Planifica: Usa Notion para dividir las tareas (Backend, Frontend, Tests). ¿No sabes cómo? Mira nuestra guía sobre Gestión de Proyectos en Notion.
- Mide el Rendimiento de Diferentes Enfoques: Implementa versiones alternativas y compáralas. Por ejemplo, en el caché LRU, compara el rendimiento usando solo un array vs HashMap + Lista Enlazada.
- Comparte tu Progreso en GitHub y LinkedIn: Crea un repositorio para cada proyecto con un README detallado. Explica el problema, tu solución, y lo que aprendiste. Comparte tus avances en LinkedIn.
- No te quedes solo con el happy path. Prueba entradas vacías o nulas, capacidades máximas y mínimas, operaciones en orden inesperado y grandes volúmenes de datos. Esto te prepara para bugs del mundo real y preguntas de entrevistas.
Recursos Adicionales para Profundizar
Para complementar estos proyectos, te recomiendo:
- Libros: «Introduction to Algorithms» de Cormen (CLRS) y «Grokking Algorithms» de Aditya Bhargava
- Plataformas de práctica: LeetCode, HackerRank y CodeSignal para problemas específicos
- Visualizadores: VisuAlgo.net para ver cómo funcionan las estructuras en tiempo real
- Cursos online: Algoritmos de Princeton en Coursera y el curso de MIT en OpenCourseWare
Conclusión: El Código Habla
Las estructuras de datos dejan de ser intimidantes cuando las aplicas a proyectos reales. Demuestra curiosidad y capacidad de implementación.
Tu misión para hoy: Elige uno de estos proyectos. Abre tu IDE. Crea el archivo README.md y explica qué vas a construir.
Recuerda que cada proyecto que completes:
- ✅ Refuerza tu comprensión de estructuras de datos fundamentales
- ✅ Te da experiencia práctica que valorarán en entrevistas
- ✅ Agrega una pieza valiosa a tu portafolio de GitHub
- ✅ Te acerca un paso más a tu próximo trabajo o proyecto
Pregunta para ti: ¿Cuál de estos 5 proyectos vas a empezar primero? ¿O ya has implementado alguno? Comparte tu experiencia en los comentarios y ayudemos a otros desarrolladores en su journey. 💻🚀
Si te gustó este artículo, guárdalo para consultarlo después y compártelo con otros desarrolladores que estén practicando estructuras de datos.
👉 Únete a mi Canal de WhatsApp para más recursos
👉 Sigueme en mis redes sociales para más contenido de programación y productividad