Delphi Listbox Items nach Teil String sortieren

[Zeref Darkmage]

Hey, ich bin auf der Suche nach der Lösung :D Ich habe mir in der Praxis die anscheinend zu gebrauchenden Befehle zusammengesucht, jedoch scheitere ich an der Zusammenführung selbst.

Das Problem in dessen Besitz ich bin ist, dass ich gern in der Form bzw. Oberfläche in einem Editfenster einen String eingeben möchte, soweit kein Problem(Syntax : Zahl Name Zahl Name)

diesen in eine Listbox schreibe, auch noch kein Problem, und dann nach der jeweils ersten Zahl sortiere, heißt, das es die gesamte liste abarbeiten soll, jeweils nur die erste Zahl der Syntax

benutzen soll, dann verschiebt, (nach oben der unten egal) um dann eine sortierte Liste zu haben ist die nach eben der ersten Zahl sortiert wurde. Jedoch den ganzen String in der Ausgabe

beinhaltet.

Die Zahlen sollen natürlich mir < oder > verglichen werden.



for i:=1 to Listbox1.items.count -1 do begin // hier soll es schonmal die ganze Liste in Agriff nehmen

for x:= 1 to length(listbox1.items[x]) do begin // hier jede einzelne Zeile bzw. item

if pos(' ',Listbox1.items[x]) then begin // hier da die erste Frage, wo ist der Fehler? - Sobald ein Leerzeichen kommt soll die Schleife beginnen


switch1:=copy(pos(' ',Listbox1.items[x])); // Es soll der Teilstring mit dem darunter liegenden String, welcher auch in einem Teilstring ist(die erste Zahl) verglichen werden


end;

end;

end;


- wie kann ich den Teilstring vergleichen, aber am Ende in der Ausgabe den ursprünglichen String eben nur nach der ersten Zahl sortiert bekommen?

Das Sortieren soll mit einem Knopfdruck auf dem Button "sortieren" passieren

die Befehle die ich einbauen wollen würde sind, pos,copy,split

ps: bin neu hoffe das es in die richtige Abteilung gepostet wurde, wenn nicht bitte ich um Entschuldigung ^^

[LTE5]

Ich habe an folgender Stelle aufgehört zu lesen.
Sicher, dass da [x] stehen soll und nicht [i]?

Delphi-Quellcode:

for x:= 1 to length(listbox1.items[x]) do begin // hier jede einzelne Zeile bzw. item

Zitat:

ps: bin neu hoffe das es in die richtige Abteilung gepostet wurde

Hobby- oder Schulprojekt? :P

[Zeref Darkmage]

nja es geht mir bei [x] oder [i] darum das es symbolisiert, hatte beides probiert. beides ging nicht ^^

hobby projekt was wenn es nicht weiter geht mit der hilfe des lehrers enden muss ^^

[LTE5]

Zitat:

beides ging nicht ^^

Dann hast du aber den Sinn und/oder die Arbeitsweise einer verschachtelten Schleife noch nicht verstanden wenn du nicht weißt, ob da i oder x stehen muss.

[Ghostwalker]

Zitat:

Zitat von Zeref Darkmage (Beitrag 1389520)

for i:=1 to Listbox1.items.count -1 do begin // hier soll es schonmal die ganze Liste in Agriff nehmen

Hier ist schonmal der erste Fehler drinn. Stringlisten (wie hier in der Listbox) fangen bei 0 an, nicht bei 1.

Korrekt währe also:

Delphi-Quellcode:

For i := 0 to Listbox1.items.count-1 do begin

Damit enthält i den index auf die Zeile.

[QUOTE]

for x:= 1 to length(listbox1.items[x]) do begin // hier jede einzelne Zeile bzw. item
[/QUOITE]

Hier soll wohl jedes einzelne ZEICHEN einer Zeile durchlaufen werden. Damit ist aber das x bei listbox1.items falsch. Hier müsste statt dessen i stehen, um die jeweilige Zeile zu referenzieren.

Korrekt währ also

Delphi-Quellcode:

for x := 1 to length(listbox1.items[i]) do begin

Damit hast in i den index auf die Zeile und in x den index des Zeichens.


Beim Rest muss ich leider passen, da sich mir noch nicht ganz erschlossen hat, was den eigentlich gemacht werdeen soll.

Vielleicht währe eine kleine Erklärung mit Datenbeispiel hilfreich :)

[Luckie]

Ganz andere Idee. Wäre da ein Listview mit mehreren Spalten nicht einfacher? Und dann eben die erste Spalte sortieren.

[Zeref Darkmage]

Im Anhang ist die Datei, danke schonmal für die berichtigung der fehler, bin noch bluts Anfänger :D

Es soll mit dem klick auf "sortieren" die Listbox nach der jeweils ersten Zahl im string vergleichen und danach verscheiben..

Bsp
71524 Tobi 7623 Müller
892748 Max 872 Müller
89237 Lucas 8723 Müller

hier wie gesagt die erste Zahl mit der jeweils anderen Zahl vergleichen um zu entscheiden was gerückt werden soll, danach aber wie gesagt den ganzen String sortiert anzeigen.

Das alles solang bis die kleinste Zahl unten steht und die größte oben

das weiter und zurück fügt es bzw. entfernt es aus der Listbox

lg

[LTE5]

Zitat:

Das alles solang bis die kleinste Zahl unten steht und die größte oben

Guck dir dafür mal, auch als kleine Übung, BubbleSort an
https://de.wikipedia.org/wiki/Bubblesort

[Amateurprofi]

@Zeref:
Ein Weihnachtsgeschenk für dich:

Delphi-Quellcode:

PROCEDURE SortListBoxBubbleSort(List:TStrings; Dsc:Boolean);
FUNCTION Compare(const A,B:String):Integer;
begin
   Result:=Pos(' ',A)-Pos(' ',B);
   if Result=0 then Result:=CompareStr(A,B);
   if Dsc then Result:=-Result;
end;
var I,First,Last:Integer; Sorted:Boolean; H:String;
begin
   List.BeginUpdate;
   First:=0;
   Last:=List.Count-1;
   repeat
      Dec(Last);
      Sorted:=true;
      for I:=First to Last do
         if Compare(List[I],List[I+1])>0 then begin
            Sorted:=false;
            H:=List[I];
            List[I]:=List[I+1];
            List[I+1]:=H;
         end;
   until Sorted;
   List.EndUpdate;
end;

Aufruf:
SortListBoxBubbleSort(ListBox1.Items,True);

Der zweite Parameter gibt an, ob die Liste aufsteigend (False) oder absteigend sortiert wird (True).

Achtung:
Das funktioniert nur, wenn alle Einträge mit einer vorzeichenlosen Ganzzahl ohne führende 0 beginnen und dieser Zahl ein Blank folgt.
Die Compare Funktion gibt 0 zurück wenn A = B ist, einen positiven Wert wenn A > B ist und einen negativen Wert, wenn A < B ist.


Wenn die Liste nur wenig Einträge hat (200 oder so) dann sollte die obige Version OK sein.
Bei mehr Einträgen hier die Quicksort-Version:

Delphi-Quellcode:

PROCEDURE SortListBoxQuickSort(List:TStrings; Dsc:Boolean);
FUNCTION Compare(const A,B:String):Integer;
begin
   Result:=Pos(' ',A)-Pos(' ',B);
   if Result=0 then Result:=CompareStr(A,B);
   if Dsc then Result:=-Result;
end;
var M,H:String;
PROCEDURE QSort(First,Last:Integer);
var I,J:Integer;
begin
   I:=First;
   J:=Last;
   M:=List[(First+Last) shr 1];
   repeat
      while Compare(List[I],M)<0 do Inc(I);
      while Compare(List[J],M)>0 do Dec(J);
      if I<=J then begin
         H:=List[I];
         List[I]:=List[J];
         List[J]:=H;
         Inc(I);
         Dec(J);
      end;
   until i>j;
   if J>First then QSort(First,J);
   if I<Last then QSort(I,Last);
end;
begin
   List.BeginUpdate;
   QSort(0,List.Count-1);
   List.EndUpdate;
end;

[Solutor]

Das ist eine häufig benötigte Funktion.
Ich habe mal einen Lösungsvorschlag mit mehreren Varianten und hoffe ich ausreichenden Kommentaren.
Hiermit lassen sich die komplexesten Sortier Varianten erstellen, was ish selbst z.B. dazu verwende eine komplett im Arbeitsspeicher
vorgehaltene Musikdatenbank nach den verschiedensten Kriterien zu sortieren, was bei mehreren 10000 Einträgen rasant schnell funktioniert.

Es werden benötigt:
Eine Form mit, 1 Listbox und 2 Buttons.
Keine besondere Uses Anweisung notwendig.


Also los gehts:
//================================================== ================================================== =================
// Die eigentliche Sortier-Callback Funktion die an TStringlist übergeben werden kann.
// Es werden die eigentliche Liste, sowie zwei Indizes der Liste an die Funktion übergeben.
// Man muss nun die beiden Elemente der Liste miteinander Vergleichen,
// die über die Indizes zur Verfügung gestellt werden.
//
// Dazu muss man also folgendes tun:
// Ist das Element der Liste mit dem Index1 größer als das Element der Liste mit dem Index2,
// so muss man als Rückgabeparameter dieser Funktion eine 1 einsetzen.
//
// Ist das Element der Liste mit dem Index1 kleiner als das Element der Liste mit dem Index2,
// so muss man als Rückgabeparameter dieser Funktion eine -1 einsetzen.
//
// Sind beide Elemente gleich,
// so muss man als Rückgabeparameter dieser Funktion eine 0 einsetzen.
//
// Der eigentliche Sortieralgorithmus ist dann Quicksort, der vom Objekt TStringlist
// auf die hier gezeigte Weise zur Verfügung steht.
// Man kann anstelle der Strings auch in gewohnter Weise auf die Objektliste zugreifen.
// z.B. TIrgendetwas(List.Objects[index1])
//
// Ich habe hier beim Vergleichen die ausführliche Schreibweise der If Anweisungen gewählt.
// Bei einem Einfachen Vergleich ist das zwar nicht nötig, doch bei Erweiterungen bietet
// die Variante mit dem "Exit" in den jeweiligen Zweigen vielfältige Möglichkeiten um
// z.B. verschachtelt zu sortieren. (Wie man es z.b.von Excel kennt - Erst nach Spalte A dann nach Spalte C.... usw.)
//================================================== ================================================== =================


//================================================== ================================================== =================
// Variante 1
// Die Führenden Ziffern des Strings als Integer interpretieren und danach sortieren, wie es eigentlich snnvoll ist.
//================================================== ================================================== =================
Function MySortByNumbersAsValue(list:TStringlist;Index1:Int eger;Index2:Integer):Integer;
Var A,B:Integer;
begin
Result:=0;//Defaultrückgabewert auf 0 setzen.
a:=StrToInt(Copy(list[index1],1,Pos(#32,(list[index1]))-1));
b:=StrToInt(Copy(list[index2],1,Pos(#32,(list[index2]))-1));
if A>B then
begin
Result:=1;
Exit;
end;
if A<B then
begin
Result:=-1;
Exit;
end;
end;

//================================================== ================================================== =================
// Variante 2
// Einfach die Strings sortieren wie sie sind, wie es z.b. der Explorer mit Dateinamen macht, was aber nicht immer schön ist.
//================================================== ================================================== =================
Function MySortByFirstChars(list:TStringlist;Index1:Integer ;Index2:Integer):Integer;
Var A,B:String;
begin
Result:=0;
a:=list[index1];
b:=list[index2];
if A>B then
begin
Result:=1;
Exit;
end;
if A<B then
begin
Result:=-1;
Exit;
end;
end;

//================================================== ================================================== =================
// Aufruf - Sortieren der Liste nach Nummern
// Die wesentliche Zeile ist die mit "CustomSort"
//================================================== ================================================== =================
procedure TForm1.Button1Click(Sender: TObject);
Var l:Tstringlist;
begin
l:=TStringlist.Create;//Hilfsliste erzeugen
Listbox1.Items.BeginUpdate;//Listbox Zeichnen einfrieren
l.Assign(Listbox1.items);//Inhalt der Listbox in die Hilfsliste kopieren
l.CustomSort(MySortByNumbersAsValue);//Hilfsliste sortieren, wobei die führenden ziffern in Zahlen umgewandelt wurden.
Listbox1.Items.Assign(L);//Hilfsliste zurück in die Listbox kopieren
l.free;//Hilfsliste wieder freigeben
Listbox1.Items.EndUpdate;//Listbox Zeichnen wieder freigeben
end;

//================================================== ================================================== =================
// Aufruf - Sortieren der Liste nach dem kompletten String - also ganz normal aber unelegant.
// Die wesentliche Zeile ist die mit "CustomSort"
//================================================== ================================================== =================
procedure TForm1.Button2Click(Sender: TObject);
Var l:Tstringlist;
begin
l:=TStringlist.Create;//Hilfsliste erzeugen
Listbox1.Items.BeginUpdate;//Listbox Zeichnen einfrieren
l.Assign(Listbox1.items);//Inhalt der Listbox in die Hilfsliste kopieren
l.CustomSort(MySortByFirstChars);//Hilfsliste einfach nach Zeichen sortieren wie in einem Telefonbuch
Listbox1.Items.Assign(L);//Hilfsliste zurück in die Listbox kopieren
l.free;//Hilfsliste wieder freigeben
Listbox1.Items.EndUpdate;//Listbox Zeichnen wieder freigeben
end;


//================================================== ================================================== =================
//Füllen der Listbox mit Zufallswerten für den Test um was zum Spielen zu haben
//================================================== ================================================== =================
procedure TForm1.FormCreate(Sender: TObject);
Var i,j:Byte;
h:string;
begin
Listbox1.Items.BeginUpdate;//Listbox Zeichnen einfrieren
for i:= 1 to 100 do
begin
h:=Inttostr(Random(1000))+' ';
for j:=1 to Random(10)+5 do
begin
h:=h+Char(Random(25)+65);
end;
h:=h+' ';
h:=h+Inttostr(Random(1000))+' ';
for j:=1 to Random(10)+5 do
begin
h:=h+Char(Random(25)+65);
end;
Listbox1.Items.add(h);
end;
Listbox1.Items.EndUpdate;//Listbox Zeichnen wieder freigeben
end;