[C#] Wie Liste mithilfe weiterer Liste sortieren?

[Matze]

Hallo,

ich habe eine Liste, die aus Instanzen besteht.

Code:

List<myClass> myList = new List<myClass>();

"myClass" enthält "Variablen" wie "Vorname", "Nachname" und "id", also myList.Vorname, myList.Nachname und myList.id. Die id entspricht dem Index der Liste.

Zusätzlich habe ich eine weitere Liste, die eine Auswahl von IDs von "myList" enthält:

Code:

List<int> mySmallList = new List<int>();

Nun möchte ich mySmallList mithilfe von MyList sortieren.

Beispiel:

MyList könnte 5 Einträge haben, beispielsweise diese:

Code:

myList[0].Vorname = "Hans";
myList[1].Vorname = "Hugo";
myList[2].Vorname = "Fritz";
myList[3].Vorname = "Dieter";
myList[4].Vorname = "Werner";

MySmallList könnte 3 Einträge beinhalten, beispielsweise so:

Code:

MySmallList[0] = 0; // Hans
MySmallList[1] = 3; // Dieter
MySmallList[2] = 4; // Werner

MySmallList soll nun so sortiert werden, dass die Vornamen der zugehörigen Einträge in myList aufsteigend (oder absteigend) sortiert sind. Das Ergebnis soll demnach das hier sein:

Code:

MySmallList[0] = 3; // Dieter
MySmallList[1] = 0; // Hans
MySmallList[2] = 4; // Werner

Mit Sort() komme ich vermutlich nicht weiter, da ich zur Sortierung beide Listen benötige.
Wie kann ich das denn möglichst performant sortieren?

Meine Überlegung war der Weg über eine weitere Liste, doch das kommt mir unsauber und langsam vor bei vielen Einträgen:

Code:

List<myClass> tempList = new List<myClass>(MySmallList.Count);

foreach (int id in mySmallList)
{
    tempList.Add(myList[id]);
}

tempList.Sort(/* ... */);
MySmallList.Clear();

foreach (myClass entry in tempList)
{
    MySmallList.Add(entry.id);
}

tempList.Clear();

Alle Codes ungetestet, aber das Prinzip sollte klar werden.

Grüße, Matze

[Christian S.]

Hallo!

Ich habe es gerade mal in Prism ausprobiert, in C# geht's ja dann in grün:

Delphi-Quellcode:

  var myList := new List<MyClass>;
  
  myList.AddRange([new MyClass(Vorname := 'Hans'), 
                   new MyClass(Vorname := 'Hugo'),
                   new MyClass(Vorname := 'Fritz'),
                   new MyClass(Vorname := 'Dieter'),
                   new MyClass(Vorname := 'Werner')]);

  var mySmallList := new List<Integer>;
  mySmallList.AddRange([0,3,4]);

  for m in mySmallList do //unsortiert ausgeben
    Console.WriteLine(myList[m].Vorname);

  var newList := mySmallList.OrderBy(i -> myList[i].Vorname);

  for n in newList do //sortiert ausgeben
    Console.WriteLine(myList[n].Vorname);

  Console.ReadLine();

Wichtig ist, dass die System.Core.dll referenziert wird und System.Linq in den using-Klauseln steht.

Grüße
Christian

[Matze]

Hallo Christian,

dankeschön. Nur ob ich das verwende, weiß ich nicht genau. Denn dann bräuchte ich nur dafür als Voraussetzung .NET 3.5 und bisher komme ich mit 2.0 aus.
Ich teste aber mal etwas herum.

Grüße, Matze

[Christian S.]

Mir ist auch gerade eingefallen, wie es ganz ohne .NET 3.5 geht und ohne LINQ und ohne CO2-Erwärmung und so ;-)

Delphi-Quellcode:

  var myList := new List<MyClass>;
  
  myList.AddRange([new MyClass(Vorname := 'Hans'), 
                   new MyClass(Vorname := 'Hugo'),
                   new MyClass(Vorname := 'Fritz'),
                   new MyClass(Vorname := 'Dieter'),
                   new MyClass(Vorname := 'Werner')]);

  var mySmallList := new List<Integer>;
  mySmallList.AddRange([0,3,4]);

  for m in mySmallList do
    Console.WriteLine(myList[m].Vorname);

  mySmallList.Sort((x,y) -> myList[x].Vorname.CompareTo(myList[y].Vorname));

  for m in mySmallList do
    Console.WriteLine(myList[m].Vorname);

  Console.ReadLine();

Den Lambda-Ausdruck kannst Du auch also anonymen Delegate schreiben, das kann auch C# 2.0 :-)

//edit: Vielleicht bei dem Compare-Dingens noch Checks auf null / nil einbauen ;-)

[Phoenix]

Zitat:

Zitat von Matze

dankeschön. Nur ob ich das verwende, weiß ich nicht genau. Denn dann bräuchte ich nur dafür als Voraussetzung .NET 3.5

Quatsch mit Soße ;-) Du legst einfach die System.Core.dll von Mono dazu und schon funktioniert das auch mit .NET 2.0.

[Matze]

"Co2-Erwärmung" ist ein interessanter Begriff. :stupid:

@Christian: Ich verstehe zwar nicht, wie die Syntax der Sort()-Zeile bei mir aussehen würde, aber das sieht bei dir vielversprechend aus.
@Sebby: Auf externe Dlls nur für diese "simple" Sortierung möchte ich nicht zurückgreifen.

Grüße, Matze

[Christian S.]

Ich glaube, das müsste irgendwie so aussehen in C# und ohne Lambda-Ausdrücke (weil ich nicht weiß, ob C# 2.0 die schon hatte):

Code:

            mySmallList.Sort(delegate(int x, int y) {return myList[x].Vorname.CompareTo(myList[y].Vorname);});

Die null-Checks fehlen immer noch ;-)

[Phoenix]

Zitat:

Zitat von Christian S.

Delphi-Quellcode:

mySmallList.Sort((x,y) -> myList[x].Vorname.CompareTo(myList[y].Vorname));

Code:

mySmallList.Sort(delegate(int x, int y) { return myList[x].Vorname.CompareTo(myList[y].Vorname) } );

[Phoenix]

Zitat:

Zitat von Christian S.

Ich glaube, das müsste irgendwie so aussehen in C# und ohne Lambda-Ausdrücke (weil ich nicht weiß, ob C# 2.0 die schon hatte)

Nein, es gab da noch keine Lambdas. C# war Oxygene halt schon damals technologisch weit hinterher :zwinker:

[Matze]

Tatsache, das ist genial. Ich wusste nicht, dass man mit Sort() auch Werte aus anderen Listen vergleichen kann.
Herzlichen Dank euch beiden. :thumb:

[Medium]

Mmmmmhhhhal ne andere Frage: Warum in der 2. Liste nicht gleich Verweise auf Instanzen in der ersten speichern? Dann ließe die sich ganz popelig normal via Sort() sortieren, ohne die erste anzurühren. :gruebel:

[Matze]

Äh jo das ist 'ne sehr gute Frage. :gruebel:
Vielleicht ändere ich das, danke.