Kapitel 5 Der Algorithmus
 In den vorangeggangenen Kapiteln wurde, aufbauend auf dem
Begriff der Information, beschrieben, wie die statischen Objekte der
Informatik aussehen und notiert werden können.
In diesem Kapitel wird aufgezeigt, wie man die Verarbeitung dieser
Objekte (also die Dynamik) beschreiben kann. Wesentlicher Begriff
dabei ist der Begriff des Algorithmus
 Inhalt
1.
2.
3.
4.
5.
6.
7.
8.
Ein Beispiel
Definition
Die Struktelemente
Strukturierung
Blockung
Iteration und Rekursion
Aufwand
Korrektheit
Teile dieses Kapitels sind aus:
R.Manthey: Vorlesung Informatik 1, Uni Bonn, 2001
5.1
Ein Beispiel
 Zunächst soll ein kleines Beispiel in eine mögliche Aufgabenstellung
aus dem (bekannten) Bereich der Mathematik einführen und dadurch
auch eine (eingeschränkte) Vorstellung über die Aufgaben und
Elemente eines Algorithmuses geben.
 Inhalt
1.
2.
3.
4.
5.
6.
7.
Das Problem (Beispiel)
Ein Algorithmus I
Ein Algorithmus II
Vergleich der Algorithmen
Ein Algorithmus III
Fragestellungen
Ein weiterer Algorithmus
5.1.1 Das Problem
 Eine quadratischen Gleichung:
x2 + 8x + 7 = 0
 Allgemeine Darstellung der quadratischen Gleichung
x2 + px + q = 0
 Allgemeine Lösung der quadratischen Gleichung
x = -p/2 + p2/4 - q
-
1,2
 Lösung der quadratischen Gleichung
x = -8/2 + 82/4 - 7
-
1,2
= -4
+
- 3
x1 = -1
x2 = -7
5.1.3 Ein Algorithmus I
 Ein Algorithmus
x1,2= -p/2 +- p2/4 - q
Zuweisungen
Berechnungen
Eingaben
1. Lies die Zahlen p und q ein
2. Berechne die Zahl w = p2/4 - q
Konstante
3. Berechne die Zahl x1 = -p/2 + w
4. Berechne die Zahl x2 = -p/2 - w
5. Gib x1 und x2 als Ergebniss aus
Variable
Ausgaben
5.1.4 Ein Algorithmus II
 Ein zweiter Algorithmus
1. Lies die Zahlen p und q ein
x1,2= -p/2 +- p2/4 - q
2. Berechne die Zahl p/2; Nenne diese Zahl a
3. Berechne die Zahl a2 ; Nenne diese Zahl b
4. Berechne die Zahl b-q ; Nenne diese Zahl c
5. Berechne die Zahl c ; Nenne diese Zahl d
6. Berechne die Zahl -a ; Nenne diese Zahl e
7. Berechne die Zahl e + d ; Nenne diese Zahl x1
8. Berechne die Zahl e - d ; Nenne diese Zahl x2
9. Gib x1 und x2 als Ergebniss aus
FHSymbol1
Es gibt (oft unendlich) viele Algorithmen zur
Lösung eines Problems
5.1.5 Vergleich der Algorithmen
Berechne die Zahl w = p2/4 - q
Berechne die Zahl p/2; Nenne diese Zahl a
Berechne die Zahl x1 = -p/2 + w
Berechne die Zahl a2 ; Nenne diese Zahl b
Berechne die Zahl x2 = -p/2 - w
Berechne die Zahl b-q ; Nenne diese Zahl c
Berechne die Zahl c ; Nenne diese Zahl d
Berechne die Zahl -a ; Nenne diese Zahl e
Berechne die Zahl e + d ; Nenne diese Zahl x1
Berechne die Zahl e - d ; Nenne diese Zahl x2
Anzahl Berechnungen
Anzahl Zuweisungen
Anzahl Variablen
A1
10
3
5
A2
7
7
9
FHSymbol1
Welcher
Algorithmus
ist besser ?
Warum ?
5.1.6 Ein Algorithmus III
 Problem: Negatives Wurzelargument
1.
Lies die Zahlen p und q ein
2.
Berechne die Zahl a = p/2
3.
Berechne die Zahl b = a2
4.
Berechne die Zahl c = b-q
5.a Wenn c negativ ist brich den
Algorithmus ab
Ansonsten mache mit nächstem
Schritt weiter
6.
Berechne die Zahl d = c
7.
Berechne die Zahl e = -a
8.
Berechne die Zahl x1 = e + d 1
9.
Berechne die Zahl x2 = e - d
10. Gib x1 und x2 als Ergebniss aus
5.b Wenn c negativ ist
gehe zu Schritt 1
Bedingte
Ausführung
Schleife
5.1.7 Fragestellungen
1.
Lies die Zahlen p und q ein
2.
Berechne die Zahl a = p/2
3.
Berechne die Zahl b = a2
4.
Berechne die Zahl c = b-q
6.
Berechne die Zahl d = c
7.
Berechne die Zahl e = -a
8.
Berechne die Zahl x1 = e + d 1
9.
Berechne die Zahl x2 = e - d
10. Gib x1 und x2 als Ergebniss aus
FHSymbol1
Welche offenen
Fragen bestehen
noch ?














Wer gibt p und q ein ?
Wie wird p und q eingegeben ?
Werden p und q in endlicher Zeit
eingegeben ?
Sind p und q im richtigen Format ?
Ist Variable a im richtigen Format ?
Gibt es die Quadrat-Funktion ?
Ist c positiv ?
Ist Variable e im richtigen Format ?
Sind die restlichen Variablen im richtigen
Format
Reicht die Genauigkeit der Darstellung ?
Wo wird das Ergebnis ausgegeben ?
Ist ausreichend Variablenkapazität für den
Algorithmus vorhanden ?
Läuft der Algorithmus schnell genug ?
...
5.1.8 Ein weiterer Algorithmus
5.2
Definition
 Der Begriff des Algorithmus ist zentral in der Informatik und soll in
diesem Unterkapitel formal definiert werden
 Inhalt
1.
2.
3.
4.
5.
6.
Herkunft
Der Algorithmus
Beispiel: Algorithmenbeweis
Weitere Prinzipien
Algorithmen und Programme
Ausflug: Algorithmus und WinOSe
5.2.1 Herkunft
 Muhammad ibn Musa abu Djafar al-Choresmi (ca. 780-850 n.Chr)
 arabischer Mathematiker, geboren in Choresmien (heute: Usbekistan)
 lebte und wirkte in Bagdad im „Haus der Weisheit“
 war beteiligt an der Übersetzung der Werke griechischer Mathematiker
ins Arabische
 schrieb ein „Kurzgefasstes Lehrbuch für die Berechnung durch
Vergleich und Reduktion“
 die lateinische Übersetzung dieses Buches („liber algorismi“) kam durch
Kreuzfahrer nach Europa
 verfasste auch ein Buch mit dem Titel „Al-Mukhtasar fi Hisab al-Jahr va
l-Muqabala“
Algorithmus
Algebra
5.2.2 Der Algorithmus
 Definition:
Ein Algorithmus (algorithm) ist die Beschreibung eines Verfahrens,
um aus gewissen Eingabegrößen bestimmte Ausgabegrößen zu
berechnen. Dabei müssen folgende Bedingungen erfüllt sein
 Spezifikation
 Durchführbarkeit
 Korrektheit
 Verfahren ohne Verständnis des Problemes
FHSymbol1
Erwarten Sie nie, dass ein
Computer für Sie mitdenkt
5.2.2 Der Algorithmus : Spezifikation
 Eingabespezifikation:
 Es muss genau spezifiziert sein, welche Eingabegrößen erforderlich
sind und welchen Anforderungen diese Größen genügen müssen, damit
das Verfahren funktioniert
EINGABE
Algorithmus
 Ausgabespezifikation
 Es muss genau spezifiziert sein, welche Ausgabegrößen (Resultate) mit
welchen Eigenschaften berechnet werden
5.2.2 Der Algorithmus : Durchführbarkeit
 Endliche Beschreibung
 das Verfahren muss in einem endlichen Text vollständig beschrieben
sein
 Effektivität
 Jeder Schritt des Verfahrens muss effektiv (d.h. tatsächlich)
„mechanisch“ ausführbar sein
Bem.: „Effektivität“ ist nicht zu verwechseln mit „Effizienz“
(„Wirtschaftlichkeit“)
 Determiniertheit
 Der Verfahrensablauf ist zu jedem Zeitpunkt fest vorgeschrieben
5.2.2 Der Algorithmus : Korrektheit
 partielle Korrektheit
 Jedes berechnete Ergebnis genügt der Ausgabespezifikation, sofern die
Eingaben der Eingabespezifikation genügt haben
 Terminierung
 Der Algorithmus hält nach endlich vielen Schritten mit einem Ergebnis
an, sofern die Eingaben der Eingabespezifikation genügt haben
5.2.2 Der Algorithmus : Zusammenfassung
 Definition
Ein Algorithmus (algorithm) ist die Beschreibung eines Verfahrens,
um aus gewissen Eingabegrößen bestimmte Ausgabegrößen zu
berechnen,
der gekennzeichnet ist durch:
1.
2.
3.
4.
5.
6.
7.
Spezifikation der Ein- und
Ausgabegrößen
eine endliche Beschreibung des Verfahrens
effektive Ausführbarkeit der Verfahrensschritte
Determiniertheit der Verfahrensschritte
partielle Korrektheit
Terminiertheit
 Bemerkung:
 Algorithmen, die eine oder mehrere dieser Eigenschaften nicht besitzen
werden dann als Nicht-<Eigenschaft> Algorithmen bezeichnet.
 Bsp: Nicht-Deterministische Algorithmen.
5.2.3 Beispiel: Algorithmenbeweis
 In gängiger mathematischer Notation könnte ein Verfahren zur Berechnung
der Modulus-Funktion a mod b wie folgt aussehen:
 Um festzustellen, ob diese Berechnungsvorschrift einen Algorithmus im Sinne
der Definition darstellt, müssen folgende Punkte beachten werden:
 Spezifikation
 Eingabe
 Ausgabe
 Durchführbarkeit
 Endliche Beschreibung
 Effektivität
 Determiniertheit
 Korrektheit
 Partielle Korrektheit
 Terminierung
5.2.3 Beispiel: Spezifikation
 Lassen sich die möglichen Ein- und Ausgabewerte genau
spezifizieren ?
5.2.3 Beispiel: Durchführbarkeit
 Ist der Algorithmus durchführbar ?
5.2.3 Beispiel: Korrektheit (partielle)
 Ist der Algorithmus korrekt (im Sinne der Spezifikation)
5.2.3 Beispiel: Korrektheit (Terminierung)
 Terminiert der Algorithmus ?
 Bemerkung: Es gibt kein Verfahren, das zu einem beliebigen
Algorithmus angibt, ob er terminiert oder nicht („Halte-Problem“)
5.2.3 Weitere Prinzipien
 Neben den in der Definition angegebenen Eigenschaften gibt es
weitere wichtige Prinzipien, die bei der Erstellung eines
Algorithmuses zu beachten sind:
 Effizienz
 Der Algorithmus soll möglichst wenig Aufwand verursachen
– Das Ergebnis mit möglichst wenig Rechenschritten (oder mit möglichst wenig
Speicherbedarf) erzielen
 Korrektheit beweisbar?
 Ein nicht-korrekter Algorithmus ist nach unserer Definition kein Algorithmus!
 Trotzdem sind nicht-korrekte Verfahren eher die Regel als die Ausnahme
5.2.4 Algorithmen und Programme: Der Weg
Algorithmierung
Programmierung
Problem
Algorithmus
Programm
Spezifizieren
Verifizieren
Testen
 gegeben: das Problem
 durch Spezifizieren wird das Problem formal beschrieben
 Durch Algorithmierung (Algorithmenentwurf) wird ein Algorithmus
erzeugt
 durch Verifizieren kann der Algorithmus auf Übereinstimmung mit der
Spezifikation überprüft werden
 Durch Programmieren wird aus den Algorithmus ein Programm
erzeugt
 durch Testen kann das Programm auf Übereinstimmung mit der
Spezifikation und dem Algorithmus überprüft werden.
5.2.4 Algorithmen und Programme: Beziehungen
Algorithmierung
Problem
Programmierung
Algorithmus
Programm
 Programmieren setzt Algorithmenentwicklung voraus
 Kein Programm ohne Algorithmus !
 Jedes Programm repräsentiert einen bestimmten Algorithmus.
 Ein Algorithmus kann durch viele Programme repräsentiert werden.
Problem
Algorithmus1
Algorithmus2
Programm21
Programm22
...
...
5.2.5 Ausflug: Algorithmus und WinOSe
Klassische
Programmierung
Windows
Programmierung
OS
Algorithmus
OS
Eventqueue
5.3
Strukturelemente
 Um die Dynamik - also die Abfolge von Aktionen - eines Algorithmuses zu beschreiben, benötigt man formale Beschreibungsmittel,
sowie eine Festlegung, wie diese Beschreibungmittel zu notieren und
zu interpretieren sind.
Dieses Unterkapitel stellt die formalen Beschreibungsmittel für
Algorithmen vor. Diese Beschreibungsmittel sind dabei gleichzeitig
Strukturierungselemente für Algorithmen, denn sie definieren die
Struktur von Algorithmen.
 Inhalt:
1.
2.
3.
4.
Die Elemente
Folge
Auswahl
Wiederholung
5.3.1 Die Elemente: Aus dem Beispiel
EINGABE
 Zuweisungen
 Berechnungen
 Variable
 Mathematische
Grundoperationen
 komplexe Funktionen
 ...
 Bedingte Ausführungen
 Schleife
 ...
AUSGABE
 Texte
 Zahlen ...
 Konstanten
(Literale)
 Texte
 Zahlen ...
5.3.1 Die Elemente: Notation
 Für die Beschreibung von Algorithmen gibt es viele Möglichkeiten
 Alltagssprache
 Konkrete Programmiersprache
 Dazwischen gibt es eine Vielzahl von Notationen, die den Übergang
zwischen Problembeschreibung und Programm erleichtern sollen
 Eine mögliche - eindimensionale - Notation ist Pseudocode:
 // Dies ist eine Zuweisung
x = 42;
 Kommentare werden (hier) mit vorangestellten Slashes „//“ gekennzeichnet
 Aktionen werden (hier) mit Semikolon „;“ getrennt
 Visualisierung durch graphische - zweidimensionale -Notation
 Flussdiagramme
 Struktogramme (=Nasi-Schneidermann-Diagramme)
Aktion
Aktion
5.3.1 Die Elemente: atomaren Elemente
 Anweisungen sind die atomaren Elemente eines Algorithmus‘, die
Elemente also, aus denen ein Algorithmus aufgebaut ist.
 Es gibt (zunächst) drei Arten dieser „atomaren“ Elemente
 Zuweisung:
 Pseudocode
X = y;
 Auf der linken Seite der Zuweisung steht eine Variable auf der rechten Seite
der Zuweisung steht entweder eine Variable, ein Literal oder eine
Berechnung aus Varaibelen und Literalen
 Eingabe
 Pseudocode:
x << <Eingabegerät> ;
 Als Eingabegerät kann ein geeignetes physikalisches Geraöt (Tastatur,
Schnittstelle, ...) angegeben werden.
 Ausgabe
 Pseudocode:
x >> <Ausgabegerät> ;
 Als Ausgabegerät kann ein geeignetes physikalisches Geraöt (Bildschirm,
Drucker, Schnittstelle, ...) angegeben werden
 Ein- und Ausgabe können auch als Zuweisung verstanden werden.
5.3.1 Die Elemente: Kontrollelemente
 Die atomaren Elemente eines Algorithmuses können durch drei
einfache Strukturierungsmethoden, den „Kontrollelementen“,
zueinander in Beziehung gesetzt werden:
1. Folge (Sequenz)
2. Auswahl (Selektion, Fallunterscheidung)
3. Wiederholung (Iteration, Schleife)
 Die Kontrollelemente bestimmen die Reihenfolge von Aktionen in
Algorithmen
 Eine Aktion (Ai) - auch Verarbeitung genannt - ist ein atomares
Element oder eine durch die Strukturmethoden zusammengefasste
Menge mehrerer Aktionen
5.3.2 Folge
 Folgen bestimmen die lineare Reihenfolge von Aktionen in
Algorithmen:
 Flussdiagramm
Struktogramm
Pseudocode:
A1
A2
..
.
An
A1
A2
{
..
.
An
}
A1;
A2;
...
An;
5.3.3 Auswahl : bedingte Verarbeitung
 Eine Aktion wird, in Abhängigkeit einer bool‘schen Bedingung
ausgeführt oder nicht
 auch „einarmiges if“ genannt.
 Flussdiagramm
Struktogramm
Pseudocode:
f
B
w
w
B
f
A1
A1
 Beispiel:
if (x<0) then x = -x;
if B then A1;
5.3.3 Auswahl : einfache Alternative
 In Abhängigkeit einer bool‘schen Bedingung wird entweder eine
Aktion oder eine andere Aktion ausgeführt
 auch „zweiarmiges if“ genannt.
 Flussdiagramm
w
B
Struktogramm
f
w
A1
A1
 Beispiel:
B
f
A2
Pseudocode
if B then A1
else A2;
A2
if (x<0) then x:=-x else x=0;
5.3.3 Auswahl : mehrfache Alternative
 In Abhängigkeit einer Bedingung (mit mehreren möglichen Werten
w1, w2, ..., wn) wird eine Aktion aus einer Menge möglicher Aktionen
ausgewählt und ausgeführt
 Flussdiagramm
Struktogramm
Pseudocode
B
w1
w2
A1 A2
 Beispiel:
w1
wn
B
A1 A2
wn
An
An
switch x: {
case 0: x = x/2;
case 1; x = x+1;
}
 Oft auch mit „else“-Alternative (statt wn)
switch
{
case
case
...
case
}
B:
w1: A1;
w2: A2;
wn: An;
5.3.4 Schleife: mit vorausgehender Prüfung
 Solange eine bool‘sche Bedingung erfüllt ist, wird eine Aktion
ausgeführt.
 Die Bedingung wird vor der ersten Ausführung der Aktion geprüft
 heißt auch: abweisende Schleife (While-Schleife)
 Flussdiagramm
f
B
Struktogramm
B
A1
w
A1
 Beispiel:
while x < 100 {
x = x + 1;
}
Pseudocode
while B
{
A1
}
5.3.4 Schleife: mit nachfolgender Prüfung
 Solange bis eine bool‘sche Bedingung erfüllt ist, wird eine Aktion
ausgeführt.
 Die Bedingung wird (erst) nach der ersten Ausführung der Aktion geprüft
 heißt auch: Repeat-Schleife
 Flussdiagramm
A1
B
Struktogramm
B
f
w
 Beispiel:
repeat {
x = x + 1;
} until x > 100
A1
Pseudocode
repeat
{
A1
} until B
5.3.4 Schleife: Beispiel (abweisende Schleife)
 Untersuche ob eine gegebene natürliche Zahl Primzahl ist.
 p > 2 ist Primzahl, falls sie durch kein t mit 1<t<p teilbar ist (p mod t  0)
 Idee:
 wenn p Primzahl, dann ist p ungerade
 es genügt, nur ungerade t zu untersuchen
 es genügt, nur solche t zu untersuchen die kleiner p sind,
 Algorithmus:
p << Tastatur;
if ((p>2) and (p mod 2 != 0)) then {
t = 3; // initialize t
while ((t*t<p) and (p mod t != 0)) {
t = t + 2;
} // nach Schleife ist t*t >=p oder p mod t == 0
if (t*t>p) then „p ist Primzahl“ >> Bildschirm;
else „p ist keine Primzahö“ >> Bildschrim;
}
else
{ „p <= 2 oder p gerade“ >> Bildschirm; } // Primzahl ?
5.3.4 Schleife: Beispiel (Vergleich while  repeat)
 Sind diese Schleifen im Ergebnis identisch ?
while x < 100
{
x = x + 1;
}
repeat
{
x = x + 1;
} until x > 100
 und jetzt ?
repeat
{
x = x + 1;
} until x >= 100
 Letzer Versuch:
if (x <= 100) then {
repeat {
x = x + 1;
} until x >= 100
}
 Welche Lösung ist eleganter ?
 aber: oft wird eine erstmalige Aktion benötigt, um ein Datum überhaupt
überprüfen zu können.
5.3.4 Schleife: Beispiel (Vergleich repeat  while)
 Ausdrucken einer Datei
repeat
{
x << Datei;
if (x != eof) x >> Drucker;
} until x == eof //endoffile
 ... das Ganze als while-Schleife ?
while (x != eof )
{
x << Datei;
x >> Drucker;
}
 Noch‘n Versuch:
x << Datei;
while (x != eof )
{
x >> Drucker;
x << Datei;
}
5.3.4 Schleife: Beispiel (Schleife mit Zählern)
 Sehr häufig werden Schleifen verwendet, deren Bedingung abhängig
von Zählerwerten sind.
 Die Zählerwerte werden vor Eintritt in die Schleife initialisiert
 Die Bedingung prüft den Zählerwert
 Im Schleifenkörper wird der Zähler erhöht (increase) oder erniedrigt
(decrease)
 Vorsicht mit: dem Zählertyp, dem Additionswert, der Bedingung
 Algorithmus:
// --- Initialisierung -----------------------------s = 0;
i = 1; // Initialisierung des Schleifenzählers
// --- Schleife (Berechnet Summe 1..n) ------------while ( i <= n )
{
s = s + i;
i = i + 1; // Erhöhung des Schleifenzählers (oft um 1)
}
5.2.4 Schleife: Die „For“-Schleife
 Da Schleifen mit Zähler sehr häufig auftreten, stellen viele
Programmiersprachen ein eigenes sprachliches Mittel dafür zur
Verfügung: Die „For“ Schleife
 Pseudocode:
Beispiel:
for var=start_value to end_value
for i=1 to 10
{
{
A;
x = x + i;
}
}
 Der Zähler (var) wird pro Schleifendurchlauf implizit um 1 erhöht
(Bei manchen Sprachen - z.B. Basic, C, C++ - kann man dies ändern)
 Dieser Code ist äquivalent mit folgender Schleife:
i = start_value
while i <= end_value
{
A;
i = i+1;
}
5.3.4 Schleife: Beispiel (Endlosschleife)
 Manchmal macht es Sinn, Schleifen endlos laufen zu lassen:
 z.B. bei der zyklischen Abprüfung von Systemzuständen (Windows
Event-Queue)
 manchmal macht das keinen Sinn - passiert aber trotzdem ;-)
 Flussdiagramm
Struktogramm
B
A1
A1
 Beispiel:
Pseudocode
while true
{
A1
}
while true {
„Druckerpapier ist teuer“ >> Drucker;
}
5.4
Strukturierung
 Mit Hilfe atomarer Elemente und der Kontrollelemente lassen sich
Algorithmen strukturieren. In diesem Kapitel sind einige Begriffe zur
Strukturierung erläutert. Insbesondere wird ein weiteres - viertes Kontrollelement vorgestellt (und auch gleich wieder verworfen)
 Inhalt
1.
2.
3.
4.
Control Flow
Strukturierung durch Sprung
Strukturiert-iterative Beschreibungsform
Strukturierungstypen
5.4.1 Control Flow
 Mithilfe der Kontrollelemente können die „atomaren“ Elemente
(Anweisungen) strukturiert werden
 Die Anordnung der Anweisungen (als atomare Elemente) eines
Algorithmus, die bestimmt, in welcher Reihenfolge Dinge geschehen,
heißt
 control flow (Steuerungsverlauf, Kontrollfluss) des Algorithmus
genannt
 Manchmal wird auch der Programmablauf oder Kontrollfaden (thread of
control, thread), also die tatsächlich abgespulten Schritte und
Anweisungen so bezeichnet
5.4.2 Strukturierung durch Sprung
 Bei der Vorstellung der Kontrollelemente wurde (aus hinterhältig,
didaktischen) Gründen auf ein viertes Element verzichtet:
Der Sprung („Goto“-Anweisung)
 Die Konstruktion „fahre fort mit Schritt x“ (goto x) stellt einen solchen
Sprung (jump) im Steuerungsverlauf dar
 Zur Anwendung von goto werden Schritte mit einer Marke (Label)
versehen, um das Ziel des Sprunges zu kennzeichnen
 Dies ist die elementarste Form, eine Wiederholung oder sonstige
Verzweigung im Ablauf auszudrücken
 Dadurch erhalten wir die elementar-iterative Beschreibungsform von
Algorithmen, die die Strukturierung mit ein-/mehrfacher Auswahl und
Schleifen funktional abdeckt.
 Beispiel:
while x<100 {
x = x+1
}
1: if x>0 100 goto 2
x = x+1;
goto 1;
2: ...
5.4.2 Strukturierung durch Sprung
 Anwendung von Sprüngen ist sehr gefährlich!
 Sprünge strukturieren komplexe Programm nicht ausreichend - der
Steuerungsverlauf kann verworren und unübersichtlich sein
 Um den Steuerungsverlauf auch bei komplexen Algorithmen
übersichtlich zu halten, schränkt man die Sprünge ein:
 Schleifen der Flussdiagramme sind höchstens ineinander geschachtelt
 Schleifen überkreuzen sich nicht!
 Bei gut strukturierten Algorithmen würde man z. B. nur wieder eine
geschlossene Schleife oder einen (vorzeitigen) Sprung bedingt durch
die Behandlung desTrivialfalls erlauben
 Wir sprechen in diesem Fall von strukturierten Sprüngen im
Gegensatz zu freien Sprüngen, die prinzipiell beliebige Ziele haben
können
5.4.3 Strukturiert-iterative Beschreibungsform
 Sprünge können die bestimmte „höhere“ Strukturierungsarten
funktional abzubilden.
Hier gilt auch der Umkehrschluss
 In der strukturiert-iterativen Beschreibungsform kommen Sprünge
nur noch implizit bei der Ausführung höherer Iterationsstrukturen vor
 Dieses sind Fallunterscheidungen (Auswahl) wie if-then-else
 oder insbesondere Schleifenkonstrukte
 Diese bewirken, dass der Programmfluss
 In einer Auswahl zu genau einer Auswahl geht.
 in einer Schleife von einer Prüfung zu den Aktionen des Schleifenkörpers
und wieder zurück zur Prüfung geht.
 Viele höhere Programmiersprachen (Pascal, C, C++) erlauben jedoch
die Verwendung von Sprüngen
 Aus Optimierungsgründen (Nähe zur Maschinensprache)
 Aus Strukturierungsgründen)
5.4.4 Strukturierungstypen
 Beispiel: Schemen einiger Kontrollflüsse
Strukturiert-iterativ
Elementar-iterativ
Spaghetti-Code
5.5
Blockung
 Mit Hilfe der bislang vorgestellten Kontrollelemente lassen sich die
atomaren Elemente (Anweisungen) eines Algorithmus‘ zu einem
Kontrolfluss strukturieren. Wie wir gesehen haben, kann dieser
Kontrollfluss mehr oder weniger „wohlstrukturiert“ sein.
In diesem Unterkapitel wird eine Element beschrieben, mit dem
Aktionen statisch nochmals zusammengefasst werden können. Diese
Zusammenfassung hat auch Einfluss auf das dynamische Verhalten
von Verarbeitungsobjekten (Variable).
 Inhalt:
1.
2.
3.
4.
5.
6.
7.
8.
Die Idee
Notation
Formale Parameter
Beispiel: Ein einfacher Block
Eigenschaften
Beispiel: Seiteneffekte
Vorzeitiges Verlassen
Goldene Regeln
5.5.1 Die Idee
 Idee:
Eine Zusammenfassung von Aktionen bekommt einen Namen und
kann durch das Nennen des Namens (Aufruf) aktiviert werden.
 In einen Block sollen Daten formal hinein und herausgelangen
 Ein Block soll eigenen Daten besitzen
 Vorteile:
 Gliederung des Algorithmus‘ durch hierarchische Dekomposition
(„Divide et impera: Teile und herrsche“)
 Wiederverwendbarkeit durch mehrfachen Aufruf statt durch mehrfaches
notieren.
 universeller ( Anzahl muss nicht bekannt sein)
 fehlerunanfälliger
 Kapselung unwichtiger Details („information Hiding“)
 Vorteile bei der Organisation von Programmiertätigkeit durch
Verteilbarkeit der Aufgaben.
5.5.2 Notation
 Ein Block ist die Zusammenfassung von Aktionen und wird wie folgt
beschrieben:
 Pseudocode:
Flussdiagramm
blockname (IN:
x1:Type1,
OUT:
y1:Type2,
THROUGH: z1:Type3,
{
lokal: w1:Type41; w2:Type42;
A;
}
… ;
… ;
…
)
blockname
… ;
 blockname ist der Name des Blockes
 xi,yi,zi heißen formale Parameter und sind typisiert
 wi heißen lokale Variable
Struktogramm
blockname
 A ist eine Menge von Aktionen.
 Blöcke werden in vielen Sprachen als Funktion (nur ein OUTParameter) bzw. Prozeduren umgesetzt
5.5.3 Formale Parameter
 IN-Parameter (Eingabeparameter) sind Parameter, die an den Block
übergeben werden
 Dazu werden beim Aufruf des Blockes an die Stelle der
Eingabeparameter Variable, Literale oder Ausdrücke (Berechnungen)
notiert. Diese werden beim Aufruf zu Werten transformiert, die an den
entsprechnden Variablen zugewisen werden.
(call by value)
 OUT-Parameter (Ausgabeparameter) sind Parameter, die aus dem
Block durch Zuweisung an Variable zurückgegeben werden.
 Dazu werden beim Aufruf des Blockes an die Stelle der
Ausgabeparameter Variablen notiert, die nach dem Aufruf die
zurückgegeben Werte beinhalten
(call-by refernce)
 THROUGH-Parameter (Ein-/Ausgabeparameter) sind Parameter die
Werte in den Block hinein und hinaus übermitteln.
 Eingabe wie bei IN-Parametern (aber: nur Angabe einer Variable)
 Rückgabe wie bei OUT-Parametern
5.5.4 Beispiel: Ein einfacher Block
 Ein Block zur Berechnung von Summen (mit Aufrufzähler)
summe (IN:
value1 : Integer; value2 : Integer;
OUT:
result : Integer;
THROUGH: counter : Integer
)
{
i : integer:
// lokale Variable
result = 0;
// Initialisierung
for i=1 to value2
// ein wenig umständlich
result = value1 + 1;
counter = counter + 1;
}
 Aufruf
anzahl = 1;
// schon erste Summe hat zwei Summanden
initial = 5;
summe(initial, 9, ergebnis, anzahl);
summe(ergebnis, 9, ergebnis, anzahl);
ergebnis/anzahl >> Bildschirm
// Mittelwert
5.5.5 Eigenschaften
 Jeder Block kann über einen Satz lokaler Variable verfügen, die
außerhalb des Blockes nicht sichtbar sind
 Die Variablenbezeichner können also außerhalb ohne Einfluss auf den
Block verwendet werden
 Auch die in der Blockdefinition als formale Parameter verwendeten
Variablenbezeichner sind nur im Block sichtbar:
 Auch sie können außerhalb ohne Einfluss verwendet werden,
 Aber Vorsicht: die Veränderung von IN und THROUGH-Parametern bewirkt
(oft) eine Veränderung der beim Aufruf verwendeten zugehörigen Parameter
(der zugehörigen „gebundenen“ Parameter).
 Variable, die in einem Block verwendet aber nicht deklariert werden,
werden als „global“ angenommen
 Viele Sprachen erlauben die Definition von Blöcken innerhalb von
Blöcken
 Variablen, die in einem Block nicht deklariert sind, werden im
umgebenden Block vermutet.
5.5.6 Beispiel: Seiteneffekt
 Das (ungewollte) implizite Verändern von „äußeren“ Parametern
durch Veränderung „innerer“ Parameter nennt man „Seiteneffekt“
summe (THROUGH: value1 : Integer; value2 : Integer;
result : Integer;
)
{
value1 = value1 + value2;
result = value 1;
}
 Aufruf
x = 5; y = 7;
summe (x,y,z);
„Die Summe von „ >> Bildschirm;
x >> Bildschirm;
„und“ >> Bildschirm;
y >> Bildschirm;
„ ist „ >> Bildschirm;
z >> Bildschirm;
Die Summe von
12
und
7
Ist
12
5.5.7 Vorzeitiges Verlassen
 Manchmal ist es sinnvoll, die Abarbeitung eines Blockes vorzeitig zu
beenden
 Dies wird oft im Fehlerfall gemacht, wenn eine Weiterbearbeitung nicht
mehr sinnvoll erscheint - z.B. nach einer negativen Überprüfung der
Eingabeparameter
 Flussdiagramm
Block
 Beispiel:
Struktogramm
Block
Pseudocode
Return;
wurzel(IN: argument:real; OUT: result:real)
{
if (x<0) return; // return already here
else result = sqr(argument);
}
5.5.8 Goldene Regeln
 Namen so lokal wie möglich deklarieren
 Möglichst keine globalen Variablen verwenden
 Wenn doch:
 Ganz wenige - nur eine (z.B. strukturiert)
 Auffällig kennzeichnen: z.B. global_error_handle
 Nach Möglichkeit „call by value“ verwenden
 Wird nicht von allen Programmiersprachen unterstützt
 Probleme bei der Rückgabe umfangreicher Daten (wg. Umkopieren)
 Blöcke sind so zu wählen dass:
 Der innere Zusammenhang stark ist
 Der äußere Zusammenhang schwach ist (minimale Schnittstellen, keine
Datenteilung , z.B. durch globale Variable)

Kapitel_5_1_5