Stringliste Umkehren

[simon790]

Hallo Ich mcöhte den Inhalt einer Stringliste Umkehren...Also erstes Elemnt an letzter Stelle und das Letzte an ester Stelle ect...

Zuerst

A
B
C
D

Nacher

D
C
B
A

Ich habe mal folgenden Code geschrieben mit dem es soweizt funktioniert.

procedure TForm1.Button1Click(Sender: TObject);
var i,d: Integer;
begin
With OpenDialog1 do
begin
if Execute then
begin
Daten.LoadFromFile(Filename); //Daten in die Stringlist kopieren
end;
end;
d:= Daten.Count; //Anzahl Zeilen ermitteln
DatenU.Assign(Daten); //Die Umgekehrte Stringlist "DatenU" mit der richtigen gGrösse erstellen
for i := 1 to d do
begin
DatenU.Strings[i-1]:= Daten.Strings[d-i] //Zeilen umsortieren
end;
Label1.Caption:=IntToStr(d);
Memo1.Lines:=Daten;
Memo2.Lines:=DatenU;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
Daten := TStringList.Create;
DatenU := TStringList.Create;
end;



Da die Stringlist aber ziemlich gross werden können (txt-Logfiles) dauert dieser Algorythmus etwas lange.

Hat jemand eine elegantere Lösung?
Besten Dank und Gruss

Simon

[Hansa]

Wohl noch nie was von DOWNTO gehört ?

[simon790]

Inwiefern ist DOWNTO die Antwort auf meine Frage?

[mkinzler]

Zitat:

Zitat von simon790

Inwiefern ist DOWNTO die Antwort auf meine Frage?

Gar nicht.

[Klaus01]

Was Hansa meint ist vielleicht das:

Delphi-Quellcode:

datenU:= TStringList.create;
for i:=daten.count -1 downto 0 do
  DatenU.add(daten[i]);

Memo2.lines.assign(datenU);
datenU.free;

Ob das schneller ist, sei mal dahingestellt.

Grüße
Klaus

[inherited]

downto brauchst du noch nicht mal!

Delphi-Quellcode:

var s: String;
...
for i := 0 to (sl.Count-1) div 2 do
begin
  s:=sl[i];
  sl[i]:=sl[sl.Count-i-1];
  sl[sl.Count-i-1]:=s;
end;

(ungetestet)

[DeddyH]

Ist TStringList.CustomSort die Antwort auf Deine Frage? :mrgreen:

[bluesbear]

Zitat:

Zitat von DeddyH

Ist TStringList.CustomSort die Antwort auf Deine Frage? :mrgreen:

Ich denke nein, Tim :mrgreen:
Es kommt darauf an, was bezweckt werden soll. DOWNTO is gut, wenn man die Elemente einer Stringlist in umgekerhter Reihenfolge durchgehen will. Wenn das nicht die beabsichtigte Aktion ist, dann fürchte ich, es geht halt nicht schneller. Zumindest fällt mir nix ein, was man an dem simon790 seinem Code verbessern könnte. Außer der Formatierung. Oder so. Ich mein ja nur..

[Klaus01]

.. ist denn TStringList.exchange nicht ehr für soetwas gut?

Delphi-Quellcode:

j:=0;
for i:=daten.count -1 downto (daten.count -1) div 2 do
  begin
    daten.exchange(i,j);
    inc(j);
  end;

[ungetestet)

Aus der Hilfe zu Exchange:
Swaps the position of two strings in the list.

procedure Exchange(Index1, Index2: Integer); override;

Description

Call Exchange to rearrange the strings in the list. The strings are specified by their index values in the Index1 and Index2 parameters. Indexes are zero-based, so the first string in the list has an index value of 0, the second has an index value of 1, and so on.

If either string has an associated object, Exchange changes the index of the object as well.

Warning: Do not call Exchange on a sorted list except to swap two identical strings with different associated objects. Exchange does not check whether the list is sorted, and can destroy the sort order of a sorted list.

Grüße
Klaus

[bluesbear]

Zitat:

Zitat von Klaus01

TStringList.exchange

Ich bin beschämt. Da kam ich nicht drauf <seufz>

[simon790]

Hallo Klaus
Deine Lösung funktioniert soweit ganz gut und schnell. Und sieht auch gut aus ;-)

Allerbesten Dank (auch an die anderen!)
Simon

[Hansa]

Ist das mit dem Downto nicht selbsterklärend ? :shock:

Delphi-Quellcode:

unit Test;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Gauges;

type
  TForm1 = class(TForm)
    memo1: TMemo;
    memo2: TMemo;
    btn1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure btn1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    sl : TStringlist;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses DateUtils;

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var i : Integer;
begin
  sl := TStringlist.Create;
  for i := 0 to 10 do
    sl.Add(IntToStr(i));
  memo1.Lines := sl;    // Stringlist-Inhalt an Memo übergeben
end;

procedure TForm1.btn1Click(Sender: TObject);
var i : Integer;
begin
  memo2.Lines.Clear;
  for i := sl.Count - 1 downto 0 do
    memo2.Lines.Add (memo1.Lines[i]) // in umgekehrter Reihenfolge in 2. Memo schieben
end;

end.

Der Rest, Exchange usw. und sonstige Verrenkungen sind eher entsetzlich. :mrgreen:

[bluesbear]

Zitat:

Zitat von Hansa

Der Rest, Exchange usw. und sonstige Verrenkungen sind eher entsetzlich. :mrgreen:

Aber Hansa! Das irritiert mich jetzt. Das mit dem Exchange ist eine superelegante Lösung! Da müssen keine Speicherbereiche kopiert oder sonstwas gemacht werden, sondern nur ein paar Pointer vertauscht. Was schreibst denn Du da für einen... okok, ich werd wieder paranoid.

[DeddyH]

Das geht btw. auch ohne downto, indem man statt Add Insert an Position 0 anwendet :zwinker:

[Hansa]

Zitat:

Zitat von bluesbear

...Exchange ist eine superelegante Lösung! Da müssen keine Speicherbereiche kopiert oder sonstwas gemacht werden, sondern nur ein paar Pointer vertauscht. Was schreibst denn Du da für einen... okok, ich werd wieder paranoid.

Jo. :mrgreen: Siehe hier :

Delphi-Quellcode:

procedure TStringList.Exchange(Index1, Index2: Integer);
begin
  if (Index1 < 0) or (Index1 >= FCount) then Error(@SListIndexError, Index1);
  if (Index2 < 0) or (Index2 >= FCount) then Error(@SListIndexError, Index2);
  Changing;
  ExchangeItems(Index1, Index2);
  Changed;
end;

procedure TStringList.ExchangeItems(Index1, Index2: Integer);
var
  Temp: Integer;
  Item1, Item2: PStringItem;
begin
  Item1 := @FList^[Index1];
  Item2 := @FList^[Index2];
  Temp := Integer(Item1^.FString);
  Integer(Item1^.FString) := Integer(Item2^.FString);
  Integer(Item2^.FString) := Temp;
  Temp := Integer(Item1^.FObject);
  Integer(Item1^.FObject) := Integer(Item2^.FObject);
  Integer(Item2^.FObject) := Temp;
end;

So sieht das intern aus. Und elegant ist IMHO lesbarer Quelltext. Wer meine 7 relevanten Zeilen nicht versteht, der tut mir leid. :mrgreen: Ergebnis : siehe Anhang.

[bluesbear]

Äh, ja. Ich gebs auf. Bin ich hier irgendeinem running gag zum Opfer gefallen?

[alzaimar]

Hansa, welche Methode ist eigentlich schneller? Deine in Fachkreisen genannte 'Downto'-Methode, oder das Vertauschen? Soweit ich mich erinnere, ging es im Post darum.

Zitat:

Zitat von Hansa

Und elegant ist IMHO lesbarer Quelltext.

Den Quelltext der Exchange-Methode sieht man doch nicht.
Aber wenn Du schon so argumentierst, dann ist erstens jede Stringzuweisung unelegant, da der Compiler ja 'Magic' mit reincodiert, und zweitens die Add-Methode auch nicht gerade elegant. Da wird erst zu AddObject gesprungen, um dann zu InsertItem zu springen und dann wird u.U. erstmal der gesammte Speicher vergrößert und umkopiert, damit danach nochmal Speicher verschoben wird. Ahhhh ja., Äh.. *räusper*.. Elegant? :gruebel: Also, Hansa, ich weiss nicht.

Delphi-Quellcode:

function TStringList.Add(const S: string): Integer;
begin
  Result := AddObject(S, nil);
end;

function TStringList.AddObject(const S: string; AObject: TObject): Integer;
begin
  if not Sorted then
    Result := FCount
  else
    if Find(S, Result) then
      case Duplicates of
        dupIgnore: Exit;
        dupError: Error(@SDuplicateString, 0);
      end;
  InsertItem(Result, S, AObject);
end;

procedure TStringList.InsertItem(Index: Integer; const S: string; AObject: TObject);
begin
  Changing;
  if FCount = FCapacity then Grow;
  if Index < FCount then
    System.Move(FList^[Index], FList^[Index + 1],
      (FCount - Index) * SizeOf(TStringItem));
  with FList^[Index] do
  begin
    Pointer(FString) := nil;
    FObject := AObject;
    FString := S;
  end;
  Inc(FCount);
  Changed;
end;

:gruebel: Elegant sieht anders aus. :mrgreen:

Zitat:

Zitat von Hansa

Wer meine 7 relevanten Zeilen nicht versteht, der tut mir leid. :mrgreen:

Och, das ist nicht das Problem. das Problem scheint zu sein, das Du die drei(!) relevanten Zeilen vom bluesbear, die zudem noch schneller sind, nicht als kürzer, schneller, leichter zu lesen und eleganter empfindest. Oder ist ein Codefragment mit mehr als doppelt so viel Zeilen, das lahm ist, etwa elegant? :shock:

Lern mal wieder argumentieren. So wird das nix mehr.

[Klaus01]

.. um das ganze einmal zu untermauern.

Getestet habe ich so:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  sl : TStringList;
  sl2 : TstringList;
  tick1 : Longword;
  i,j : longint;

begin
   sl := TstringList.create;
   sl2 := TStringList.create;
   StatusBar1.Panels[0].Text:='';
   sl.LoadFromFile(ExtractFilePath(ParamStr(0))+'testFile.txt');
   tick1 := GetTickCount;
   for i:=sl.Count -1 downto 0 do
    sl2.add(sl[i]);
   label4.Caption := IntToStr(GetTickCount - tick1);
   StatusBar1.Panels[0].Text:='downto fertig';
   sl.Free;
   sl2.Free;

   sl := TstringList.create;

   sl.LoadFromFile(ExtractFilePath(ParamStr(0))+'testFile.txt');
   tick1 := GetTickCount;
   for i:=sl.count -1 downto (sl.count -1) div 2 do
     begin
       sl.Exchange(i,sl.count -1 -i);
     end;
   label5.Caption:= IntToStr(GetTickCount - tick1);
   StatusBar1.Panels[0].Text:='exchange fertig';

   sl.free;

   StatusBar1.Panels[0].Text:='fertig';
end;

mit einer 350MByte Datei.
Herausgekommen ist, das was im Screenshot zu sehen ist.

Grüße
Klaus

[thkerkmann]

Hi,

es geht doch hier wohl um Geschwindigkeit und eine Stringlist.
In der Aufgabenstellung taucht kein Memo und keine Objekte an der Stringlist auf.

Damit ist der Code von inherited IMHO unschlagbar der schnellste und eleganteste.

Gruss

[Klaus01]

Zitat:

Zitat von thkerkmann

Damit ist der Code von inherited IMHO unschlagbar der schnellste und eleganteste.

Gruss

Würde ich nicht so sagen:

TestCode:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  sl : TStringList;
  sl2 : TstringList;
  tick1 : Longword;
  i,j : longint;
  s: String;

begin
   sl := TstringList.create;
   sl2 := TStringList.create;
   StatusBar1.Panels[0].Text:='';
   sl.LoadFromFile(ExtractFilePath(ParamStr(0))+'testFile.txt');
   tick1 := GetTickCount;
   for i:=sl.Count -1 downto 0 do
    sl2.add(sl[i]);
   label4.Caption := IntToStr(GetTickCount - tick1);
   StatusBar1.Panels[0].Text:='downto fertig';
   sl.Free;
   sl2.Free;

   sl := TstringList.create;

   sl.LoadFromFile(ExtractFilePath(ParamStr(0))+'testFile.txt');
   tick1 := GetTickCount;
   for i:=sl.count -1 downto (sl.count -1) div 2 do
     begin
       sl.Exchange(i,sl.count -1 -i);
     end;
   label5.Caption:= IntToStr(GetTickCount - tick1);
   StatusBar1.Panels[0].Text:='exchange fertig';

   sl.free;

   sl := TstringList.create;

   sl.LoadFromFile(ExtractFilePath(ParamStr(0))+'testFile.txt');
   tick1 := GetTickCount;
   for i:=0 to (sl.count -1) div 2 do
     begin
      s:=sl[i];
      sl[i]:=sl[sl.Count-i-1];
      sl[sl.Count-i-1]:=s;
     end;
   label7.Caption:= IntToStr(GetTickCount - tick1);
   StatusBar1.Panels[0].Text:='exchange fertig';

   sl.free;


   StatusBar1.Panels[0].Text:='fertig';
end;

Ergebnis im Anhang.

Grüße
Klaus

[thkerkmann]

Ok, das sind mal Zahlen :thumb:

Ich muss gestehen, ich habs nicht gemessen, kam mir nur so vor.
Aber beim Exchange werden ja nur die Pointer getauscht. Das kann ja nur schnell sein :-D

Algo1 alloziert neue strings und ausserdem befindet sich die Ergebnismenge erst mal in einer anderen Stringliste. Der fällt also auf jeden Fall durch.

Gruss

[bluesbear]

Zitat:

"alzaimar"(...)das Problem scheint zu sein, das Du die drei(!) relevanten Zeilen vom bluesbear(...)

Nee, die waren von Klaus01. Ich ärgere mich immer noch, daß ich nicht selber darauf gekommen bin.

[Hansa]

Es geht nur um die Zeit ?

Delphi-Quellcode:

// braucht 6 Min. 44 Sek.
  sl2 := TStringlist.Create;
  for i := sl1.count - 1 downto (sl1.count - 1) div 2 do begin
    sl1.exchange(i,j);
    j := j + 1;
  end;
  memo2.Lines := sl1;
(* braucht 6 Min. 41 Sek.
  for i := sl1.Count - 1 downto 0 do
    sl2.Add (sl1[i]); // in umgekehrter Reihenfolge in 2. Memo schieben
  memo2.Lines := sl1;
*)

30 MB. Zeit ist unwichtig. :mrgreen:

[Sharky]

Zitat:

Zitat von Hansa

Es geht nur um die Zeit ?

...

30 MB. Zeit ist unwichtig. :mrgreen:

Hi,

zum einen sagen die 30 MB alleine nichts aus. Wenn schon solltest Du auch sagen wieviele Zeilen es sind.
Zum anderen braucht nicht das Umsortieren so lange sondern das Eintragen in das Memo :!:
Sehe es doch ein: TStrings.Exchange ist die schnellste Lösung.

[Hansa]

Es sind fast 400.000 Zeilen. Add hat gegenüber exchange einen geringen Vorteil von 0,7 % = 3 Sek.

[Union]

Zitat:

Zitat von Hansa

Es sind fast 400.000 Zeilen. Add hat gegenüber exchange einen geringen Vorteil von 0,7 % = 3 Sek.

Putz mal Deine Brille! Wie hast Du denn das gemessen? Bei meinem nicht taufrischen Laptop habe ich für Add 89 ms und für Exchange 10 ms (400000 x 80 Byte). Ausserdem belegt die Add-Methode doppelt so viel Speicher, ist also nicht skalierbar:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
const
   NUM_ENTRIES = 400000;
   ENTRY = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789AAAA'+
           'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789AAAA';
var
   slDown : TStringlist;
   slUp   : TStringList;
   i, j : integer;
   dtStart : TDateTime;
begin
   Button1.Enabled := False;

   // Füllen
   slDown := TStringList.Create;
   slDown.Capacity := NUM_ENTRIES;
   for i := 0 to NUM_ENTRIES-1 do
      slDown.add(ENTRY);
   Button1.Enabled := True;

   // Methode mit Add
   slUp := TStringList.Create;
   dtStart := Now;
   for i := slDown.Count-1 downto 0 do
      slUp.Add(slDown[i]);
   ShowMessage(Format('Add %d ms', [MillisecondsBetween(Now, dtStart)]));
   slUp.Free;

   // Methode mit Exchange
   dtStart := Now;
   j := 0;
   for i := slDown.count - 1 downto (slDown.count - 1) div 2 do
   begin
     slDown.exchange(i,j);
     inc(j);
   end;
   ShowMessage(Format('Exchange %d ms', [MillisecondsBetween(Now, dtStart)]));
   slDown.Free;
end;

[edit]Ahh, ich hab Deine geniale Messmethode erkannt: Du misst wahrscheinlich das Update des Memo mit. Warum trägst Du das ganze nicht noch in eine Datenbank ein und misst das ebenfalls dazu? Das Update des Memo mag ja ein paar Minuten dauern, das will ich mir nicht antun. Dadurch verschwindet die Messdifferenz im Nirvana.[/edit]

[Hawkeye219]

Hallo Hansa,

ich möchte ja jetzt kein Spielverderber sein, aber hast du die beiden Blöcke einmal vertauscht?

Gruß Hawkeye

[Muetze1]

... und ich verstehe bei den ganzen Vorschlägen hier nicht, warum ihr alle die ständig reallocation der StringList mit messt, anstatt schon vor der jeweiligen Schleife einfach Count entsprechend zu setzen (oder alternativ Capacity).

[inherited]

Zitat:

Zitat von thkerkmann

Damit ist der Code von inherited IMHO unschlagbar der schnellste und eleganteste.

Leider nicht. Da ich hier das Exchange selber implementiere weil ich nicht wusste das es das schon gibt.
Ich benutze einen temporären string und mache wüßte Stringzuweisungen, das kostet Zeit. Wenn man den Block dann aber durch das StringListen eigene Exchange ersetzt hat man ziemlich exakt die exchange-methode und müsste vergleichbar schnell sein.

[himitsu]

Weil ich's grade seh und danach keiner mehr darauf eingegangen ist....

Zitat:

Zitat von bluesbear (Beitrag 750638)

Zitat:

Zitat von DeddyH

Ist TStringList.CustomSort die Antwort auf Deine Frage? :mrgreen:

Ich denke nein, Tim :mrgreen:

Wieso nicht?

Die Liste soll ja schließlich umsortiert werden.
Die vorhandene Standardsortierung sortiert es zwar alphabetisch, aber in aufsteigender Richtung.
Läßt man nun die Liste sortieren und gibt dabei eine Vergleichsfunktion an, welche andersrum vergleicht, dann wird die Liste nun in absteigender Richtung sortiert, also ist es genu die Lösung für das Problem der Ausgangsfrage (im Zusammenhang mit den Beispleidaten).



Soll aber die Liste umgedreht werden, unabhängig von einer eventuell vorandenen Sortierung, bzw. wenn es unsortiert ist, dann ist natürlich Exchange die Lösung.
OK und natürlich auch, wenn es möglichst schnell "umsortiert" werden muß und es dabei auf jede Nanosekunde drauf ankommt.


Nja, aber da hier oftmals die Daten von einer Liste in eine andere kopiert werden, dann kann man es sich überlegen
ob man die Daten gleich richtig läd und sortiert ... dann kann man sie mit AddStrings oder sonstwie in einem Schwung übergeben,
bzw. ob man sie gleich in die richtige Komponente läd und da "sortiert",
oder ob man sie eben ganz einfach in umgekehrter Reihenfolge in die andere Liste überträgt. (downto oder mathematisch den Index umkehreren)

[waterboy]

Zitat:

Zitat von Klaus01 (Beitrag 750641)

.. ist denn TStringList.exchange nicht ehr für soetwas gut?

Delphi-Quellcode:

j:=0;
for i:=daten.count -1 downto (daten.count -1) div 2 do
  begin
    daten.exchange(i,j);
    inc(j);
  end;

[ungetestet)

Aus der Hilfe zu Exchange:
Swaps the position of two strings in the list.

procedure Exchange(Index1, Index2: Integer); override;

Description

Call Exchange to rearrange the strings in the list. The strings are specified by their index values in the Index1 and Index2 parameters. Indexes are zero-based, so the first string in the list has an index value of 0, the second has an index value of 1, and so on.

If either string has an associated object, Exchange changes the index of the object as well.

Warning: Do not call Exchange on a sorted list except to swap two identical strings with different associated objects. Exchange does not check whether the list is sorted, and can destroy the sort order of a sorted list.

Grüße
Klaus

Super, klasse. Funktioniert einwandfrei. Vielen Dank, Klaus.
Warum es keine direkt Funktion in Delphi gibt (wie in Python z.B.) verstehe ich nicht...

viele Grüße

rainer

[freimatz]

Zitat:

Zitat von waterboy (Beitrag 1518013)

Warum es keine direkt Funktion in Delphi gibt (wie in Python z.B.) verstehe ich nicht...

Ich schon. Vermutlich weil es nur Dinge gibt die man auch braucht. :twisted:

Natürlich wird das Umkehren einer Liste schon benötigt. Aber meistens sind es dann nicht einfache Listen sondern gleiche komplexere Datensätze die man in einem Grid hat und dann oft auch nach allen Spalten sortieren lassen kann.

Wofür brauchst Du denn das?