Comment supprimer les doublons d'un vecteur C ++
'E' se produit trois fois dans différentes positions. 'A' se produit deux fois dans des positions différentes. «C» se produit deux fois dans des positions différentes. Donc, «e», «a» et «c» ont des doublons. Chacun des autres personnages se produit une fois.
Pour éliminer les doublons dans ce vecteur, signifie supprimer les doublons de «e», «a» et «c», et de permettre la première occurrence de chaque caractère, dans sa position. Le résultat doit être:
vecteurIl existe deux façons principales d'éliminer les doublons d'un vecteur. Une façon est la voie directe ou brute. De cette façon, le premier élément est vérifié par rapport au reste des éléments, et tout duplicata est supprimé. Le deuxième élément est vérifié par rapport au reste des autres éléments à droite, en supprimant les doublons. La même procédure est effectuée pour le troisième élément et le reste des éléments. De cette façon, prend généralement trop de temps. L'autre moyen est de maintenir le vecteur d'origine et d'en avoir une copie triée. Supprimer les doublons du vecteur trié tout en faisant la copie de tout élément dupliqué, comme clé dans une carte. Enfin, parcourez le vecteur d'origine du début à la fin à l'aide de la carte pour effacer les doublons.
Ces deux façons peuvent être appelées la méthode de force brute et la méthode de tri-compare, respectivement. Cet article illustre les deux façons. N'oubliez pas d'inclure la bibliothèque vectorielle au début du programme.
Supprimer un élément vectoriel
Un élément vectoriel est supprimé avec la fonction de membre d'effacement du vecteur. La syntaxe est:
Consxpr Iterator Erase (const_iterator position);L'argument est un itérateur qui pointe vers l'élément, à supprimer.
Supprimer les doublons par force brute
Avec cette approche, le premier élément est comparé au reste des éléments à droite, un par un, et tout duplicata est effacé. Le deuxième élément, s'il n'a pas été effacé, est comparé au reste des autres éléments sur les doublons à droite, effaçant les doublons. La même procédure est effectuée pour le troisième élément et le reste des éléments. Cette approche prend généralement trop de temps. Le code suivant l'illustre avec des itérateurs:
vectorvtr = 'e', 'g', 'i', 'e', 'a', 'e', 'c', 'a', 'c';pour (vecteur :: iterator itei = vtr.commencer(); itei
for (vector :: iterator itej = itei + 1; itej
vtr.Effacer (ITEJ);
pour (int i = 0; i
couter<
entre parenthèses de la boucle intérieure.
Supprimer les doublons par tri-compare
Remarquez de la méthode ci-dessus qu'il y a beaucoup de rediffusion (relier et comparer) de la grande séquence à une petite séquence d'éléments du seul vecteur. Si tout le vecteur est numérisé une ou deux ou trois fois, cela signifierait probablement moins d'accès des éléments par rapport à l'approche ci-dessus. Eh bien, tout le vecteur peut même être scanné quatre fois ou plus, mais pas plusieurs fois. Cela ne doit pas nécessairement être fait avec le même vecteur. Cela peut être fait avec des copies du vecteur.
Avec la deuxième approche, le vecteur d'origine est maintenu tandis qu'une copie triée en est fait. Le vecteur trié est lu (scanné), effaçant le double des éléments consécutifs qui se sont produits plus d'une fois. Un iterator for-boucle peut y parvenir, du début à la fin du vecteur trié, une fois à travers. Alors que cette lecture et une efface se déroulent, pour tout élément qui se produit plus d'une fois, une copie de l'élément est faite dans une carte, et la valeur correspondante de cette clé, reçoit la valeur -1. Cette valeur de -1 sera changée à 1 pour indiquer un double. Chaque valeur de la carte est un indicateur en double de sa clé qui pourrait se produire deux fois ou plus dans le vecteur d'origine.
Si le vecteur trié avec des doublons supprimés était nécessaire, le vecteur trié est retourné et le travail est effectué. Si l'ordre de la première occurrence des éléments vectoriels doit être maintenu, la sous-procédure suivante doit avoir lieu (continuer):
Relisez le vecteur d'origine depuis le début. Pendant la lecture, si une clé ne se produit pas dans la carte (la carte renvoie 0), permettez cette clé dans le vecteur d'origine. Cela signifie que la clé n'a pas de double. Si une clé du vecteur d'origine se produit dans la carte, cela signifie que c'est la première occurrence de doublons pour cet élément du vecteur. Faites la valeur de l'indicateur de la clé de la carte, 1. Cette valeur d'indicateur a maintenant la valeur, 1. Continuez à lire le reste des éléments du vecteur d'origine et vérifiez l'élément en double avec la carte. Si une clé est trouvée et que la valeur de la clé de carte est 1, alors l'élément actuel est un double. Supprimer l'élément actuel. (N'oubliez pas que la première occurrence d'une clé en double a tourné la valeur d'indicateur correspondant dans la carte de -1 à 1.) Continuez à donner une valeur de 1 pour les indicateurs clés de la carte, en supprimant l'élément vectoriel actuel d'origine qui a déjà un 1 correspondant dans la carte du vecteur d'origine; jusqu'à la fin du vecteur d'origine. Le vecteur d'origine résultant est le vecteur sans aucun élément en double, et dans l'ordre avec les premiers événements.
Afin de coder la carte en C ++, la bibliothèque de la carte (non ordonnée_map) doit être incluse. Étant donné que la fonction tri () dans la bibliothèque d'algorithmes sera utilisée, la bibliothèque d'algorithme doit également être incluse dans le programme. La tête du programme de cette approche devrait être:
#inclure#inclure
#inclure
#inclure
Utilisation de Namespace Std;
Le premier segment de code dans la fonction principale C ++ peut être:
vecteurvecteur
trier (vtr.begin (), vtr.fin());
non ordonné_map
La première déclaration définit le vecteur d'origine. La deuxième déclaration fait une copie du vecteur d'origine. La troisième déclaration trie le vecteur copié. La quatrième déclaration déclare la carte, sans initialisation. Le segment de code suivant dans la fonction principale C ++ peut être:
pour (vector :: iterator iter = vtr.commencer(); iterif (* iter0 == * iter1)
mp [* iter1] = -1;
iter--;
vecteur :: iterator iter2 = vtr.Effacer (ITER1);
Ce segment de code efface les doublons du vecteur copié trié. En faisant cela, il crée les entrées de carte. Notez que dans les parenthèses de la boucle for, l'itération atteint l'élément dernier mais un (et non le dernier élément). En effet, les éléments actuels et suivants sont impliqués dans le code. Notez également que lorsqu'un élément doit être effacé, l'itérateur est retardé (décrémenté) d'une étape.
Si le vecteur trié sans doublons est ce qui était nécessaire, le code suivant affiche le résultat:
pour (int i = 0; icouter<
vtro.effacer (iter);
iter--;
if (mp [* iter] == -1)
mp [* iter] = 1;
La raison du choix, -1 et 1, au lieu de 0 et 1, est que la valeur par défaut (absente) de cette carte est 0. Cela évite la confusion avec les éléments qui n'ont pas du tout du double. Une boucle pour la boucle ordinaire comme suit peut imprimer le vecteur original final (réduit):
pour (int i = 0; icouter<
La sortie du programme est:
A c e g iE g i a c
La première ligne de la sortie est l'entrée triée sans doublons. La deuxième ligne est l'entrée dans l'ordre donné, les doublons supprimés.
Conclusion
Afin de supprimer les doublons d'un vecteur C ++, la méthode de force brute peut être utilisée. Cette méthode est généralement lente. Il est conseillé au lecteur d'utiliser la méthode de tri-compare, qui est généralement rapide, pour son travail commercial. Les deux méthodes ont été expliquées ci-dessus.