Array sortieren

[Marcel1990]

Hallo,
ich bin neu in der Programmierung und hab eine höchstwahrscheinlich leicht zu beantwortbare Frage, zu der ich keine Antwort im Internet finden konnte. Ich habe eine Klasse (TPerson) durch ein Array sagen wir mal 100-mal erstellt, in ihr kann der Nutzer Merkmale wie Name, Vorname, Alter usw. eingeben, nun möchte ich diese Personen in einer Liste nach einem Merkmal sortiert ausgeben. Wie mache ich das :? ? (Ein Sortierverfahren hab ich schon im Kopf, ich weiß nur nicht wie ich auf eines der Merkmale zugreife.)

[Delphi-Laie]

Bei hundert Leutchens reicht ein einfacher, elementarer Sortieralgorithmus. Welcher schwebt Dir denn vor?

Die Instanzen von TPerson sind die Sortierelemente. Deren Merkmale, die zum Sortieren relevant sind (auf die wird zwecks Vergleichens lesend zugegriffen), sind die Sortierschlüssel.

Und dann benötigst Du noch eine weitere Instanz von TPerson für die Tauschvorgänge als Puffer.

Zeig doch mal ein bißchen Quellcode, wieweit Du schon kamst.

[haentschman]

Moin...:P

Zitat:

durch ein Array sagen wir mal 100-mal erstellt

[Provokation On]...ein Array ist das was heute eine generische Liste ist. :thumb:

Auch wenn man in der Programmierung neu ist, darf man auch die modernen Sprachkonstrukte benutzen. Da du nicht deine Delphi Version hinterlegt hast (ich tippe auf Berlin Starter 8-)), gebe ich dir trotzdem mal die Links zu der Doku.
Liste:
http://docwiki.embarcadero.com/Libra...ectList.Create
http://docwiki.embarcadero.com/Libra...ults.IComparer
Sortieren:
http://docwiki.embarcadero.com/Libra...ons.TList.Sort

8-)

[p80286]

Der TE versucht wohl gerade an Hand eines Lehrbuches, das Sortieren zu lernen. Auch wenn eine (generische) Liste, die bessere Wahl wäre, beziehen seine Beispiele sich wohl auf ein Array. Darum kann er zunächst einmal nichts für die etwas krude Fragestellung.

@Marcel1990
Was hast du denn bisher?

Gruß
K-H

[HolgerX]

Hmm..

Und außerdem ist das Sortieren eines Array 'bildlich' besser zu erkennen/verstehen, wie bei bei einer generischen Liste, welche durch .Sort viele Dinge versteckt, wie z.B. das Verschieben/Tauschen von Positionen.

Gerade, wenn es ums lernen geht, sollte mehr 'back to the roots' gemacht werden, da vieles in aktuellen Konstrukten versteckt wird.
Spätestens, wenn es mehr in Richtung Windows API geht, muss mann wissen, was Arrays sind (inl. Speichermanagment)! Da gibt es keine Generischen Listen.

Viele Lehrbücher und Tutorials arbeiten mit Delphi 6/7, teilweise, weil sie aus der Zeit stammen!
Dazu sind Delphi 6/7 'Lightwigth' und laufen auch auf älterer 'Schulhardware'.

Ich arbeite viel mit TList (ohne generisch), wohl auch weil ich Delphi 6 verwenden muss..

Und, bitte nicht 'Wieso noch Delphi 6, Wieso nicht 10.x'! Das würde nicht in diesen Thread gehören und wurde schon zu oft breitgetreten.

[Delphi-Laie]

Sollte der Diskussioneröffner (warum meldet er sich nicht mehr?) tatsächlich Programmieranfänger sein, so ist es letztlich eine didaktisch-methodische Frage, ihn mit dem "Urschleim" (also Records und Arrays) sanft einzuführen oder gleich mit objektorientierten Dingen zu "erschlagen". Sicher steckt ersteres in letzterem mehr oder weniger drin, aber auch ersteres hat auch heutzutage noch seine Berechtigung.

Mathematik erlernt man ja auch nicht mit einer Einführung in die Differentialgeometrie und Topologie.

[Marcel1990]

Sorry erstmal, dass ich mich in den letzten zwei Tagen nicht gemeldet habe, hatte viel um die Ohren.
Also ich nutze Delphi 7 und mein Problem sieht wie folgt aus, ich möchte ein Array einer Klasse TPerson nach einem Kriterium sortieren, z.B der Größe der Personen und das dann anhand eines Memos ausgeben.

Delphi-Quellcode:

private
    Feld : array of TPerson;
    Groesse : array of real;
    Hilfe : array of TPerson;

Delphi-Quellcode:

procedure TListe.CreateArray;
var
  i : Integer;
begin
  SetLength(Feld, AnzahlPatienten-1);
  SetLength(Groesse, AnzahlPatienten-1);
  SetLength(Hilfe, AnzahlPatienten-1);
  for i := 0 to AnzahlPatienten-1 do begin
    Feld[i] := TPerson.Create;
    Hilfe[i] := TPerson.Create;
  end;
end;

Delphi-Quellcode:

function TListe.GetPerson(A : Integer) : TPerson;
begin
  Result := Feld[A];
end;

function TListe.GetArrayGroesse(A : Integer) : Real;
begin
  Result := Feld[A].GetGroesse;
end;

Delphi-Quellcode:

procedure TListe.SortGroesse;
var
  i, j : Integer;
  Hilf : Real;
  begin
    for i := High(Feld) downto Low(Feld) do
      for j := 0 to i-1 do
        if Groesse[j] > Groesse[j+1] then begin
          Hilf := Groesse[j];
          Groesse[j] := Groesse[j+1];
          Groesse[j+1] := Hilf;
          Hilfe[j] := Feld[j];
          Feld[j] := Feld[j+1];
          Feld[j+1] := Hilfe[j];
        end;
  end;

Delphi-Quellcode:

procedure TFensterFrm.BtnEinlesenClick(Sender: TObject);
begin
  if (EdtAnzahl.Text = '') or (AlterEdt.Text = '') or (GroesseEdt.Text = '') or (NameEdt.Text = '') or (EdtAnzahlPersonen.Text = '') 
    then ShowMessage('Bitte Fehlende Daten eingeben')
      else begin
  Anzahl := StrtoInt(EdtAnzahl.Text)-1;
  Liste.GetPerson(Anzahl).SetName(NameEdt.Text);
  Liste.GetPerson(Anzahl).SetGroesse(StrToFloat(GroesseEdt.Text));
  Liste.GetPerson(Anzahl).SetAlter(StrToFloat(AlterEdt.Text));
  Liste.GetArrayGroesse(Anzahl);
  Inc(Anzahl);
  EdtAnzahl.Text := InttoStr(Anzahl+1);
 end;

end;

Delphi-Quellcode:

procedure TFensterFrm.BtnSortGroesseClick(Sender: TObject);
var
  i : Integer;
begin
  Liste.SortGroesse;
  MemListe.Clear;
  for i := 0 to AnzahlPersonen-1 do begin
    MemListe.Lines.Add('Name: '+ Liste.GetPerson(i).GetName +'  Größe:'+ FloatToStrF(Liste.GetArrayGroesse(i),ffFixed,8,2) +'   Alter:'+ FloatToStrF(Liste.GetPerson(i).GetAlter)
end;

Irgendwo hier müsste sich ein logischer Fehler befinden, denn das Programm läuft, aber es liefert nicht das gewünschte Ergebnis.

[himitsu]

System.Generics.Collections.TArray.Sort :stupid:

[HolgerX]

Zitat:

Zitat von himitsu (Beitrag 1357362)

System.Generics.Collections.TArray.Sort :stupid:

Nicht gelesen: Delphi 7 ;)

[p80286]

Delphi-Quellcode:

private
     Feld : array of TPerson;
     Groesse : array of real;
     Hilfe : array of TPerson;

Falls Du mit dem Inhalt von

Delphi-Quellcode:

Groesse

Delphi-Quellcode:

Feld

oder

Delphi-Quellcode:

Hilfe

sortieren willst, vergiss es!

Delphi-Quellcode:

TPerson

sollte die Eigenschaft enthalten, die Du zum sortieren benutzen willst.

Wie sieht denn

Delphi-Quellcode:

TPerson

aus?

Gruß
K-H

[himitsu]

Zitat:

Zitat von HolgerX (Beitrag 1357374)

Nicht gelesen: Delphi 7 ;)

Hmmmmmmmm, neee?
Ach, da unten, heimlich in dem überlangen Beitrag versteckt? (musste oft F3 drücken, um es zu finden)

Aber das Problem läßt sich ja inzwischen notfalls leicht lösen. :stupid:

[Marcel1990]

Also TPerson bekommt anhand von Set-Prozeduren Werte zugeschrieben und durch Get-Funktionen werden sie abgerufen.

Delphi-Quellcode:

type
  TPerson = class(TObject)
    private
      Name      : string;
    Groesse : real;
    Alter : Integer;
   public
    constructor Create;
    procedure SetName (n : string);
    function  GetName : string;
    procedure SetGroesse (gr : real);
    function  GetGroesse : real;
    procedure SetAlter (alt : Integer);
    function  GetAlter : Integer;

[Luckie]

Name ist eine etwas unglückliche Bezeichnung. Wie du siehst markiert die IDE ihn fett, wie Schlüsselwürter.

[himitsu]

Und wenn du die Felder so undekoriert benennst, wie würdest du dann die Property benennen, welche man an die Getter und Setter hängen könnte?

[HolgerX]

Zitat:

Zitat von Marcel1990 (Beitrag 1357398)

Also TPerson bekommt anhand von Set-Prozeduren Werte zugeschrieben und durch Get-Funktionen werden sie abgerufen.

Delphi-Quellcode:

type
  TPerson = class(TObject)
    private
      Name      : string;
    Groesse : real;
    Alter : Integer;
   public
    constructor Create;
    procedure SetName (n : string);
    function  GetName : string;
    procedure SetGroesse (gr : real);
    function  GetGroesse : real;
    procedure SetAlter (alt : Integer);
    function  GetAlter : Integer;

Hmm..

ich würde deine Class wohl eher so deklarieren:

Delphi-Quellcode:

type
  TPerson = class(TObject)
  private
    FNachName : string;
    FGroesse : double;
    FAlter : Integer;
  protected
    procedure SetName(Value : string);
    function GetName : string;
    procedure SetGroesse (Value : double);
    function GetGroesse : double;
    procedure SetAlter (Value : Integer);
    function GetAlter : Integer;
  public
    constructor Create;
    property NachName : string read GetName write SetName;
    property Groesse : double read GetGroesse write SetGroesse;
    property Alter : Integer read GetAlter write SetAlter;
  end;

Oder (vereinfacht):

Delphi-Quellcode:

type
  TPerson = class(TObject)
  private
    FNachName : string;
    FGroesse : double;
    FAlter : Integer;
  protected
    procedure SetName(Value : string);
    procedure SetGroesse (Value : double);
    procedure SetAlter (Value : Integer);
  public
    constructor Create;
    property NachName : string read FNachName write SetName;
    property Groesse : double read FGroesse write SetGroesse;
    property Alter : Integer read FAlter write SetAlter;
  end;

[jaenicke]

Da das hier noch nicht erwähnt wurde, nur angedeutet:
Es gibt die aktuellste Version 10.1 als Starter Edition kostenlos.

Wenn du die Version 7 nicht von jemandem vorgegeben bekommen hast, würde ich gleich mit der neuen lernen. (Und wenn du die vorgegeben bekommen hast, gibt es ja vielleicht die Möglichkeit eines Wechsels. ;-))

Ansonsten kannst du bei Delphi 7 einmal in den mitgelieferten Beispielen schauen. Da sind Sortieralgorithmen als Beispiele enthalten.

[striderx]

wie wäre es denn hiermit (ohne Klasse):

Delphi-Quellcode:

type
  tPerson = record
              FNachName: String;
              FGroesse:  Double;
              FAlter:    Word;
            end;  

var
 aPersons:  Array of tPerson;
 SortMode:  Word = 1;

...
SetLength(aPersons, N + 1];     //+ 1 wg. des Elements 0


procedure SortPersons;         //Insertion-Sort

var
  I:  Word;
  J:  Word;

begin
  for I := 1 to Length(aPersons) - 1 do begin
      J := I;
      aPersons[0] := aPersons[I];
      while (J > 0) and (Less(aPersons[0], aPersons[J - 1])) do begin
        aPersons[J]:= aPersons[J - 1];
        Dec(J);
      end;
      aPersons[J]:= aPersons[0];
  end;
end

function  Less(X, Y:  Word):  Boolean;

var
  R:  Integer;

begin
  Result := False;
  case SortMode of
     1:  begin
           R := AnsiCompareText(aPersons[X].FNachname, aPersons[Y].FNachname);
           if  R < 0 then Result := True
           else if R = 0 then begin
              if aPersons[X].FAlter < aPersons[Y].FAlter then Result := True
              else if aPersons[X].FAlter = aPersons[Y].FAlter then begin
                 if aPersons[X].Groesse < aPersons[Y].FGroesse then Result := True;
              end;
         end;
     2:  begin
           ...
         end;
     3:  begin
           ...
         end;
end;

[p80286]

Delphi-Quellcode:

procedure TListe.SortGroesse;
var
   i, j : Integer;
   Hilf : Real;
   begin
     for i := High(Feld) downto Low(Feld) do
       for j := 0 to i-1 do
         if Groesse[j] > Groesse[j+1] then begin
           Hilf := Groesse[j];
           Groesse[j] := Groesse[j+1];
           Groesse[j+1] := Hilf;
           Hilfe[j] := Feld[j];
           Feld[j] := Feld[j+1];
           Feld[j+1] := Hilfe[j];
         end;
   end;

Du willst hier in einer Liste sortieren, Deine Daten stehen aber in Arrays!
Was Du vielleicht willst wäre:

Delphi-Quellcode:

for i := High(Feld) downto Low(Feld) do
       for j := 0 to i-1 do
         if Feld[j].Groesse > Feld[j+1].Groesse then begin
           Hilf := Feld[j];
           
usw.

end;

(ich bin mir über die korrekte Syntax nicht so ganz sicher)
(und auch ich plädiere für den gebrauch einer Liste)


Gruß
K-H

[Bjoerk]

Wenn TPerson eine Klasse ist könnten TPeronen eine TObjectList sein.
Unter D7 z.B. so:

Delphi-Quellcode:

  TPersonen = class(TObjectList)
  private
    function GetItems(Index: integer): TPerson;
  public
    property Items[Index: integer]: TPerson read GetItems; default;
    procedure SortByGroesse;
  end;

..

{ TPersonen }

function TPersonen.GetItems(Index: integer): TPerson;
begin
  Result := TPerson(inherited Items[Index]);
end;

function GroesseCompare(A, B: TPerson): integer;
begin
  if A.Groesse > B.Groesse then
    Result := 1
  else
    if A.Groesse < B.Groesse then
      Result := -1
    else
      Result := 0;
end;

procedure TPersonen.SortByGroesse;
begin
  inherited Sort(@GroesseCompare);
end;

..

procedure TSomeForm.Button1Click(Sender: TObject);
var
  Personen: TPersonen;
  I, Index: integer;
begin
  Personen := TPersonen.Create;
  try
    for I := 1 to 10 do
    begin
      Index := Personen.Add(TPerson.Create);
      Personen[Index].Name := ..
      Personen[Index].Groesse := ..
      Personen[Index].Alter := ..
    end;
    Personen.SortByGroesse;
  finally
    Personen.Free;
  end;
end;

[Luckie]

Langsam. es handelt sich um einen Anfänger, der ein Übungsprogramm schreibt. Da nützen ihm weder hinweise auf aktuelle Delphi Versionen noch auf Sprachfeatures, die ihm die ganze Arbeit abnehmen.

[HolgerX]

Hmm..

Auch wenn er es eigendlich selber machen sollte.. ;)

Habe ich nach seiner Vorgabe ein kleines Demo erstellt: