Diferentes formas de inicializar un conjunto en C++

Un conjunto es un contenedor asociativo disponible en la Biblioteca de plantillas estándar (STL) de C++ que se utiliza para elementos únicos en un orden específico. Utiliza internamente el principio de funcionamiento de un árbol de búsqueda binaria para almacenar elementos.

Diferentes formas de inicializar un conjunto en C++ : 

1. Inicialización utilizando el constructor predeterminado.
2. Inicialización usando la lista de inicializadores.
3. Inicialización usando una array.
4. Inicialización mediante un vector.
5. Inicialización desde otro conjunto utilizando el constructor de copias.
6. Inicialización desde otra estructura de datos iterables utilizando el constructor de rango.

1. Inicialización utilizando el constructor predeterminado

Una forma estándar de inicializar un conjunto es inicializar usando el constructor predeterminado, esto generará un conjunto vacío. Se le pueden agregar elementos usando un conjunto incorporado. Insertar() método.

Sintaxis:

establecer<int>Nuevo_conjunto;
Nuevo_conjunto.insertar(elemento1)

Aquí, el método insert() se puede usar para insertar elementos en el conjunto.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <set>
using namespace std;
 
// Driver code
int main()
{   
    // Initialize set using
    // default constructor
    set<int>New_set;
   
    // set.insert() method to
    // insert elements to the set
    New_set.insert(5);
    New_set.insert(1);
    New_set.insert(3);
    New_set.insert(2);
    New_set.insert(7);
     
    // Traverse through the set(elements
    // will be returned in ascending order)
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

1
2
3
5
7

2. Inicialización usando una lista de inicializadores

Otra forma de inicialización es pasar una lista predefinida de elementos (initializer_list) como argumento al constructor predeterminado del conjunto, como se muestra a continuación:

Sintaxis:

set<int>Nuevo_conjunto({elemento1, elemento2, elemento3, elemento4});

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <set>
using namespace std;
 
// Driver code
int main()
{  
   // Initialize set passing initializer
   // list as an argument to the
   // default constructor
   set<int>New_set({4, 3, 9, 2, 0, 6});
    
   // Traverse through the unordered_set
   for(auto x: New_set)
   {
      cout << x << endl;
   }
   return 0;
}

0
2
3
4
6
9

3. Inicialización usando una array

Los elementos se pueden agregar al conjunto utilizando una array del mismo tipo de datos.

Sintaxis:

set<int>Nuevo_conjunto(old_arr, old_arr + n); 

Aquí, old_arr es la array de enteros desde la cual se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an array of
    // integers
    int old_arr[] = {4, 3, 6, 1, 8};
    int n = (sizeof(old_arr) /
             sizeof(old_arr[0]));
   
    // Adding these elements stored
    // in the array
    set<int>New_set(old_arr,
                    old_arr + n);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

1
3
4
6
8

4. Inicialización usando un vector

Uno puede almacenar los elementos en el conjunto usando un vector del mismo tipo de datos.

Sintaxis:

set<int>New_set(old_vector.begin(),old_vector.end()); 

Aquí, old_vector es el vector de enteros desde el cual se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Driver code
int main()
{
    // Initialize a vector of integers
    vector<int>old_arr = {4, 1, 8, 2, 9};
   
    // Adding these elements
    // stored in the vector
    set<int>New_set(old_arr.begin(),
                    old_arr.end());
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

Table
Cement
Floor
Grass
Ground

5. Inicialización desde otro conjunto utilizando el constructor de copia

Una forma de inicializar un conjunto es copiar los contenidos de otro conjunto uno tras otro usando el constructor de copias.

Sintaxis:

set<int>Nuevo_conjunto(antiguo_conjunto);

Aquí, old_set es el conjunto desde el cual se copiarán los contenidos en New_set

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <set>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an unordered_set
    // using default constructor
    set<int>old_set;
   
    // set.insert() method to insert
    // elements to the unordered_set
    old_set.insert(5);
    old_set.insert(3);
    old_set.insert(4);
    old_set.insert(1);
    old_set.insert(2);
   
   
    // Create a new_set where contents
    // of the previous set will be
    // copied using copy constructor   
    set<int>New_set(old_set);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <<endl;
    }
    return 0;
}

1
2
3
4
5

6. Inicialización desde otra estructura de datos iterables usando el constructor de rangos

Otra forma de inicializar un conjunto es usar un constructor de rango para copiar elementos de una estructura de datos iterables al conjunto recién inicializado.

Sintaxis:

set<int>New_set(begin(old_set), end(old_set));

Aquí, old_set es el conjunto desde el cual se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <set>
using namespace std;
 
// Driver code
int main()
{
    // Initialize a set using
    // default constructor
    set<int>old_set;
   
    // unordered_set.insert() method
    // to insert elements to the
    // unordered_set
    old_set.insert(3);
    old_set.insert(1);
    old_set.insert(4);
    old_set.insert(8);
    old_set.insert(5);
   
   
    // Create a new_set where contents
    // of the previous set will be
    // copied using range constructor   
    set<int>New_set(begin(old_set),
                    end(old_set));
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <<endl;
    }
    return 0;
}

1
3
4
5
8