Fonctions multiset C ++

Le composant multiset de la bibliothèque standard C ++ est utilisé pour le stockage et l'accès à partir d'un ensemble où les valeurs des composants impliqués sont utilisés comme des valeurs clés pour organiser dynamiquement les données même si elles ne doivent pas être uniques. Il n'est pas facile de modifier manuellement la valeur clé d'un élément dans un multiset. Au contraire, les composants qui ont de nouvelles valeurs doivent être ajoutés et les anciennes valeurs doivent être éliminées des composants. Les multisets sont des conteneurs identiques pour définir des conteneurs. Ils détiennent les valeurs sous forme de clés dans une séquence particulière, tout comme un ensemble. Les éléments d'un multiset sont spécifiés comme des clés tout comme les ensembles.

La principale distinction entre un ensemble et un multiset est qu'un ensemble a des clés distinctes, mais un multiset permet des clés avec une valeur similaire. Les arbres de recherche binaires sont implémentés à l'aide de clés multiset. Une fois les éléments inclus dans le multiset, ces éléments ne peuvent pas être modifiés; Ils ne pouvaient être ajoutés ou supprimés que. Le fichier d'en-tête pour #include contient un multiset. Les itérateurs peuvent être utilisés pour récupérer les composants du multiset.

Méthodes utilisées sur les multisets

Voici les méthodes multiset C ++ suivantes:

• Fonction begin (): il donne un itérateur à l'élément initial de l'ensemble.
• Fonction end (): il fournit un itérateur à l'élément après l'élément final de l'ensemble.
• Fonction size (): il fournit les informations de taille multiset.
• Fonction insert (): il ajoute un élément au multiset.
• Fonction ERASE (): il supprime les composants du multiset.
• Fonction Find (): Si l'élément est situé, cette fonction donne un itérateur en faisant référence; Sinon, il fournit un itérateur faisant référence à la fin du multiset.
• Clear () Fonction: il supprime tous les éléments de Multiset.
• Fonction vide (): il nous informe du statut multiset comme étant vide ou non.

Discutons de l'utilisation de ces fonctions.

Exemple 1:

La méthode Begin () intégrée de C ++ STL est spécifiée dans le fichier d'en-tête. L'itérateur renvoyé par cette méthode pointe vers le premier élément du conteneur multiset auquel il est lié. La fonction début () fait référence au composant qui est le premier élément du conteneur en fonction de la condition de tri car les conteneurs multiset conservent les éléments dans l'ordre croissant.

#inclure
Utilisation de Namespace Std;
int main()
int a [] = 22, 34, 51, 83, 68, 50, 96;
MultiSetcheck (A, A + 7);
couter<<"The elements of the list are: ";
pour (auto x = chèque.commencer(); X != vérifier.fin(); x ++)
couter<< *x << " ";
couter<<"\nFirst element of the list: "<<*(check.begin());
retour 0;

Tout d'abord, nous présentons le fichier d'en-tête . Ce fichier d'en-tête est associé à l'utilisation des fonctions multiset dans les programmes C ++. Ensuite, nous utilisons l'espace de noms standard comme std. Maintenant, nous invoquons la méthode principale (). Ici, nous initialisons un tableau. Ce tableau contient 7 valeurs différentes. Ces éléments du tableau sont enregistrés dans une variable «A». Ensuite, nous utilisons la fonction multiset. Ici, nous passons le tableau comme paramètre de la fonction. Maintenant, la déclaration «cout» est utilisée pour afficher tous les éléments de la liste requise. Nous appliquons la boucle «pour». Cette boucle itère chaque valeur de la liste jusqu'à ce que la condition soit remplie.

Nous utilisons les méthodes début () et end () dans la boucle «pour». La fonction début () démarre la liste à imprimer. Tandis que la fonction fin () termine la liste. Ensuite, nous augmentons la valeur de la variable de boucle. Nous utilisons à nouveau l'instruction «cout» pour imprimer la première valeur de la liste spécifiée. Nous utilisons la méthode début () pour obtenir la première valeur de la liste,. En fin de compte, nous entrons la commande «return 0».

Exemple 2:

La fonction fin () est une partie intégrée du C ++ STL et se trouve dans le fichier d'en-tête. Cette fonction rend un itérateur qui pointe vers le conteneur multiset avant l'emplacement de fin. L'article qui vient après le dernier élément d'un conteneur multiset est connu comme le composant antérieur. En d'autres termes, il ne montre aucun composant de conteneur multiset particulier. Cette méthode ne prend aucun argument.

#inclure
Utilisation de Namespace Std;
int main()
int v [] = 24, 64, 19, 35, 82, 59, 46;
MultiSetcheck (V, V + 7);
couter<<"The items of the list are: ";
pour (auto j = chèque.commencer(); J != vérifier.fin(); J ++)
couter<< *j << " ";
retour 0;

Tout d'abord, le fichier d'en-tête «bits / stdc++.h ”est ajouté. Cette bibliothèque est associée à la façon dont les fonctions multiset sont utilisées dans les programmes C ++. L'espace de noms standard est désormais inclus et désigné comme MST. Maintenant que nous invoquons la méthode principale (), nous exécutons les scripts dans le corps de la fonction. Ici, un tableau est initialisé. Il y a 7 éléments différents dans ce tableau. Les éléments de ces tableau sont conservés dans la variable «V.«La fonction multiset est alors appelée. Le nombre réel d'éléments dans le tableau spécifié est également indiqué.

Maintenant, toute la liste requise s'affiche à l'aide de l'instruction «cout». Nous utilisons la boucle «pour». Cette boucle répète chaque valeur dans la liste jusqu'à ce que l'exigence soit satisfaite. Nous appelons les méthodes début () et end () dans la boucle «pour». La liste à afficher est lancée par la méthode Begin (), et elle est complétée à l'aide de la fonction fin (). La valeur de «J» est augmentée dans le dernier segment de la boucle «pour». Nous utilisons à nouveau la déclaration «cout». L'instruction «return 0» est exécutée à la fin.

Exemple 3:

Le fichier d'en-tête «bits / stdc++.H ”contient la méthode du nombre intégré () de la bibliothèque de modèle standard C ++. À l'aide de cette fonction, nous déterminons combien d'éléments ont une certaine clé. Cette fonction peut être appliquée pour compter le nombre de fois. Le même élément est utilisé dans un multiset car un multiset peut inclure de nombreuses valeurs pour un membre particulier. Dans tout le conteneur, Count () recherche la clé, puis il renvoie les résultats. La méthode renvoie 0 s'il n'y a aucun des éléments que nous recherchons dans l'ensemble. Le conteneur multiset connexe doit être examiné pour la seule valeur de la méthode comme argument, qu'il prend.

#inclure
Utilisation de Namespace Std;
int main()
int u [] = 78, 23, 56, 78, 91, 16, 78, 62;
MultiSetcheck (U, U + 8);
couter<<"The values of the list are: ";
pour (auto l = chèque.commencer(); l != vérifier.fin(); l ++)
couter<< *l << " ";
couter<< "\n78 is present: "<couter<< "\n56 is present: "<retour 0;

Au début, nous incluons la bibliothèque. Dans l'étape suivante, nous utilisons l'espace de noms par défaut. La méthode principale () est maintenant appelée. Ici, un tableau est initialisé. Huit entiers différents sont spécifiés dans ce tableau. Ces membres du tableau sont conservés dans une variable appelée «u."Ensuite, nous utilisons la méthode multiset. Ici, nous fournissons le tableau en tant que paramètre à la fonction multiset. Nous indiquons également le nombre global d'éléments de ce tableau. Les valeurs de la liste requise sont ensuite affichées à l'aide de l'instruction «cout». La boucle «pour» est utilisée ici. Jusqu'à ce que la condition soit remplie, cette boucle itère à travers chaque élément du tableau.

Nous utilisons les fonctions begin () et end () avec la boucle «pour». La liste commence à imprimer lorsque la méthode Begin () est utilisée. Mais la liste est terminée par la méthode fin (). La valeur du «i» est augmentée à l'intérieur de la boucle «pour». Une fois de plus, la commande «cout» est appliquée pour imprimer la probabilité avec laquelle le nombre 78 apparaît dans la liste définie. La méthode «count ()» est appelée pour trouver la probabilité. Nous voulons également savoir à quelle fréquence la valeur «56» existe dans la liste. Donc, nous utilisons encore la fonction Count (). Pour afficher la réponse, nous utilisons la déclaration «cout». L'instruction «retour 0» est tapée à la résiliation du code.

Exemple 4:

La valeur donnée comme point d'un paramètre est supprimée par la méthode multiset, effacer (). Exécutez le programme suivant pour voir comment fonctionne la méthode ERASE ():

#inclure
Utilisation de Namespace Std;
int main()

Multisetset;
MultiSet :: Iterator ITR;
pour (int k = 1; k < 20; k++)
ensemble.insérer (k);

couter<< "Original set: ";
for (itr = set.commencer();
itr != Set.fin();
++itr)
couter
<< " << *itr;
couter<< '\n';
iTr = set.commencer();
ITR ++;
ensemble.Effacer (ITR);
couter<< "Updated set: ";
for (itr = set.commencer();
itr != Set.fin();
++itr)
couter<< " << *itr;
couter<< '\n';
retour 0;

Ici, nous incorporons la bibliothèque . Ce fichier d'en-tête traite de l'utilisation des fonctions multiset. Ensuite, nous utilisons l'espace de noms standard. Parallèlement à cela, nous appelons la fonction principale (). Nous utilisons la fonction multiset deux fois. Pour la première méthode multiset, l'ensemble est passé comme un attribut. Et pour la deuxième méthode multiset, l'itérateur «ITR» est fourni comme l'argument.

De plus, nous appliquons la boucle «pour». Nous initialisons d'abord une variable de boucle. Ensuite, la boucle itère sur la valeur inférieure à 20. Ensuite, faites une augmentation de la variable de boucle. Nous utilisons l'instruction «cout» pour afficher l'ensemble réel d'éléments. Utilisons à nouveau la boucle «pour». Ici, nous appelons la méthode début (). Parallèlement à cela, nous invoquons la fonction fin (). Nous appliquons ces fonctions sur la valeur de l'itérateur «ITR». Ensuite, la valeur de l'itérateur est augmentée de 1. Nous voulons supprimer la deuxième valeur de l'ensemble requis, nous utilisons donc la méthode effacer ().

Après cela, l'instruction «cout» est appliquée pour imprimer les éléments de l'ensemble après la suppression de la deuxième valeur. Pour afficher les éléments de l'ensemble dans une séquence, nous utilisons à nouveau la boucle «pour». Dans la boucle «pour», les fonctions begin () et end () sont utilisées pour démarrer et résilier l'ensemble. En fin de compte, nous utilisons la commande «return 0».

Exemple 5:

Dans cette illustration, nous insérons les valeurs de l'ensemble à l'aide de la fonction multiset insert (). Ensuite, nous supprimons tous les éléments de l'ensemble à l'aide de la méthode MultiSet Clear ().

#inclure
#inclure
Utilisation de Namespace Std;
int main()
Multiset A1;
multiset A2;
pour (int j = 0; j < 15; j++)
A1.insérer (J + 1);

pour (int j = 0; j < 15; j++)
A1.insérer (J + 1);

pour (int j = 0; j < 15; j++)
A2.insérer ((j + 1) * 10);

pour (int j = 0; j < 15; j++)
A2.insérer ((j + 1) * 10);

set :: iteratoriter;
pour (iter = a1.commencer(); iter != A1.fin(); iter ++)
couter<< * iter<< " ";
couter<< '\n';
pour (iter = a2.commencer(); iter != A2.fin(); iter ++)
couter<< * iter<< " ";
couter<< '\n';

Nous incluons deux fichiers d'en-tête et au début du code. Parallèlement à cela, nous utilisons un espace de noms standard. Ensuite, nous appelons la fonction principale (). Commençons par coder dans le corps de la fonction principale (). Tout d'abord, nous appelons la fonction multiset deux fois. Nous initialisons deux variables différentes nommées «A1» et «A2». Ensuite, nous appliquons la boucle «pour».

Après avoir initialisé la variable de boucle, en appliquant la condition sur la variable de boucle et en incrément la valeur de la variable de boucle, nous utilisons la méthode insert () pour ajouter les éléments. De plus, nous invoquons la fonction définie. Ici, nous déclarons une variable «iter» pour l'itérateur. Nous augmentons la valeur du «iter». La boucle «pour» est utilisée pour les deux variables «A1» et «A2», respectivement.

A1.effacer (6);
A2.Effacer (A2.begin (), A2.trouver (12));
couter<< "After removing the element from the required set, now the size will be: " << a1.size() << '\n';
int v = 9;
if (a1.trouver (v) != A1.fin())
couter<< "The defined set has: " << v << " values" <autre
couter<< "The defined set does not have: " << v <couter<< "The new values of the set: ";
pour (iter = a1.commencer(); iter != A1.fin(); iter ++)
couter<< * iter<< " ";
couter<< '\n';
A1.clair();
if (a1.vide () == true)
couter<< "The set has no element";

retour 0;

De plus, nous utilisons la méthode effacer (). Ensuite, nous utilisons la méthode find () pour obtenir l'élément «12» de l'ensemble. Nous utilisons l'instruction «cout» pour afficher l'ensemble après avoir retiré l'élément «6». Ensuite, nous initialisons une variable «V». Nous appelons les fonctions find () et end () dans la condition «if» qui sont associées au premier ensemble. Nous appliquons la condition «IF» sur l'élément fourni à la fonction find (). Si cette condition est remplie, «cout» imprime les éléments de l'ensemble. Sinon, l'instruction «cout» imprime le message qui montre que la valeur requise n'est pas présente dans l'ensemble.

Encore une fois, nous utilisons la boucle «pour», commencez () et end (). En fin de compte, nous appliquons la méthode claire () et la condition «IF». Nous définissons la condition dans le corps de la condition «si». Si l'ensemble est vide, l'instruction «cout» montre le texte «L'ensemble n'a pas d'élément». Après tout cela, la commande "return0" est entrée.

Conclusion

Tout d'abord, nous avons parlé de ce qu'est un multiset C ++. Ensuite, nous avons observé plusieurs fonctions C ++ appliquées aux multisets. Dans cet article, nous exécutons divers codes contenant une variété de méthodes multiset. Dans la première illustration, nous avons utilisé la fonction début () et démontré sa fonctionnalité. Un itérateur faisant référence au tout premier membre du multiset lié à cette méthode est la valeur de retour de la fonction. Le deuxième exemple a montré comment utiliser la fonction multiset final (). La sortie de cette méthode est un itérateur qui pointe devant le dernier composant du multiset. La méthode Count () est utilisée dans l'instance suivante pour examiner ce qui se passe dans le code. Cette fonction totalise tous les entiers disponibles et partagent la même clé. Ensuite, nous exécutons le programme à l'aide de la fonction Erase (). L'élément est supprimé de l'ensemble en utilisant cette approche. Pour ajouter l'élément à l'ensemble, nous avons finalement utilisé la technique INSERT ().