TList Filterfunktion

[Henriko]

Morgen zusammen!

Ich programmiere im Moment ne kleine "Verwaltungssoftware" für nen Freund. Es ähnelt im Prinzip nem Karteikartensystem, wo er kleine Datensätze mit Name, Telefon und nem kurzen Kommentar speichern kann. Dieser Datensatz wird dann in ner Liste vom Typ TList gespeichert.
Die Namen werden dann in ner ListBox angezeigt und wenn er drauf klickt werden alle Daten in nem Feld neben der ListBix angezeigt.

Jetzt will ich halt, ne Prozedur schreiben, die es ermöglicht, die Elemente der Liste nach bspw. Namen ordnet. Ich hab schon viel versucht, aber es will einfach nicht laufen!

Mein Plan war eben Mit ner For Schleife die ganze Liste durchzugehen. Dann in eine VAriabel "aktuell" das aktuelle Elemente einzulesen und in die Variabel "naechstes" das folgende Element(aktuell.next) zu speichern. Dann per IF Abfrage den aktuellen Nachnamen mit dem naechsten Nachnamen UND den "naechstnaechsten" (Sorry ) Nachnamen mit dem mittleren Vergleichen. Ziel ist es also zwei Elemente zu finden, ZWISCHEN die das aktuelle eingeordnet werden kann! Dann soll das ganze in ne zweite temporäre Liste geschrieben werden, die dann auf die "richtige" Liste übertragen wird... Problem ist aber, dass dieses Vorgehen nicht klappt wenn die Liste am Anfang noch leer ist, weil die IF Funktion eben nicht erfüllt wird :/ ICh hoffe ihr könnt mir helfen und den Code schonmal im Anhang !

Delphi-Quellcode:

procedure TForm1.DBOrdnen(o:TListBox);
VAR x,i:integer;
VAR aktuell, naechstes:TELement;
begin

Datanbank.AnAnfang;

FOR x:=1 TO Datenbank.getAnzahl DO
BEGIN
aktuell:=Datenbank.getaktuell;
naechstes:=aktuell.next;

IF (aktuell.Nachname<naechstes.Nachname) AND (naechstes.Next.Nachname > naechstes.Nachname) THEN tempDB.EinfuegenVor(aktuell);

Datenbank.Vor;

END;

[CCRDude]

Ich hab hier mal vor Ewigkeiten etwas eingestellt: CollectionTemplater.

Ist ein Hilfsmittel, das Code für Collections erzeugt. Suchen und auch Filtern gehört da zum generierten Code gleich dazu (genauso wie Laden und Speichern aus XML, INI und Datenbanken, letzteres evtl. noch nicht in der dortigen Version).

[p80286]

So richtig verstanden habe ich nicht, was Du vorhast.

Zitat von Henriko:

Jetzt will ich halt, ne Prozedur schreiben, die es ermöglicht, die Elemente der Liste nach bspw. Namen ordnet. Ich hab schon viel versucht, aber es will einfach nicht laufen!

Hierfür gibt es TList.Sort(Vergleichsfunktion); wobei Du die entsprechende Vergleichsfunktion selbst schreiben mußt.

Oder falls Du unbedingt die Listboxeinträge sortieren willst, schau mal hier herein.
Ist aber nicht zu empfehlen.

Gruß
K-H

[DeddyH]

Ist das wirklich eine TList? Anhand des Codes würde ich eher auf eine verkettete Liste schließen.

[Jumpy]

Ansonsten gibt es doch hier im Forum ein Tutorial zu Sortier-Algorithmen, vllt. wär das ja ein Anfang, wenn man es selber zu Fuß machen will?

[p80286]

Ich hab da was aus TP Zeiten ausgegraben, es muß also auf jeden Fall überarbeitet werden:

Delphi-Quellcode:

type
  sortpoint =^sorts;
  sorts     = record next    :sortpoint;    {-  4 -}
                     last    :sortpoint;    {-  4 -}
                     satz    :string;       { +1  -}
              end;

var
  markpoint:^integer;
  lsterst :sortpoint;
  lstlezt :sortpoint;
  actsatz :sortpoint;
  sc      :longint;
  c       :integer;         { z„hler sc-    lc-L„ufe c-geschriebeneS.}
  hilfp   :string[5];
  cc      :integer;

procedure HEAPSORT; (*..............................................*)
var
    helpp  :sortpoint;
    medium :sortpoint;   { mittleres Element }
    klein  :sortpoint;   { Kleineres Element }
    gross  :sortpoint;   { GrӇeres Element  }
    n,m,i  :integer;


begin
  { -----------------------------------------INITIALISIEREN -----------}
  n:=0;
  m:=0;
  medium :=lsterst;                  {-- erstes E = MittelElem --}
  klein  :=medium;
  gross  :=medium;
  lstlezt:=lsterst^.next;
  medium^.last:=nil;
  medium^.next:=nil;
  { ----------------------------------------- SORTIEREN ---------------}
  repeat
    actsatz:=lstlezt;
    lstlezt:=lstlezt^.next;
    if actsatz^.satz<medium^.satz then begin  {------------------}
      inc(n,1);         {----------------- actsatz kleiner mittlerer satz --}
      if actsatz^.satz<klein^.satz then begin  {-- act<klein -----}
        if klein^.last=nil then begin
          klein^.last:=actsatz;
          actsatz^.next:=klein;
          klein:=actsatz;
          klein^.last:=nil;
        end
        else begin
          repeat
            helpp:=klein;
            klein:=klein^.last;
          until (klein^.satz<=actsatz^.satz) or (klein=nil);
          helpp^.last:=actsatz;
          actsatz^.last:=klein;
          actsatz^.next:=helpp;
          klein^.next:=actsatz;
          klein:=actsatz;
        end;
      end     { -------------------- actsatz< klein -------------------}
      else begin        {----------- actsatz>= klein-------------------}
        helpp:=klein;
        repeat
          helpp:=helpp^.next;
        until helpp^.satz>actsatz^.satz;
        klein:=helpp^.last;
        helpp^.last:=actsatz;
        klein^.next:=actsatz;
        actsatz^.next:=helpp;
        actsatz^.last:=klein;
      end;
    end   {------------ act<medium ----------------------------------- }
    else begin  {-------------------  actsatz>= medium --------------- }
      inc(m,1);
      if gross^.satz<=actsatz^.satz then begin  { gross<=act. ---}
        if gross^.next=nil then begin
          gross^.next:=actsatz;
          actsatz^.last:=gross;
          gross:=actsatz;
          gross^.next:=nil;
        end
        else begin
          repeat
            helpp:=gross;
            gross:=gross^.next;
          until (gross^.satz>actsatz^.satz) or (gross=nil);
          helpp^.next:=actsatz;
          actsatz^.last:=helpp;
          actsatz^.next:=gross;
          gross^.last:=actsatz;
          gross:=actsatz;
        end
      end
      else begin     {------------------ gross>actsatz -----------------}
        repeat
          gross:=gross^.last;
        until gross^.satz<=actsatz^.satz;
        helpp:=gross;
        gross:=gross^.next;
        helpp^.next:=actsatz;
        actsatz^.last:=helpp;
        actsatz^.next:=gross;
        gross^.last:=actsatz;
        gross:=actsatz;
      end; {---- gross>actsatz -----------------------------------------}
    end; {-------------- actsatz>=medium ----------------------------- }
    { ------------ ende Einf�gen ------------------------------------- }
    (*
    gotoxy(5,19);
    writeln(n:5,m:6);
    *)
    if abs(n-m)>200 then begin
      if m>n then begin
        for c:=1 to 50 do medium:=medium^.next;
        n:=n+50;
        m:=m-50;
      end
      else begin
        for c:=1 to 50 do medium:=medium^.last;
        m:=m+50;
        n:=n-50;
      end;
      if klein^.last<>nil then
        repeat
          klein:=klein^.last
        until klein^.last=nil;
      if gross^.next<>nil then
        repeat
          gross:=gross^.next
        until gross^.next=nil;
    end;
  until lstlezt=nil;
  { -------------------- ENDE SORTIEREN ------------------------------ }
  if klein=nil then klein:=medium;
  if klein^.last <>nil then repeat
    klein:=klein^.last;
  until klein^.last=nil;
  lsterst:=klein;
  writeln('verarbeitete S„tze: ',n+m+1);
end; {------------ HEAPSORT ------------------------------------------- }

Gruß
K-H