Trier plusieurs listes en fonction d’une liste C #

Structure d’object Une classe a plusieurs listes de données. Class List1 of double List2 of double List3 of double List4 of double

Objectif: sortinger plusieurs listes en fonction d’une liste. Par exemple, List1 dans l’ordre croissant et toutes les autres listes doivent suivre cet ordre pour maintenir la relativité de point individuelle basée sur l’index.

Les implémentations initiales que j’ai essayées sont:

List2 listes 2, 3 et 4 avec la liste 1, puis sortingez en fonction de la liste 1. Combinez ensuite à nouveau les listes sortingées.

par exemple

  var x1 = testData.SelectMany(d => d.xData).ToList(); var y1 = modelData.SelectMany(d => d.yData).ToList(); var y2 = modelData.SelectMany(d => d.y2Data).ToList(); var sampleValues = x1.Zip(y1, (x, y) => new { X = x, Y = y }).OrderBy(v => vX); var sampleValues1 = x1.Zip(y2, (x, y) => new { X = x, Y2 = y }).OrderBy(v => vX);` //Next select X, Y from sampleValues and select Y2 from sampleValue2

Essayé d’utiliser SelectMany sur différentes listes, puis de le mettre dans un type anonyme. SelectMany ne fonctionne pas avec cela car il a besoin d’un type de données défini pour être retourné.

Tout ce qui me manque dans ces approches ou il y a une autre approche requirejse pour obtenir ce que j’essaie de réaliser.

Avoir aussi une classe avec toutes ces données ou des listes sous forme de lignes individuelles et des données dans des colonnes n’est pas une option pour moi. C’est parce que j’ai une liste d’objects ayant ces propriétés. Donc, finalement, je souhaite fusionner des listes de données avec des exemples de listes de données, puis sortinger et utiliser ces données.

N’hésitez pas à me le faire savoir au cas où d’autres informations seraient nécessaires.

Il existe une méthode Array.Sort connue, Array.Sort qui sortinge un tableau en fonction de l’ordre d’un second tableau. J’ai fait une petite méthode d’extension qui utilise cette ancienne:

 public static class ICollectionExtensions { public static IEnumerable SortLike(this ICollection source, IEnumerable sortOrder) { var cloned = sortOrder.ToArray(); var sourceArr = source.ToArray(); Array.Sort(cloned, sourceArr); return sourceArr; } }

Vous pouvez l’utiliser en appelant …

 var list21 = list2.SortLike(list1);

L’avantage de cette méthode est qu’elle est extrêmement rapide, malgré les deux ToArray() qu’elle ToArray() . ToArray() crée une copie superficielle de la collection, ce qui ne prend que quelques millisecondes avec une liste de 10 millions d’éléments. Array.Sort est rapide car il sélectionne le meilleur algorithme de sorting pour la taille du tableau.

Vous pouvez faire ceci:

 var listA = new List { 1.0, 2.0, 3.0 }; var listB = new List { 1.1, 2.1, 3.1 }; var listC = new List { 1.2, 2.2, 3.2 }; var listD = new List { 1.3, 2.3, 3.3 }; var items = new List>(); for (var i = 0; i < listA.Count; ++i) items.Add(Tuple.Create(listA[i], listB[i], listC[i], listD[i])); var sorted = items.OrderBy(x => x.Item1); listA = sorted.Select(x => x.Item1).ToList(); listB = sorted.Select(x => x.Item2).ToList(); listC = sorted.Select(x => x.Item3).ToList(); listD = sorted.Select(x => x.Item4).ToList();

Vous feriez probablement mieux de faire quelque chose comme:

 public class MyClass { public double A { get; set; } public double B { get; set; } public double C { get; set; } public double D { get; set; } }

Et puis travaillez sur List au lieu de quatre listes différentes.

Voici

 double[] input1 = ..., input2 = ..., input3 = ..., input4 = ...; var sortIndex = Enumerable.Range(0, input1.Count).OrderBy(i => input1[i]).ToList(); var output1 = sortIndex.Select(i => input1[i]).ToList(); var output2 = sortIndex.Select(i => input2[i]).ToList(); var output3 = sortIndex.Select(i => input3[i]).ToList(); var output4 = sortIndex.Select(i => input4[i]).ToList();