Les ensembles sont un type de conteneur associatif dans lequel chaque élément doit être unique car la valeur de l'élément l'identifie. Les valeurs sont stockées dans un ordre de tri spécifique, c'est-à-dire croissant ou décroissant.
Le std :: ensemble La classe fait partie de la bibliothèque de modèles standard C++ (STL) et elle est définie dans le En tête de fichier.
Syntaxe:
écrire json dans le fichier python
std::set set_name;>
Type de données: Set peut prendre n'importe quel type de données en fonction des valeurs, par ex. int, char, float, etc.
Exemple:
set val; // defining an empty set set val = {6, 10, 5, 1}; // defining a set with values> Programme:
C++
// C++ Program to Demonstrate> // the basic working of STL> #include> #include> int> main()> {> >std::set<>char>>une;> >a.insert(>'G'>);> >a.insert(>'F'>);> >a.insert(>'G'>);> >for> (>auto>& str : a) {> >std::cout << str <<>' '>;> >}> >std::cout <<>'
'>;> >return> 0;> }> |
>
>
multiplexeur deux à unSortir
F G>
Complexité temporelle : O(N) // N est la taille de l'ensemble.
Espace auxiliaire : SUR)
La raison pour laquelle il n'a imprimé que F et G est que set ne prend pas plusieurs valeurs identiques, il n'accepte qu'une valeur unique. On peut utiliser Multiensemble si nous voulons stocker plusieurs mêmes valeurs.
Définir trié par ordre décroissant
Par défaut, le std::set est trié par ordre croissant. Cependant, nous avons la possibilité de modifier l'ordre de tri en utilisant la syntaxe suivante.
std::set set_name;>
Exemple:
C++
// C++ program to demonstrate the creation of descending> // order set container> #include> #include> using> namespace> std;> int> main()> {> >set<>int>, greater<>int>>>s1;> >s1.insert(10);> >s1.insert(5);> >s1.insert(12);> >s1.insert(4);> >for> (>auto> i : s1) {> >cout << i <<>' '>;> >}> >return> 0;> }> |
>
>
chaîne à char en javaSortir
12 10 5 4>
Complexité temporelle : O(N) // N est la taille de l'ensemble.
Espace auxiliaire : SUR)
Note: Nous pouvons utiliser n’importe quel comparateur à la place de Greater pour définir un tri de commande personnalisé.
Propriétés
- Ordre de stockage – L'ensemble stocke les éléments dans trié commande.
- Caractéristiques des valeurs – Tous les éléments d’un ensemble ont des valeurs uniques .
- Valeurs Nature – La valeur de l'élément ne peut pas être modifiée une fois qu'il est ajouté à l'ensemble, bien qu'il soit possible de supprimer puis d'ajouter la valeur modifiée de cet élément. Ainsi, les valeurs sont immuable .
- Technique de recherche – Les ensembles suivent le Arbre de recherche binaire mise en œuvre.
- Organisation de la commande – Les valeurs d'un ensemble sont non indexé .
Note: Pour stocker les éléments dans un ordre non trié(aléatoire), unordered_set() peut être utilisé.
Quelques fonctions de base associées à Set
- commencer() – Renvoie un itérateur vers le premier élément de l’ensemble.
- fin() – Renvoie un itérateur vers l'élément théorique qui suit le dernier élément de l'ensemble.
- taille() – Renvoie le nombre d'éléments dans l'ensemble.
- taille max() – Renvoie le nombre maximum d’éléments que l’ensemble peut contenir.
- vide() – Indique si l'ensemble est vide.
Les complexités temporelles pour effectuer diverses opérations sur les ensembles sont :
- Insertion d'éléments – O (log N)
- Suppression d'éléments – O (log N)
RPC
// C++ program to demonstrate various functions of> // STL> #include> #include> #include> using> namespace> std;> int> main()> {> >// empty set container> >set<>int>, greater<>int>>>s1;> >// insert elements in random order> >s1.insert(40);> >s1.insert(30);> >s1.insert(60);> >s1.insert(20);> >s1.insert(50);> >// only one 50 will be added to the set> >s1.insert(50);> >s1.insert(10);> >// printing set s1> >set<>int>, greater<>int>>>::itérateur itr;> >cout <<>'
The set s1 is :
'>;> >for> (itr = s1.begin(); itr != s1.end(); itr++) {> >cout << *itr <<>' '>;> >}> >cout << endl;> >// assigning the elements from s1 to s2> >set<>int>>s2(s1.begin(), s1.end());> >// print all elements of the set s2> >cout <<>'
The set s2 after assign from s1 is :
'>;> >for> (itr = s2.begin(); itr != s2.end(); itr++) {> >cout << *itr <<>' '>;> >}> >cout << endl;> >// remove all elements up to 30 in s2> >cout <<>'
s2 after removal of elements less than 30 '> >':
'>;> >s2.erase(s2.begin(), s2.find(30));> >for> (itr = s2.begin(); itr != s2.end(); itr++) {> >cout << *itr <<>' '>;> >}> >// remove element with value 50 in s2> >int> num;> >num = s2.erase(50);> >cout <<>'
s2.erase(50) : '>;> >cout << num <<>' removed
'>;> >for> (itr = s2.begin(); itr != s2.end(); itr++) {> >cout << *itr <<>' '>;> >}> >cout << endl;> >// lower bound and upper bound for set s1> >cout <<>'s1.lower_bound(40) : '> ><< *s1.lower_bound(40) << endl;> >cout <<>'s1.upper_bound(40) : '> ><< *s1.upper_bound(40) << endl;> >// lower bound and upper bound for set s2> >cout <<>'s2.lower_bound(40) : '> ><< *s2.lower_bound(40) << endl;> >cout <<>'s2.upper_bound(40) : '> ><< *s2.upper_bound(40) << endl;> >return> 0;> }> |
>
>
npm vider le cacheSortir
The set s1 is : 60 50 40 30 20 10 The set s2 after assign from s1 is : 10 20 30 40 50 60 s2 after removal of elements less than 30 : 30 40 50 60 s2.erase(50) : 1 removed 30 40 60 s1.lower_bound(40) : 40 s1.upper_bound(40) : 30 s2.lower_bound(40) : 40 s2.upper_bound(40) : 60>
Fonction différente de Set en C++ STL
| Fonction | Description |
|---|---|
| commencer() | Renvoie un itérateur vers le premier élément de l'ensemble. |
| fin() | Renvoie un itérateur vers l'élément théorique qui suit le dernier élément de l'ensemble. |
| rcommencer() | Renvoie un itérateur inverse pointant vers le dernier élément du conteneur. |
| rend() | Renvoie un itérateur inverse pointant vers l’élément théorique juste avant le premier élément du conteneur défini. |
| crbegin() | Renvoie un itérateur constant pointant vers le dernier élément du conteneur. |
| crend() | Renvoie un itérateur constant pointant vers la position juste avant le premier élément du conteneur. |
| ccommencer() | Renvoie un itérateur constant pointant vers le premier élément du conteneur. |
| quelques() | Renvoie un itérateur constant pointant vers la position après le dernier élément du conteneur. |
| taille() | Renvoie le nombre d'éléments dans l'ensemble. |
| taille max() | Renvoie le nombre maximum d'éléments que l'ensemble peut contenir. |
| vide() | Renvoie si l'ensemble est vide. |
| insérer (const g) | Ajoute un nouvel élément « g » à l'ensemble. |
| insert d'itérateur (position de l'itérateur, const g) | Ajoute un nouvel élément 'g' à la position pointée par l'itérateur. |
| effacer (position de l'itérateur) | Supprime l'élément à la position pointée par l'itérateur. |
| effacer (const g) | Supprime la valeur « g » de l'ensemble. |
| clair() | Supprime tous les éléments de l'ensemble. |
| clé_comp() / valeur_comp() | Renvoie l'objet qui détermine la façon dont les éléments de l'ensemble sont ordonnés ('<' par défaut). |
| trouver (const g) | Renvoie un itérateur à l'élément « g » dans l'ensemble s'il est trouvé, sinon renvoie l'itérateur à la fin. |
| compter (const g) | Renvoie 1 ou 0 selon que l'élément « g » est présent ou non dans l'ensemble. |
| limite_inférieure (const g) | Renvoie un itérateur vers le premier élément qui est équivalent à « g » ou qui ne ira certainement pas avant l'élément « g » dans l'ensemble. |
| upper_bound (const g) | Renvoie un itérateur vers le premier élément qui ira après l'élément « g » dans l'ensemble. |
| plage_égale() | La fonction renvoie un itérateur de paires. (key_comp). La paire fait référence à la plage qui comprend tous les éléments du conteneur qui ont une clé équivalente à k. |
| remplacer() | Cette fonction permet d'insérer un nouvel élément dans le conteneur de l'ensemble, uniquement si l'élément à insérer est unique et n'existe pas déjà dans l'ensemble. |
| emplace_hint() | Renvoie un itérateur pointant vers la position où l'insertion est effectuée. Si l'élément passé en paramètre existe déjà, alors il renvoie un itérateur pointant vers la position où se trouve l'élément existant. |
| échanger() | Cette fonction permet d'échanger le contenu de deux ensembles mais les ensembles doivent être du même type, bien que les tailles puissent différer. |
| opérateur= | Le '=' est un opérateur en C++ STL qui copie (ou déplace) un ensemble vers un autre ensemble et set::operator= est la fonction d'opérateur correspondante. |
| get_allocator() | Renvoie la copie de l'objet allocateur associé à l'ensemble. |
Différence entre un ensemble et un ensemble non ordonné
| Ensemble | Ensemble non ordonné |
|---|---|
| Définir stocke les éléments dans un ordre trié | Unordered Set stocke les éléments dans un ordre non trié |
| Définir des magasins/acquérir des éléments uniques uniquement | L'ensemble non ordonné stocke/acquiert uniquement des valeurs uniques |
| Set utilise des arbres de recherche binaires pour la mise en œuvre | Unordered Set utilise des tables de hachage pour la mise en œuvre |
| Plus d'un élément peut être effacé en donnant l'itérateur de début et de fin | Nous pouvons effacer l'élément pour lequel la position de l'itérateur est donnée |
| définir Set_Name ; | unordered_set UnorderedSet_Name ; |
Pour plus d’informations, vous pouvez vous référer à l’article – Ensembles vs ensemble non ordonné .