Array sortieren

[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.