Sortieren mit direktem Auswahlort

[rebellxsky]

Hi Leute,

ich muss in der Schule die Arbeitsweise des Sortierverfahrens mit direktem Auswahlort erklären.
Das Prinzip habe ich schon verstanden.
Mein Problem ist, dass ich nicht weiß, wie man dies in Delphi/Lazarus durchführt.

Ich würde denken, dies macht man mit zwei Array´s, ein unsortiertes und ein sortiertes.:?
Aber wie sucht man denn die kleinste Zahl im unsortierten Feld heraus???
Außerdem will ich die Zahlen alle über ein Edit-Feld erstmal einlesen (einzeln). Geht das irgendwie???

Ich wäre euch echt dankbar für jede Hilfe.

LG.

[himitsu]

Array oder Liste ... ist am Ende in etwa das Gleiche ... was man halt lieber hat.

Zitat:

Zitat von rebellxsky (Beitrag 1282465)

Außerdem will ich die Zahlen alle über ein Edit-Feld erstmal einlesen (einzeln). Geht das irgendwie???

TEdit ... TButton (hinzufügen) ... im OnClick das Array vergrößern und den neuen Wert anhängen oder ein Add auf die Liste ? :stupid:

[rebellxsky]

ja genau.

jeder wert soll einzeln eingelesen werden und dann angehängt.
Aber dafür muss ja mit jedem betätigen des Buttons das Array um eins vergrößert und dann noch die zahl hinzugefügt werden.
Und an dieser Stelle komme ich nicht weiter.

Und dann sollen die zahlen noch sortiert werden...

[humbuck]

Probiers mal damit:

Delphi-Quellcode:

procedure auswahlsort (var a: array of Word);
var bis,i,j,k : LongInt;
h : Word;
begin
bis := High(a);
for i := 0 to bis - 1 do
begin
h := a[i];
k := i;
for j := i + 1 to bis do if a[j] < h then
begin
h := a[j];
k := j
end;
a[k] := a[i];
a[i] := h
end
end;

[humbuck]

...oder das...

Trifft es vielleicht noch eher...

Delphi-Quellcode:

procedure austauschsort (var a: array of Word);
var bis,i,j : LongInt;
h : Word;
begin
bis := High(a);
for i := 0 to bis - 1 do
for j := i + 1 to bis do
If a[i] > a[j] then begin
h := a[i];
a[i] := a[j];
a[j] := h
end
end;

[humbuck]

Letzteres entspricht dem folgenden Schema:

[Dejan Vu]

Zitat:

Zitat von rebellxsky (Beitrag 1282475)

Aber dafür muss ja mit jedem betätigen des Buttons das Array um eins vergrößert und dann noch die zahl hinzugefügt werden.
Und an dieser Stelle komme ich nicht weiter.

Und dann sollen die zahlen noch sortiert werden...

Zitat:

Zitat von humbuck (Beitrag 1282478)

...das...Trifft es vielleicht noch eher...

Delphi-Quellcode:

procedure austauschsort (var a: array of Word);
...

Also irgendwie... ;-) Glaub nich (Antwort passt nicht so richtig zur Frage). Bezüglich der o.g. Frage wäre eher folgender Schnippsel hilfreicher:

Delphi-Quellcode:

var
  myList : TList<integer>;
  myArray : Array of Integer;

begin
  myList := TList<integer>.Create;
  setLength(myArray,0);

// Anfügen eines Wertes
// 1. An eine TList<int>
myList.Add(Value);

// 2. An ein Array
  SetLength(myArray, Length(myArray) + 1);
  myArray [Length(myArray)] := Value;

[humbuck]

Morgens!

Zitat:

Also irgendwie... Glaub nich (Antwort passt nicht so richtig zur Frage).

Lieber Dejan Vu :?:

Die Aufgabenstellung umfasst doch die Frage nach einem bestimmten Algorithmus: Sortieren mit direktem Auswahlort sprich: Sortierung durch direkte Auswahl...
Meine Programmbeispiele beantworten die Frage nach dem gesuchten Algorithmus definitiv... Ein anderes Programmbeispiel mit umfassender Beschreibung findet man (sogar in Delphi geschrieben) unter Wikipedia. :wink:
Dazu muss man dann noch EINE seiner Fragen berücksichtigen:

Zitat:

Aber wie sucht man denn die kleinste Zahl im unsortierten Feld heraus???

Hmmm... Da passt meine Antwort doch auch oder? :wink:

Naja, ich gebe zu, nicht all seine Fragen werden von mir beantwortet...
Aber ich glaube darum sollte es hier auch gar nicht gehen.

Ich denke, an dieser Stelle müsste der junge Padawan noch mal zum Zuge kommen und vielleicht erklären, was genau die Aufgabenstellung an IHN ist.

Mir stellt sich nämlich die Frage, ob es eine genaue Definition zur Lösung einer gestellten Aufgabe gibt, oder ob er vielleicht nur das gesucht Sortierverfahren, bzw. den Algorithmus, in Delphi umzusetzen hat und es ihm dabei frei gestellt ist, wie er ein veranschaulichendes Programm schreibt; nämlich mit dem benannten Button (auf den bisher noch keiner von uns genauer eingegangen ist) und einem dynamischen Array.
Es stellt sich nämlich hieraus unweigerlich die Frage, wird von einer statischen Werte-Menge wie z.B. Lottozahlen ausgegangen oder eine variable Werte-Menge wie z.B. aus sich veränderten Messergebnissen...?

Also: Ein Appell an den Verfasser dieses Themas: Schreib doch mal wieder. :-D

[Dejan Vu]

Zitat:

Zitat von humbuck (Beitrag 1282497)

Hmmm... Da passt meine Antwort doch auch oder? :wink:

Stimmt ja, nur so unmittelbar nach der Frage, wie man Zahlen in ein Array stopft, fand ich deine Antwort halt lustig.

Stell Dir vor, jemand will von Hamburg nach Berlin mit dem Auto, und zwar in die Skeuderitzer Str. 28. Er fragt, wo der Rückwärtsgang ist, weil er ausparken muss und Du gibst im Tipps, wie man in die Skeuderizter Str. einbiegt (weil da ne Baustelle ist). Klar, ohne deinen Tipp kommt er nicht an, aber er muss doch erst mal losfahren :lol:

Komm schon, die Sonne scheint (jedenfalls hier)

Grüße
:-D

[humbuck]

Naja, wenn der Autofahrer nicht mal weiß, wo der Rückwärtsgang ist, sollte er sich vielleicht mit einem öffentlichen Verkehrsmittel anfreunden. Vielleicht hat er ja noch gar keinen Führerschein. Mit Bus oder Bahn käme er aber wahrscheinlich schon mal ans Ziel.

*grins*

Ich habe so das Gefühl, als wenn der junge Verfasser dieses Themas auch noch keine Plan hat, wo er die Gänge findet.

Aber wir können ihm ja Stück für Stück weiter helfen. 8-)

Dabei ist es dann auch sehr schön, wenn jemand noch was zu schmunzeln hat. :thumb:

[rebellxsky]

Erstmal möchte ich mich für die Antworten bedanken.
Trotzdem habe ich noch ein paar Fragen:
1. Um die Zahlen in das Array (sort) einzufügen habe ich das so gemacht:

Delphi-Quellcode:

zahl:= strtoint(edteingabe.caption);
 for a:= min + 1 to bis do
       begin
            sort[a]:= zahl;
       end;

Delphi-Quellcode:

bis := High(sort);
 min := low (sort);

Frage: Funktioniert das so?

2. Um die Zahlen zu sortieren:

Delphi-Quellcode:

For i:= 1 to N-1 Do
   Begin
     min:= i;
     For j:= i+1 To N Do
       If (sort[j] < sort[min]) Then
       min:= j;

bis dahin bin ich gekommen(vgl.http://www.delphipraxis.net/281-tuto...hmen-i-ii.html)
Dort steht nun aber die Werte i und min müssen getauscht werden (Dreieckstausch?). Aber wieso und wie sieht das dann aus?
Und wie kann man dann das sortierte Array auf ein Label ausgeben???

Ich bedanke mich schonmal für alle Antworten.

[humbuck]

Also:

Zitat:

1. Um die Zahlen in das Array (sort) einzufügen habe ich das so gemacht:



Delphi-Quellcode:

zahl:= strtoint(edteingabe.caption);
for a:= min + 1 to bis do
begin
sort[a]:= zahl;
end;

Leider ist nicht genau zu erkennen, wie die chronologische Abfolge deines Quellcodes ist.
Sei mal so nett und poste ihn mal vollständiger...
Im ersten Moment sieht es nämlich so aus, als würde dein Array nach dem Buttonclick immer mit dem jeweiligen Caption Wert gefüllt werden können: d.H. die Felder des Arrays hätten dann alle den selben Wert, wie er nach dem letzten Buttonclick übergeben würde...

Zitat:

Dort steht nun aber die Werte i und min müssen getauscht werden (Dreieckstausch?). Aber wieso und wie sieht das dann aus?

Keine Ahnung... wie du das meinst?

Zitat:

Und wie kann man dann das sortierte Array auf ein Label ausgeben???

Du könntest dein Array mit einer For-Schleife durchlaufen und den jeweiligen Wert nach Umwandlung in ein String (IntToStr(STRING)) + einem Trenner wie einer Leerstelle, Bindestrich oder was weiß ich deinem Label anfügen:

Delphi-Quellcode:

Label1.Caption := '';
For I := 0 To Length(Array)-1 do
  begin
    Label1.Caption := Label1.Caption + IntToStr(Array[i]) + ' ';
  end;

[rebellxsky]

Also das mit dem sortieren klappt erstmal soweit. Denke ich. Siehe hier:

Delphi-Quellcode:

procedure TForm1.btnsortClick(Sender: TObject);
begin
   For i:= 1 to 10-1 Do
   Begin
     min:= i;
     For j:= i+1 To 10 Do
       If (sort[j] < sort[min]) Then
       begin
         h        :=sort[j]  ;
         sort[j]  :=sort[min];
         sort[min]:=h        ;
       end;
   end;
lblsort.caption := '';
   For i := 0 To Length(sort) do
     begin
       lblsort.caption := lblsort.caption + IntToStr(sort[i]) + ' ';
     end;
end;

Aber das Einfügen geht wirklich nicht.
Hier mal alles von Implementation an:

Delphi-Quellcode:

implementation

{$R *.lfm}

{ TForm1 }
var sort        : array[1..10]of integer;
    zahl, bis, i, a, j, h, min : integer  ;
procedure TForm1.FormCreate(Sender: TObject);
begin
 bis := High(sort);
 min := low (sort);
end;

procedure TForm1.btnhinzuClick(Sender: TObject);
begin
 zahl:= strtoint(edteingabe.caption);
 for a:= min + 1 to bis do
       begin
            sort[a]:= zahl;
       end;
 lblunsort.caption := inttostr(sort[1]) + ' hinzugefügt';


end;

Zitat:

Im ersten Moment sieht es nämlich so aus, als würde dein Array nach dem Buttonclick immer mit dem jeweiligen Caption Wert gefüllt werden können: d.H. die Felder des Arrays hätten dann alle den selben Wert, wie er nach dem letzten Buttonclick übergeben würde...

also das array hat nach dem sortieren die ersten beiden Werte = 0; Und die letzten (8) = so groß wie der zuletzt eingegebene Wert.

Ich weiß, das kann eigentlich nicht so schwer sein. Aber ich kenne mich damit nicht aus...

[humbuck]

Zitat:

var sort : array[1..10]of integer;

Das sagt mir ja schon mal, es handelt sich bei dir um statisches Array mit 10 Werten... (Ein Array fängt übrigens bei 0 : Array[0..9])

Auf jeden Fall macht es das schon insgesamt einfacher.

Du musst jetzt nur systematisch vorgehen:

1) Der erste Wert soll nach dem Button-Click an deine Array übergeben werden, natürlich dann auch gleich einsortiert werden.
Das Problem ist, dass, wenn du z.B. drei Mal per Button-Click jeweils unterschiedliche Werte an deine Array übergibst, bekommst du folgendes Ergebnis (Allerdings nicht mit deiner Routine...):

0 0 0 0 0 0 0 14 47 81

Liegt da dran, dass du ja immer noch 7 unbelegte Werte im Array hast.

2) Voraussetzung dafür, dass du überhaupt einen Wert per Button-Click an dein Array gesichert übergeben kannst ist:
a) verhindern, dass du über 10 Werte hinausschießt
b) dass du mithilfe eines für a) notwendigen Zählers ERST alle Werte mit jedem Button-Click an dein Array übergibst und danach oder zwischendurch per zweiten Schalter dein Array sortierst und dann zur Ausgabe an ein Label übergibst.
Sollten dich dann möglicherweise die '0'-Werte bei der Ausgabe stören, kannst du diese ja herausfiltern (alles außer 0 darf dem Label angefügt werden)...
3) Vielleicht solltest du bei der Eingabemöglichkeit für einzelne Werte noch verhindern, dass im TEdit was anderes, außer Ganzahlen eingegeben werden kann, da dein Array ja OF INTEGER ist...

[humbuck]

Noch ein Nachtrag:

Wenn du z.B. drei Werte übergeben hast, dann mal 'kurz' sortierst fehlt dir plötzlich die Position, wo du weitere in dein Array füllen kannst, da dann deine Zählerposition hinfällig ist.

Daher wäre es das Einfachste, erst alle Werte zu übergeben und danach zu sortieren.

Alles Andere macht dein Projekt deutlich komplexer... außer du arbeitest tatsächlich mit einem ZWEITEN Array, dass dann nur ein sortiertes Ergebnis enthält...

[Sir Rufo]

Ein dynamisches Array

Delphi-Quellcode:

var Foo : array of integer;

fängt bei 0 an.
Ein statisches Array

Delphi-Quellcode:

var Foo : array[42..45] of integer

fängt bei der angegebenen unteren Grenze an (hier 42)!

[humbuck]

Zitat:

Ein statisches Array var Foo : array[42..45] of integer fängt bei der angegebenen unteren Grenze an (hier 42)!

Da hast du zweifellos Recht, fängt aber intern trotzdem bei 0 an. Erwähnt hatte ich das auch nur, viele Anfänger meinen, dass man mit 1 anfängt zu zählen, das in der Programmierung aber etwas anders ist.

Aber dein Einwand ist sinnvoll und berechtigt.

[rebellxsky]

Zitat:

Das sagt mir ja schon mal, es handelt sich bei dir um statisches Array mit 10 Werten... (Ein Array fängt übrigens bei 0 : Array[0..9])

Das habe ich mal versucht anzupassen:

Delphi-Quellcode:

var sort        : array[0..9]of integer;  
procedure TForm1.btnsortClick(Sender: TObject);
begin
   For i:= 0 to 9-1 Do
   Begin
     min:= i;
     For j:= i+1 To 9 Do
       If (sort[j] < sort[min]) Then
       begin
         h        :=sort[j]  ;
         sort[j]  :=sort[min];
         sort[min]:=h        ;
       end;
   end;
lblsort.caption := '';
   For i := 0 To Length(sort) -1 do
     begin
       lblsort.caption := lblsort.caption + IntToStr(sort[i]) + ' ';
     end;

end;

Das scheint jetzt zu funktionieren. Ausprobiert habe ich das, indem ich die Werte des Arrays erstmal im Quellcode definiert habe.

Zitat:

a) verhindern, dass du über 10 Werte hinausschießt
b) dass du mithilfe eines für a) notwendigen Zählers ERST alle Werte mit jedem Button-Click an dein Array übergibst

Man könnte den Button doch nach zehnmaligen betätigen deaktiviern, oder?
Wenn man anstatt integer --> real nimmt ginge es ja auch mit dezimalzahlen?
Trotzdem weiß ich nicht wie man die Werte übergibt. Nach jedem betätigen des Buttons würde dieser doch das gesammte Array überlaufen?

[Sir Rufo]

Dann musst du dir halt merken wieweit das Array gefüllt ist. Dafür gibt es Variablen.

Daran kannst du auch festmachen, ob das Array komplett gefüllt ist (keine weitere Eingabe möglich, aber Sortieren jetzt möglich). Mit einem Reset-Button kannst du dann die Variable wieder zurücksetzen.

[Sir Rufo]

Es macht überigens Sinn, für einzelne Teile separate Methoden zu erstellen:

Delphi-Quellcode:

procedure TForm1.SortArray;
begin
  // hier der Code zum Sortieren
end;

function TForm1.ArrayToString : string;
begin
  // hier der Code um aus dem Array einen String zu machen
  Result := ...
end;

procedure TForm1.Button1Click( Sender : TObject );
begin
  SortArray;
  lblsort.Caption := ArrayToString;
end;

[Amateurprofi]

Zitat:

Zitat von Dejan Vu (Beitrag 1282488)

Delphi-Quellcode:

var
  myArray : Array of Integer;

begin
  myList := TList<integer>.Create;
  setLength(myArray,0);

// Anfügen eines Wertes
// 2. An ein Array
  SetLength(myArray, Length(myArray) + 1);
  myArray [Length(myArray)] := Value;

@Dejan Vu:
Besser so, sonst schepperts.

Delphi-Quellcode:

SetLength(myArray, Length(myArray) + 1);
myArray [High(myArray)] := Value;

@rebellxsky:
Ein kleines Beispiel Projekt:
Ins Edit gibst du eine Zahl ein, mit Return wird die Zahl in die Liste übernommen.
Mit Escape wird die Liste gelöscht (Das Edit muß hierbei den Fokus haben).
Die Eingabe und Ausgabe wird im ebNumberKeyPress gesteuert.
Ich vermute, mit "Sortieren mit direktem Auswahlort" ist ein sog. SelectionSort gemeint.
Eine Übersicht mit diversen Sortierverfahren findest du hier http://www.delphipraxis.net/72182-sortieren.html

Delphi-Quellcode:

unit AS_Main;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
  Vcl.StdCtrls;

type
  TNumbers=Array of Integer;

  TMain = class(TForm)
    ebNumber: TEdit;
    lbUnsorted: TListBox;
    lbSorted: TListBox;
    lblUnsorted: TLabel;
    lblSorted: TLabel;
    procedure ebNumberKeyPress(Sender: TObject; var Key: Char);
  private
     fInput:TNumbers;
     fOutput:TNumbers;
     PROCEDURE Sort(List:TNumbers);
     PROCEDURE TransferToListBox(LB:TListBox; List:TNumbers);
  public
    { Public-Deklarationen }
  end;

var
  Main: TMain;

implementation

{$R *.dfm}

procedure TMain.ebNumberKeyPress(Sender: TObject; var Key: Char);
begin
   case Ord(Key) of
      VK_Escape:
         begin
            fInput:=Nil;
            fOutput:=Nil;
            lbUnsorted.Clear;
            lbSorted.Clear;
            ebNumber.Text:='';
         end;
      VK_Return:
         if ebNumber.Text<>'' then begin
            SetLength(fInput,Length(fInput)+1);
            fInput[High(fInput)]:=StrToInt(ebNumber.Text);
            fOutput:=Copy(fInput);
            Sort(fOutput);
            TransferToListBox(lbUnsorted,fInput);
            TransferToListBox(lbSorted,fOutput);
            ebNumber.Text:='';
         end;
      VK_Back,Ord('0')..Ord('9'):
         Exit;
      else
         Key:=#0;
   end;
end;

PROCEDURE TMain.Sort(List:TNumbers);
var I,J,K,H:Integer;
begin
   for I:=0 to High(List)-1 do begin
      K:=I;
      for J:=I+1 to High(List) do
         if List[J]<List[K] then K:=J;
      H:=List[I];
      List[I]:=List[K];
      List[K]:=H;
   end;
end;

PROCEDURE TMain.TransferToListBox(LB:TListBox; List:TNumbers);
var I:Integer;
begin
   LB.Clear;
   LB.Items.BeginUpdate;
   for I:=0 to High(List) do
      LB.Items.Add(IntToStr(List[I]));
   LB.Items.EndUpdate;
end;

end.

[humbuck]

Na hoffentlich versteht er das alles...:shock:

Er war gerade auf dem richtigen Weg...

Zitat:

Wenn man anstatt integer --> real nimmt ginge es ja auch mit dezimalzahlen?

Ja...

Dein Button zum hinzufügen eines Wertes sollte ungefähr so ausehen:

Delphi-Quellcode:

procedure Form1.Button....;
begin
  CASE Zaehler < 10 OF
    true : begin
             DEIN_ARRAY[Zaehler] := StrToInt(Edit1.Text); //Die Variable ZAEHLER global deklarieren
             INC(Zaehler);  //Funktion zählt Integerwert um 1 auf
           end;
    false: begin
             Showmessage('Array voll.');
           end;
  end;
end;

Ein Reset-Button (übrigens gute Idee):

Delphi-Quellcode:

procedure Form1.ResetButton...;
Var I : Integer;
begin
  Zaehler := 0;
  For I := 0 to Length(DEIN_ARRAY)-1 do
    begin
      DEIN_ARRAY[I] := 0;
    end;
  Edit1.Text := '';
end;

[rebellxsky]

Ok ich hab es jetzt geschnallt. Dankeschön.

Aber zwei Fragen zur Verbesserung noch.

Delphi-Quellcode:

var sort        : array[0..9]of integer;
    max, min, s : integer              ;
procedure TForm1.FormCreate(Sender: TObject);
begin
 max := High(sort);           
 min := low (sort);           
 s   := 0         ;           
      btnsort.enabled :=false;
      btnhinzu.enabled :=true;
end;

procedure TForm1.btnhinzuClick(Sender: TObject);
begin
 sort[s]:= strtoint(edteingabe.caption);

 if s = 0 then
 lblunsort.caption:=lblunsort.caption + inttostr(sort[s])
              else
                  if sort[s]<>0 then
                  lblunsort.caption:=lblunsort.caption + '; ' + inttostr(sort[s]);
 if s >= max then
    begin
         btnsort.enabled:=true ;
        btnhinzu.enabled:=false;
    end;
 s:=s + 1;
end;

procedure TForm1.btnsortClick(Sender: TObject);
var b, h  : integer  ;            
begin                             
   For min:= 0 to max-1 Do        
       Begin
            For b:= min+1 To max Do
                If (sort[b] < sort[min]) Then
                   begin
                        h        :=sort[b]  ;
                        sort[b]  :=sort[min];
                        sort[min]:=h        ;
                   end;
       end;
   For min := 0 To max do
     begin
       lblsort.caption := lblsort.caption + IntToStr(sort[min]) + '; ';

     end;

end;
end.

Wie die Kenner unter euch wohl feststellen können, erscheint durch die letzte Zeile auch am Ende der Sortierten Variablen ein --> ; _ Wie kann man dieses nun weglassen?

Und noch eine Frage zum Array:

Kann man es nicht definieren, mit einer Variablen --> sort : array[0..n] of integer.?
Dann könnte man die Variable im Program eingeben lassen. Dadurch wäre es ein wenig flexibler.

Die letzten Antworten habe ich erst eben gelesen, deswegen hat das nichts mehr damit zu tun...

[Sir Rufo]

Entweder du nimmst ein statisches Array oder ein dynamisches. Ein paar Beiträge zurück findest du die Dejlarationen.

[humbuck]

Und das Problem mit der letzten 'Zeile':

Delphi-Quellcode:

For min := 0 To max do
      begin
        lblsort.caption := lblsort.caption + IntToStr(sort[min]) + '; ';

      end;

kannste z.B. so lösen:

Delphi-Quellcode:

For min := 0 To max do
      begin
        IF Min < max then
          lblsort.caption := lblsort.caption + IntToStr(sort[min]) + '; ';
        else
          lblsort.caption := lblsort.caption + IntToStr(sort[min]);

      end;

Könnte man aber auch eleganter lösen... wenn's gewollt ist..

[Sir Rufo]

Wenn wir schon beim eleganter sind, dann sowas in der Art:

Delphi-Quellcode:

unit ValueSorter;

interface

type
  TValueSorter = class
  private
    FValues: array of Integer;
    FCurrentValue: string;
    FValue: Integer;
    FValuesAsString: string;
    procedure SetCurrentValue( const Value: string );
    function GetValue( index: Integer ): Integer;
    function GetValueCount: Integer;
  protected
    // diese Methoden verrichten die eigentliche Arbeit
    procedure DoAddValue;
    procedure DoSort;
    procedure DoReset;
    procedure DoUpdateValuesAsString;
  public
    // Commands
    function CanAddValue: Boolean;
    procedure AddValue;

    function CanSort: Boolean;
    procedure Sort;

    function CanReset: Boolean;
    procedure Reset;

    // Eigenschaften
    property CurrentValue: string read FCurrentValue write SetCurrentValue;
    property ValueCount: Integer read GetValueCount;
    property Values[index: Integer]: Integer read GetValue;
    property ValuesAsString: string read FValuesAsString;
  end;

implementation

uses
  System.SysUtils;

{ TValueSorter }

procedure TValueSorter.AddValue;
begin
  if CanAddValue
  then
    DoAddValue;
end;

function TValueSorter.CanAddValue: Boolean;
begin
  Result := TryStrToInt( FCurrentValue, FValue );
end;

function TValueSorter.CanReset: Boolean;
begin
  Result := Length( FValues ) > 0;
end;

function TValueSorter.CanSort: Boolean;
begin
  Result := Length( FValues ) > 1;
end;

procedure TValueSorter.DoAddValue;
begin
  SetLength( FValues, Length( FValues ) + 1 );
  FValues[High( FValues )] := FValue;
  FCurrentValue := '';
  DoUpdateValuesAsString;
end;

procedure TValueSorter.DoReset;
begin
  SetLength( FValues, 0 );
  DoUpdateValuesAsString;
end;

procedure TValueSorter.DoSort;
var
  LIIdx, LJIdx, LMinIdx: Integer;
  LTmp: Integer;
begin
  For LIIdx := Low( FValues ) to High( FValues ) - 1 Do
    Begin
      LMinIdx := LIIdx;
      For LJIdx := LIIdx + 1 To High( FValues ) Do
        If ( FValues[LJIdx] < FValues[LMinIdx] )
        Then
          begin
            LTmp := FValues[LJIdx];
            FValues[LJIdx] := FValues[LMinIdx];
            FValues[LMinIdx] := LTmp;
          end;
    end;
  DoUpdateValuesAsString;
end;

procedure TValueSorter.DoUpdateValuesAsString;
var
  LIdx: Integer;
begin
  FValuesAsString := '';
  for LIdx := Low( FValues ) to High( FValues ) do
    begin
      if LIdx > Low( FValues )
      then
        FValuesAsString := FValuesAsString + ';';
      FValuesAsString := FValuesAsString + IntToStr( FValues[LIdx] );
    end;
end;

function TValueSorter.GetValue( index: Integer ): Integer;
begin
  Result := FValues[Index + Low( FValues )];
end;

function TValueSorter.GetValueCount: Integer;
begin
  Result := Length( FValues );
end;

procedure TValueSorter.Reset;
begin
  if CanReset
  then
    DoReset;
end;

procedure TValueSorter.SetCurrentValue( const Value: string );
begin
  FCurrentValue := Value;
end;

procedure TValueSorter.Sort;
begin
  if CanSort
  then
    DoSort;
end;

end.

Delphi-Quellcode:

unit Form.Main;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, System.Actions,
  Vcl.ActnList, Vcl.AppEvnts, 

  ValueSorter;

type
  TForm1 = class( TForm )
    ValueEdit: TEdit;
    AddButton: TButton;
    SortButton: TButton;
    ResetButton: TButton;
    Label1: TLabel;
    ApplicationEvents1: TApplicationEvents;
    procedure ApplicationEvents1Idle( Sender: TObject; var Done: Boolean );
    procedure ValueEditChange( Sender: TObject );
    procedure AddButtonClick( Sender: TObject );
    procedure SortButtonClick( Sender: TObject );
    procedure ResetButtonClick( Sender: TObject );
  private
    FValueSorter: TValueSorter;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
{ TForm1 }

procedure TForm1.AddButtonClick( Sender: TObject );
begin
  FValueSorter.AddValue;
end;

procedure TForm1.AfterConstruction;
begin
  inherited;
  FValueSorter := TValueSorter.Create;
end;

procedure TForm1.ApplicationEvents1Idle( Sender: TObject; var Done: Boolean );
begin
  // Aktualisierung der Anzeige
  ValueEdit.Text := FValueSorter.CurrentValue;
  Label1.Caption := FValueSorter.ValuesAsString;
  AddButton.Enabled := FValueSorter.CanAddValue;
  SortButton.Enabled := FValueSorter.CanSort;
  ResetButton.Enabled := FValueSorter.CanReset;
end;

procedure TForm1.BeforeDestruction;
begin
  FValueSorter.Free;
  inherited;
end;

procedure TForm1.ResetButtonClick( Sender: TObject );
begin
  FValueSorter.Reset;
end;

procedure TForm1.SortButtonClick( Sender: TObject );
begin
  FValueSorter.Sort;
end;

procedure TForm1.ValueEditChange( Sender: TObject );
begin
  // Aktualisierung der Benutzereingabe
  FValueSorter.CurrentValue := ValueEdit.Text;
end;

end.

[humbuck]

LOL!

Haste dat alles grad reingehackt?!

NETT!

[Sir Rufo]

Zitat:

Zitat von humbuck (Beitrag 1282529)

LOL!

Haste dat alles grad reingehackt?!

NETT!

Nun ja, bis auf die Do...-Methoden ist es ja nur Standard abarbeiten :)

[Dejan Vu]

Die Klasse macht imho zu viel: 1. Liste verwalten UND 2. sortieren. Trenn doch den Sortierer von der Liste.

[Sir Rufo]

Zitat:

Zitat von Dejan Vu (Beitrag 1282534)

Die Klasse macht imho zu viel: 1. Liste verwalten UND 2. sortieren. Trenn doch den Sortierer von der Liste.

Du bist herzlich eingeladen das zu machen. Mir ging es generell darum die Trennung zwischen Logik und Anzeige zu zeigen. Wie diese Klasse nun intern arbeitet (Sortierer in eigener Klasse oder ausgelagert auf einem Webserver in Timbuktu) ist der Anzeige völlig wurscht und so soll es sein.

[humbuck]

:lol:

Ich schätze, wenn rebellxsky das Code-Beispiel von dir, Sir Rufo, in der Schule vorbringt, könnte man vielleicht... ein bisschen... daran zweifeln, dass das alles auf seinem Mist gewachsen ist. :wink:
Damit möchte ich allerdings nicht deinen Lösungsvorschlag schmälern. :thumb:

Ergänzend müsstest du jetzt nur erklären, wie das alles funktioniert, damit er das zumindest versteht... und sich bei seinem nächsten Problem auch traut, mal wieder etwas zu posten... :roteyes:

[Delphi-Laie]

rebellxsky, lade Dir mein Sortierkino herunter (auch in diesem Forum zu finden), das enthält auch Select(ion)sort. Es funktioniert auch "in place / in situ", man benötigt demnach keine zusätzliche Datenstruktur, um die sortierte Menge zu erzeugen.

[Sir Rufo]

@humbuck

Aus dem Grund habe ich den Quellcode auch hier veröffentlicht, weil man ihm das nicht glauben würde. Also habe ich auch nicht seine Hausaufgaben gemacht.

Aber an dem konkreten Beispiel kann man eben die oft abstrakt ans Herz gelegte Trennung zwischen Logik und Ansicht zeigen. Nur darum geht es mir dabei ;)