Suppression de doublons dans un vecteur de chaînes de caractères

J'ai un vecteur de chaînes de caractères:

std::vector<std::string> fName

qui contient une liste de noms de fichiers <a,b,c,d,a,e,e,d,b>.

Je veux me débarrasser de tous les fichiers qui ont des doublons et que vous voulez conserver uniquement les fichiers qui n'ont pas de doublons dans le vecteur.

for(size_t l = 0; l < fName.size(); l++)
{
    strFile = fName.at(l);
    for(size_t k = 1; k < fName.size(); k++)
    {
        strFile2 = fName.at(k);
        if(strFile.compare(strFile2) == 0)
        {
            fName.erase(fName.begin() + l);
            fName.erase(fName.begin() + k);
        }
    }
}

Ce est de retirer un peu de la double, mais a encore un peu de doublons gauche, besoin d'aide au débogage.

Aussi mon entrée ressemble à <a,b,c,d,e,e,d,c,a> et ma sortie attendue est <b> comme tous les autres fichiers b,c,d,e ont des doublons, ils sont retirés.

Voulez-vous de garder une copie des doublons? I. e. voulez-vous <a,b,c,d,e>, ou tout simplement <c>?
Je ne veux pas garder la copie de dupilcates.

OriginalL'auteur Deepak B | 2012-02-11

c++vector

13
```
#include <algorithm>

template <typename T>
void remove_duplicates(std::vector<T>& vec)
{
  std::sort(vec.begin(), vec.end());
  vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}
```
Note: ceci nécessite T a operator< et operator== défini.

Pourquoi ça marche?

std::sort trier les éléments à l'aide de leurs moins-que l'opérateur de comparaison

std::unique supprime les doublons consécutifs éléments, en les comparant à l'aide de leur égalité, opérateur de comparaison

Que faire si je ne veux que les éléments uniques?

Alors vous feriez mieux d'utiliser std::map
```
#include <algorithm>
#include <map>

template <typename T>
void unique_elements(std::vector<T>& vec)
{   
  std::map<T, int> m;
  for(auto p : vec) ++m[p];
  vec.erase(transform_if(m.begin(), m.end(), vec.begin(),
                         [](std::pair<T,int> const& p) {return p.first;},
                         [](std::pair<T,int> const& p) {return p.second==1;}),
            vec.end());
}
```
Voir: ici.

Également besoin d'inclure #include <algorithm> std::sort et std::unique de travail.
Gigi merci cela a fonctionné, mais n'a pas résolu mon problème... j'ai commencé avec <a,b,c,d,e,e,d,b,a> je veux que ma sortie de la <a> et pas <a,b,c,d,e>
Désolé, je veux ma sortie de la <c> qui n'est pas répété.
édité
Votre solution à l'aide std::set fait la même chose que votre solution à l'aide std::sort/unique.

OriginalL'auteur
3

Si je comprends vos exigences correctement, et je ne suis pas entièrement sûr de ce que je fais. Vous souhaitez ne conserver que les éléments de votre vecteur de qui ne le répétez pas, c'est exact?

Faire une carte de chaînes à ints, utilisé pour compter les occurrences de chaque chaîne. Claire le vecteur, puis copiez uniquement les chaînes qui ne s'est produite qu'une fois.
```
map<string,int> m;
for (auto & i : v)
    m[i]++;
v.clear();
for (auto & i : m)
    if(i.second == 1)
        v.push_back(i.first);
```
Ou, pour le compilateur-fonction contestée:
```
map<string,int> m;
for (vector<string>::iterator i=v.begin(); i!=v.end(); ++i)
    m[*i]++;
v.clear();
for (map<string,int>::iterator i=m.begin(); i!=m.end(); ++i)
    if (i->second == 1)
        v.push_back(i->first);
```
OriginalL'auteur Benjamin Lindley

#include <algorithms>

template <typename T>
remove_duplicates(std::vector<T>& vec)
{
  std::vector<T> tvec;
  uint32_t size = vec.size();
  for (uint32_t i; i < size; i++) {
    if (std::find(vec.begin() + i + 1, vec.end(), vec[i]) == vector.end()) {
      tvec.push_back(t);
    } else {
      vec.push_back(t);
    }
  vec = tvec; //: )
  }
}

clairement, ce n'est pas efficace
std::vector n'a pas pop_front()
il y a seulement pop_back() ne pouvait pas trouver un pop_front(). M. Lindley serait génial si vous pouviez m'aider. merci perreal
Je l'ai aidé. Ne voyez-vous pas ma réponse?

OriginalL'auteur perreal

0

Vous pouvez éliminer les doublons en O(log n) d'exécution et de O(n) de l'espace:
```
std::set<std::string> const uniques(vec.begin(), vec.end());
vec.assign(uniques.begin(), uniques.end());
```
Mais le O(log n) runtime est un peu trompeur, parce que le O(n) l'espace ne fait O(n) des allocations dynamiques, qui sont coûteux en termes de vitesse. Les éléments doivent aussi être comparables (ici avec operator<(), qui std::string prend en charge comme un lexicographiques comparer).

Si vous souhaitez stocker uniquement des éléments uniques:
```
template<typename In>
In find_unique(In first, In last)
{
    if( first == last ) return last;
    In tail(first++);
    int dupes = 0;
    while( first != last ) {
        if( *tail++ == *first++ ) ++dupes;
        else if( dupes != 0 ) dupes = 0;
        else return --tail;
    }
    return dupes == 0 ? tail : last;
}
```
L'algorithme ci-dessus prend une triés gamme et renvoie le premier élément unique, dans le temps linéaire et constante de l'espace. Pour obtenir tous uniques dans un conteneur, vous pouvez l'utiliser comme ceci:
```
auto pivot = vec.begin();
for( auto i(find_unique(vec.begin(), vec.end()));
     i != vec.end();
     i = find_unique(++i, vec.end())) {
    std::iter_swap(pivot++, i);
}
vec.erase(pivot, vec.end());
```
Pour être franc, j'irais avec le std::sort() et std::unique() approche. J'ai juste pensé que je voudrais vous présenter une alternative. 🙂
un horrible exemple dans tous les cas (performance, etc), sent comme une solution de contournement pour ceux qui sont paresseux suffit de ne pas cocher l'algorithme de la bibliothèque

OriginalL'auteur wilhelmtell

Vous devez vous connecter pour publier un commentaire.