¿Sabías que dominar estructuras de datos puede ser la diferencia entre conseguir o no un trabajo como desarrollador?
Las estructuras de datos son la forma en que organizamos y almacenamos información en nuestros programas. Y no, no es solo teoría aburrida: elegir la estructura correcta puede hacer que tu aplicación sea 10 veces más rápida.
En esta guía completa, te voy a enseñar las 10 estructuras de datos más importantes que todo programador debe conocer, con ejemplos prácticos en JavaScript.
- ¿Por qué son importantes las estructuras de datos?
- Estructuras de Datos Básicas
- Estructuras de Datos Lineales
- Estructuras de Datos Jerárquicas
- Estructuras de Datos de Búsqueda Rápida
- ¿Cuándo usar cada estructura de datos? (Tabla comparativa)
- Preguntas Frecuentes sobre Estructuras de Datos
- Tu siguiente paso para dominar las estructuras de datos
¿Por qué son importantes las estructuras de datos?
Las estructuras de datos son fundamentales en programación porque:
- Mejoran el rendimiento: Elegir la estructura correcta puede hacer tu código 10 veces más rápido
- Facilitan el mantenimiento: El código organizado siempre será fácil de mantener
- Son clave en entrevistas: El 80% de las entrevistas técnicas incluyen preguntas sobre estructuras de datos
- Optimizan el uso de memoria: No todas las estructuras usan la misma cantidad de recursos
Ahora que estamos claros, veamos las 10 estructuras más importantes que todo desarrollador debe dominar.
Estructuras de Datos Básicas
Estas son las estructuras fundamentales que todo programador debe conocer desde el inicio. Es de las primeras estructuras de datos que enseñan en las universidades y cursos.
Arrays: La base de todo
Un array es una estructura de datos que permite almacenar y acceder a múltiples elementos del mismo tipo. Es decir, un array lo puedes ver como una lista de elementos.
¿Cuándo usar Arrays?
Usa Arrays cuando:
- Necesites almacenar una lista de elementos del mismo tipo
- Requieras acceso rápido por índice (posición)
- Trabajes con datos ordenados secuencialmente
Ejemplos de implementación:
- Lista de productos en un carrito de compras
- Historial de navegación del usuario
- Colección de imágenes en una galería
Implementación de Arrays
// Declaración de un array
let myArray = [1, 2, 3, 4, 5];
console.log(myArray) // [1, 2, 3, 4, 5];En este caso, myArray contiene cinco elementos: los números del 1 al 5.
Algo que nunca debes olvidar: Los elementos de un array se enumeran a partir de 0. El primer elemento está en la posición 0. El segundo elemento está en la posición 1. Y así sucesivamente.
Operaciones Comunes con Arrays
Para acceder a un elemento de un array, se utiliza su índice. Por ejemplo, si queremos acceder al primer elemento de myArray, lo haríamos así:
console.log(myArray[0]); // 1Si quieres aprender a utilizar los métodos de un array en javascript, te recomiendo revisar este post. Puede ayudarte a profundizar en el tema.
Listas: Flexibilidad en Javascript
Una lista es similar a un array, solo que hay una diferencia clave: las listas contienen elementos de diferentes tipos.
Esto significa que puedes almacenar números, cadenas de texto, booleanos, objetos y otros tipos de datos en la misma lista.
Implementación de Listas
let myList= ["Juan", 25, true]; // Declración de ListasEn este caso, myList es una lista que contiene tres elementos. Uno es una cadena de texto ("Juan"). Otro es un número (25). El último es un booleano (true).
Al igual que con los arrays, puedes acceder a los elementos de una lista utilizando su índice:
console.log(myList[0]); // "Juan"
console.log(myList[1]); // 25
console.log(myList[2]); // trueDiferencia entre Arrays y Listas
Muchos confunden arrays con listas en JavaScript. Para que encuentres la diferencia clave:
- Arrays: Normalmente contienen elementos del mismo tipo
- Listas: Pueden contener diferentes tipos de datos
En JavaScript: Los arrays funcionan como listas, permitiendo tipos mixtos. Esto hace que JavaScript sea muy flexible, pero también requiere más cuidado al programar. Por eso, puedes utilizar todos los métodos de array.
Estructuras de Datos Lineales
Aquí cambiamos un poco la dinámica: Las estructuras lineales siguen un orden específico para agregar y eliminar elementos.
Pilas (LIFO): Último en entrar, primero en salir
Una pila es una estructura de datos. Sigue el principio de «último en entrar, primero en salir» (LIFO, por sus siglas en inglés).
Esto significa que el último elemento que se añade a la pila es el primero en ser eliminado.
Mi ejemplo favorito para visualizar el uso de una pila es utilizando el juego de las Torres de Hanoi: Tienes que apilar los discos del poste ocupado a uno de los postes vacíos. Los discos deben quedar al fondo desde el más grande al más pequeño.
Implementación de Pilas
Una pila se pueda implementar en forma de array en Javascript:
let miPila = [];
miPila.push("Elemento 1"); // [1]
miPila.push("Elemento 2"); // [1, 2]
miPila.pop(); // [1]Métodos de Pila
Además de push y pop, existen otros métodos para trabajar con pilas:
.peek(): devuelve el elemento superior de la pila sin eliminarlo. En JavaScript, lo puedes lograr conmiPila[miPila.length - 1]..isEmpty(): verifica si la pila está vacía. En JavaScript, se hace conmiPila.length === 0.
Aquí tienes un ejemplo de cómo se utilizan estos métodos:
// Crear una pila con dos elementos iniciales
let miPila = ["Elemento 1", "Elemento 2"];
// peek() - Ver el elemento en el tope de la pila sin eliminarlo
console.log(miPila[miPila.length - 1]); // "Elemento 2"
// isEmpty() - Verificar si la pila está vacía
console.log(miPila.length === 0); // false
// push() - Agregar un elemento al tope de la pila
miPila.push("Elemento 3");
console.log(miPila); // ["Elemento 1", "Elemento 2", "Elemento 3"]
// pop() - Eliminar y devolver el elemento del tope
let elementoEliminado = miPila.pop();
console.log(elementoEliminado); // "Elemento 3"
console.log(miPila); // ["Elemento 1", "Elemento 2"]
// size() - Obtener el tamaño de la pila
console.log(miPila.length); // 2Cuándo usar Pilas en proyectos reales
Mayormente usas Pilas cuando:
- Implementes funcionalidad de «Deshacer/Rehacer» (Undo/Redo)
- Evalúes expresiones matemáticas
- Manejes el historial de navegación del navegador
Ejemplos prácticos:
- Sistema de «Ctrl+Z» en editores de texto
- Validación de paréntesis en expresiones matemáticas
- Navegación «Atrás» en navegadores web
- Call stack en la ejecución de funciones
Colas
Si la pila es “último en entrar, primero en salir”. La cola sigue el principio de «primero en entrar, primero en salir». Este principio se conoce como FIFO, por sus siglas en inglés.
Para visualizarlo, imagina una cola para ir al banco o al supermercado. Podrás ver que el primero que entra es el primero en ser atendido. Una vez que terminan de atenderlo, es el primero en salir.
Para implempentar una cola se utiliza en forma de array:
// Crear cola vacía (FIFO: First In, First Out)
let miCola = [];
// Agregar elementos al final de la cola
miCola.push("Elemento 1");
miCola.push("Elemento 2");
// Remover el primer elemento de la cola
let atendido = miCola.shift();
console.log(atendido); // "Elemento 1"
console.log(miCola); // ["Elemento 2"]En este caso, miCola es una cola que contiene dos elementos: "Elemento 1" y "Elemento 2". El método push se utiliza para agregar elementos al final de la cola.
Para eliminar un elemento de la cola, se utiliza el método shift. Este método elimina el primer elemento que se agregó a la cola, siguiendo el principio FIFO:
miCola.shift(); // "Elemento 1"Después de ejecutar shift, miCola solo contiene "Elemento 2".
Métodos de Cola
Además de push y shift, JavaScript proporciona otros métodos útiles para trabajar con colas: .peek() y .isEmpty(). Ambos se aplican igual como se mostró en los métodos de la pila.
Aquí te dejo un ejemplo:
let miCola = ["Elemento 1", "Elemento 2"];
console.log(miCola[0]); // "Elemento 1"
console.log(miCola.length === 0); // falseEjemplos prácticos de Colas
Usa Colas cuando:
- Proceses tareas en orden de llegada
- Implementes sistemas de mensajería
- Manejes peticiones asíncronas
Ejemplos reales:
- Sistema de tickets de soporte (primero en llegar, primero en atender)
- Cola de impresión de documentos
- Procesamiento de trabajos en segundo plano (background jobs)
- Gestión de requests en un servidor web
Estructuras de Datos Jerárquicas
Ahora estamos entrando en terreno un poco más complejo (No te detengas, vas por buen camino). Estas estructuras representan relaciones padre-hijo entre elementos.
Árboles: Organización jerárquica de datos
Un árbol es una estructura de datos jerárquica que posee nodos conectados entre sí. Cada nodo puede tener cero o más nodos hijos, lo que permite representar relaciones entre los elementos.
Representación de Árboles
En JavaScript, se representa un árbol utilizando objetos. Cada objeto representa un nodo del árbol, y puede contener un valor y una lista de sus nodos hijos.
// Declaramos un objeto que representa un árbol jerárquico
let miArbol = {
// La raíz del árbol tiene el valor "A"
valor: "A",
// El arreglo "hijos" contiene los nodos descendientes de "A"
hijos: [
{
// Primer hijo de "A" con valor "B"
valor: "B",
// "B" no tiene hijos (nodo hoja)
hijos: []
},
{
// Segundo hijo de "A" con valor "C"
valor: "C",
// "C" tampoco tiene hijos (nodo hoja)
hijos: []
}
]
};En este caso, miArbol es un árbol que contiene tres nodos: «A», «B» y «C». «A» es el nodo raíz del árbol, y tiene dos hijos: «B» y «C».
Trabajando con Árboles
Para trabajar con árboles en JavaScript, puedes utilizar una variedad de algoritmos de recorrido de árboles. Estos incluyen el recorrido en profundidad (DFS, por sus siglas en inglés). También está el recorrido en amplitud (BFS, por sus siglas en inglés).
Aquí tienes un ejemplo de cómo se puede implementar el recorrido en profundidad:
function dfs(nodo) {
console.log(nodo.valor);
for (let hijo of nodo.hijos) {
dfs(hijo);
}
}
dfs(miArbol); // "A", "B", "C"Casos de uso de Árboles
- Representes jerarquías (organigramas, sistemas de archivos)
- Implementes búsquedas eficientes (árboles binarios de búsqueda)
- Manejes estructuras anidadas (DOM en HTML)
Ejemplos reales:
- Sistema de carpetas y archivos en tu computadora
- Estructura del DOM en una página web
- Menús con submenús en aplicaciones
- Árbol de decisiones en IA
Grafos
Un grafo es similar a un árbol, solo que esta estructura de datos se maneja con nodos y aristas.
Representación de Grafos
Los nodos representan entidades, mientras que las aristas representan las relaciones entre esas entidades. Cada elemento es un nodo del grafo. Las aristas son como pares de nodos.
// Definición de un grafo con nodos (vértices) y aristas (conexiones)
let miGrafo = {
// Lista de nodos: representa las entidades del grafo
nodos: ["Usuario", "Producto", "Categoría"],
// Lista de aristas: representa las relaciones entre nodos
aristas: [
{ origen: "Usuario", destino: "Producto" }, // Usuario compra Producto
{ origen: "Producto", destino: "Categoría" }, // Producto pertenece a Categoría
{ origen: "Categoría", destino: "Usuario" } // Categoría recomienda a Usuario
]
};
// Acceder a los nodos
console.log(miGrafo.nodos); // ["Usuario", "Producto", "Categoría"]
// Acceder a las aristas (conexiones)
console.log(miGrafo.aristas[0]); // { origen: "Usuario", destino: "Producto" }En este caso, miGrafo es un grafo que contiene tres nodos: “A”, “B” y “C”. Tiene tres aristas que conectan estos nodos.
Trabajando con Grafos
Para trabajar con grafos, puedes utilizar una variedad de algoritmos de recorrido de grafos. Además de DFS y BFS, hay otros métodos para recorrer un árbol.
// Función DFS (Depth-First Search) - Búsqueda en Profundidad
function dfs(nodo, visitados = {}) {
// Si ya visitamos este nodo, salimos para evitar ciclos infinitos
if (visitados[nodo]) {
return;
}
// Procesamos el nodo actual (en este caso, lo mostramos)
console.log(nodo);
// Marcamos el nodo como visitado
visitados[nodo] = true;
// Recorremos todas las aristas del grafo
for (let arista of miGrafo.aristas) {
// Si encontramos una arista que sale de este nodo
if (arista.origen === nodo) {
// Visitamos recursivamente el nodo destino
dfs(arista.destino, visitados);
}
}
}
// Ejemplo de uso: iniciamos DFS desde el nodo "A"
dfs("A"); // Salida: "A", "B", "C"Aplicaciones reales de Grafos
- Representes redes sociales (amigos, conexiones)
- Calcules rutas óptimas (GPS, mapas)
- Modeles relaciones complejas entre entidades
Ejemplos reales:
- Red de amigos en Facebook o LinkedIn
- Rutas de navegación en Google Maps
- Sistema de recomendaciones de productos
- Análisis de dependencias entre módulos de código
Estructuras de Datos de Búsqueda Rápida
Estas estructuras están optimizadas para encontrar información de forma ultrarrápida.
Hash Tables: Búsqueda ultrarrápida
Un hash es una función que toma una entrada (o ‘mensaje’). Retorna una cadena de longitud fija. Esta cadena normalmente se parece a un número aleatorio.
La salida es única para cada entrada única. Incluso un pequeño cambio en la entrada producirá un hash completamente diferente.
Se aprovechan los hashes en las situaciones donde necesitas identificar rápidamente una pieza de datos en un conjunto grande.
En este caso se utilizará una dependencia llamada object-hash para convetir un objeto en un hash.
// Importar la librería object-hash para generar hashes de objetos
let hash = require('object-hash');
// Crear un objeto con información de usuario
let usuario = {
nombre: 'Ana García',
edad: 28,
rol: 'desarrolladora'
};
// Generar un hash único del objeto
// El hash siempre será el mismo para este objeto específico
console.log(hash(usuario));
// Output: un string único como "a3f5c891b2e4d6f7..."
// 💡 Caso de uso: Verificar si un objeto cambió
let usuarioModificado = {
nombre: 'Ana García',
edad: 29, // Cambió la edad
rol: 'desarrolladora'
};
console.log(hash(usuarioModificado));
// Output diferente porque el objeto cambió
Dictionaries en JavaScript
Un diccionario es una estructura de datos que almacena pares de elementos clave-valor. Cada clave es única y se utiliza para encontrar su valor correspondiente.
Es útil para acceder a elementos con eficiencia a través de una clave.
let diccionario = {
'manzana': 'Una fruta deliciosa',
'naranja': 'Otra fruta deliciosa'
};
console.log(diccionario['manzana']); // Imprime 'Una fruta deliciosa'Map: Clave-valor
Un Map en JavaScript es una colección de elementos clave-valor, similar a un diccionario. Las claves pueden ser de cualquier tipo. No solo pueden ser cadenas o números.
Los Maps mantienen el orden de inserción de los elementos. Esto significa que puedes iterar sobre los elementos en el orden en que fueron agregados.
let mapa = new Map();
mapa.set('manzana', 'Una fruta deliciosa');
mapa.set('naranja', 'Otra fruta deliciosa');
console.log(mapa.get('manzana')); // Imprime 'Una fruta deliciosa'
Set: Valores únicos
Un Set en JavaScript es una colección de valores únicos. Limpia todos los elementos duplicados y deja solo los elementos únicos.
Aquí tienes un ejemplo de cómo se usa un Set en JavaScript:
let conjunto = new Set();
// Añadir elementos al Set
conjunto.add('manzana');
conjunto.add('naranja');
conjunto.add('manzana'); // Este no se añadirá porque ya existe en el Set
console.log(conjunto); // Imprime Set { 'manzana', 'naranja' }
// Comprobar si un elemento está en el Set
console.log(conjunto.has('manzana')); // Imprime true
console.log(conjunto.has('pera')); // Imprime false
// Eliminar un elemento del Set
conjunto.delete('manzana');
console.log(conjunto); // Imprime Set { 'naranja' }
// Obtener el número de elementos en el Set
console.log(conjunto.size); // Imprime 1
¿Cuándo usar cada estructura de datos? (Tabla comparativa)
Para ayudarte a elegir la estructura correcta, aquí tienes una tabla comparativa rápida:
| Estructura | Ventaja Principal | Cuándo Usarla | Complejidad (Búsqueda) |
|---|---|---|---|
| Array | Acceso rápido por índice | Listas ordenadas, acceso por posición | O(1) por índice, O(n) por valor |
| Lista | Flexibilidad de tipos | Datos mixtos en JavaScript | O(n) |
| Pila | LIFO, fácil de implementar | Deshacer/Rehacer, historial | O(1) para push/pop |
| Cola | FIFO, orden garantizado | Procesos en orden, tareas | O(1) para enqueue/dequeue |
| Árbol | Jerarquías, búsqueda eficiente | Sistema de archivos, DOM | O(log n) en árboles balanceados |
| Grafo | Relaciones complejas | Redes sociales, rutas, mapas | Depende del algoritmo |
| Hash/Dictionary | Búsqueda ultrarrápida | Clave-valor, cachés | O(1) promedio |
| Map | Orden + claves de cualquier tipo | Diccionarios avanzados | O(1) promedio |
| Set | Valores únicos garantizados | Eliminar duplicados, membresía | O(1) promedio |
Te comparto este video de Carlos Azaustre donde te enseña 7 estructuras de datos utilizando ejemplos con Javascript.
Preguntas Frecuentes sobre Estructuras de Datos
¿Cuál es la estructura de datos más rápida?
Depende de la operación:
- Búsqueda por clave: Hash Table / Map (O(1))
- Acceso por índice: Array (O(1))
- Inserción/eliminación: Depende de la posición y estructura
¿Qué estructura de datos usan las bases de datos?
Las bases de datos usan principalmente B-trees y Hash tables:
- B-trees: Para índices y búsquedas ordenadas
- Hash tables: Para búsquedas rápidas por clave primaria
¿Cómo saber qué estructura de datos usar en mi proyecto?
Hazte estas preguntas:
- ¿Necesito acceso rápido por posición? → Array
- ¿Necesito búsqueda rápida por clave? → Hash/Map
- ¿Necesito orden de llegada? → Cola
- ¿Necesito deshacer/rehacer? → Pila
- ¿Necesito representar jerarquías? → Árbol
- ¿Necesito representar relaciones complejas? → Grafo
¿Son importantes las estructuras de datos para entrevistas técnicas?
Sí, es innegable. El 80% de las entrevistas técnicas en empresas como Google, Facebook, Amazon incluyen preguntas sobre estructuras de datos y algoritmos.
¿Necesito saber todas las estructuras de datos para empezar a programar?
No necesariamente. Empieza con:
- Arrays y Listas (lo básico)
- Pilas y Colas (fáciles de entender)
- Hash/Dictionary (muy útiles en el día a día)
Las estructuras más complejas (Árboles, Grafos) puedes aprenderlas conforme las necesites.
Tu siguiente paso para dominar las estructuras de datos
Estas son solo algunas de las muchas estructuras de datos que se utilizan en programación. Cada una tiene sus propias características y se utiliza en diferentes situaciones.
Aprender y conocer acerca de estas estructuras son una base fundamental para todo programador para resolver problemas con eficiencia. Además, en las entrevista de trabajo pueden hacer preguntas acerca de este tema.
Mi recomendación: Elige una estructura de datos (empieza con Arrays o Pilas) y crea un pequeño proyecto esta semana. Por ejemplo:
- Un sistema de deshacer/rehacer usando Pilas
- Una lista de tareas con Colas
- Un árbol de comentarios para un blog
¿Te ha servido esta guía? Compártela con alguien que esté aprendiendo a programar.
👉 Únete a mi Canal de WhatsApp para más recursos
👉 Sigueme en mis redes sociales para más contenido de programación y productividad