C# Déterminer les doublons dans une liste

Question

Exigence : Dans une liste non triée, déterminez si un doublon existe. La façon typique de faire cela est une boucle imbriquée à n carrés. Je me demande comment les autres résolvent ce problème. Existe-t-il une méthode élégante et performante en Linq ? Quelque chose de générique qui prend un lambda ou un comparateur serait bien.

Answer 1

À moins que je ne manque quelque chose, vous devriez pouvoir vous en sortir avec quelque chose de simple, en utilisant les éléments suivants Distinct() . Certes, ce ne sera pas la mise en œuvre la plus complexe que vous puissiez imaginer, mais elle vous indiquera si des doublons ont été supprimés :

var list = new List<string>();

// Fill the list

if(list.Count != list.Distinct().Count())
{
     // Duplicates exist
}

Answer 2

Ce problème a été abordé ici : Duplicata de MSDN linq Le lien contient un exemple complet que vous pouvez suivre.

Answer 3

Afin de permettre le court-circuitage si le doublon existe au début de la liste, vous pouvez ajouter une balise HashSet<T> et vérifier la valeur de retour de son .Add méthode.

En utilisant .Any vous pouvez court-circuiter l'énumération dès que vous trouvez un doublon.

Voici une méthode d'extension LINQ à la fois en C# et en VB :

CSharp :

public static bool ContainsDuplicates<T>(this IEnumerable<T> enumerable)
{
    var knownKeys = new HashSet<T>();
    return enumerable.Any(item => !knownKeys.Add(item));
}

Visual Basic :

<Extension>
Public Function ContainsDuplicates(Of T)(ByVal enumerable As IEnumerable(Of T)) As Boolean
    Dim knownKeys As New HashSet(Of T)
    Return enumerable.Any(Function(item) Not knownKeys.Add(item))
End Function

Note : pour vérifier s'il y a pas de les doublons, il suffit de changer Any à All

Answer 4

Placez tous les éléments dans un ensemble et si le compte de l'ensemble est différent du compte de la liste, alors il y a un doublon.

bool hasDuplicates<T>(List<T> myList) {
    var hs = new HashSet<T>();

    for (var i = 0; i < myList.Count; ++i) {
        if (!hs.Add(myList[i])) return true;
    }
    return false;
}

Devrait être plus efficace que Distinct car il n'est pas nécessaire de parcourir toute la liste.

Answer 5

Quelque chose de ce genre est relativement simple et vous fournira un compte des doublons.

var something = new List<string>() { "One", "One", "Two", "Three" };

var dictionary = new Dictionary<string, int>();

something.ForEach(s =>
    {
        if (dictionary.ContainsKey(s))
        {
            dictionary[s]++;
        }
        else
        {
            dictionary[s] = 1;
        }
    });

J'imagine que cela ressemble à l'implémentation de Distinct, mais je n'en suis pas certain.