Was ist schneller TComboBox oder TStringlist?

[Binärbaum]

Zitat von Hansa:

...
Deshalb : für so was sind dynamische Datenstrukturen gemacht (verkettete Listen -> Zeiger). Genau für solche Fälle. Fügt man immer nur das ein, was tatsächlich gebraucht wird und schreibt man allgemeingültige Prozeduren dafür, dann ist es fast egal ob es sich um 100 oder 500.000 Einträge handelt.

Ja, schon möglich aber:

Zitat von smart:

Ich habe eben nach einer Möglichkeit gesucht, diese schnell einzulesen und zu sortieren.

Das Einlesen ist ja noch nicht das Problem, da spielt es auch kaum eine Rolle, ob man (dynamische) Arrays oder verkettete Listen verwendet, da beim Einlesen höchstwahrscheinlich die Festplatte der Flaschenhals sein wird.
Allerdings sind Arrays für das Sortieren die bessere Wahl, da der Zugriff auf die einzelnen Elemente über den Index relativ schnell erfolgt. Bei verketteten Listen hingegen muss man immer erst die Liste vom Anfang an Element für Element durchlaufen bis man beim jeweiligen Element angekommen ist. Und bei ca. 50.000 Einträgen ist das schon ein erheblicher Nachteil, da man da im Mittel 25.000 Einträge durchlaufen muss, um auf ein beliebiges Element zuzugreifen (bei doppelt verketteten Listen wären es zwar "nur" noch 12.500, aber das ist auch noch zu viel).
Fazit: Beim Sortieren sind Array eindeutig schneller als verkettete Listen.

MfG
Binärbaum

[Edit]
Hier mal ein Beispiel, wie die Prozedur zum Einlesen aussehen könnte:

Delphi-Quellcode:

procedure Einlesen(dateiname: string; var arr: array of string; anzahl: Cardinal= 5000);
var zeilen, gr: Integer;
    dat: TextFile;    
begin
  gr:=anzahl;
  SetLength(arr, gr);
  zeilen:= 0;
  try
    Assign(dat, dateiname);
    Reset(dat); 
    while not Eof(dat) do begin
      zeilen:= zeilen+1;
      if zeilen>gr then begin 
        SetLength(arr, High(arr)+1001);
        gr:= High(arr)+1;
      end;
      ReadLn(dat, arr[zeilen-1]);
    end;
  finally
    Close(dat);
  end;
  SetLength(arr, zeilen);
end;

Zur Erklärung der Parameter:
dateiname ist der Name der Textdatei, die ausgelesen werden soll.
anzahl ist die geschätzte Anzahl der Zeilen (hier: 5000 als Standard).
arr ist der Array in den die Datei zeilenweise eingelesen wird.

Ein Beispielaufruf könnte dann so aussehen:

Delphi-Quellcode:

Einlesen('C:\Pfad\name.txt', meinArray, 2000);
//oder
Einlesen('C:\Pfad\name.txt', meinArray);
//entspricht Einlesen('C:\Pfad\name.txt', meinArray, 5000);

[/Edit Ende]

[Hansa]

Zitat von Binärbaum:

...Fazit: Beim Sortieren sind Array eindeutig schneller als verkettete Listen...

Verkettete Liste, das war ein Beispiel. Sonst nichts. Bei größeren Datenstrukturen macht man so was mit einem Baum. Oder eventuell mit einem Ring, sofern eine Richtung darstellbar ist. Dann braucht man nämlich den Zeiger von Position 49999 nur noch eins weiter zu setzen, um wieder am Anfang zu sein. Und selbst das ist egal. Man merkt sich sowieso den Anfang, das Ende usw.

Dann geht es nur noch darum, den Zeiger auf eine gewisse Position zu setzen. Und das geschieht mit minimalem Aufwand und geringstem Speicherbedarf. Ein Array (vor allem ein dynamisches) wird wohl intern auch in solche Strukturen zerlegt und dementsprechend behandelt.

Vielleicht taucht negaH noch auf, dann kann er ja mal erklären, wieviele Zugriffe man z.B. im DB Bereich braucht, um einen genau defininierten Datensatz aus einer Isam mit 50.000 Datensätzen herauszufischen. Wer will, kann ja mal schätzen und wird sich wohl wundern.

Zurück zur Frage : wer nicht weiß, was dynamische Strukturen sind, der soll sie eben nicht benutzen. Was bei der Combobox schneller sein soll, als bei der Stringliste ist mir rätselhaft. Ohne Beantwortung meiner beiden Fragen läßt sich schwer ein Tip geben, was jetzt wo gemacht werden soll/muß.

@Binärbaum : das sehe ich ja jetzt erst. Wo hast Du den Namen her ?

[Sharky]

Hai,

ich habe da eben mal etwas herum gespielt. Ich habe zum einen eine TComboBox auf der Form und eine TListBox. Ausserdem noch eine zur Laufzeit erzeugte TStringList. In alle drei Objekte habe ich dann eine Textdatei mit 50.000 Zeilen geladen (ohne sortierung).
Hier mal die Zeiten:

Code:

*  TStringList :      63 ms
*  TComboBox   :  50.750 ms
*  TListBox    :  51.200 ms

Beim einlesen ist die TStringList also die schnellste Variante.

[alcaeus]

Hallo Sharky,

hast du die ComboBox auch unsichtbar gemacht? Wenn die Box sichtbar ist dann geht doch viel Zeit fuer die Anzeige drauf.

Greetz
alcaeus

[Sharky]

Zitat von alcaeus:

... Wenn die Box sichtbar ist dann geht doch viel Zeit fuer die Anzeige drauf....

Hai alcaeus,

wenn ich die TCombobox.Visible := False setze sparte ich im Schnitt ca. 120 ms.
Es sieht so aus als wäre einfach bei der implementierung des LoadFromFile bei der TComboBox wesentich mehr overhead vorhanden.

[alcaeus]

Zitat von Sharky:

wenn ich die TCombobox.Visible := False setze sparte ich im Schnitt ca. 120 ms.
Es sieht so aus als wäre einfach bei der implementierung des LoadFromFile bei der TComboBox wesentich mehr overhead vorhanden.

Das ueberrascht mich jetzt, ich hab naemlich in den Sourcen nachgesehn, und TStringList.LoadFromFile sowie TComboBox.Items.LoadFromFile gehn beide auf TStrings.LoadFromFile, und dort wird mit TStrings.LoadFromStream gearbeitet. Von daher kann es nicht der Overhead sein. Hast du das Ausblenden auch mit der ListBox probiert? Evtl. kann auch ein BeginUpdate helfen.

Greetz
alcaeus

[Sharky]

Zitat von alcaeus:

... Hast du das Ausblenden auch mit der ListBox probiert? Evtl. kann auch ein BeginUpdate helfen.

Ein Begin/EndUpdate war auch mein gedanke. Hat aber nichts gebracht. Und auch bei der ListBox ist es egal ob Visible oder nicht.
Es ist echt interesant warum die TStringList bei mir da viel schneller ist.
Hast Du auch einmal einen Test gemacht?

[Edit]Ich habe mein Testprogramm man angehängt

[alcaeus]

Hallo Sharky,

hier mal meine Ergebnisse:

Code:

Added 50000 items to visible Listbox in 730 ms 
Added 50000 items to visible Listbox in 860 ms (using Begin/EndUpdate)
Added 50000 items to invisible Listbox in 931 ms 
Added 50000 items to invisible Listbox in 842 ms (using Begin/EndUpdate)
Added 50000 items to visible Combobox in 1320 ms 
Added 50000 items to visible Combobox in 1081 ms (using Begin/EndUpdate)
Added 50000 items to invisible Combobox in 1281 ms 
Added 50000 items to invisible Combobox in 1151 ms (using Begin/EndUpdate)
Added 50000 items to Stringlist in 60 ms 
Added 50000 items to Stringlist in 61 ms (using Begin/EndUpdate)


Added 100000 items to visible Listbox in 1703 ms 
Added 100000 items to visible Listbox in 1852 ms (using Begin/EndUpdate)
Added 100000 items to invisible Listbox in 2083 ms 
Added 100000 items to invisible Listbox in 2032 ms (using Begin/EndUpdate)
Added 100000 items to visible Combobox in 2423 ms 
Added 100000 items to visible Combobox in 2382 ms (using Begin/EndUpdate)
Added 100000 items to invisible Combobox in 2412 ms 
Added 100000 items to invisible Combobox in 2073 ms (using Begin/EndUpdate)
Added 100000 items to Stringlist in 49 ms 
Added 100000 items to Stringlist in 100 ms (using Begin/EndUpdate)

Die Testdateien enthielten einfach die Zahlen 1-50000 bzw. 100000, ich hatte sie zuvor per SaveToFile reingeschrieben. Das Begin/EndUpdate war nicht in der Zeitmessung enthalten, mich ueberraschen die Ergebnisse also schon. Was auch sehr eigenartig ist, ist dass die StringList bei 100000 Zahlen schneller laeuft als bei 50000

Bei deinem Test gabs die folgenden Ergebnisse:

Code:

TStringList: 110
TComboBox (sichtbar): 31616
TComboBox (unsichtbar): 30103
TListBox (sichtbar): 30704
TListBox (unsichtbar): 30724

Die Ergebnisse sind durchaus interessant...

Greetz
alcaeus

[Sharky]

Hai alcaeus,

ein Geheimniss das es zu lösen gilt

P.S.: Das deine Ergebnisse schneller sind dürfte daran liegen das ich durch meinen "Test-String" jede Zeile verlängert habe.

[SirThornberry]

der geschwindigkeitsverlust liegt in der schlechten umsetzung der Darstellung. Für unser Newsletterprogramm hab ich früher eine normales TListView genutzt (mit Beginupdate-EndUpdate). Damit hat das programm über 2 Minuten geladen. Inzwischen haben wir eine Skinbare Listview programmiert, man müsste also eigentlich von längerne Ladezeiten ausgehen weil ja noch hintergrundbilder etc. dazu kommen. Ergebnis ist aber das mit der neuen Skinbaren Listview das Programm in weniger als 10 Sekunden startet.

Allerdings haben wir auch darauf verzichtet das ganze über TStringlist umzusetzen beim laden, da bei dieser variante immer erst die Zeilenumbrüche gesucht werden müssen. Wir haben einfach immer die länge der zeile und dahinter die eigentliche Zeile gespeichert. Somit kann man beim einlesen einfach mit Stream.Read gleich die gesamte zeile lesen ohne sie später nochmal zu zerlegen müssen.

Manchmal muss man eben einfach das Rad neu erfinden um es wirklich rund zu bekommen.