Discussion :

[pyriame]

Bonjour,

J'ai une table de jonction (ID, A(int), B(int)) entre 2 tables. Dans la colonne A plusieurs fois le même int possible et dans la colonne B plusieurs fois le même int possible aussi. Seul le couple Ax/Bx est unique.

Je soupçonne dans cette table qu'il y'est des doublons, c'est a dire qu'un Ax soit lié exactement aux même B1,B2,Bn etc... qu'un autre Ay. En soit ce n'est pas un problème et je ne cherche pas à éliminé ces doublons mais juste a les confondre pour pouvoir faire un traitement un peu différent.

Pour cela je suis partie sur un dictionnaire de list<int> avec pour chaque Ax dans la table, la liste de tous les B existants.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 using (var db = new DiagEntities())
                {
                    Dictionary<int, List<int>> Dict_Sum_Qvrai = new Dictionary<int, List<int>>();
 
                    var TableRestante = (from p in db.Jonctabs  // jonctabs = table complete
                                  where p.QuestionSEQ==8
                                  select p).ToList();
 
                    var Reponse = ((from p in TableRestante
                                    select p.ReponseSEQ).Distinct()).ToList();
 
                    foreach (var item in Reponse)
                    {
                        var ListeQuestion = (from p in TableRestante
                                       where p.ReponseSEQ == item
                                      select p.QuestionSEQ).ToList();
 
                        Dict_Sum_Qvrai.Add(item, ListeQuestion);
                    }
 
 
                    Rita1.DataSource = Dict_Sum_Qvrai;
                    Rita1.DataBind();

Déja mon gridview refuse de m'afficher un dictionnaire de liste , il me sort une erreur du style il lui manque la capacity . Je suppose que l'autocolumn ne lui va pas et que je doit lui donner le nombre de colonne que je souhaite. Je sais pas faire Bon c'est pas grave cela me sert uniquement de contrôle visuel.

A présent je voulais savoir de qu'elle façon il était possible de comparer des listes entre elles afin de déterminer si une ou plusieurs d'entre elles étaient strictement identique ?

merci de votre aide

[jopopmk]

Salut,

avec Linq une méthode possible pour comparer deux énumérables peut être d'utiliser les fonctions Except et Union. La première fera la soustraction des éléments de la liste en paramètre (liste2) dans la liste appelante (list1). Problème : si liste2 possède tous les éléments de liste1 avec quelques valeurs en plus on obtient quand même 0 éléments en sortie. Il faut donc faire la même manip' dans l'autre sens et agglomérer les deux différences dans un même set, c'est là qu'intervient la deuxième fonction. En gros ça donnerait un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

MessageBox.Show((list1.Except(list2).Union(list2.Except(list1)).Count() == 0) ? "same lists" : "different lists");

Niveau perf' je sais pas ce que ça vaut par contre.

[pyriame]

Bonjour merci pour ton aide .

Effectivement j'avais passer en revu le travail sur les ensembles et j'avais tenté un truc avec exept, intersect union etc.. et une double boucle (for (int i.....) dans for (int j...) sans grande réussite. Enfin je dit ça mais en vérité le truc était tellement tordu que j'arrivais même plus a me représenter le résultat que je devrais obtenir pour me dire "ça marche "
Je pensais pas pouvoir agréger les choses comme tu l'as fait donc à tester !

Pour la perf je me pose toujours la question aussi . Les tables de jonctions peuvent être treeesss longue... le compare " List 1 à List2, puis list1 a List3 puis List 1 à list n. Ensuite compare List2 a List3, puis List 2 à List4 , ensuite compare List3 etc...
ça risque de faire trèeeeesss long niveau nombre d'opération. Comme je suis sur des fonctions de vérification j'ai pas trop le moyen de m'y soustraire. Pour une toute petite table j'ai déjà 19 listes donc a la louche 324 comparaison a faire.

Il n'existerait pas a votre connaissance un moyen peu gourmand en ressource de comparer un grand nombre de liste entre elle ?

Bonne journée et merci!

[jopopmk]

Pour la comparaison de toutes les listes entre elles je penses pas qu'on puisse y échapper (c'est le but même de l'exercice). On pourrait simplement imaginer ne pas refaire les comparaisons sur des listes identiques (ex. List1 == List7, alors plus besoin de comparer la List7 avec les listes List8 à ListN, on l'aura déjà fait via List1). Plus les "doublons" sont fréquents, plus le code sera rapide.

Pour la comparaison d'une liste avec une autre, à regarder si une comparaison sur des listes triées ne seraient pas plus rapide. En effet comparer deux listes triées c'est beaucoup plus rapide que comparer deux listes mélangés, et les algo de tris peuvent être particulièrement performants. A tester.

[pyriame]

Oui j'y est penser après coup , trier la liste et effacer les doublons est peut être une meilleur solution qu'un algo de comparaisons naïf à complexité quadratique (enfin je crois ... ).
Je vais m'orienter vers des algo de tri un peu plus sophistiquer et je reviendrais poster la réponse.

merci de ton aide

[jopopmk]

Autre chose que j'ai oublié : dans un test préliminaire, avant de comparer tous les éléments des deux listes, tu pourrais vérifier que celles-ci ont le même nombre d'éléments. Si ce n'est pas le cas pas besoin d'aller plus loin dans la comparaison.

Pour le tri je pensais simplement à utiliser celui fournit par .NET qui semble pas mal géré, extrait :

[..] Cette méthode utilise le Array.Sort méthode qui applique le tri approfondie comme suit :

• Si la taille de partition est moins de 16 éléments, il utilise un algorithme de tri d'insertion.
• Si le nombre de partitions est supérieure à 2 * LogN, où N correspond à la plage du tableau d'entrée, il utilise un algorithme de Heapsort.
• Sinon, il utilise un algorithme de tri rapide.

(source)

Après y'a plus qu'à comparer élément par élément, à partir du moment ou deux sont différents pas besoin d'aller plus loin : les listes sont différentes (on économise la comparaison des éléments restants).