Estructuras de Datos

Imagina que en tu casa tienes en todos lados de tu recámara zapatos, playeras, pantalones y demás ropa, también tienes libros, dinero, plumas, etc, pero nada tiene un lugar específico y llega un armario a tu vida, entonces podrás acomodar en él toda tu ropa, también te compras un librero y ahí colocas todos tus libros y cuadernos… Así actúan las estructuras de datos, nos facilitan la vida porque nos permiten agrupar nuestros datos, ordenarlos y consultarlos cuando deseemos…

Ahora que ya entendimos cómo funcionan las estructuras vamos a ver de manera general algunos de ellos:

Arreglos (Arrays)

Son llamados también Vectores o Matrices y nos permiten organizar series de datos que comparten el mismo nombre pero se diferencian por un índice. Se les asocia un nombre general y a los elementos se organizan por medio de una posición la cual inicia en 0, siendo la última posición la cantidad de datos menos 1 (ya que la posición como lo dije anteriormente inicia en 0).

Hay tres maneras de declarar un array:

1.Con contenido al momento de la declaración
var arrayName = [item1, item2, ...];
2. Arreglo Vacío
var fruits = [];
fruits[0] = "Lemon";
fruits[1] = "Banana";
fruits[2] = "Orange";
fruits[3] = "Apple";
// fruits = ["Lemon", "Banana", "Orange", "Apple"];
3. Instancia al objeto array
var fruits = new Array();
fruits[0] = "Lemon";
fruits[1] = "Banana";
fruits[2] = "Orange";
fruits[3] = "Apple";
// fruits = ["Lemon", "Banana", "Orange", "Apple"];

Objetos

Son unas estructuras maravillosas que agrupan datos y funcionalidad, normalmente los datos los almacenamos en variables y la funcionalidad en funciones ¿no es así? pues en el mundo de los objetos, tanto datos como funcionalidad están en la misma estructura.

Imagina que tienes un objeto botón el cual tiene un texto escrito, un color y tamaño específico, etc, pues ese texto, fondo y tamaño serían datos y por lo tanto le llamaríamos propiedad (con sus respectivos valores); otra propiedad de un botón sería si está o no activado. Por otra parte, un botón podría tener funcionalidad asociada, que estaría en un método, como procesar la acción de un clic. Imagina algo más genérico como un teléfono. El teléfono puede tener propiedades como la marca, modelo, sistema operativo y métodos como encender, apagar, llamar a un número, etc.

1.
var nombreObjetoCreado = {
propiedad1: valorPropiedad1,
propiedad2: valorPropiedad2,
propiedadN: valorPropiedadN,
   metodo1: function () { … código … }
metodo2: function (par1, par2, …, parN) { … código … }
metodoN: function () { … código … }
}
2.
var
nombreObjetoCreado = new Object();
nombreObjetoCreado.propiedad1 = valorPropiedad1;
nombreObjetoCreado.propiedad2 = valorPropiedad2;
nombreObjetoCreado.propiedad3 = valorPropiedad3;

Arreglos de Objetos

Estas estructuras aunque suenan muy rebuscadas realmente lo que hacen es, como los significados que ya vimos dicen, agrupar objetos, así que no te preocupes, veremos que en la declaración es muy sencillo visualizarlos:

var arreglo = [
{
propiedad1:valor,
propiedad2:valor
},
{
propiedad1:valor,
propiedad2:valor
},
{
propiedad1:valor,
propiedad2:valor
},
{
propiedad1:valor,
propiedad2:valor
}
];

Pilas (Stacks)

Una pila es una colección de datos que sigue el principio de LIFO (Last In-First Out — Último en entrar primero en salir). La eliminación o adición de nuevos elementos siempre se agregarán al inicio, quiere decir que los elementos más viejos estarán siempre en la base, ¿te parece confuso? Imagínate una pila de libros y quieres sacar el último entonces deberías quitar uno por uno para llegar a él. Así funcionan las pilas.

Para crear una pila en JS primero vamos a definir algunos métodos que vamos a utilizar:

  • add(element(s)): Con este método agregaremos uno o más elementos a nuestra pila (en la parte superior).
  • pop(): Este método quitará de la parte superior el último elemento y también lo regresará.
  • getTopElement(): Este método solamente nos regresará el elemento que se encuentre en la parte superior sin modificarlo ni removerlo.
  • hasElements(): Retornará true si nuestra pila tiene al menos un elemento, o en su defecto false si esta vacía.
  • removeAll(): Limpia la pila quitando todos los elementos.
  • size(): Regresará el tamaño de la pila (cuantos elementos hay en ella).
function Stack() {
var elements = [];

this.add = add;
this.pop = pop;
this.getTopElement = getTopElement;
this.hasElements = hasElements;
this.removeAll = removeAll;
this.size = size;

function add(element) {
elements.push(element);
}

function pop() {
return elements.pop();
}

function getTopElement() {
return elements[elements.length - 1];
}

function hasElements() {
return elements.length > 0;
}

function removeAll() {
elements = [];
}

function size() {
return elements.length;
}
}

Para ver si funcionan nuestros métodos podemos correr este programa:

var fruitsStack = new Stack();
if (!fruitsStack.hasElements()) {
fruitsStack.add('Banana');
fruitsStack.add('Apple');
fruitsStack.add('Mango');
console.log(fruitsStack.size()); // Mostrará 3
var mango = fruitsStack.pop(); //Obtiene mango y lo saca de la pila, ahora solo quedan 2 elementos.
console.log(mango);
console.log(fruitsStack.getTopElement()); // Imprimirá Apple, puesto que es el elemento que quedo hasta arriba.
console.log(fruitsStack.size()); // Mostrará 2
fruitsStack.removeAll(); // Limpia la pila
console.log(fruitsStack.hasElements()); // Retornará falso puesto que la pila esta vacía
}

Colas (queue)

Al contrario de las pilas, las colas siguen el principio FIFO (First In First Out — Primero en entrar, primero en salir). La adición de nuevos elementos se hace en la cola (tail) y la eliminación de elementos se hace al inicio (front), es decir que los nuevos elementos deberán esperar a que todos los demás elementos de la cola hayan salido. ¿Te parece confuso? Imagina una cola de personas para entrar al cine o una cola para pagar un café, los que llegaron primero están al frente (front) y los que van llegando están en la cola (tail), por cierto aquí no vale eso de que “se meten a la cola” como buen mexicano jajaja, pensemos en que son personas civilizadas y van 1 a 1 hasta entrar todos en orden.

Muy similares a los métodos de las pilas vamos a poner para las colas para explicarlas:

  • add(element(s)): Este método se encargará de agregar nuevos elementos a la cola (tail).
  • remove(): Quita el primer elemento que este al frente de la cola y lo regresa.
  • getFrontElement(): Obtiene el elemento que esta al frente pero no lo elimina ni modifica.
  • hasElements(): Valida si al menos existe 1 elemento en la cola.
  • removeAll(): Limpia la cola.
  • size(): Nos regresa el tamaño de la cola (número de elementos).
  • toString(): Este método nos servirá para mostrar todos los elementos que están en la cola en forma de string.
function Queue() {
var elements = [];

this.add = add;
this.remove = remove;
this.getFrontElement = getFrontElement;
this.hasElements = hasElements;
this.removeAll = removeAll;
this.size = size;
this.toString = toString;

function add(element) {
elements.push(element);
}

function remove() {
return elements.shift();
}

function getFrontElement() {
return elements[0];
}

function hasElements() {
return elements.length > 0;
}

function removeAll() {
elements = [];
}

function size() {
return elements.length;
}

function toString() {
console.log(elements.toString());
}
}

Y para probar la queue utilizaremos este código:

var peopleQueue = new Queue();
console.log(peopleQueue.hasElements()); // Mostrará falso

peopleQueue.add('Carlos');
peopleQueue.add('Cristina');
peopleQueue.add('Mario');

peopleQueue.toString(); // Mostrará: Carlos,Cristina,Mario
console.log(peopleQueue.size()); // Mostrará 3
console.log(peopleQueue.hasElements()); // Mostrará true
peopleQueue.remove(); // Quitamos a Carlos
peopleQueue.remove(); // Quitamos a Cristina
peopleQueue.toString(); // Mostrará: Mario

Bueno, ya vimos de manera general las estructuras de datos, en publicaciones posteriores veremos a detalle cada uno…

Así que no olvides seguir estudiando porque la única forma de programar… es programando.