Austausch-Sortieralgorithmus mit Prozeduren

[haui95]

Guten Tag,
wir sind jetzt im Unterricht etwas weiter und sind jetzt auch endlich bei den Routinen angekommen.
Bis jetzt haben wir nur die Prozeduren kennengelernt, dir wir mit dem Austausch-Sortieralgorithmus
in Verbindung bringen sollen. Es ist zwar keine Hausaufgabe, aber dennoch habe ich mir ein bisschen Zeit genommen,
um den Quelltext neu zu formulieren. Und genau dort liegt das Problem, ich bin soweit fertig, das Programm startet auch, doch ich erhalte immer, wenn ich den Sortieren-Button klicke eine Zugriffsverletzung. Gut, ich poste euch mal meinen Quelltext und hänge die Projektdateien als Anhang an.
Bedanke mich schon einmal im Voraus.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    ListBox1: TListBox;
    Edit1: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

Type TFeld = Array [1..100] of Integer;

var
  Form1: TForm1;
  x: Integer;
  Feld: TFeld;

implementation

{$R *.dfm}

procedure Beenden();
begin
  Application.Terminate;
end;

procedure Generieren(var Feld: TFeld; x: Integer);
var
  i: Integer;
begin
  for i := 1 to x do
    begin
      Feld[i] := Random(x) + 1;
      Form1.ListBox1.Items.Add(IntToStr(Feld[i]));
    end;
end;

procedure Ausgabe(x: Integer);
var
  i, j: Integer;
begin
  for i := 1 to x do
    Form1.ListBox1.Items.Add(IntToStr(Feld[j]));
end;

procedure Tauschen(var Feld: TFeld);
var
  i, j, Temp: Integer;
begin
  if (Feld[i] > Feld[j]) then
    begin
      Temp := Feld[i];
      Feld[i] := Feld[j];
      Feld[j] := Temp;
    end;
  Ausgabe(StrToInt(Form1.Edit1.Text));
end;

procedure Sortieren(var Feld: TFeld; x: Integer);
var
  i, j: Integer;
begin
  for i := 1 to x - 1 do
    for j := i + 1 to x do
      Tauschen(Feld);
end;

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

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

procedure TForm1.Button3Click(Sender: TObject);
begin
  ListBox1.Clear;
  Generieren(Feld, StrToInt(Form1.Edit1.Text));
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Ausgabe(StrToInt(Form1.Edit1.Text));
end;
end.

[Dalai]

Eiei, jede Menge Fehler sehe ich da...

Die Funktion Sortieren wird gar nicht aufgerufen, warum? Warum sind die Funktionen Sortieren, Tauschen, Ausgabe & Co nicht deklariert? Auch wenn man eine Deklaration weglassen kann, wenn die aufgerufene Funktion vor dem Aufruf steht, so sollte man sich angewöhnen, immer eine Deklaration vorzunehmen.

Delphi-Quellcode:

procedure Ausgabe(x: Integer);
var
  i, j: Integer;
begin
  for i := 1 to x do
    Form1.ListBox1.Items.Add(IntToStr(Feld[j]));
end;

Öhm, die Schleife benutzt i als Laufvariable, aber der Feldindex benutzt j? Das kann nicht funktionieren und wird wahrscheinlich auch der Grund für die AV sein.

Und wäre es nicht besser, das

Delphi-Quellcode:

var Feld: TFeld;

durch ein

Delphi-Quellcode:

const Feld: TFeld;

zu ersetzen? Bin mir nicht ganz sicher, ob hier dasselbe zutrifft wie bei Objekten, deren Adresse ja durch das const geschützt wird und nicht deren Inhalt.

Noch ein paar Kleinigkeiten:

• Application.Terminate sollte man vermeiden, wenn es geht. Ein einfaches TForm.Close tut seinen Dienst ebenfalls, bedeutet aber deutlich weniger hartes Beenden des Programms (härter ist nur Halt oder das Abschießen des Prozesses).
• Verwende aussagekräftige Bezeichner! Button1 und Edit1 sind kein solchen.
• Auch wenn man
  Delphi-Quellcode:

  Funktion();

  für parameterlose Funktionen verwenden kann, ich vermeide es und benutze stattdessen
  Delphi-Quellcode:

  Funktion;

  . Keine Ahnung, ob das Verwenden leerer Klammern Auswirkungen haben kann und/oder ob das irgendeinem Standard entspricht oder widerspricht (nein, ich meine nicht den C-Standard ;)).
• Du benutzt ein statisches Feld mit 100 Elementen, erlaubst dem Benutzer aber gleichzeitig, eine Zahl in ein Edit einzugeben, die darüber hinausgehen kann. Das ist potentiell fehlerträchtig! Dazu kommt, dass ungültige Eingaben (Buchstaben & Co) nicht weggeworfen werden.

MfG Dalai

[implementation]

Zitat:

Zitat von Dalai (Beitrag 1163910)

Auch wenn man eine Deklaration weglassen kann, wenn die aufgerufene Funktion vor dem Aufruf steht, so sollte man sich angewöhnen, immer eine Deklaration vorzunehmen.

Aber nur, wenn die Funktion auch für andere Units sichtbar sein soll. Ist es eine unitinterne Funktion, gehört sie nicht in den Interface-Teil und sollte höchstens im implementation-Teil mit

Delphi-Quellcode:

forward

deklariert werden.

Zitat:

[*]Auch wenn man

Delphi-Quellcode:

Funktion();

für parameterlose Funktionen verwenden kann, ich vermeide es und benutze stattdessen

Delphi-Quellcode:

Funktion;

. Keine Ahnung, ob das Verwenden leerer Klammern Auswirkungen haben kann und/oder ob das irgendeinem Standard entspricht oder widerspricht (nein, ich meine nicht den C-Standard ;)).

Ich habe mir inzwischen wieder Klammern angewöhnt, weil sonst Selbstaufrufe doppeldeutig sein können:

Delphi-Quellcode:

function xyz: Integer;
begin
  // do smthng
  a := xyz;
  // do smthng
end;

Nun steht es dem Compiler offen, ob er "xyz" wie "Result" wertet (TP-Abwärtskompatibilität) oder als Selbstaufruf, der Ausdruck ist nicht eindeutig. Aber zugegeben - rekursive Funktionen haben ja meist Parameter, daher kommt's selten vor.

[Aphton]

Zitat:

Zitat von haui95 (Beitrag 1163899)

Delphi-Quellcode:

Type TFeld = Array [1..100] of Integer;

var
  Form1: TForm1;
  x: Integer;  // -> was zur hölle?
  Feld: TFeld;

procedure Beenden(); // -> warum unnötig 2x deklarieren? da wo es geschlossen werden muss, die aktuelle schließ-routine aufrufen (in deinem fall: application.terminate; sollte man meiden - weiteres problem)
begin
  Application.Terminate;
end;

procedure Generieren(var Feld: TFeld; x: Integer); // -> warum nur von 1 bis x? warum nicht die ganze liste?
var
  i: Integer;
begin
  for i := 1 to x do
    begin
      Feld[i] := Random(x) + 1;
      Form1.ListBox1.Items.Add(IntToStr(Feld[i]));
    end;
end;

procedure Ausgabe(x: Integer);
var
  i, j: Integer;
begin
  for i := 1 to x do  // warum immer bis zu einer bestimmten stelle? (x)
    Form1.ListBox1.Items.Add(IntToStr(Feld[j])); // j ist nicht intitialisiert -> enthält zufälligen wert -> was zur hölle? hausverstand?
end;

procedure Tauschen(var Feld: TFeld);
var
  i, j, Temp: Integer;
begin  // i und j sind nicht definiert; enthalten zufällige werte!
  if (Feld[i] > Feld[j]) then  // was zur hölle?
    begin
      Temp := Feld[i];
      Feld[i] := Feld[j];
      Feld[j] := Temp;
    end;
  Ausgabe(StrToInt(Form1.Edit1.Text));
end;

procedure Sortieren(var Feld: TFeld; x: Integer);
var
  i, j: Integer;
begin
  for i := 1 to x - 1 do
    for j := i + 1 to x do
      Tauschen(Feld);  // hier besser i und j als parameter übergeben, beim rumpf der tauschen procedure dies umändern und die lokalen variable derselben routine entfernen
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Beenden();  // besser: application.terminate (nach deinem geschmack); ordnetlich: close;
end;

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

procedure TForm1.Button3Click(Sender: TObject);
begin
  ListBox1.Clear;
  Generieren(Feld, StrToInt(Form1.Edit1.Text));
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Ausgabe(StrToInt(Form1.Edit1.Text));
end;
end.

Text..

[haui95]

Danke für die bisherigen Antworten, aber an einigen Stellen verstehe ich nicht, was gemeint ist. Vielleicht könnte jemand mir in meinem Quelltext Erklärungen bzw. noch nähere Erläuterungen reinschreiben, was zu ändern ist, oder den Quelltext einmal überarbeiten, sodass das Sortieren auch funktioniert. Mein Problem liegt eigentlich nur bei den Prozeduren.

MfG

[Aphton]

Nein. Du musst genauer werden!

Dein Problem liegt nicht nur bei Proceduren. Du hast da einige andere Fehler.

[Dalai]

Zitat:

Zitat von implementation (Beitrag 1163912)

Zitat:

Zitat von Dalai (Beitrag 1163910)

Auch wenn man eine Deklaration weglassen kann, wenn die aufgerufene Funktion vor dem Aufruf steht, so sollte man sich angewöhnen, immer eine Deklaration vorzunehmen.

Aber nur, wenn die Funktion auch für andere Units sichtbar sein soll. Ist es eine unitinterne Funktion, gehört sie nicht in den Interface-Teil und sollte höchstens im implementation-Teil mit

Delphi-Quellcode:

forward

deklariert werden.

Da hast du Recht. Allerdings kann man - und hier bietet sich das eigentlich an - die Funktionen innerhalb der Klasse TForm deklarieren. Dann sind sie deklariert, aber nicht von einer anderen Unit aus zugänglich (private genügt ja).

MfG Dalai

[haui95]

So..
habe noch einmal die Fehler überarbeitet, die mir hier genannt wurden, das Programm läuft auch, doch beim Sortieren wieder eine Zugriffsverletzung. Vielleicht könnte sich jemand den Quelltext noch mal anschauen oder mir auch noch einmal kurz erläutern, wie man dieses Programm mit Prozeduren umsetzen kann.

MfG

Delphi-Quellcode:

Type TFeld = Array [1..100] of Integer;

var
  Form1: TForm1;
  Feld: TFeld;

implementation

{$R *.dfm}

procedure Beenden();
begin
  Application.Terminate;
end;

procedure Generieren(var Feld: TFeld);
var
  i: Integer;
begin
  for i := 1 to 100 do
    begin
      Feld[i] := Random(100) + 1;
      Form1.ListBox1.Items.Add(IntToStr(Feld[i]));
    end;
end;

procedure Ausgabe(j: Integer);
var
  i: Integer;
begin
  for i := 1 to 100 do
    Form1.ListBox1.Items.Add(IntToStr(Feld[j]));
end;

procedure Tauschen(var Feld: TFeld; i, j: Integer);
var
  Temp: Integer;
begin
  if (Feld[i] > Feld[j]) then
    begin
      Temp := Feld[i];
      Feld[i] := Feld[j];
      Feld[j] := Temp;
    end;
  Ausgabe(j);
end;

procedure Sortieren(var Feld: TFeld);
var
  i, j: Integer;
begin
  for i := 1 to 100 - 1 do
    for j := i + 1 to 100 do
      Tauschen(Feld, i, j);
end;

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

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

procedure TForm1.Button3Click(Sender: TObject);
begin
  ListBox1.Clear;
  Generieren(Feld);
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  j: Integer;
begin
  Ausgabe(j);
end;
end.

[Aphton]

Das hier ist unfug:

Delphi-Quellcode:

procedure Ausgabe(j: Integer);
var
  i: Integer;
begin
  for i := 1 to 100 do
    Form1.ListBox1.Items.Add(IntToStr(Feld[j]));
end;

Du lässt nur das j.te Element ausgeben.. und das 100 x

Edit: + j ist nicht initialisiert so wie du ihn aufrufst (himitsu)

[himitsu]

Zitat:

Delphi-Quellcode:

var
  j: Integer;
begin
  Ausgabe(j);
end;

Und dann wurde noch nichtmal angegeben welches j-te ausgegeben werden soll.
Selbst Schuld, wenn du nicht auf die Compilermeldungen hörst, denn da steht bestimmt garantiert was vonwengen "j sei nicht initialisiert".

Wenn du mal in den Projektoptionen die Bereichsprüfung aktivierst, dann wirst du direkt informiert wo und vorallem warum es da knallt.

Es kann auch nicht schaden sich mal mit dem Debugger vertraut zu machen.
Erstmal um uns genau die Fehlerstelle zu nennen. ( wurde dir denn keine Fehlerzeile gezeigt? )
Und auserdem hättest du im Debuger selber erkennen können warum es knallt, indem du dir an der Fehlerstelle mal die Variablen ansiehst (speziell das j :roll: )

[Delphi-Laie]

Zitat:

Zitat von haui95 (Beitrag 1163899)

mit dem Austausch-Sortieralgorithmus

Es gibt nicht "den" Austausch-Sortieralgorithmus, sondern (nur) Sortieralgorithmen, die (auch oder ausschließlich) (aus-)tauschen oder nicht.

[haui95]

So, habe mir Zeit genommen mich nochmal mit den Routinen zu beschäftigen und habe den "Austausch-Algorithmus" noch einmal neu in Quelltext verfasst, jedoch sortiert mir mein Programm nun Namen oder Wörter in einer ListBox. Vielleicht könnte jemand einmal drüber schauen. Bis jetzt funktioniert das Programm ;)

Delphi-Quellcode:

const n = 100;

var
  Form1: TForm1;
  Feld: Array[1..n] of String;
  Zaehler: Integer;

implementation

{$R *.dfm}

procedure Hinzufuegen(Name: String);
begin
  Feld[Zaehler] := Name;
  inc(Zaehler);
end;

procedure Tausche(var Str1, Str2: String);
var
 Temp: String;
begin
  Temp := Str1;
  Str1 := Str2;
  Str2 := Temp;
end;

procedure Sortieren;
var
  i, j: Integer;
begin
  for i := 1 to n - 1 do
    for j := i + 1 to n do
      if (Uppercase(Feld[i]) > Uppercase(Feld[j])) then
        Tausche(Feld[i], Feld[j]);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Zaehler := Zaehler + 1;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  i: Integer;
begin
  Hinzufuegen(Edit1.Text);
  ListBox1.Clear;
    for i := 1 to n do
      if (Feld[i] <> '') then
        ListBox1.Items.Add(Feld[i]);
        Edit1.Clear;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Application.Terminate;
end;

procedure TForm1.Button3Click(Sender: TObject);
var
  i: Integer;
begin
 Sortieren;
 ListBox1.Clear;
 for i := 1 to n do
   if (Feld[i] <> '') then
     ListBox1.Items.Add(Feld[i]);
end;
end.

[Aphton]

Ja sieht nun viel ordentlicher aus.

Es gibt aber immernoch Probleme, wenn auch nur kleine:

1. deine Zählervariable:
- es findet keine Initialisierung statt - nirgendswo bekommt Zähler einen Anfangswert (1?) verpasst. Im FormCreate wird sie "erhöht" (inkrementiert) - sie hat aber einen zufälligen Wert (davon ist auszugehen, wenn nichts zugewiesen wurde bei globalen Variablen).
- die Procedure "hinzufügen" ist fehleranfällig: wenn du es nämlich genau 100x ausführst und noch ein weiteres Mal. Da wird dann versucht, auf einen Index zuzugreifen, der außerhalb des Bereiches liegt (Bereichsfehler). Besser wäre es, wenn du ne Kontrolle einbaust ~ (Zähler <= n)

2. der "Schließknopf"
- Application.Terminate funktioniert zwar, aber dies gibt deiner Anwendung nicht die Möglichkeit, Deinitialitsierungen durchzuführen (Speicherfreigaben usw). Besser ist es, wenn du einfach ein Close; aufrufst.

[Delphi-Laie]

Was, zum Teufel, ist der "Austausch-Sortieralgorithmus"?

[Furtbichler]

Google, zum Teufel, mal.

[Delphi-Laie]

Zitat:

Zitat von Furtbichler (Beitrag 1164658)

Google, zum Teufel, mal.

Was google wohl findet...diese Diskussion an vorderster Stelle!

Den "Austausch-Sortieralgorithmus" gibt mit dieser Bezeichnung (derzeit sonst) nicht, zumal (aus)tauschen eine essentielle Operation allgemeiner Sortieralgorithmen gibt, was demnach eine solche Bezeichnung sehr unglücklich dastehen ließe. Wenn ich "exchange sort" suche, komme ich auf Lösungen, die an manchem Simplesort (sicher auch keine selbsterklärende Bezeichnung) auf sortieralgorithmen.de zu entsprechen scheint.

[Aphton]

"Selection Sort" (wenn man sicht die diversen Sortieralgorithmen auf Wikipedia ansieht und von der Logik (nicht Code) her vergleicht, so kommt man zu diesem Entschluss =P)

[BUG]

Manche Lehrer scheinen Bubble-Sort auch so zu bezeichnen (sagt zumindest Google), es scheint aber wirklich Selection-Sort zu sein.

Aber eigentlich ist das egal, der nächste arme Hund, dem der Lehrer den richtigen Namen des Algorithmus nicht verrät, wird diese Thema mit der Überschrift finden.
Wenn du über die Qualität des Info-Unterichts diskutieren willst, kannst du ja ein Thema in K&T aufmachen :mrgreen:

[DeddyH]

Zitat:

Zitat von BUG (Beitrag 1164736)

Wenn du über die Qualität des Info-Unterichts diskutieren willst, kannst du ja ein Thema in K&T aufmachen :mrgreen:

Bloß nicht :shock:

[Aphton]

Da gibts nichts zum Diskutieren; soetwas wie Qualität gibt es im Info Unterricht (zumindest in der Oberstufe) nicht!