Comment trouver efficacement l'intersection de plusieurs listes en C# à l'aide de IEnumerable.Intersect() ?

Utilisez IEnumerable.Intersect() pour trouver efficacement l'intersection de plusieurs listes en C#

Dans le domaine de l'analyse et du traitement des données, trouver l'intersection de plusieurs listes est une tâche très courante. Bien qu'il existe plusieurs façons de résoudre ce problème, l'utilisation de la méthode IEnumerable.Intersect() fournit une solution efficace. Cet article explique comment utiliser cette méthode pour identifier et récupérer l'intersection de plusieurs listes.

En C#, lorsqu'elle est appliquée à plusieurs séquences, la méthode IEnumerable.Intersect() peut être utilisée pour obtenir des éléments communs à toutes les séquences. Pour voir comment utiliser cette méthode pour trouver l'intersection de plusieurs listes, considérons l'exemple suivant :

<code class="language-csharp">var list1 = new List<int>() { 1, 2, 3 };
var list2 = new List<int>() { 2, 3, 4 };
var list3 = new List<int>() { 3, 4, 5 };
var listOfLists = new List<List<int>>() { list1, list2, list3 };

// 预期交集为 List<int>() { 3 };</code>

Pour trouver l'intersection de ces listes en utilisant IEnumerable.Intersect() nous pouvons utiliser la méthode suivante :

<code class="language-csharp">var intersection = listOfLists
    .Skip(1)
    .Aggregate(
        new HashSet<int>(listOfLists.First()),
        (h, e) => { h.IntersectWith(e); return h; }
    );</code>

Dans cette solution nous :

1. Ignorer la première liste : Nous utilisons d'abord Skip(1) pour ignorer la première liste de listOfLists. Ceci est nécessaire pour démarrer le processus d'agrégation avec la deuxième liste.
2. Agrégation : Nous utilisons la méthode Aggregate pour accumuler les résultats d'intersection. Les fonctions d'agrégation acceptent deux paramètres : une valeur de départ et une fonction à exécuter sur chaque élément suivant.
3. Création d'un HashSet : Nous créons un HashSet à partir de la première liste comme intersection initiale. HashSet est utilisé car il identifie efficacement les éléments en double et prend en charge les opérations d'intersection rapides.
4. Intersecter avec chaque liste : Pour chaque liste suivante, nous appelons IntersectWith() sur le HashSet. Cette méthode met à jour le HashSet afin qu'il contienne uniquement des éléments communs au HashSet et à la liste actuelle.
5. Renvoie l'intersection : Une fois que toutes les listes ont été traitées, le HashSet contient l'intersection de toutes les listes. Nous renvoyons ce HashSet sous forme d'intersection.

Cette solution fournit un moyen concis et efficace de trouver l'intersection de plusieurs listes à l'aide de IEnumerable.Intersect(). Il exploite les fonctionnalités d'optimisation de HashSet pour gérer les éléments en double et effectuer des opérations d'intersection rapides.

Il est important de noter que listOfLists doit toujours contenir au moins une liste avec laquelle initialiser l'intersection. Si la liste est vide, une ArgumentNullException est levée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!