Min-Sort Verfahren

[p80286]

Ich habe mir einmal erlaubt, Deinen Sourcecode ein wenig zu formatieren:

Delphi-Quellcode:

procedure TForm1.Button3Click(Sender: TObject);
var i,j,m,x:integer;
begin
  for I:=1 to 6 do begin
    x:=i;
    for j:=i+1 to 6 do
      if za[x] > za[j] then
        x:=j;
    begin
      m:=za[x];
      za[x]:=za[i];
      za[i]:=m;
      memo2.lines.Add(inttostr(za[i]));
    end;
  end;

end;

Da frag ich mich schon was Du erreichen willst.
Übrigens ist Delphi natürlich selbstdokumentierend, aber Kommentare erleichtern die Fehlersuche meist ungemein, vor allem wenn darin steht warum etwas gemacht wird.

Gruß
K-H

[cobi23]

Ich möchte das so haben:
Mittels einen ersten Button soll im 1.Memo-Feld, die Zufallszahlen generiert werden und mittels einen 2.Button soll in einen 2.Memo diese Zufallszahlen mittels selectionsort geordnet werden.
Mein Problem ist, dass mein Programm beim ersten button-Klick im Memo die gleichen Zufallszahlen erscheinen unzwar alle 100. Im ersten Memo wird dabei in allen Arrays von 1 bis 100 hochgezählt bis es zur 100 angelangt.
Und wenn ich mit den 2.Button die Zahlen sortieren möchte kommt folgende Reihenfolge:

98
98
99
100
100

Und es kommt immer die gleichen zufallszahlen und die gleiche REihenfolge nacht selectionsort.

Das ist wirklich zum verzweifeln.

Hier noch mal der Quellcode

Code:

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    Label1: TLabel;
    Label2: TLabel;
    Memo1: TMemo;
    Memo2: TMemo;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
    za: array [1..6] of integer;
  public
    { public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
begin
  close;
end;

procedure TForm1.Button2Click(Sender: TObject);
var i,x,y,k:integer;
begin
  memo1.Clear; memo2.Clear;
  for I:=1 to 6 do za[k]:=i;
  for I:=1 to 6 do
  begin
    x:=IntToStr(Random(100)+1);
    y:=za[k];
    za[k]:=y;
    for k:=1 to 6 do
    memo1.Lines.Add(IntToStr(za[k]));
  end;

end;

procedure TForm1.Button3Click(Sender: TObject);
var i,j,m,x:integer;
begin
  for I:=1 to 6 do
  begin
    x:=i;
    for j:=i+1 to 6 do
    if za[x] > za[j] then
    x:=j;
    begin
    m:=za[x];
    za[x]:=za[i];
    za[i]:=m;
    memo2.lines.Add(inttostr(za[i]));
    end;
  end;

end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  randomize;
end;

end.

Ach ja ich benutze Lazarus, ist das der Grund dafür?

[DeddyH]

Wenn man sich das mal in Ruhe anschaut:

Zitat:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var i,x,y,k:integer;
begin
  memo1.Clear; memo2.Clear;
  for I:=1 to 6 do za[k]:=i; //??, wo liegt der Sinn?
  for I:=1 to 6 do
  begin
    x:=IntToStr(Random(100)+1); //IntToStr dürfte gar nicht funktionieren, x ist integer
    y:=za[k]; //Einmal hin...
    za[k]:=y; //und einmal her, was soll sich geändert haben?
    for k:=1 to 6 do
    memo1.Lines.Add(IntToStr(za[k]));
  end;

end;

[p80286]

Nach einem zweiten Blick auf Deinen Sourcecode
würde ich sagen, der compiliert noch nicht einmal:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
....,x,...:integer;
begin
  ...
    x:=IntToStr(Random(100)+1);
   ...
end;

Des weiteren könnte es Dir helfen wenn Du ein wenig Ordnung in Deinen Code bringst.
Dann sollte Dir aufffallen, daß Du den wert von x niemals in das Array bzw. das Memo bringst.

Also investiere einmal 10 Minuten, und dann sehen wir weiter.

Gruß
K-H

[DeddyH]

Meine Rede

[p80286]

[OT] hab ich jetzt auch gemerkt, da fehlte wohl der rote Kasten [/OT]

Gruß
K-H

[Jumpy]

Ich weise nur mal darauf hin, dass das Problem scheinbar 2x bearbeitet wird:

http://www.delphipraxis.net/newreply...ime=1362468766

[Sir Rufo]

Also beim Programmieren kommt es auch darauf an, dass man die Arbeit strukturiert und sich diese damit wesentlich vereinfacht.

• Ein Array mit Integer-Zahlen soll mit Zufallszahlen gefüllt werden
• Ein Array mit Integer-Zahlen soll sortiert werden
• Ein Array mit Integer-Zahlen soll in einem Memo ausgegeben werden

Das führt uns doch schon mal zu folgenden Rümpfen:

Delphi-Quellcode:

// Ein Integer-Array mit zufälligen Zahlen füllen

procedure FillArray( var AIntArray : array of Integer; Min, Max : Integer );
begin

end;

// Ein Integer-Array sortieren

procedure SortArray( var AIntArray : array of Integer );
begin
  
end;

// Ein Integer-Array in ein Memo ausgeben

procedure WriteArrayToMemo( const AIntArray : array of Integer; AMemo : TMemo );
begin

end;

Unsere Hauptaufgabe sieht damit schon sehr reduziert aus

Delphi-Quellcode:

// Mit Zahlen im Bereich 1 bis 100 füllen
FillArray( MeinArray, 1, 100 );
// Ausgabe im Memo1 
WriteArrayToMemo( MeinArray, Memo1 );
// Array Sortieren
SortArray( MeinArray );
// Ausgabe in Memo2
WriteArrayToMemo( MeinArray, Memo2 );

Im ganzen Satz und mit den programmierten Rümpfen (ausgenommen der Sortierung) sieht das dann so aus
(EDIT: ich habe das jetzt auch mal an den Aufgabentext angepasst )

Delphi-Quellcode:

unit Main_ViewU;

interface

uses
  SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type
  TForm1 = class( TForm )
    Unsortiert_Memo : TMemo;
    Sortiert_Memo : TMemo;
    Erzeuge_Button : TButton;
    MaxSort_Button : TButton;
    procedure Erzeuge_ButtonClick( Sender : TObject );
    procedure MaxSort_ButtonClick( Sender : TObject );
  private

  public

  end;

var
  Form1 : TForm1;
  // Array mit den Zahlen
  MeinArray : array [1 .. 20] of integer;

implementation

{$R *.dfm}
// Ein Integer-Array mit zufälligen Zahlen füllen

procedure FillArray( var AIntArray : array of integer; Min, Max : integer );
var
  LIdx : integer;
begin
  for LIdx := Low( AIntArray ) to High( AIntArray ) do
    begin
      AIntArray[LIdx] := Random( Max - Min + 1 ) + Min;
    end;
end;

// Ein Integer-Array sortieren

procedure SortArray( var AIntArray : array of integer );
begin

end;

// Ein Integer-Array in ein Memo ausgeben

procedure WriteArrayToMemo( const AIntArray : array of integer; AMemo : TMemo );
var
  LIdx : integer;
begin
  AMemo.Lines.BeginUpdate;
  try

    AMemo.Clear;

    for LIdx := Low( AIntArray ) to High( AIntArray ) do
      begin
        AMemo.Lines.Add( IntToStr( AIntArray[LIdx] ) );
      end;

  finally
    AMemo.Lines.EndUpdate;
  end;
end;

procedure TForm1.Erzeuge_ButtonClick( Sender : TObject );
begin
  // Mit Zahlen im Bereich 1 bis 100 füllen
  FillArray( MeinArray, 1, 100 );

  // Ausgabe im Memo1
  WriteArrayToMemo( MeinArray, Unsortiert_Memo );
end;

procedure TForm1.MaxSort_ButtonClick( Sender : TObject );
begin
  // Array Sortieren
  SortArray( MeinArray );

  // Ausgabe in Memo2
  WriteArrayToMemo( MeinArray, Sortiert_Memo );
end;

end.