Conjunto de lista y lista de reenvío en C++ con ejemplos

Conjuntos

Los conjuntos son un tipo de contenedor asociativo en el que cada elemento tiene que ser único porque el valor del elemento lo identifica.

• begin(): Devuelve un iterador al primer elemento del conjunto.
• end() :Devuelve un iterador al elemento teórico que sigue al último elemento del conjunto.
• size() :Devuelve el número de elementos del conjunto.
• max_size() :Devuelve el número máximo de elementos que puede contener el conjunto.
• vacío() :devuelve si el conjunto está vacío.

Liza

Las listas son contenedores de secuencias que permiten la asignación de memoria no contigua. En comparación con el vector, la lista tiene un recorrido lento, pero una vez que se ha encontrado una posición, la inserción y la eliminación son rápidas. Automóvil club británico

• push_front(): esta función se usa para insertar elementos en una lista desde el frente.
• push_back(): esta función se usa para insertar elementos en una lista desde atrás. 

Listas de reenvío

La lista de reenvío en STL implementa una lista enlazada individualmente. Introducidas desde C++ 11, las listas de reenvío son más útiles que otros contenedores en las operaciones de inserción, eliminación y movimiento (como ordenar) y permiten la inserción y eliminación constante de elementos en el tiempo. 

Funciones utilizadas con listas de reenvío:

• push_front(): esta función se utiliza para insertar elementos en una lista de avance desde el frente.

Conjuntos de Lista en STL

Un conjunto de listas puede ser muy útil para diseñar estructuras de datos complejas.

Sintaxis:

set<list<data_type>> set_of_list: This stores lists. 
set<forward_list<data_type>> set_of_forward_list: This stores forward lists.

A continuación se muestra el programa C++ para demostrar la implementación del conjunto de listas:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print set contents
void print(set<list<int> >& setOfList)
{
    for (auto x : setOfList) {
        // Each element of the set is
        // a list itself
        list<int> li = x;
  
        // Printing list elements
        cout << "[ ";
        for (auto element : li)
            cout << element << ' ';
        cout << ']';
        cout << '\n';
    }
}
  
// Driver code
int main()
{
    set<list<int> > setOfList;
  
    // Declaring a list
    list<int> list1;
  
    // Pushing elements in the list
    // Pushing at the back
    list1.push_back(10);
    list1.push_back(12);
  
    // Pushing at the front
    list1.push_front(21);
  
    // Pushing at the back
    list1.push_back(16);
  
    // Inserting a list into the set
    setOfList.insert(list1);
  
    // Declaring another list
    list<int> list2;
  
    // Pushing elements in the list
    // Pushing at the back
    list2.push_back(6);
    list2.push_back(9);
    list2.push_back(11);
  
    // Pushing at the front
    list2.push_front(2);
  
    setOfList.insert(list2);
  
    // Declaring another list
    list<int> list3;
  
    // Pushing elements in the list
    // Pushing at the back
    list3.push_back(2);
    list3.push_back(6);
    list3.push_back(9);
    list3.push_back(1);
  
    setOfList.insert(list3);
  
    print(setOfList);
  
    return 0;
}

[ 2 6 9 1 ]
[ 2 6 9 11 ]
[ 21 10 12 16 ]

A continuación se muestra el programa C++ para demostrar la implementación del conjunto de listas de reenvío:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print set contents
void print(set<forward_list<int> >& setOfForwardList)
{
    for (auto x : setOfForwardList) {
        // Each element is a forward list
        // itself
        forward_list<int> li = x;
        cout << "[ ";
  
        for (auto element : li)
            cout << element << ' ';
  
        cout << ']';
        cout << '\n';
    }
}
  
// Driver code
int main()
{
    // Declaring a setOfForwardList
    set<forward_list<int> > setOfForwardList;
  
    // Declaring a forward list
    forward_list<int> forwardList1;
  
    // Pushing elements in the forward
    // list
    forwardList1.push_front(10);
    forwardList1.push_front(12);
    forwardList1.push_front(21);
    forwardList1.push_front(16);
  
    // Inserting forward list into
    // the set
    setOfForwardList.insert(forwardList1);
  
    // Declaring another forward list
    forward_list<int> forwardList2;
  
    // Pushing elements in the forward
    // list
    forwardList2.push_front(6);
    forwardList2.push_front(9);
    forwardList2.push_front(11);
    forwardList2.push_front(2);
  
    // Inserting forward list into
    // the set
    setOfForwardList.insert(forwardList2);
  
    // Print set contents
    print(setOfForwardList);
  
    return 0;
}

[ 2 11 9 6 ]
[ 16 21 12 10 ]

De forma predeterminada, las listas se organizan en orden no descendente en el conjunto y siguen la lógica que en el conjunto, si el primer valor de dos listas es igual, se compara el segundo valor de las listas, y así sucesivamente.