Uso básico de la lista STL

La capa inferior de la lista es en realidad una estructura de lista doblemente vinculada.

uso de lista

Sobrecarga de constructores y tareas

Constructor	ilustrar
lista()	Construcción sin argumentos
lista (tipo_tamaño n, tipo_valor constante y val = tipo_valor())	La lista construida contiene n elementos con el valor val.
lista (lista constante y x)	constructor de copias
lista (InputIterator primero, InputIterator último)	Construya una lista con elementos en el rango [primero, último)

El constructor se utiliza igual que el contenedor anterior.

void test1()
{
    
    
	list<int> lt1;//无参构造

	list<int> lt2(10, 1);//1,1,1,1,1,1,1,1,1,1

	list<int> lt3(lt2);//拷贝构造

	list<int> lt4(lt2.begin(), lt2.end());
}

Sobrecarga de tareas

list& operator= (const list& x);

void test1()
{
    
    
	list<int> lt1;//无参构造

	list<int> lt2(10, 1);//1,1,1,1,1,1,1,1,1,1

	list<int> lt3(lt2);//拷贝构造

	list<int> lt4(lt2.begin(), lt2.end());

	list<int> lt5;
	lt5 = lt4;//赋值重载
}

---

Iterador (el más importante)

Hay tres tipos de iteradores: iterador unidireccional, iterador bidireccional e iterador aleatorio.

Iterador unidireccional: admite ++. Por ejemplo, el tipo de iterador de forward_list y hash es un iterador unidireccional.
Iterador bidireccional: admite ++, - - Por ejemplo, el tipo de iterador de lista, mapa y conjunto es iterador bidireccional
Iterador aleatorio: admite ++, - -, +, -. Por ejemplo, los tipos de iterador vector, cadena y deque son iteradores aleatorios.

Los iteradores aleatorios pueden considerarse iteradores bidireccionales especiales, y los iteradores bidireccionales pueden considerarse iteradores unidireccionales especiales.

El iterador de la lista es diferente vectordel de la lista: el tipo de iterador está determinado por la estructura subyacente del contenedor.string

vectorLa capa inferior de y stringes continua, por lo que sus iteradores son en realidad punteros, por lo que admiten ++, –, +, -, y el tipo es un iterador aleatorio.

La listcapa inferior es discontinua y la parte delantera y trasera están conectadas entre sí mediante punteros, por lo que su iterador no es un puntero (en realidad, el puntero está encapsulado). Después de la encapsulación, el iterador admitirá ++, - - y el tipo es único. iterador

Para aquellos que no son compatibles +, -el motivo de la encapsulación es que it.begin()+5la eficiencia es demasiado baja y C++ no la admite.

El iterador de la lista no admite el iterador en el vector it.begin()+5. Si lo escribe así, se informará un error.

solo admite ++,--

void test2()
{
    
    
	list<int> lt{
    
     1,2,3,4,5,6 };
	lt.begin()--;
	lt.begin()++;
}

Si desea mover listel iterador en varias posiciones como vectoren , solo puede hacer esto:it.begin()+5

void test2()
{
    
    
	list<int> lt{
    
     1,2,3,4,5,6 };
	list<int>::iterator it = lt.begin();
	for (size_t i = 0; i < 5; i++)
	{
    
    
		++it;
	}
}

Por lo demás, listlos iteradores también admiten las funciones anteriores y su uso es el mismo.

---

Relacionado con la capacidad

vacío

bool empty() const;

Determinar si el contenedor está vacío.

tamaño

size_type size() const;

Devuelve el número de elementos en el contenedor.

---

insertar eliminar

listComo lista enlazada circular bidireccional, la inserción de encabezado, la eliminación de encabezado, la inserción de cola y la eliminación de cola son todas muy eficientes, por lo que estas operaciones son compatibles con la lista.

función	ilustrar
void push_front (const value_type& val);	Insertar un elemento con valor val antes del primer elemento de la lista
vacío pop_front();	Eliminar el primer elemento de la lista.
void push_back (const value_type& val);	Insertar un elemento con valor val al final de la lista
vacío pop_back();	Eliminar el último elemento de la lista.

void test3()
{
    
    
	list<int> lt{
    
     1,2,3,4,5,6 };
	lt.push_back(10);
	lt.push_front(0);
	lt.pop_back();
	lt.pop_front();
}

insertar

iterator insert (iterator position, const value_type& val);

void insert (iterator position, size_type n, const value_type& val);
	
template <class InputIterator>
    void insert (iterator position, InputIterator first, InputIterator last);

insertLa operación vectores la misma que en, pero esto insertno hará que el iterador falle
. Debido a que la inserción de la lista vinculada debe expandirse, el iterador apunta a un determinado nodo. Después de la inserción, el iterador aún apunta al nodo original. lo que no causará la falla.

borrar

iterator erase (iterator position);
iterator erase (iterator first, iterator last);

erase La operación vectores la misma que en. Esto erase hará que el iterador deje de ser válido.
El iterador apunta a un determinado nodo. Después de eliminar este nodo, el iterador deja de ser válido.

---

Operaciones de elementos

contrarrestar

void reverse();

Esta reversees listuna función que viene con la clase y su función es invertir la lista vinculada.

También hay <algorithm>una reversefunción
reverseen la que el tipo de iterador es un iterador bidireccional y el tipo de iterador de lista es un iterador bidireccional, por lo que la lista también se puede usar <algorithm>enreverse

void test4()
{
    
    
	list<int> lt{
    
     1,2,3,4,5,6 };
	lt.reverse();
	reverse(lt.begin(), lt.end());
}

---

clasificar

void sort();

La función es ordenar. La capa inferior es que
<algorithm>hay sortfunciones en la combinación. Pero para las listas, si desea ordenar, solo puede usar las funciones listde la biblioteca sort. No puede usar las funciones <algorithm>de la biblioteca.sort

Debido a que el tipo de iterador de la lista es un iterador bidireccional y el tipo de iterador del <algorithm>parámetro sortes un iterador aleatorio, la función <algorithm>en la lista no se puede utilizar sort.

De hecho, no significa mucho aquí , porque es menos eficiente sortque la del <algorithm>medio (la capa inferior del medio usa fusión y la del medio usa clasificación rápida). El único significado es: conveniencia. Si el La cantidad de datos es pequeña, puedes disparar, pero si la cantidad de datos ya no es demasiado grande, no la uses .sortlistsort<algorithm>sort
listsort

Si desea ordenar, puede listcopiar los datos al vectormedio, luego ordenar y luego copiar los datos al medio vectordespués de ordenar.list

void test5()
{
    
    
	list<int> lt{
    
     5,7,3,9,1,0,4,7,8,9,4, };
	vector<int> v;

	//将数据从list拷贝到vector
	for (auto e : lt)
	{
    
    
		v.push_back(e);
	}

	//在vector中排序
	reverse(v.begin(), v.end());

	//再把数据从vector拷贝到list中
	for (auto e : v)
	{
    
    
		lt.push_back(e);
	}
}

---

único

void unique();

La función es eliminar duplicados, pero primero es necesario ordenarlos.

void test6()
{
    
    
	list<int> lt{
    
    2,6,5,2,2,2,2};
	lt.sort();
	lt.unique();// 5,6
}

---

eliminar

void remove (const value_type& val);

La función de eliminar es buscar primero todas vallas ubicaciones y luego eraseeliminar todas.val

void test6()
{
    
    
	list<int> lt{
    
    1,2,3,4,5,6,6,7,8};

	//移除元素6
	lt.remove(6);//1,2,3,4,5,7,8
}

---

empalme

void splice (iterator position, list& x);

void splice (iterator position, list& x, iterator i);
	
void splice (iterator position, list& x, iterator first, iterator last);

La función del empalme es transferir nodos.

• void splice (iterator position, list& x), transfiera xtodos los elementos en la lista vinculada a positionla posición
• void splice (iterator position, list& x, iterator i), transfiera el elemento en la posición xen la lista vinculada a la posicióniposition
• void splice (iterator position, list& x, iterator first, iterator last), xtransfiera los elementos en [primero, último) en la lista vinculada a positionla posición

void test7()
{
    
    
	list<int> lt1{
    
     1,2,3,4,5,6,7 };
	list<int> lt2{
    
     0,0 };

	lt2.splice(++lt2.begin(), lt1);

	for (auto e : lt1)
	{
    
    
		cout << e << " ";
	}//lt1中的元素转移空了
	cout << endl;

	for (auto e : lt2)
	{
    
    
		cout << e << " ";
	}//0 1 2 3 4 5 6 7 0
	cout << endl;


	list<int> lt3{
    
     1,2,3,4,5,6,7 };
	list<int> lt4{
    
     0,0 };

	lt4.splice(++lt4.begin(), lt3, ++lt3.begin());
	for (auto e : lt3)
	{
    
    
		cout << e << " ";
	}//1 3 4 5 6 7
	cout << endl;

	for (auto e : lt4)
	{
    
    
		cout << e << " ";
	}//0 2 0
	cout << endl;


	list<int> lt5{
    
     1,2,3,4,5,6,7 };
	list<int> lt6{
    
     0,0 };

	lt6.splice(++lt6.begin(), lt5,++++lt5.begin(), --lt5.end());
	for (auto e : lt5)
	{
    
    
		cout << e << " ";
	}//1 2 7
	cout << endl;

	for (auto e : lt6)
	{
    
    
		cout << e << " ";
	}//0 3 4 5 6 0
	cout << endl;
}