En el mundo de la programación, las estructuras de datos se refiere a la forma en que organizamos y almacenamos datos para su manipulación eficiente.
Hay varios tipos de estructuras de datos comunes que se utilizan en programación, y en este post conocerás algunos de ellos junto con ejemplos en JavaScript.
Arrays
Un array es una estructura de datos que permite almacenar y acceder a múltiples elementos del mismo tipo. Es decir, un array es como una lista de elementos.
Implementación de Arrays
La declaración de un array sería de la siguiente manera:
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.
Los elementos de un array se enumeran a partir de 0, por lo que el primer elemento está en la posición 0, el segundo elemento 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 para profundizar en el tema.
Listas
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
En JavaScript se usa el array para crear una lista:
let myList= ["Juan", 25, true];En este caso, myList es una lista que contiene tres elementos: una cadena de texto ("Juan"), un número (25) y 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]); // trueDado que las listas en JavaScript son simplemente arrays con tipos de datos mixtos, puedes utilizar todos los métodos de array.
Pilas
Una pila es una estructura de datos que 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 graficar una pila es utilizando el juego de las Torres de Hanoi. Donde tienes que apilar los disco del poste ocupado a uno de los postes vacios, quedando 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");
miPila.push("Elemento 2");
miPila.pop();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:
let miPila = ["Elemento 1", "Elemento 2"];
console.log(miPila[miPila.length - 1]); // "Elemento 2"
console.log(miPila.length === 0); // falseColas
Si la pila es “último en entrar, primero en salir”, la cola sigue el principio de «primero en entrar, primero en salir» (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, y una vez que terminan de atenderlo, es el primero en salir.
Para implempentar una cola se utiliza en forma de array:
let miCola = [];
miCola.push("Elemento 1");
miCola.push("Elemento 2");
miCola.shift();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); // falseÁrboles
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.
Aquí te muestro cómo:
let miArbol= {
valor: "A",
hijos: [
{
valor: "B",
hijos: []
},
{
valor: "C",
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, como el recorrido en profundidad (DFS, por sus siglas en inglés) y 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"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.
La representación del grafo también se hace utilizando objetos, donde cada elemento es un nodo del grafo, y las aristas se representan como pares de nodos.
let miGrafo = {
nodos: ["A", "B", "C"],
aristas: [
{ origen: "A", destino: "B" },
{ origen: "B", destino: "C" },
{ origen: "C", destino: "A" }
]
};En este caso, miGrafo es un grafo que contiene tres nodos: “A”, “B” y “C”, y 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 para recorrer un árbol.
Apliquemos un ejemplo con el recorrido en profundidad pero en gráfos:
function dfs(nodo, visitados = {}) {
if (visitados[nodo]) {
return;
}
console.log(nodo);
visitados[nodo] = true;
for (let arista of miGrafo.aristas) {
if (arista.origen === nodo) {
dfs(arista.destino, visitados);
}
}
}
dfs("A"); // "A", "B", "C"Hash
Un hash es una función que toma una entrada (o ‘mensaje’) y retorna una cadena de longitud fija que normalmente se parece a un número aleatorio.
La salida es única para cada entrada única, lo que significa que 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, como buscar un registro en una base de datos.
En este caso se utilizará una dependencia llamada object-hash para convetir un objeto en un hash.
let hash = require('object-hash');
let objeto = {nombre: 'Juan', edad: 30};
console.log(hash(objeto)); // 3301acdada31cc85cbb7b7a34cb9d99d3dcd4c05
Dictionaries
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.
La ventaja de usar diccionarios es cuando quieres acceder a elementos de manera eficiente a través de una clave, en lugar de una posición de índice, como en una lista o un arreglo.
let diccionario = {
'manzana': 'Una fruta deliciosa',
'naranja': 'Otra fruta deliciosa'
};
console.log(diccionario['manzana']); // Imprime 'Una fruta deliciosa'Map
Un Map en JavaScript es una colección de elementos clave-valor, similar a un diccionario.
Sin embargo, a diferencia de los objetos, las claves en un Map pueden ser de cualquier tipo, no solo cadenas o números.
Además, los Maps mantienen el orden de inserción de los elementos, lo que significa que puedes iterar sobre los elementos de un Map 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
Un Set en JavaScript es una colección de valores únicos. Es decir, un valor solo puede aparecer una vez en un Set.
Los Sets son útiles cuando quieres mantener una lista de elementos, pero te aseguras de que no haya duplicados.
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
Resumen
Para resumir, te quiero compartir este video de Carlos Azaustre donde te enseña 7 estructuras de datos utilizando ejemplos con Javacript.
Conclusión
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.
Te invito a seguir profundizando sobre el tema y que haya dado una idea de las estructuras de datos. No olvides compartir y seguirme en redes sociales para más contenido.
Sigueme en mis redes sociales para más contenido