e-mail adressen ordnen im memo

[biby90]

hi leute,
ich habe jetzt eine ausbildung zur fachinformatikerin angefangen habe jedich fast null vorkenntnisse.
jetzt habe ich die aufgabe bekommen die e-mail liste in einem Memo zu ziehen und ein programm zu erstellen die das ganze alphabetisch sortiert.
ich habe eine kleine ahnung wie ich es hinbekommen könnte.... aber weiß nicht wie ich anfangen soll.

danke im vorraus.

[sirius]

Kannst du es etwas ausführlicher formulieren?

Woher ziehst du die Liste (mit Drag and Drop?)?
Nach was sortieren? einfach nach Alphabet oder auch nach Domains...

mfg
sirius


PS: Wieso fängt man mit 0 Vorkenntnissen eine Ausbildung zur Fachinformatikerin an? Gestern noch Praktikum, damit müsstest du doch wissen, was auf dich zukommt.
Nach deinen bisherigen Fragen würde ich dir dringend raten nicht von einer Aufgabe zur nächsten zu rennen, sondern sich mit einem Buch mal Grundlagen anzueignen.

[biby90]

also wenn neue dazu kommen sollen sie auf knopfdruck immer neu sortiert werden.... also zeile für zeile wenn man neue in das memo eingetragen hat


naja bin erst seit einer woche hier und habe noch kein buch -.-
ach und die anderen aufgaben sind ja fertig^^

[Angel4585]

Schau dir mal Sortieralgorithmen an, ich denke darum geht es deinem Ausbilder grad.
BubbleSort ist für den Anfang ganz ok, dann sollten aber schon bald InsertionSort, SelectionSort, QuickSort und ShellSort kommen :)
RadixSort schaut man in der Ausbildung garnicht an glaub ich :gruebel:

[biby90]

ja er meinte grad ich soll mir kopfschleifen, bubble sort und string analysen ansehen.
mal gucken was ich herausbekomme.
ich werde euch meine erfolge mitteilen ^^

[biby90]

könnt ihr mir sagen wie ich den bubblesort jetzt die positionen tauschen lasse?
wäre total lieb von euch

[DeddyH]

TStrings.Exchange dürfte zielführend sein.

[biby90]

also ich bin jetzte bis dahin gekommen

Delphi-Quellcode:

unit sortieren;

interface

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

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  i: Integer; //Position
  Done: Boolean; //Fertig oder Nicht
  Adresse: String; //E-Mail Adressen


implementation


{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
 Memo1.Text;
 begin;
    Done:= false;
    begin;
      i:=0;
      Done:= true;
      begin;
        While i < Adresse do
          if Adresse[i] > Adresse[i+1] then // wenn A größer als +1 dann...
           Adresse[i] Adresse[i+1]; //Adressen tauschen... wie?
           Done:= false;
      end;
      i:= +1;
    end;
 end;
end;

vergesst das ding es geht nicht also denk ich nochmal nach

[Angel4585]

warum hast du da mehrere begin und end?
in Adresse hast du alle adressen drin?
Dann kannst über Adresse[i] nur auf ein zeichen einer adresse zugreifen.
Schau dir mal TMemo.Lines an, das ist die Klasse TStrings.

tauschen:

Delphi-Quellcode:

hilfsvariable = Adresse[i]
Adresse[i] = Adresse[i+1]
Adresse[i+1] = hilfsvariable

[biby90]

mein ausbilder möchte es so er sagt dann ist es übersichlicher.... ich persönlich finde es etwas verwirrend

[DeddyH]

Was soll denn das Memo1.Text bewirken? Wieso vergleichst Du Strings (Adresse) mit Integers (i)?

[biby90]

ja hab ich auch gemerkt. naja die e-mail adressen sollen eben in das memo geschrieben werden.
also habs nochmal umgeschrieben aber es funktioniert nicht so wie ich es haben will

Delphi-Quellcode:

var
  Form1: TForm1;
  i : Integer; //Position
  Done: Boolean; //Fertig oder Nicht
  hilfe: String; //E-Mail Adressen
  Adresse: array of String;

implementation


{$R *.dfm}



procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Text;
  begin;
    repeat
      done:= true;
      for i:=Low(Adresse) to High(Adresse) -1 do
      begin;
        if Adresse[i] > Adresse [i+1] then
        begin;
          hilfe:=Adresse[i];
          Adresse[i]:=Adresse[i+1];
          Adresse[i+1]:=hilfe;
          done:=false;
        end;
      end;
    until done;
  end;
end;

end.

[DeddyH]

Adresse ist ja auch leer, was willst Du da sortieren? Außerdem kannst Du Dir das Array doch komplett sparen, Du kannst auf die Art und Weise doch gleich Memo1.Lines nehmen, nur dass Du dort nicht Low() und High() verwendest, sondern von 0 bis Count - 2 durchgehst.

[biby90]

ja er ist leer weil der button sich das zu sortierende aus dem memo holen soll.

[DeddyH]

Das tust Du aber nicht, außerdem ist es wie gesagt unnötig.

[biby90]

na dann gebt mir doch mal einen tipp.... zusagen ja oder nein ist nicht gerade hilfreich

[DeddyH]

Du musst aber auch lesen, was wir schreiben.

Delphi-Quellcode:

for i := 0 to Memo1.Lines.Count - 2 do
  if Memo1.Lines[i] > Memo1.Lines[i + 1] then

[biby90]

mach ich ja -.-

geht das denn mit buchstaben?

[himitsu]

Tipp:

Erstmal verabschiede dich von globalen Variablen.

Delphi-Quellcode:

  i : Integer; //Position
  Done: Boolean; //Fertig oder Nicht
  hilfe: String; //E-Mail Adressen
  Adresse: array of String;

Das gehört alles als lokale Variablen in das Button-Klick-Ereignis.



Entweder du übergibst den Inhalt von Memo.Lines an dein Adresse
(Delphi macht sowas nicht von alleine, denn woher soll es denn wissen was du machen willst)

oder du nimmst statt Adresse das Memo.Lines in der Sortierfunktion.

[biby90]

ok ich versuchs mal

[biby90]

hundert prozentig... danke danke danke!!!

[biby90]

da war ich die ganze zeit so nah dran und doch so weit entfernt
:oops:

[DeddyH]

Aber letztendlich konnten wir Dich ja noch "hinschubsen" :mrgreen:

[biby90]

jop mein freund sagt auch immer wenn er mir mathe bei bringt dass ich immer mal ein ar**hvoll brauche^^

[biby90]

eine frage habe ich noch für mein eigenes verständnis....
was hat es mit dem auf sich:

Delphi-Quellcode:

 for i:=0 to Memo1.Lines.Count - 2 do

[RWarnecke]

Mit der FOR-Schleife wird jede einzelne Zeile vom Memo durchgegangen und alles was zwischen begin und end für die FOR-Schleife steht, wird ausgeführt.

[himitsu]

Der Index des Arrays, bzw. der StringListe geht von

Delphi-Quellcode:

0 bis Length - 1

, bzw.

Delphi-Quellcode:

0 bis Count - 1

.

Da du jeweils den aktuellen mit dem nachfolgenden Wert vergleichst, mußt du für den ersten Wert also von

Delphi-Quellcode:

KleinsterIndex bis HöchsterIndex - 1

durchlaufen, also

Delphi-Quellcode:

0 bis Count - 1 - 1

.

[biby90]

danke... dann hab ihr erstmal übers wochenende ruhe vor mir^^

[DeddyH]

Oder etwas anders ausgedrückt: Listen (also auch TStrings) sind 0-indiziert, d.h. das erste Element hat den Index 0. Count gibt die Anzahl der enthaltenen Elemente zurück, da das erste den Index 0, das zweite den Index 1 usw. hat, muss das letzte Element also den Index Count - 1 haben. So, da wir ja jedes Element mit seinem Nachfolger vergleichen wollen, darf die Schleife nur bis Count - 2 (also vorletztes Element) laufen, da wir sonst hinter der Liste lesen würden.

[biby90]

zuhause probier ichs nochmal mit einer quicksort... das dauert ja ewig bis die 4000 e-mails geordnet sind xD

[DeddyH]

Das geht schon schneller, wenn Du am Anfang Memo1.Lines.BeginUpdate und am Ende Memo1.Lines.EndUpdate aufrufst.

[Bjoerk]

Die Bremse dürfte hier dennoch (trotz BeginUpdate/EndUpdate) das Memo sein. Vielleicht temporär in einer SL speichern.

Delphi-Quellcode:

var
  SL: TStringList;
begin
  SL:= TStringList.Create;
  SL.Assign(Memo1.Lines);
  EmailAddressesSort(SL);
  Memo1.Lines.Assign(SL);
  SL.Free;
end;

[DeddyH]

Und was soll das bringen? Wenn das Memo nicht neu gezeichnet wird, haben wir doch denselben Effekt ohne Hin- und Herkopiererei.

[Bjoerk]

Probier's halt aus.

Delphi-Quellcode:

function GetNamePart(const s: string): string;
var
  I: integer;
begin
  Result:= '';
  for I:= 1 to Length(S) do
    if S[I] = '@' then
    begin
      Result:= Copy(S, 1, I-1);
      Break;
    end;
end;

function GetDomainPart(const s: string): string;
var
  I: integer;
begin
  Result:= '';
  for I:= 1 to Length(S) do
    if S[I] = '@' then
    begin
      Result:= Copy(S, I+1,  Length(S)-I);
      Break;
    end;
end;

procedure QuickSort(const Strings: TStrings; L, R: Integer);
var
  I, J, K: Integer;
  P: string;
begin
  repeat
    I:= L;
    J:= R;
    K:= (L + R) shr 1;
    P:= AnsiLowerCase(Trim(Strings[K]));
    repeat
      while AnsiLowerCase(Trim(Strings[I])) < P do Inc(I);
      while AnsiLowerCase(Trim(Strings[J])) > P do Dec(J);
      if I <= J then
      begin
        Strings.Exchange(I, J);
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then QuickSort(Strings, L, J);
    L:= I;
  until I >= R;
end;

procedure EMailAddressesSort(const Strings: TStrings; const SortByDomain: boolean = false);
var
  I, J: integer;
  T1, T2, D1, D2: string;
  ExChange: boolean;
begin
  Strings.BeginUpdate;
  if not SortByDomain then
    QuickSort(Strings, 0, Strings.Count-1)
  else
  begin
    for I:= 0 to Strings.Count-2 do
      for J:= I+1 to Strings.Count-1 do
      begin
        T1:= AnsiLowerCase(Trim(Strings[I]));
        T2:= AnsiLowerCase(Trim(Strings[J]));
        ExChange:= false;
        if T1 > T2 then
          ExChange:= true
        else
        begin
          D1:= GetDomainPart(T1);
          D2:= GetDomainPart(T2);
          if D1 > D2 then
            ExChange:= true
          else
            if D1 = D2 then
              if GetNamePart(T1) > GetNamePart(T2) then ExChange:= true;
        end;
        if ExChange then Strings.Exchange(I,J);
      end;
  end;
  Strings.EndUpdate;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  SL: TStringList;
begin
  SL:= TStringList.Create;
  SL.Assign(Memo1.Lines);
  EmailAddressesSort(SL);
  Memo1.Lines.Assign(SL);
  SL.Free;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  EmailAddressesSort(Memo1.Lines);
end;

[DeddyH]

Wenn Du mir jetzt noch erklärst, wieso Du einmal ein Memo und einmal eine TStringlist übergibst anstatt einfach nur TStrings und damit nur eine einzige Sort-Routine benötigst, dann probiere ich es vielleicht tatsächlich.

[edit] Und wenn man schon auf Quicksort umschwenkt: das bringt die TStringList schon von Haus aus mit. [/edit]

[Bjoerk]

daran hatte ich nicht gedacht, da hast du natürlich recht. aber wie kriegt man dann den lowercase (bei stringlist) in den algo rein?

Edit: DeddyH, hab's entsprehend überarbeitet.
Ist aber immer noch ein erheblicher Geschwindigkeitsunterschied!?

[DeddyH]

In der allergrößten Not über CustomSort. In der Hilfe steht etwas von einer Property CaseSensitive, aber ich weiß nicht, seit wann es die gibt.

[himitsu]

Nee, die Bremse ist die Speicherverwaltung des Memos.
BeginUpdate kann schon viel erreichen, aber ein externes Sortieren kann schneller sein.

Zumindestens ein Sortierverfahren mit möglichst wenigen lesenden und vorallem schreibenden zu Griffen kann da schon so einiges rausholen.




Bei einer TStringList liegen die einzelnen Strings (Zeilen) schon einzeln im Speicher vor und man kann da sehr schnell drauf zugreifen und auch was ändern/verschieben, da nur Zeiger verschoben werden.

Beim Memo liegt alles als ein einziger großer String vor, wo beim Tausch zweier Zeilen schonmal der gesamte Memo-Inhalt mehrmals umkopiert werden muß.

[DeddyH]

Findet Ihr es nicht selber albern, bei einem Bubblesort über Optimierungen zu schwadronieren? Da ist doch jede Anstrengung verschwendete Zeit, das Ganze ist ja wohl eher als Übungsaufgabe in der Ausbildung zu sehen.

[Bjoerk]

Sehe jetzt nicht, daß hier jemand albern ist. BTW: Wenn in Abhängigkeit sortiert werden soll, geht der Quciksort nicht, da dieser auf <= prüft.