Directorio de artículos
1. Introducción y uso de la lista
Una introducción completa a la lista
(1) La lista es un contenedor secuencial que se puede insertar y eliminar en cualquier posición dentro de un rango constante, y el contenedor se puede iterar en ambas direcciones.
(2) La capa inferior de la lista es una estructura de lista doblemente enlazada. Cada elemento de la lista doblemente enlazada se almacena en un nodo independiente que no está relacionado entre sí, y el puntero apunta al elemento anterior y al siguiente elemento en el nodo
(3) list es muy similar a forward_list: la principal diferencia es que forward_list es una lista enlazada única, que solo se puede iterar hacia adelante, lo que la hace más simple y eficiente.
(4) En comparación con otros contenedores en serie (matriz, vector, deque), la lista generalmente tiene una mejor eficiencia de ejecución para insertar y eliminar elementos en cualquier posición.
(5) En comparación con otros contenedores secuenciales, el mayor defecto de list y forward_list es que no admite el acceso aleatorio en ninguna posición. Por ejemplo, para acceder al sexto elemento de la lista, debe comenzar desde una posición conocida (como la cabeza o la cola) Iterar a esta ubicación lleva un tiempo lineal para iterar; la lista también necesita algo de espacio adicional para contener la información asociada para cada nodo (esto puede ser un gran problema para una lista grande que almacena elementos de un tipo más pequeño Factor importante)
list es una lista enlazada circular bidireccional principal
2. El constructor de lista
(1) lista (tamaño_tipo n, constante valor_tipo& val = valor_tipo())
La clase list proporciona una lista constructora (size_type n, const value_type& val = value_type()), que se usa para crear una lista enlazada que contiene un número específico de elementos.
n: Indica el número de elementos a crear.
val (opcional): Indica el valor predeterminado que se insertará en cada posición de la lista enlazada.
El siguiente es un ejemplo de uso de este constructor:
#include <iostream>
#include <list>
int main() {
// 创建一个包含5个元素的链表，每个元素的值都为100
std::list<int> myList(5, 100);
// 遍历链表并输出元素
for (const auto& element : myList) {
std::cout << element << " ";
}
std::cout << std::endl;
return 0;
}
//100 100 100 100 100
(2) list() construye una lista vacía
La clase de lista también proporciona un constructor predeterminado list(), que crea una lista enlazada vacía sin ningún elemento.
El constructor predeterminado list() de list se usa para crear una lista enlazada vacía. Podemos agregar elementos a la lista enlazada a través de funciones de operación de lista enlazada (como push_back(), push_front(), etc.) para completar la construcción de la lista enlazada.
El siguiente es un ejemplo de uso del constructor list():
#include <iostream>
#include <list>
int main() {
// 创建一个空链表
std::list<int> myList;
// 在链表末尾添加元素
myList.push_back(10);
myList.push_back(20);
myList.push_back(30);
// 遍历链表并输出元素
for (const auto& element : myList) {
std::cout << element << " ";
}
std::cout << std::endl;
return 0;
}
//10 20 30
(3) constructor de copia de lista (const list& x)
La clase de lista también proporciona una lista de constructores de copias (const list& x) para crear una nueva lista enlazada que contenga los mismos elementos que en la lista enlazada x dada.
La lista de constructores de copias (const list& x) de list se usa para crear una nueva lista enlazada que contiene los mismos elementos que en la lista enlazada x dada. La lista vinculada creada por el constructor de copia es independiente de la lista vinculada original y las modificaciones a la lista vinculada original no se reflejarán en la lista vinculada copiada.
El siguiente es un ejemplo de uso del constructor de copias list(const list& x):
#include <iostream>
#include <list>
int main() {
// 创建一个链表
std::list<int> originalList{
1, 2, 3, 4, 5};
// 使用拷贝构造函数创建另一个链表
std::list<int> copiedList(originalList);
// 修改原始链表
originalList.push_back(6);
// 遍历拷贝链表并输出元素
for (const auto& element : copiedList) {
std::cout << element << " ";
}
std::cout << std::endl;
return 0;
}
//1 2 3 4 5
(4) lista (InputIterator primero, InputIterator último)
list(InputIterator primero, InputIterator último) es un constructor de rango para std::list que crea una nueva lista enlazada que contiene elementos copiados del rango especificado [primero, último].
El constructor de rango de list list (InputIterator primero, InputIterator último) se usa para crear una nueva lista enlazada cuyos elementos se copian del rango especificado [primero, último]. El rango se puede especificar pasando el rango del iterador del contenedor, un puntero de matriz más el número de elementos, etc. La lista vinculada así creada contendrá los mismos elementos que en el rango de origen, y estos elementos se copiarán en la nueva lista vinculada, donde se redistribuirán los nodos y datos individuales.
Aquí hay un ejemplo de uso del constructor de rango list (InputIterator primero, InputIterator último):
#include <iostream>
#include <list>
#include <vector>
int main() {
// 创建一个 vector，并初始化其中的元素
std::vector<int> vec{
1, 2, 3, 4, 5};
// 使用范围构造函数创建一个链表，从 vector 中复制元素
std::list<int> myList(vec.begin(), vec.end());
// 遍历链表并输出元素
for (const auto& element : myList) {
std::cout << element << " ";
}
std::cout << std::endl;
return 0;
}
//1 2 3 4 5
3. iterador de lista
(1) inicio + final
list es un contenedor de lista doblemente enlazado, que proporciona funciones begin() y end() para obtener iteradores que apunten al primer elemento y al último elemento de la lista enlazada.
La función begin() devuelve un iterador que apunta al primer elemento de la lista enlazada, y la función end() devuelve un iterador que apunta al elemento posterior al final de la lista enlazada. Mediante el uso de los iteradores devueltos por estas dos funciones, los elementos de la lista vinculada se pueden recorrer en un bucle.
Las siguientes son definiciones y ejemplos de uso de las funciones begin() y end():
#include <iostream>
#include <list>
int main() {
std::list<int> myList = {
1, 2, 3, 4, 5};
// 使用 begin() 获取链表首元素的迭代器
std::list<int>::iterator itBegin = myList.begin();
// 使用 end() 获取链表尾后元素的迭代器
std::list<int>::iterator itEnd = myList.end();
// 输出链表中的元素
for (std::list<int>::iterator it = itBegin; it != itEnd; ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
return 0;
}
//1 2 3 4 5
(2) rbegin + rend
list es un contenedor de lista doblemente vinculado, que también proporciona funciones rbegin() y rend(), que se utilizan para obtener iteradores inversos que apuntan al primer elemento de la lista vinculada en orden inverso y al elemento posterior al final del orden inverso.
La función rbegin() devuelve un iterador inverso que apunta al primer elemento en orden inverso de la lista enlazada, y la función rend() devuelve un iterador inverso que apunta al elemento después del final del orden inverso de la lista enlazada. Al utilizar el iterador inverso devuelto por estas dos funciones, los elementos de la lista enlazada se pueden recorrer en orden inverso en un bucle.
Las siguientes son definiciones y ejemplos de uso de las funciones rbegin() y rend():
#include <iostream>
#include <list>
int main() {
std::list<int> myList = {
1, 2, 3, 4, 5};
// 使用 rbegin() 获取链表逆序首元素的反向迭代器
std::list<int>::reverse_iterator itRbegin = myList.rbegin();
// 使用 rend() 获取链表逆序尾后元素的反向迭代器
std::list<int>::reverse_iterator itRend = myList.rend();
// 输出链表中的元素（逆序）
for (std::list<int>::reverse_iterator it = itRbegin; it != itRend; ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
return 0;
}
//5 4 3 2 1