Sortieren mit direktem Auswahlort

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