Directorio de artículos
Extraiga la traducción del documento para obtener las siguientes conclusiones
-
list 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 de un lado a otro.
-
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 del nodo.
-
list es muy similar a forward_list: la principal diferencia es que forward_list es una lista enlazada individualmente que solo se puede iterar hacia adelante, lo que la hace más simple y eficiente.
-
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.
-
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 iterar desde una posición conocida (como la cabeza o tail) a la posición sobre la cual la iteración requiere una sobrecarga de tiempo lineal; la lista también requiere algo de espacio adicional para contener la información asociada para cada nodo (esto puede ser un factor importante para listas grandes que almacenan elementos de tipos más pequeños)
push_front &&pop_front
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_front(0);
lt.push_front(1);
lt.push_front(2);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //2 1 0
lt.pop_front();
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 0
return 0;
}
push_back&&pop_back
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(0);
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //0 1 2 3
lt.pop_back();
lt.pop_back();
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;//0 1
return 0;
}
insertar
1. Inserte un número en la posición del iterador especificada.
2. Inserte n números cuyo valor sea val en la posición del iterador especificada.
3. Inserte un intervalo de iterador (izquierdo cerrado y derecho abierto) en la posición de iterador especificada.
El iterador no se invalidará después de insertar
#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
list<int>::iterator pos = find(lt.begin(), lt.end(), 2);
//auto pos =find (lt.begin(),lt.end() ,2);
lt.insert(pos, 9); //在2的位置插入9
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 9 2 3
pos = find(lt.begin(), lt.end(), 3);
lt.insert(pos, 2, 8); //在3的位置插入2个8
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 9 2 8 8 3
vector<int> v(2, 7);
pos = find(lt.begin(), lt.end(), 1);
lt.insert(pos, v.begin(), v.end()); //在1的位置插入2个7
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //7 7 1 9 2 8 8 3
return 0;
}
borrar
1. Eliminar el elemento en la posición del iterador especificada.
2. Eliminar todos los elementos en el rango de iterador especificado (izquierdo cerrado y derecho abierto).
El iterador puede volverse inválido después de borrar
#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
list<int>::iterator pos = find(lt.begin(), lt.end(), 2);
lt.erase(pos); //删除2
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 3 4 5
pos = find(lt.begin(), lt.end(), 4);
lt.erase(pos, lt.end()); //删除4及其之后的元素
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 3
return 0;
}
iterador
empezar y terminar
La función de inicio obtiene el iterador de avance del primer elemento en el contenedor, y la función final puede obtener el iterador de avance de la última posición del último elemento en el contenedor.
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt(10, 2);
//正向迭代器遍历容器
list<int>::iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
it++;
}
cout << endl;
return 0;
}
rbegin y rend
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt(10, 2);
//反向迭代器遍历容器
list<int>::reverse_iterator rit = lt.rbegin();
while (rit != lt.rend())
{
cout << *rit << " ";
rit++;
}
cout << endl;
return 0;
}
frente atrás
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(0);
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
cout << lt.front() << endl; //0
cout << lt.back() << endl; //4
return 0;
}
tamaño
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
cout << lt.size() << endl; //4
return 0;
}
cambiar el tamaño
Cuando el valor dado > el tamaño actual, expanda el tamaño a este valor, y los datos expandidos son el segundo valor dado. Si no se da, por defecto es el valor construido por el constructor predeterminado del tipo almacenado en el contenedor.
Cuando el valor dado < el tamaño actual, reduce el tamaño a este valor
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt(5, 3);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //3 3 3 3 3
lt.resize(7, 6); //将size扩大为7，扩大的值为6
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //3 3 3 3 3 6 6
lt.resize(2); //将size缩小为2
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //3 3
return 0;
}
vacío
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
cout << lt.empty() << endl; //1
return 0;
}
claro
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt(5, 2);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //2 2 2 2 2
cout << lt.size() << endl; //5
lt.clear(); //清空容器
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //(无数据)
cout << lt.size() << endl; //0
return 0;
}
clasificar
Ordenar ascendente por defecto
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(4);
lt.push_back(7);
lt.push_back(5);
lt.push_back(9);
lt.push_back(6);
lt.push_back(0);
lt.push_back(3);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //4 7 5 9 6 0 3
lt.sort(); //默认将容器内数据排为升序
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //0 3 4 5 6 7 9
return 0;
}
empalme
1. Unir todo el contenedor a la posición de iterador especificada de otro contenedor.
2. Unir una pieza de datos en el contenedor a la posición de iterador especificada de otro contenedor.
3. Empalme los datos en el intervalo de iterador especificado del contenedor a la posición de iterador especificada de otro contenedor
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt1(4, 2);
list<int> lt2(4, 6);
lt1.splice(lt1.begin(), lt2); //将容器lt2拼接到容器lt1的开头
for (auto e : lt1)
{
cout << e << " ";
}
cout << endl; //6 6 6 6 2 2 2 2
list<int> lt3(4, 2);
list<int> lt4(4, 6);
lt3.splice(lt3.begin(), lt4, lt4.begin()); //将容器lt4的第一个数据拼接到容器lt3的开头
for (auto e : lt3)
{
cout << e << " ";
}
cout << endl; //6 2 2 2 2
list<int> lt5(4, 2);
list<int> lt6(4, 6);
lt5.splice(lt5.begin(), lt6, lt6.begin(), lt6.end()); //将容器lt6的指定迭代器区间内的数据拼接到容器lt5的开头
for (auto e : lt5)
{
cout << e << " ";
}
cout << endl; //6 6 6 6 2 2 2 2
return 0;
}
único
La función única se utiliza para eliminar elementos duplicados consecutivos en el contenedor.
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(4);
lt.push_back(3);
lt.push_back(3);
lt.push_back(2);
lt.push_back(2);
lt.push_back(3);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 4 3 3 2 2 3
lt.sort(); //将容器当中的元素排为升序
lt.unique(); //删除容器当中连续的重复元素
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //1 2 3 4
return 0;
}
unir
La función de fusión se usa para fusionar un contenedor de lista ordenado en otro contenedor de lista ordenado, de modo que el contenedor de lista fusionado aún esté ordenado.
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt1;
lt1.push_back(3);
lt1.push_back(8);
lt1.push_back(1);
list<int> lt2;
lt2.push_back(6);
lt2.push_back(2);
lt2.push_back(9);
lt2.push_back(5);
lt1.sort(); //将容器lt1排为升序
lt2.sort(); //将容器lt2排为升序
//merge前提是lt1和lt2都有序
lt1.merge(lt2); //将lt2合并到lt1当中
for (auto e : lt1)
{
cout << e << " ";
}
cout << endl; //1 2 3 5 6 8 9
return 0;
}
contrarrestar
La función inversa se utiliza para invertir la posición de los elementos en el contenedor.
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
lt.reverse(); //将容器当中元素的位置进行逆置
for (auto e : lt)
{
cout << e << " ";
}
cout << endl; //5 4 3 2 1
return 0;
}
Si crees que este artículo es útil para ti, también podrías mover los dedos para indicar Me gusta, recopilar y avanzar, y prestarle mucha atención a Xi Ling. ¡Cada apoyo tuyo se transformará en mi motivación para seguir adelante! ! !
