merge sort Programm

[hanselmansel]

HiHo,

ich habe deine eigenen Kommentare einfach mal entfernt, und durch meinen Senf ersetzt:

Delphi-Quellcode:

type
  TSortierverfahren = class(TForm)
  //Ich würde einen anderen Namen vergeben. Einen, aus dem ersichtlich wird, dass es sich um ein form handelt.
    nsortiert_lb: TListBox;
    sortiert_lb: TListBox;
    Enter_b: TButton;
    Sort_b: TButton;
    New_b: TButton;
    End_b: TButton;
    Eingabefeld_e: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    procedure Enter_bClick(Sender: TObject);
    procedure Sort_bClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Mergesort(var List:array of integer);
    procedure New_bClick(Sender: TObject);
    procedure End_bClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Sortierverfahren: TSortierverfahren;
  //Die folgenden 2 Variablen kannst du genausogut im Implementation-Teil deklarieren
  Elements: integer;
  nsortiert: array of integer;

implementation

{$R *.DFM}

procedure TSortierverfahren.Enter_bClick(Sender: TObject);
begin
Sortierverfahren.nsortiert_lb.items.add(eingabefeld_e.text);
Setlength (nsortiert,Elements+1);
nsortiert[Elements] := (StrToInt(eingabefeld_e.text));
Elements:=Elements+1;
Sortierverfahren.eingabefeld_e.text :='';
end;

procedure TSortierverfahren.Sort_bClick(Sender: TObject);
var
  i:integer;
begin
Sortierverfahren.Mergesort(nsortiert);

for i:= 0 to Elements-1 do
  Sortierverfahren.sortiert_lb.items.add(IntToStr(nsortiert[i]));
{Der Begin-End Block ist unnötig. Wenn du wirklich viele Elemente hast, kannst du
die Listbox erst unsichtbar machen, dann die Items einfügen und sie dann wieder sichtbar
machen. Geht schneller. ;-) }
end;

procedure TSortierverfahren.Mergesort(var List:array of integer);
var
  laenge,x,y,z: integer;
  h_array1, h_array2:array of integer;
begin
{MergeSort wird SEHR viel schneller ablaufen, wenn du das Teilen des Feldes erstmal
nur über die Indizies machst. In einer Prozedur "Mische" kannst du die Felder dann flott
zusammenkleben.}
laenge:= length(List);

  Setlength (h_array1, laenge div 2);
  Setlength (h_array2,(laenge + 1) div 2);

  for x:=0 to laenge div 2 - 1 do
    h_array1[x]:=List[x];

  for y:=0 to (laenge + 1) div 2 - 1 do
    h_array2[y]:=List[y+((laenge) div 2)];

  if laenge>2 then
  begin
    mergesort(h_array1);
    mergesort(h_array2);
  end;
  z:=0;
{Wenn du das 2. HilfsFeld spiegelverkehrt einsortierst, dann kannst du einen Zähler
von Rechts loslaufen lassen. wenn sich die zähler treffen isses sortiert. -->
SEHR schöner code}
  while (length(h_array1) <> 0) and (length(h_array2) <>0) do
  begin

    if h_array1[0]<h_array2[0] then
    begin

      List[z]:=h_array1[0];

      for x:=0 to length(h_array1)-2 do
      //unnötiger begin-end-block
      begin
        h_array1[x]:=h_array1[x+1];
      end;

      Setlength (h_array1,length(h_array1)-1);
      end
      else

      begin
        List[z]:=h_array2[0];
        for y:=0 to length(h_array2)-2 do
        begin
          h_array2[y]:=h_array2[y+1];
        end;
        setlength(h_array2,length(h_array2)-1);
      end;
      z:=z+1;
    end;
    if length(h_array1)<>0 then
    begin
      for x:=0 to length(h_array1)-1 do
      begin
        List[z]:=h_array1[x];
        z:=z+1;
      end;
{Nach dem Durchlauf der Schleife ist eins der Hilfsfelder auf jeden Fall leer.
Wenn das andere noch Elemente enthält, dann wird es komplett ins Quell-Array
geschrieben.} {O-Ton ich}
    end;
    if length(h_array2)<>0 then
    begin
    for y:=0 to length(h_array2)-1 do
    begin
      List[z]:=h_array2[y];
      z:=z+1;
    end;
  end;
end;

Selbst wenn mein eigener (und von Zeit zu Zeit etwas stranger) Formatierungsstil nicht den offiziellen Regeln entspricht, so ist er dennoch an diese angelehnt. Ich würde dir einmal empfehlen, dir anzuschauen, wie der Rest der Welt den Code formatiert. Für Dritte wird es dadurch sehr viel einfacher deinen Code zu lesen. Hier habe ich das Formatieren "gelernt"

MfG,

hanselmansel