Estrategias de Inicialización de std::list

El contenedor std::list de la STL es una lista doblemente enlazada que permite diversas formas de construcción según las necesidades de memoria y datos iniciales.

1. Constructor por defecto
Crea una lista vacía sin elementos iniciales.

std::list<int> listaVacia;

2. Constructor con tamaño y valor predeterminado
Permite definir un número específico de nodos inicializados con un mismo valor.

// Crea una lista con 8 elementos, todos con el valor 100
std::list<int> listaRellena(8, 100);

3. Construcción mediante un rango de iteradores
Es posible crear una lista a partir de una secuencia existente en otro contenedor.

std::list<int> origen = {10, 20, 30, 40};
std::list<int> destino(origen.begin(), origen.end());

4. Constructor de copia
Crea un nuevo objeto que es un duplicado exacto de otro std::list.

std::list<int> original = {1, 2, 3};
std::list<int> copia(original);

5. Inicialización mediante lista de inicializadores (C++11)
Permite definir los elementos directamente entre llaves.

std::list<std::string> palabras = {"C++", "STL", "List"};

Acceso a los Elementos

Debido a su estructura de nodos enlazados, std::list no admite acceso aleatorio mediante índices. El acceso se limita a los extremos:

std::list<int> datos = {50, 60, 70};
int primero = datos.front(); // Retorna 50
int ultimo = datos.back();   // Retorna 70

Gestión de Capacidad y Estado

Podemos verificar el estado de la estructura mediante los métodos de capacidad estándar.

• empty(): Devuelve verdadero si la lista carece de elementos.
• size(): Retorna la cantidad actual de nodos.

std::list<double> valores = {1.1, 2.2};
if (!valores.empty()) {
    std::cout << "Elementos: " << valores.size() << std::endl;
}

Operaciones de Modificación de Datos

Las listas son altamente eficientes para insertar o eliminar elementos en cualquier posición una vez que se tiene un iterador.

Inserción y eliminación en extremos:

std::list<int> seq;
seq.push_back(10);  // Agrega al final
seq.push_front(5);  // Agrega al inicio
seq.pop_back();     // Elimina el último
seq.pop_front();    // Elimina el primero

Inserción por posición (insert):

std::list<int> nums = {1, 5};
auto it = nums.begin();
++it; 
nums.insert(it, 10); // Inserta 10 antes del 5

Redimensionamiento (resize):
Ajusta el número de elementos. Si el nuevo tamaño es mayor, rellena con el valor indicado.

std::list<int> v = {1, 2, 3};
v.resize(5, 0); // La lista ahora es {1, 2, 3, 0, 0}
v.resize(2);    // La lista ahora es {1, 2}

Limpieza y eliminación específica:

std::list<int> coleccion = {10, 20, 30, 40};
coleccion.erase(coleccion.begin()); // Elimina el primer elemento
coleccion.clear();                  // Vacía la lista por completo

Operaciones Avanzadas de la Lista

std::list incluye métodos optimizados para su estructura de nodos que son más eficientes que los algoritmos genéricos de <algorithm>.

remove y unique
remove elimina todas las instancias de un valor, mientras que unique elimina duplicados adyacentes.

std::list<int> items = {1, 2, 2, 3, 2, 4};
items.remove(2); // Resultado: {1, 3, 4}

std::list<int> duplicados = {1, 1, 2, 2, 1};
duplicados.unique(); // Resultado: {1, 2, 1}

sort y reverse
Ordena los elemantos o invierte su orden actual.

std::list<int> desorden = {5, 1, 9, 3};
desorden.sort();    // {1, 3, 5, 9}
desorden.reverse(); // {9, 5, 3, 1}

splice
Transfiere elementos de una lista a otra sin copiar los datos, solo reubicando los punteros de los nodos.

std::list<int> listaA = {1, 2, 3};
std::list<int> listaB = {10, 20};

// Mover todo listaB al inicio de listaA
listaA.splice(listaA.begin(), listaB); 
// listaA: {10, 20, 1, 2, 3}, listaB queda vacía

merge
Combina dos listas ordenadas en una sola lista ordenada.

std::list<int> L1 = {1, 3, 5};
std::list<int> L2 = {2, 4, 6};
L1.merge(L2); // L1: {1, 2, 3, 4, 5, 6}, L2 queda vacía