Qué son y cómo usar las listas o arrays dinámicos

Las LISTAS, o arrays dinámicos, son estructuras de datos similares a los ARRAYS, pero que tiene tamaño variable. A diferencia de los arrays, en una lista podemos añadir o eliminar elementos según sea necesario.

Es decir, disponemos de las mismas operaciones que tendríamos en un array de tamaño fijo. Pero incorporan funcionalidades la funcionalidad adicional de,

• Agregar elementos
• Eliminar elementos

Las LISTAS ofrecen una forma sencilla de almacenar datos, que nos permite agregar, eliminar y acceder a elementos. Esto las hace ideales para el manejo de colecciones de datos donde la estructura puede cambiar a lo largo del tiempo.

Propiedades

Cuando usar una Lista

El uso principal de las LISTAS es trabajar con ellos. Es tu colección favorita para trabajar con colecciones.

Una LISTA tiene todas las funcionalidades de un ARRAY además de permitir añadir y eliminar objetos. Por lo cuál, son mucho más potentes y versátiles.

¿Cuándo no usarlas? En general, conviene evitarlas para o devolver colecciones entre funciones. Para eso es mejor usar un ARRAY de longitud fija.

Ejemplos de lista en distintos lenguajes

Sintaxis y declaración de una Lista

La sintaxis para declarar una lista puede variar dependiendo del lenguaje de programación que se esté utilizando. Vamos a ver algunos ejemplos en distintos lenguajes,

List<int> numeros = new List<int>();

#include <vector>

std::vector<int> numeros;

let numeros = [];

nombres = []

En los ejemplos anteriores, creamos listas vacías que pueden almacenar elementos de un tipo específico, como enteros en el caso de C# y C++, y de tipo variable en el caso de JavaScript y Python.

Acceso y Manipulación de Listas

Una vez que hemos declarado una lista, podemos acceder y manipular sus elementos de manera similar a como lo haríamos con un array.

Agregar elementos a una Lista

numeros.Add(10); // Agrega el elemento 10 a la lista
numeros.Add(20); // Agrega el elemento 20 a la lista

numeros.push(10); // Agrega el elemento 10 a la lista
numeros.push(20); // Agrega el elemento 20 a la lista

numeros.push(10); // Agrega el elemento 10 a la lista
numeros.push(20); // Agrega el elemento 20 a la lista

nombres.append(10)  # Agrega el elemento 10 a la lista
nombres.append(20)  # Agrega el elemento 20 a la lista

Eliminar un elemento de una Lista

numeros.Remove(10); // Elimina la primera aparición del elemento 10
numeros.RemoveAt(2); // Elimina el elemento en la posición 2

numeros.erase(numeros.begin() + 2); // Elimina el elemento en la posición 2

numeros.splice(2, 1); // Elimina 1 elemento a partir de la posición 2

nombres.remove(10)  # Elimina la primera aparición del elemento "10"
del nombres[2]  # Elimina el elemento en la posición 2

Eficiencia de las Listas Intermedio

Las LISTAS comparten los parámetros de eficiencia con sus hermanos los ARRAYS. Porque, internamente, generalmente son un array.

Sin embargo, ahora tenemos disponible añadir y eliminar elementos. Eliminar un elemento al final de la colección es O(1), ya que únicamente tenemos que reducir el contador de elementos.

Añadir un elemento al final puede ser O(1), si la lista tiene capacidad disponible. Si justo da la casualidad de que está lleno, la lista tendrá que ampliarse, lo cuál es una operación O(n).

Finalmente, añadir o eliminar un elemento al principio o en medio de la colección es O(n), porque la lista tiene que desplazar todos los elementos para ubicar / quitar el nuevo elemento.

Leer más sobre eficiencia de colecciones leer más ⯈

Funcionamiento interno

Internamente una LISTA suele implementarse como un objeto alrededor de un ARRAY. Este objeto contiene:

• El array de datos
• La capacidad de la lista
• El número de elementos

Al crear una LISTA, el array interno inicializa a un tamaño determinado, que es la capacidad de la lista.

A medida que vamos agregando elementos, la lista contabiliza las posiciones del array que estamos empleando.

Si en algún momento el número de elementos es igual a la capacidad de la lista:

• Se genera un nuevo array de mayor tamaño (típicamente el doble)
• Se copian los elementos del array anterior
• Al finalizar, el array posterior se destruye

Esto se realiza de forma transparente para el programador, de forma que no tenemos que preocuparnos por la gestión de memoria.