Entwurf, Implementierung und Dokumentation eines

Sortierprogramms mit dem Insertionsort-Verfahren in

Delphi 7
Fach Informatik

Eingereicht von: Eingereicht von:

Inhaltsverzeichnis

1. Einleitung ........................................................................................................................... 3

2. Was ist Insertionsort? ......................................................................................................... 3

2.1. Erläuterung des "Insertionsort"-Sortierverfahrens ..................................................... 3

2.2. Funktionsweise an einem Beispiel ............................................................................. 3

3. Dokumentation des Sortierprogramms............................................................................... 5

3.1. Erklärung der Funktion anhand des Quelltextes und des Interfaces .......................... 5

3.2. Bedienungsanleitung .................................................................................................. 9

4. Anhang ............................................................................................................................. 10

4.1. Quelltext ................................................................................................................... 10

4.2. Abbildung 1.............................................................................................................. 14

4.3. Abbildung 2.............................................................................................................. 14

4.4. Abbildung 3.............................................................................................................. 15

4.5. Abbildung 4.............................................................................................................. 15

4.6. Struktogramm der Prozedur "Löschen" ................................................................... 16

4.7. Struktogramm der Prozedur zum generieren der Zufallszahlen............................... 16

4.8. Struktogramm der Prozedur des Sortierverfahrens .................................................. 17

4.9. Struktogramm der Prozedur zur Statistische Auswertung ....................................... 18

4.10. Prozedur zum Beenden des Programms................................................................... 18

5. Quellenverzeichnis ........................................................................................................... 19

5.1. Mündliche Quellen................................................................................................... 19

5.2. Internetquellen.......................................................................................................... 19

5.3. Buchquellen.............................................................................................................. 19

6. Eidesstattliche Erklärung.................................................................................................. 20
1. Einleitung
In der vorliegenden Arbeit haben wir uns intensiv mit dem Sortierverfahren Insertionsort
beschäftigt. Im Laufe dessen haben wir dazu ein Programm geschrieben, welches wir in der
Programmiersprache Delphi verfassten.

2. Was ist Insertionsort?

2.1. Erläuterung des "Insertionsort"-Sortierverfahrens
Insertionsort ist ein Sortierverfahren für eine Reihe von unsortierten Zahlen. Es ist ein
ziemlich ineffizientes Sortierverfahren, da im schlimmsten Falle alle Elemente von ihrer
jetzigen Position ganz an den Anfang der Reihe verschoben werden müssen.

Die erste Zahl der Reihe wird erstmal stehen gelassen und es wird sofort die zweite Zahl
genommen. Anstatt das jetzt speziell mit a1 und a2 zu erläutern, erläutere ich das mit ai-1 und
ai. Es wir die Zahl ai genommen, denn alle Zahlen im Intervall [a1|ai-1] sind schon sortiert.
Nun wird die Zahl ai mit der Zahl ai-1 verglichen. Ist ai größer oder gleich ai-1, dann wir i um
eins erhöht und weiter sortiert. Ist dem nicht der Fall, dann rückt die Zahl von der Position ai-
1 auf die Position ai vor und die vorige Zahl auf ai wird zwischen dem jetzigen ai und ai-2,
also auf ai-1 eingefügt1. Nun wird das i um eins verkleinert und wieder überprüft, wie sie sich
zu der Vorgängerzahl verhält.

2.2. Funktionsweise an einem Beispiel

Als Beispiel nehmen wir die folgende Zahlenfolge:

a1 a2 a3 a4 a5
5 7 9 1 4

Als erstes beginnen wir bei der Zahl a1. Diese Zahl lassen wir einfach stehen, da sie am
Anfang der Folge steht.

a1 a2 a3 a4 a5
5 7 9 1 4

Als nächstes gehen wir zu der Zahl a2. a2 vergleichen wir mit der Zahl a1. Da die Zahlen in
der richtigen, aufsteigenden, Reihenfolge sind, nämlich a1 mit 5 und a2 mit 7, lassen wir die
Zahlen so stehen wie sie sind.

1
"eingefügt" wurde markiert, um auf die Namensgebung von "Insertionsort" hinzuweisen. "Insertiosort"
beinhaltet das englische Wort "insert", was "einfügen" bedeutet.

3
 a1 a2 a3 a4 a5
5 7 9 1 4

Nun gehen wir wieder einen Schritt weiter und nehmen uns die Zahl a3 vor. Sie beträgt 9.
Jetzt vergleichen wir diese 9 mit der Zahl a2 = 7. Wir stellen fest, dass a3 größer ist als a2 und
somit stehen die Zahlen schon wieder in der richtigen Reihenfolge.

a1 a2 a3 a4 a5
5 7 9 1 4

Der nächste Schritt ist der Vergleich der Zahlen a4 und a3. Und dort fällt uns zum ersten mal
auf, dass a4 kleiner ist als a3 (1 < 9). Da dieser Fall nun eintrat, rückt a3 auf die Position a4
vor und wir fügen das vorige a4 (die 1) zwischen a2 und a4 ein.

a1 a2 a3 a4 a5
5 7 1 9 4

Da die 1 nun eins weiter zurückgerückt ist, müssen wir weiter überprüfen, bis die
vorhergehende Zahl kleiner oder gleich der 1 ist. a2 = 7 und a3 = 1. Dies heißt, dass a3 < a2
ist. Also muss a2, die 7, auf die Position a3 vorrücken und die 1 wird auf Position a2,
zwischen a1 und a3 eingefügt.

a1 a2 a3 a4 a5
5 1 7 9 4

Nun überprüfen wir, wie a1 zu a2 steht und wir erkennen das a2 < a1 ist, da 1 < 5. Also muss
die 5 von a1 auf a2 vorrücken und die 1 auf a1 eingefügt werden. In einem weiteren
Durchlauf würden wir feststellen, dass die 1 auf der ersten Position steht und somit nicht
weiter vertauscht werden muss.

a1 a2 a3 a4 a5
1 5 7 9 4

Nun nehmen wir uns a5 vor und sehen, das a5 < a4 ist. Also geht das Spiel wie bei der 1
weiter. Um das abzukürzen, werde ich hier jetzt erstmal nur die Tabellen aufschreiben:

a1 a2 a3 a4 a5
1 5 7 4 9
4
 a1 a2 a3 a4 a5
1 5 4 7 9

a1 a2 a3 a4 a5
1 4 5 7 9

a1 a2 a3 a4 a5
1 4 5 7 9

Nun haben wir die Zahlenreihe sortiert. Die Anzahl der Vertauschungen betrug, wenn man
nachzählt, sechs. Diese Zahl ist so klein, weil die ersten drei Zahlen vorsortiert waren.

3. Dokumentation des Sortierprogramms

3.1. Erklärung der Funktion anhand des Quelltextes und des Interfaces
Das Programm wurde relativ einfach konzeptioniert, was auch am Quelltext ersichtlich ist.
Was ich noch hinzufügen möchte ist, dass die vier Ausgaben zur statistischen Auswertung,
ausschließlich aus ästethischen und logischen Gründen hinzugefügt wurden. Dadurch sieht
das Interface nicht all zu leer aus und das Programm hat auch einen anderen Nutzen, außer
das Sortierverfahren "Insertionsort" zu demonstrieren.

Als erstes wurde, wie man es im Quelltext sehen kann, ein globales Array "zahlen", mit
10.000 Elementen maximal, deklariert. Ich gehe später weiter darauf ein.

Als nächstes kommt schon die erste Prozedur, welche bei Betätigung des "Alles leeren"-
Buttons aufgerufen wird (Struktogramm). In ihr werden alle Ausgabekomponenten des
Programms, die beiden Memokomponenten zur Arrayausgabe und die Edit-Felder zur
Ausgabe der Statistischen Auswertungen, der benötigten Zeit und der Anzahl der
Vertauschungen, geleert. Des weiteren wird die Edit-Komponente, in der die Anzahl der
Array-Elemente eingegeben werden soll, wieder auf den Standardwert "100" gesetzt. Und
wenn diese Edit-komponente im Laufe des Programms deaktiviert wurde, wird sie wieder
aktiviert und freigeschalten. Auch werden die beiden Buttons "Sortieren" und "Feld
auswerten" deaktiviert. Dies verbessert das Programm insofern, dass nur das Array
ausgewertet oder sortiert wird, das zur Zeit sowohl in der ersten Memokomponente, als auch
im Array "zahlen" liegt.

5
Zu den Formularkomponenten ist anzumerken, dass bis auf die "Zahlenbereichs-Edit-
Komponente", in keiner anderen Komponente des Formulars eine Eingabe getätigt werden
kann. Jetzt weiter im Quelltext.

Als nächstes wird die Prozedur zur Generierung der Zufallszahlen aufgerufen
(Struktogramm). Dies geschieht mit einem Knopfdruck auf den "Liste neu generieren"-
Button. Als erstes werden in dieser Prozedur alle Ausgabekomponenten des Formulars
geleert. Zu diesem Schritt habe ich mich entschlossen, damit man weder eine ellenlange
Memokomponente bekommt noch das bei einer Neugenerierten Liste/einem Neugenerierten
Array immer noch die alten Ergebnisse angezeigt werden. Des weiteren wird der "Feld
auswerten"-Button deaktiviert. Anschließend wird die Möglichkeit abgefangen, weniger als
100 oder mehr als 10.000 Elemente zu generieren. Dies habe ich mithilfe von If-Then
Entscheidungsstrukturen realisiert. Die Editkomponente wird in diesen Fällen auf die
Grenzwerte festgelegt, also 100 oder 10.000. Anschließend wird die Edit-Komponente, in der
man den Zahlenbereich der Arrayanzahl eingeben kann, für Eingaben gesperrt
(Edit1.ReadOnly := true) und dies wird auch kenntlich gemacht, indem die Editkomponente
deaktiviert wird und die Zahl in ihr grau wird. Nun aktiviert sich der Zufallsgenerator über
das Schlüsselwort "randomize" und über eine For-To-Schleife werden das Array und die
Memo-komponente mit den Zufallswerten gefüllt. Schlussendlich wird der "Sortieren"-Button
wieder freigeschalten. Hiermit endet auch diese Prozedur.

Die folgende Prozedur ist, im Gegensatz zu den anderen Prozeduren, das Kernstück des
Programms, denn es ist die Sortierprozedur (Struktogramm). Hier laufen die Prozesse ab,
welche für das Sortieren nach dem Insertionsortverfahren zuständig sind. Als erstes ist auch
hier die Variablendeklaration. Die Variablen "Anfang" und "Ende" sind für die Zeitmessung
zuständig, die das Programm benötigt, um das Array zu sortieren. Sie werden als Real-
Variablen deklariert. Als nächstes werden die Variablen "i", "j", "grenze", die
Zwischenspeichervariable "Zv" und die Variable "Durchlaeufe" als Integervariablen
deklariert. Der Variable "grenze" wird die Anzahl der Elemente des Arrays zugewiesen,
während die Variable "Anfang" die aktuelle Zeit und die Variable "Durchlaeufe" 0
zugewiesen bekommt. Anschließend beginnt die Sortierschleife mit einer "For-To"-Schleife.
Diese Schleife beginnt mit ihrer Zählvariable "i" bei 2 und Zählt rauf bis sie die Zahl erreicht,
welche der Variable "grenze" zugewiesen ist. Nun wird aus dem Array "zahlen" das Element
an der i-ten Stelle, also "zahlen[i]", abgegriffen und in der Zwischenspeichervariable "Zv"
zwischengespeichert.

6
Der Variable j, die in der "Unterschleife" als Zählvariable gilt, wird nun der Wert von "i"
zugewiesen. Nun geht es in die "Unterschleife", welche eine "While"-Schleife ist. In ihr wird
überprüft, ob die Element in dem Array, die vor der zwischengespeicherten Zahl stehen,
größer sind, als die in "Zv" zwischengespeicherte Zahl. Die Schleife läuft ab, solange die Zahl
in der Variable "j" größer als 1 ist und das Element "zahlen[j-1]" größer als die auf "Zv"
zwischengespeicherte Zahl ist. Solange dies der Fall ist, rückt immer das Element "zahlen[j-
1]", also praktisch immer das Element, was vor dem auf "Zv" zwischengespeichertem
Element steht, um eine Position im Array vor2, während das zwischengespeicherte "imaginär"
eine Stelle weiter zurückrückt3. Des weiteren wird in der "While"-Schleife "j" um 1
vermindert und die Variable "Durchlaeufe", zur Messung der benötigten Vertauschungen, um
1 erhöht. Damit endet die "While"-Schleife. Zurück in der "For-To"-Schleife wird die
zwischengespeicherte Variableauf den jetzt leeren Platz "zahlen[j]" abgelegt und ist nun
sortiert. Wenn nun auch die "For-To"-Schleife abgearbeitet ist, dann wird sofort der Variable
"Ende" die nun aktuelle Zeit zugewiesen, um die Zeitmessung der Sortierverfahrens
realisieren zu können. Anschließend wird in der "Edit2"-Komponente die benötigte Zeit in
Sekunden, auf zwei Nachkommastellen genau, ausgegeben, wobei sie erst während der
Ausgabe berechnet und umgerechnet wird nach der Formel: (Ende - Anfang) * 24 * 3600.
ACHTUNG: Der ermittelte Wert kann mit +/- 5 Sekunden abweichen! Nun wir die Anzahl
der Vertauschungen, in Form der Variable "Durchlaeufe" in der "Edit3"-Komponente
ausgegeben. Als vorletzte Aktion muss aber noch das geordnete Array in der "Memo2"-
Komponente ausgegeben werden. Dies geschieht über eine "For-To"-Schleife, die die
Variable "i" von 1 bis zu der Gesamtanzahl der Arrayelemente hochzählt und jedes Element
"zahlen[i]" der "Memo2"-Komponente hinzufügt. Anschließend wird der Button "Feld
auswerten" freigeschalten.

Bevor ich die Prozedur zum Auswerten des Feldes erkläre, möchte ich ganz kurz auf die
Kunstgriffe bei den Formularkomponenten eingehen. Um eine möglichst unkomplizierte und
ziemlich Eingabefehler resistente Möglichkeit des Implementierens diese Programms zu
gewährleisten, ist von Anfang an nur die Eingabe in die "Edit1"-Komponente (Anzahl der
Arrayelement" vorgesehen. Bis auf den Fehler, das dort möglicherweise keine Ziffern
eingegeben werden, habe ich den Fehler von einer Unter- bzw. Überschreitung der Elemente
des Arrays mit zwei "If-Then"-Verzweigungen abgefangen.

2
"vorrücken" bedeutet hier, dass die Zahl ein Element höher gesetzt wird, z. B. "zahlen[2]" nach "zahlen[3]"
3
"zurückrücken" bedeutet hier z. B. "zahlen[5]" rückt zu "zahlen[4]" zurück

7
Die Deaktivierung dieses Edit-Feldes verhindert nach der Erstellung eines Arrays aus
Zufallszahlen, dass das erstellte Array überschrieben wird. Dadurch das erst nach dem
generieren der vorher deaktivierte "Sortieren"-Button aktiviert wird, verhindert das Sortieren
eines nicht "erwünschten" Arrays aus lauter Nullen oder das Sortieren des vorhergehend
erstellten Arrays wenn noch kein neues zufällig generiert wurde. Und schlussendlich wird
durch das Drücken des "Sortieren"-Buttons der "Feld auswerten"-Button reaktiviert. Dies ist
notwendig, damit nur das Array ausgewertet wird, das auch ausgewertet werden soll. Des
weiteren ist der Quelltext der Statistische Auswertung darauf ausgelegt, mit einem schon
sortiertem Array zu arbeiten.

Sobald der "Alles Leeren"-Button betätigt wird, werden die Buttons "Sortieren" und "Feld
auswerten" deaktiviert, alle Ausgabekomponenten des Formulars geleert und, das wichtigste,
die Edit-Komponente zur Eingabe der (genutzten)4 Arraygröße wird auf den Standartwert
zurückgesetzt und freigeschalten.

Nun kommen wir zur Erläuterung des Quelltextes, der hinter dem "Feld auswerten"-Button
steckt (Struktogramm). Zu Anfang werden drei Variablen deklariert ("i", "grenze" und "ari")
die, bis auf "grenze", alle nur zur Ermittlung des Arithmetischen Mittels benötigt werden.
Denn zur Minimumermittlung und -ausgabe wird einfach das erste Element ("zahlen[1]") des
sortierten Arrays ausgegeben und fertig. Bei der Ausgabe des Maximums ist es ähnlich. Da
wird einfach das letzte Element ("zahlen[grenze]") des Arrays ausgegeben. Bei der Ausgabe
der Spannweite wird einfach die Differenz aus letztem und erstem Arrayelement ausgegeben
("zahlen[grenze]" - "zahlen[1]"). Bei der Ermittlung des Arithmetischen Mittels greife ich auf
eine Zählschleife zurück, die die Variable "i" bis zum Wert, der unter "grenze" gespeichert ist,
hochzählt und somit der Variable "ari" die Summe der Werte aller Elemente des Arrays
übergibt. Diese Summe wird durch die Anzahl der Elemente des Arrays geteilt, der Variable
"ari" zugewiesen und als Arithmetisches Mittel ausgegeben.

Und nun zum Schluss wird, bei Betätigung des "Beenden"-Buttons das Programm beendet
(Struktogramm).

4
Das Array ist eigentlich schon definiert und zwar auf genau 10.000 Elemente. Damit aber eine Differenzierung
der Arraygröße seitens des Benutzers geschehen kann, muss ein Wert x für die effektiv genutzte Arraygröße
eingegeben werden, für den gilt: 100 ≤ x ≤ 10.000 .

8
3.2. Bedienungsanleitung
Nach dem Start der "Insertionsort.exe" erschient dieses Interface (siehe Abbildung 1) auf dem
Bildschirm. Nun können Sie die Anzahl der Zufallszahlen eingeben, die sie sortieren lassen
wollen, indem Sie in der Edit-Komponente in der '100' steht, eine Eingabe zwischen 100 und
10.000 tätigen. Diese Eingabe bestätigen Sie mit einem Druck auf den Knopf "Liste neu
generieren". Wie Sie nun sehen sind in der linken Memokomponente des Formulars einige
Zufallszahlen erschienen. Die Oberfläche des Programms müsste jetzt so ungefähr aussehen
wie in Abbildung 2. Wie Sie bestimmt gemerkt haben, ist der "Sortieren"-Button aktiviert
worden. Nach einem kurzen Klick auf jenen, müssen Sie sich erst einmal eine kurze Zeit
gedulden. Nun müsste die rechte Memokomponente mit dem jetzt geordneten Array gefüllt
werden. Nach dem dieser Vorgang abgeschlossen ist, werden auch die Edit-Komponenten
unter dem "Sortieren"-Button mit der, für den Sortiervorgang benötigten Zeit in Sekunden
und den vollzogenen Vertauschungen, gefüllt. Nun müsste die Oberfläche wie in Abbildung 3
aussehen. Wies Sie auch hier bemerkt haben, wurde der "Feld auswerten"-Button aktiviert.
Mit Druck auf diesen, werden die, noch leeren Edit-Komponenten, mit dem Minimum,
Maximum, der Spannweite und dem Arithmetischen Mittel der Werte des Arrays, gefüllt (sieh
Abbildung 4).

Wenn Sie jetzt erneut mit derselben Anzahl an Arrayelementen eine neue Zufallszahlenliste
erzeugen wollen drücken Sie einfach nochmal den Knopf "Liste neu generieren". Wenn Sie
jedoch mehr oder weniger Zufallszahlen erzeugen wollen, müssen Sie erst mal auf "Alles
leeren" drücken und anschließend die gewünschte Anzahl an Zufallsahlen eingeben und den
Knopf "Liste neu generieren" betätigen. Wollen Sie nichts von beidem, dann drücken Sie den
"Beenden"-Button und schließen somit das Programm.

Anmerkung: Der Zahlenbereich, in dem die Zufallszahlen liegen beträgt immer

[1|Anzahl der Zufallszahlen * 10].

Am Beispiel: Wenn ich als Eingabe für die Anzahl der Zufallszahlen 100
eingebe, dann ist der Bereich [1|1000].

9
4. Anhang
4.1. Quelltext
unit Unit1;

interface

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

type
TForm1 = class(TForm)
Panel1: TPanel;
GroupBox1: TGroupBox;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
Edit1: TEdit;
Label1: TLabel;
Memo1: TMemo;
GroupBox2: TGroupBox;
Label2: TLabel;
Memo2: TMemo;
BitBtn3: TBitBtn;
Label3: TLabel;
Label4: TLabel;
Edit2: TEdit;
Label5: TLabel;
Edit3: TEdit;
Label6: TLabel;
Edit4: TEdit;
Edit5: TEdit;
BitBtn4: TBitBtn;
Label7: TLabel;
Edit6: TEdit;
BitBtn5: TBitBtn;
Edit7: TEdit;
Label8: TLabel;
procedure BitBtn2Click(Sender: TObject);
procedure BitBtn1Click(Sender: TObject);
procedure BitBtn3Click(Sender: TObject);
procedure BitBtn4Click(Sender: TObject);
procedure BitBtn5Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;

10
var
Form1: TForm1;
zahlen : array [1..10000] of Integer;

implementation

{$R *.dfm}

procedure TForm1.BitBtn2Click(Sender: TObject);

begin
Memo1.Clear;
Memo2.Clear;
Edit1.Enabled := true;
Edit1.ReadOnly := false;
Edit2.Text := '';
Edit3.Text := '';
Edit4.Text := '';
Edit5.Text := '';
Edit6.Text := '';
Edit7.Text := '';
Edit1.Text := '100';
BitBtn3.Enabled := false;
BitBtn4.Enabled := false;
end;

//Generierung der Zufallszahlen

procedure TForm1.BitBtn1Click(Sender: TObject);

var i, grenze : integer;
begin

Memo1.Clear;
Memo2.Clear;
Edit2.Text := '';
Edit3.Text := '';
Edit4.Text := '';
Edit5.Text := '';
Edit6.Text := '';
Edit7.Text := '';
BitBtn4.Enabled := false;

If StrToInt(Edit1.Text) < 100 Then

begin
Edit1.Text := '';
Edit1.Text := '100';
end;
If StrToInt(Edit1.Text) > 10000 Then
begin
Edit1.Text := '';
Edit1.Text := '10000';
end;

11
Edit1.ReadOnly := true;
Edit1.Enabled := false;

randomize;
grenze := StrtoInt(Edit1.Text);
For i := 1 To grenze Do
begin
zahlen[i] := random(grenze * 10) + 1;
Memo1.Lines.Add(InttoStr(zahlen[i]));
end; // of For-To

BitBtn3.Enabled := true;

end;

procedure TForm1.BitBtn3Click(Sender: TObject);

var Anfang, Ende : Real;
grenze, i, j, Zv, Durchlaeufe : Integer;
begin
grenze :=StrToInt(Edit1.Text);
Anfang := Time;
Durchlaeufe := 0;

// Sortierschleifen

For i := 2 To grenze Do
begin
Zv := zahlen[i];
j := i;
while (j > 1) and (zahlen[j - 1] > Zv) Do
begin
zahlen[j] := zahlen[j - 1];
j := j - 1;
Durchlaeufe := Durchlaeufe + 1;
end; // of While

zahlen[j] := Zv;
end; // of For-To

Ende := Time;

//Zeit- und Durchlaufsanzahlausgabe

Edit2.Text := FloattoStrF((Ende - Anfang) * 24 * 3600, ffFixed, 10, 2);

Edit3.Text := InttoStr(Durchlaeufe);

//Feldausgabe
Memo2.Clear;

12
For i := 1 To StrToInt(Edit1.Text) Do
begin
Memo2.Lines.Add(InttoStr(zahlen[i]));
end; // of For-To

BitBtn4.Enabled := true;

end;

// optional //// optional //// optional //// optional //// optional //// optional //

//////////////////////////////////////////////////////
//////////// Statistisches Auswerten des Feldes //////
//////////////////////////////////////////////////////
procedure TForm1.BitBtn4Click(Sender: TObject);
var i, grenze : Integer;
ari : real;
begin
grenze := StrToInt(Edit1.Text);

//Minimum

Edit4.Text := IntToStr(zahlen[1]);

//Maximum

Edit5.Text := IntToStr(zahlen[grenze]);

//Spannweite

Edit7.Text := IntToStr(zahlen[grenze] - zahlen[1]);

//Arithmetisches Mittel

For i := 1 To grenze Do
begin
ari := ari + zahlen[i];
end; // of For-To

ari := ari / grenze;

Edit6.Text := FloatToStr(ari);

end;

procedure TForm1.BitBtn5Click(Sender: TObject);

begin
Form1.Close;
end;

end.

13
4.2. Abbildung 1

4.3. Abbildung 2

14
4.4. Abbildung 3

4.5. Abbildung 4

15
4.6. Struktogramm der Prozedur "Löschen"

Löschprozedur
Beide Memokomponenten leeren
"Zahlenbereichs"-Eingabe-Edit-Feld
reaktivieren und die Zeichenkette
'100' zuweisen
Alle Ausgabe-Edit-Komponenten
leeren
"Sortieren"-Knopf deaktivieren
"Feld auswerten"-Knopf
deaktivieren

4.7. Struktogramm der Prozedur zum generieren der Zufallszahlen

Zufallszahlen generieren
Variablen "i" und "grenze" als Integervariablen deklarieren
Ausgabekomponenten leeren
Knopf "Feld auswerten" sperren
Zahlenbereichseingabe < 100
J N
Zahlenbereichseingabe auf
100 setzen
Zahlenbereichseingabe > 10000
J N
Zahlenbereichseingabe auf
10000 setzen
Zahlenbereichseingabe-Edit-Komponente sperren und
deaktivieren
Der Variable "grenze" wird die Maximalanzahl der
Arrayelemente, sprich der "Zahlenbereich", des Arrays
"zahlen" zugewiesen
Zähle i von 1 bis grenze, Schrittweite 1
Zufallszahl auf das Arrayelement "zahlen[i]" zuweisen
Zahl der ersten Memokomponente hinzufügen
Knopf "Sortieren" freischalten

16
4.8. Struktogramm der Prozedur des Sortierverfahrens
Sortiervorgang
Variablen "Anfang" und "Ende" als Real-variablen deklarieren
Variablen "i", "j", "Zv" und "Durchlaeufe" als Integervariablen
deklarieren
Der Variable "grenze" wird der Zahlenbereich zugeordnet
Varable "Anfang" bekommt die aktuelle Zeit zugewiesen
Variable "Durchlaeufe" wird auf 0 gesetzt
Zähle "i" von 2 bis "grenze", Schrittweite 1
Element "zahl[i]" auf der Zwischevariable "Zv"
zwischenspeichern
Die Variable "j" wird auf den Wert der Variable "i" gesetzt
Solange "j">1 und ("zahlen[j-1]">"Zv")
Arrayelement "zahlen[j]" bekommt die Vorgängerzahl
"zahlen[j-1]" zugewiesen
"j" wird um 1 verringert
Variable "Durchlaeufe" wird um 1 erhöht
Dem Arrayelement "zahlen[j]" wird die vorher
zwischengespeicherte Zahl von "Zv" zugewiesen
Aktuelle Zeit wird auf die Variable "Ende" zugewiesen
Ausgabe der Variable "Durchlaeufe" und der Differenz der
Variablen "Ende" und "Anfang" (umgerechnet von Tage auf
Sekunden)
Memokomponente zur Ausgabe des geordneten Arrays leeren
Zähle "i" von 1 bis "grenze", Schrittweite 1
Füge Feld "zahlen[i]" der Memokomponente hinzu
Knopf "Feld auswerten" wird freigeschalten

17
4.9. Struktogramm der Prozedur zur Statistische Auswertung
Statistische Auswertung
Variablen "i" und "grenze" als Integervariablen deklarieren
Variable "ari" als Real-Variable deklarieren
Die Variable "grenze" bekommt die Anzahl der Elemente
des Arrays "zahlen" zugewiesen
Die Variable "ari" wird 0 gesetzt
Ausgabe des ersten Elements des geordneten Arrays
"zahlen" als Minimum
Ausgabe des letzten Elements des geordneten Arrays
"zahlen" als Maximum
Ausgabe der Differenz des letzten und des ersten
Elements des Arrays "zahlen" als Spannweite
Zähle "i" von 1 bis "grenze", Schrittweite1
Der Variable "ari" wird die Summe aus sich selbst und
dem aktuellen Arrayelement "zahlen[i]" zugewiesen
Die Variable "ari" wird durch die numerische Anzahl der
Elemnte des Arrays "zahlen", sprich dem auf "grenze"
zugewiesenen" Wert, geteilt und sich selbst wieder
zugewiesen
Ausgabe der Vriable "ari" als Arithmetisches Mittel

4.10. Prozedur zum Beenden des Programms

Prozedur zum Beenden des Programms
Schließen des Programms/des Forms durch
den Befehl "Form1.Close"

18
5. Quellenverzeichnis
5.1. Mündliche Quellen

5.2. Buchquellen
Praktische Informatik 2 mit Delphi S. 164/165

5.3. Internetquellen
http://www.inf.fh-flensburg.de/lang/algorithmen/sortieren/insert/insertion.htm

http://de.wikipedia.org/wiki/Insertionsort

19
6. Eidesstattliche Erklärung
Hiermit versichern wir, dass wir die Hausarbeit selbstständig verfasst und keine anderen als
die angegebenen Quellen und Hilfsmittel benutzt haben, alle Ausführungen, die anderen
Schriften wörtlich oder sinngemäß entnommen wurden, kenntlich gemacht sind.

20