4. Prozedurales Programmieren

4. Prozedurales 

Programmieren 

• Der Begriff des Algorithmus‘ 

• Grundkonzepte prozeduraler Programmierung 

• Formulierung von Algorithmen und Daten- 

strukturen mit prozeduralen Sprachen 

• Verifikation prozeduraler Programme 

04.12.08 © A. Poetzsch-Heffter, TU Kaiserslautern 

1

4.1 Der Begriff des Algorithmus 

Zentrale Begriffe der algorithmischen Vorgehens: 

• Algorithmus 

• Variablen zur Speicherung von Werten 

• Ausführungszustand = 

Speicherzustand + Steuerungszustand 

• Zustandsveränderung 

• Aktion 

• Ablauf 

• Determinismus, Determiniertheit 

Die prozedurale Modellierung und Programmierung 

baut auf den klassischen Algorithmusbegriff auf. 

Eine Berechnung wird als zustandsverändernder 

Ablauf betrachtet. 

Damit orientiert sie sich am Berechnungskonzept von 

Rechnern, der auch auf die Beschreibung von 

Abläufen basiert, in denen in jedem Schritt der 

Ausführungszustand verändert wird. 


2

Begriffsklärung: (Algorithmus) 

Ein Algorithmus ist ein Verfahren zur schrittweisen 

Ausführung von (Berechnungs-) Abläufen, das 

sich präzise und endlich beschreiben lässt, so dass: 

- die Beschreibung auf wohlverstandenen, ausführbaren 

(„effektiven“) Einzelschritten basiert; 

- in jedem Schritt eine oder mehrere Aktionen ggf. 

parallel ausgeführt werden; 

- jede Aktion von einem Zustand in einen 

Nachfolgezustand führt. 

Man sagt, die Ausführung eines Algorithmus 

terminiert, wenn sie nach endlich vielen Schritten 

beendet ist; andernfalls spricht man von einer nichtterminierenden 

Ausführung. 

Bemerkung: 

Es gibt viele Begriffsklärungen für „Algorithmus“, die 

sich aber in den wesentlichen Aspekten gleichen. 


3

Beispiel: (Algorithmus, der erste) 

Verdoppeln nach Adam Riese (1574): 

Dupliren: 

Lehret wie du ein zahl zweyfaltigen solt. 

Thu ihm also 

Schreib die zahl vor dich / 

mach ein Linien darunder / 

heb an zu forderst / 

Duplir die erste Figur. 

Kompt ein zahl die du mit einer Figur schreiben magst / 

so setz die unden. 

Wo mit zweyen / 

schreib die erste/ Die ander behalt im sinn. 

Darnach duplir die ander / 

und gib darzu/ 

das du behalten hast / 

und schreib abermals die erste Figur / 

wo zwo vorhanden / 

und duplir fort biß zur letzsten / 

die schreibe gantz auß / 

als folgende Exempel außweisen: 

... 


4

Um die Zustände zwischen den Schritten 

präziser fassen zu können, führt man Variablen 

ein, die Werte speichern können: 

Variablen stellen wir graphisch durch Rechtecke dar: 

v: true 

v1: 7 

v enthält/speichert den Wert true 

v1 enthält/speichert den Wert 7 

Begriffsklärung: (Speichervariable) 

Eine Speichervariable (oder einfach nur Variable) 

ist ein Speicher/Behälter für Werte. Charakteristische 

Operationen auf einer Variablen v: 

- Zuweisen eines Werts w an v; 

- Lesen des Wertes, den v enthält/speichert/hat. 

Der Zustand einer Variablen v ist undefiniert, wenn 

ihr noch kein Wert zugewiesen wurde; andernfalls ist 

der Zustand von v durch den gespeicherten Wert 

charakterisiert (vgl. Folie 179). 


5

Beispiel: (Algorithmus, der zweite) 

Berechnung des größten gemeinsamen Teilers: 

Seien m, n, v Variablen für int-Werte; 

lese die Werte w1 und w2 ein, für die der ggT berechnet 

werden soll, und weise w1 an m und w2 an n zu; 

solange der Wert von m größer als 0 ist, tue Folgendes 

und prüfe danach wieder die Bedingung: 

berechne n mod m und weise das Ergebnis an v zu; 

weise den Wert von m an n zu; 

weise den Wert von v an m zu; 

gebe den Wert aus, den n enthält. 

Aufgabe: 

Führen Sie den Algorithmus für mehrere Eingaben aus. 

m: n: v: 


6

Formulierung des obigen Algorithmus durch ein 

Flussdiagramm: 

GGT-Beginn 

leseInt � m 

leseInt � n 

m>0 

true 

n mod m � v 

m � n 

v � m 

false 

schreibeInt � n 

GGT-Ende 


7


Java-Programm: 

public class GGT { 

// Berechnet ggT für 2 gelesene Werte 

} 

public static void main( String[] args ){ 

int m; 

int n; 

int v; 

} 

IO.println("Argument 1:"); 

m = IO.readInt(); 

IO.println("Argument 2:"); 

n = IO.readInt(); 

IO.println("ggT:"); 

while( m>0 ) { 

v = n % m; 

n = m; 

m = v; 

} 

IO.println( n ); 


8


C++ Programm (ohne zusätzliche Ausgaben): 

#include 

// Berechnet ggT für 2 gelesene Werte 

void main(){ 

int m; 

int n; 

int v; 

} 

cin >> m; 

cin >> n; 


v = n % m; 

n = m; 

m = v; 

} 

cout

Begriffsklärung: (Zustände) 

Jeder Schritt bei der Ausführung eines Algorithmus 

führt von einem Ausführungszustand zum 

Nachfolgezustand. Ein Ausführungszustand ist 

gekennzeichnet durch 

- den Speicherzustand (im Wesentlichen der 

Zustand der Variablen); 

- den Steuerungszustand (vereinfacht gesagt, die 

Stelle im Programm, an der die Ausführung 

angekommen ist). 

Ein Ausführungsschritt führt zu einer Zustandsveränderung, 

also einer Veränderung von Speicherund/oder 

Steuerungszustand. 

Begriffsklärung: (Aktion) 

In einem Ausführungsschritt wird üblicherweise 

eine Aktion ausgeführt. Aktionen sind: 

- Zuweisungen an Variablen 

- Kommunikation mit der Umgebung (Ein- und Ausgabe) 

Die Aktion bestimmt nachfolgende Steuerungszustände 

bzw. die Terminierung des Algorithmus. 


10

Begriffsklärung: (Ablauf) 

Der Ablauf eines Algorithmus zu gegebenen 

Eingaben wird charakterisiert durch 

- die Sequenz der Ausführungszustände, 

- die Sequenz der ausgeführten Aktionen. 

Begriffsklärung: (Effizienz) 

Ein Algorithmus A heißt effizienter als ein Algorithmus 

B, wenn der „Aufwand“ zur Ausführung von A geringer 

ist als der „Aufwand“ zur Ausführung von B und zwar 

für die zulässigen Eingabedaten. 

Oft wird nur erwartet, dass der Aufwand für alle bis 

auf endlich viele Eingaben geringer ist oder nur im 

Mittel über die zulässigen Eingaben. 

Mit den gemachten Präzisierungen lässt sich der 

Aufwand einer Ausführung quantifizieren: 

- Zeitkomplexität: Wie viele Schritte braucht der 

Algorithmus in Abhängigkeit von den Eingabewerten? 

- Raumkomplexität: Wie viel Speicherplatz braucht der 

Algorithmus in Abhängigkeit von den Eingabewerten? 


11

Begriffsklärung: (deterministisch) 

Ein Algorithmus heißt deterministisch, wenn 

für alle Eingabedaten der Ablauf des Algorithmus 

eindeutig bestimmt ist. 

Andernfalls heißt er nicht-deterministisch. 

Beispiel: (nicht-deterministischer Algorithmus) 

Aufgabe: 

Erkenne, ob eine Eingabezeichenreihe über Kleinbuchstaben 

eines der Worte “otto“, “toto“, “total“ enthält. 

Nicht-deterministischer Algorithmus: 

• Seien 

- z die Eingabe und 

- pflän(z) = { 0, ... , länge(z)-4 } 

• Solange pflän ≠ ∅ tue Folgendes: 

- wähle ein x aus pflän aus; 

- pflän = pflän \ { x } ; 

- w = „z ohne die ersten x Buchstaben“ ; 

- prüfe, ob w mit “otto“, “toto“, “total“ beginnt ; 

- wenn ja, terminiert der Algorithmus mit „ja“; 

andernfalls setze die Schleife fort. 

• Terminiere mit „nein“. 


12

Begriffsklärung: (determiniert) 

Ein Algorithmus heißt determiniert, wenn er 

bei gleichen zulässigen Eingabewerten stets das 

gleiche Ergebnis liefert. 

Andernfalls heißt er nicht-determiniert. 

Beispiele: (Determiniertheit) 

1. Jeder Algorithmus, der eine Funktion berechnet, 

ist determiniert. 

2. Der Algorithmus von der letzten Folie ist 

determiniert. 

4.2 Grundkonzepte 

prozeduraler Programmierung 

Algorithmen lassen sich mit unterschiedlichen 

Sprachmitteln beschreiben: 

- umgangssprachlich 

- mit graphischen Notationen 

- mit mathematischer Sprache 

- mit programmiersprachlichen Mitteln. 


13

Begriffsklärung: (prozedurales Paradigma) 

Gemäß des prozeduralen Paradigmas (vgl. F2.39) wird 

- der Zustand eines Systems mit Variablen beschrieben 

- werden die möglichen Systemabläufe algorithmisch 

formuliert und 

- bilden Prozeduren das zentrale Strukturierungs- 

und Abstraktionsmittel. 

Beispiel: (Prozedurale Systemsicht) 

Ein Rechensystem (z.B. PC) kann man prozedural 

wie folgt beschreiben: 

- Jede Datei ist eine Variable für Listen von Bytes. 

- Nach dem Starten des Rechners wird ein nichtterminierender 

Algorithmus ausgeführt: 

} 

while( true ) { 

warte auf Eingabe eines Programmnamens; 

starte Programm mit eingegebenem Namen 

als parallelen Algorithmus; 

- Jedes Programm entspricht dabei einer Prozedur. 


14

4.2.1 Sprachliche Basis: 

Teilsprache von Java 

Der Abschnitt 4.2 stellt diejenigen Grundkonzepte 

der prozeduralen Programmierung vor, die als 

Voraussetzung für die objektorientierte 

Programmierung benötigt werden: 

• Deklaration und Verwendung von Variablen 

• Anweisungen 

• Deklaration und Verwendung von Prozeduren 

Zur praktischen Programmierung verwenden wir 

eine Teilsprache von Java. 

Vorteile: 

- Der Übergang zur objektorientierten Programmierung 

wird einfacher. 

- Der Zusammenhang zwischen prozeduraler und 

objektorientierter Programmierung wird klarer. 

Nachteile: 

- Da klassenlose, rein prozedurale Programmierung 

von Java nicht unterstützt wird, entsteht ein 

notationeller Mehraufwand. 

- Bestimmte Sprachelemente bleiben zunächst 

unerklärt. 


15

Vorgehen: 

- Basisdatentypen 

- Ausdrücke 

- Variablendeklarationen 

- Programmstruktur und vereinfachte Notation 

Basisdatenstrukturen in Java: 

Java bietet insbesondere Basisdatenstrukturen 

mit den Typen 

boolean 

char 

int, long, short, 

float, double 

sowie entsprechende Funktionen und Konstanten. 

Die nichtstrikten Operationen sind: 

_ ? _ : _ statt if _ then _ else _ in ML 

_ && _ statt _ andalso _ in ML 

_ || _ statt _ orelse _ in ML 


16

Ausdrücke in Java: 

Mittels der Konstanten und Funktionen der 

elementaren Datenstrukturen lassen sich analog 

zu ML Ausdrücke bilden. 

(Darüber hinaus kann man deklarierte Prozeduren 

in Ausdrücken aufrufen. Dadurch können bei der 

Auswertung von Ausdrücken Seiteneffekte 

entstehen.) 

Beispiel: (Ausdrücke in Java) 

5 + 89 

45 / 6 

47474747L * a für geeignetes a 

3.6 * (-4 + 23) 

d == 78 + e für geeignete d, e 

7 >= 45 == true 

abs(a) + abs(d) für geeignete a, d, abs 

sein | !sein für geeignete Variable sein 

true || tuEs() für geeignete Prozedur tuEs 

a > b ? a : b // liefert max(a,b) 


17

Variablendeklarationen in Java: 

Eine Variablendeklaration hat die Form: 

; 

und definiert eine neue Variable vom angegebenen 

Typ mit dem angegebenem Bezeichner. Beispiele: 

int a; 

boolean b; 

float meineGleitkommavariable; 

char cvar; 

Eine Variablendeklarationsliste entsteht durch 

Aneinanderreihen von einzelnen Deklarationen. 

Programmstruktur und -syntax: 

Ein prozedurales Programm besteht aus: 

- einer Liste von Typdeklaration 

- einer Liste von globalen Variablendeklarationen 

- einer Liste von Prozedurdeklarationen 

- einer Hauptprozedur 

In Java lassen sich prozedurale Programme mit 

folgendem Programmrahmen formulieren: 


18

.java 

public class { 

} 

static 

... 

static 

static 

... 

static 

static 

... 

static 

public static void main(String[] args) 

 

wobei k ≥ 0, m ≥ 0, n ≥ 0. 

Bemerkung: 

• Die Reihenfolge der Deklarationen kann vertauscht 

werden. 

• Die hier nicht erklärten Sprachkonstrukte werden 

in Kapitel 5 behandelt. 


19

Konventionen: 

• Wir gehen davon aus, dass die Datei InputOutput.java 

im aktuellen Dateiverzeichnis liegt. Sie stellt bereit: 

public class IO { 

} 

public static int readInt(){...} 

public static String readString(){...} 

public static char readChar(){...} 

public static void print(Object o){...} 

public static void println(Object o){...} 

Mit den Prozeduren print und println können 

insbesondere Werte und Objekte der Typen 

int, char und String ausgegeben werden. 

• Im Folgenden werden wir die ersten beiden und 

die letzte Zeile des Programmschemas der letzten 

Folie sowie die Schlüsselwörter static und 

public auf Folien der Übersichtlichkeit halber 

weglassen. 


20

Beispiel: (Notation prozeduraler Programme) 

Foo.java 

public class Foo { 

} 

static int a; 

static boolean bvar; 

static int abs( int n ) { 

if( n>=0 ){ 

return n; 

} else { 

return -n; 

} 

} 

static void setA() { 

a = abs(a); 

} 

public static void main( String[] args ){ 

} 

IO.println("Eingabe von a:"); 

a = IO.readInt(); 

setA(); 

IO.println( a ); 


21

Abkürzend schreiben wir hier: 

int a; 

boolean bvar; 

int abs( int n ) { 

if( n>=0 ){ 

return n; 

} else { 

return -n; 

} 

} 

void setA() { 

a = abs(a); 

} 

void main( String[] args ){ 

} 

println("Eingabe von a:"); 

a = readInt(); 

setA(); 

println( a ); 


22

Überblick übers weitere Vorgehen: 

• Anweisungen 

• Prozeduren 

• Variablen in Programm und Speicher 

• Felder 

• Benutzerdefinierte Typen 

• Sichtbarkeit von Bindungen 

• Iteration und Rekursion 

• Weitere prozedurale Sprachkonzepte 

Bemerkung: 

• Die Konzepte sind rekursiv von einander abhängig: 

- Anweisungen benutzen Variablen und Ausdrücke 

- Prozeduren basieren auf Anweisungen 

- Verwendung von Variablen kann nur im Kontext 

von Anweisungen und Prozeduren erklärt werden. 

- Ausdrücke erlauben die Verwendung von 

Prozeduren. 


23

• In der programmiersprachlichen Realisierung 

der Konzepte verwischen ihre Grenzen; z.B.: 

- Parameter lassen sich wie Variable verwenden. 

- Einfache Anweisungen lassen sich in Ausdrücken 

verwenden. 

4.2.2 Anweisungen 

Begriffsklärung: (Anweisung) 

Anweisungen sind programmiersprachliche Beschreibungsmittel: 

- Einfache Anweisungen beschreiben Aktionen. 

- Zusammengesetzte Anweisungen beschreiben, 

wie mehrere Aktionen auszuführen sind, also 

Teile von Algorithmen. 

Beispiel: (Anweisungen) 

1. Zuweisung eines Werts an eine Variable: 

= ; 

2. Schleifenanweisung: 

while( ) { 

} 

 


24

Bemerkung: 

Unterschied: Anweisung / Ausdruck 

- Die Auswertung von Ausdrücken liefert ein 

Ergebnis. 

- Die Ausführung von Anweisungen verändert 

den Zustand. Im Allg. liefert sie kein Ergebnis. 

Wir betrachten die folgenden Anweisungen und ihre 

Realisierung in Java: 

• Einfache Anweisungen: 

- Zuweisung 

- Prozeduraufruf 

• Anweisungsblöcke 

• Schleifenanweisungen: 

- while-, do-, for-Anweisung 

• Verzweigungsanweisungen: 

- bedingte Anweisung 

- Fallunterscheidung 

- Auswahlanweisung 

• Sprunganweisungen: 

- Abbruchanweisung 

- Rückgabeanweisung 


25

Einfache Anweisungen 

Zuweisung: (engl. assignment) 

Syntax in Java: 

= ; 

Semantik: 

Werte den Ausdruck aus und weise das Ergebnis 

der Variablen zu. (In Java ist eine Zuweisung 

syntaktisch ein Ausdruck, liefert also einen Wert und 

zwar das Ergebnis der Auswertung von der rechten 

Seite der Zuweisung.) 

Beispiele: 

a = 27 % 23; 

b = true; 

meineGleitkommavariable = 3.14; 

Sprechweise: 

„Variable b ergibt sich zu true“ oder 

„Variable b wird true zugewiesen“ . 


26

Bemerkung: 

In einer Zuweisung (und anderen Sprachkonstrukten) 

kann eine Variable v mit zwei Bedeutungen 

vorkommen: 

1. Das Vorkommen links vom Zuweisungszeichen 

meint die Variable. Man spricht vom L-Wert 

(engl. l-value) des Ausdrucks v . 

2. Das Vorkommen rechts vom Zuweisungszeichen 

meint den in v gespeicherten Wert. Man spricht 

vom R-Wert (engl. r-value) des Ausdrucks v . 

Die Unterscheidung wird wichtiger, wenn auch links 

des Zuweisungszeichens komplexere Ausdrücke 

stehen. 

Beispiel: (L-Wert, R-Wert) 

a = 7 + a ; 

L-Wert R-Wert 


27

Prozeduraufruf: (engl. procedure call) 

Syntax: 

( ) ; 

� ε | 

� 

Semantik: 

| , 

Werte die Ausdrücke der aktuellen Parameter aus. 

Übergebe die Ergebnisse an die formalen Parameter. 

Führe die Anweisungen der Prozedur aus. 

Liefere den Rückgabewert, wenn vorhanden. 

Beispiele: 

1. Prozeduraufruf mit Ergebnis: 

a = ggt(a,abs(45-87)); // Zuweisung 

2. Prozeduraufruf mit Seiteneffekt: 

print( ggt(24,248)); // Anweisung 


28

Anweisungsblöcke 

Ein Anweisungsblock (engl. block statement) ist eine 

Liste bestehend aus Deklarationen und Anweisungen. 


{ } 

� ε 

Semantik: 

| 

| 

| 

| 

Stelle den Speicherplatz für die Variablen bereit und 

führe die Anweisungen der Reihe nach aus. 


29

Beispiel: 

{ int i; i = 7; int a; a = 27 % i; } 

Üblicherweise schreibt man Deklarationen und 

Anweisungen untereinander, so dass ein Textblock 

entsteht. 

{ 

} 

int i; 

int x; 

i = readInt(); 

x = abs(i); 

Schleifenanweisungen 

Schleifenanweisungen (engl. loop statements) 

steuern die iterative, d.h. wiederholte Ausführung 

von Anweisungen/Anweisungsblöcken. 

while-Anweisung: 


while( ) 


30

Semantik: 

Werte den Ausdruck aus, die sogenannte Schleifenbedingung. 

Ist die Bedingung erfüllt, führe die 

Anweisung aus, den sogenannten Schleifenrumpf, 

und wiederhole den Vorgang. Andernfalls beende 

die Ausführung der Schleifenanweisung. 

Beispiel: 

Aus der Prozedur ggt: 

while( m>0 ) 

{ 

v = n % m; 

n = m; 

m = v; 

} 

Bemerkung: 

Der Schleifenrumpf ist in den meisten Fällen ein 

Anweisungsblock. Syntaktisch korrekt ist aber 

auch z.B.: 

while( true ) print(i); 


v = n % m; 

n = m; 

m = v; 

} 


31

do-Anweisung: 


do while( ) ; 

Semantik: 

Führe die Anweisung aus. Werte danach den booleschen 

Ausdruck aus. Ist die Bedingung erfüllt ist, 

wiederhole den Vorgang. Andernfalls beende die 

Ausführung der Schleifenanweisung. 

Bemerkung: 

Die do-Anweisung ist immer dann sinnvoll, wenn man 

einen Vorgang mindestens einmal ausführen muss. 

In solchen Situationen spart man sich gegenüber der 

Verwendung der while-Schleife die anfänglich unnötige 

Auswertung der Bedingung. 


32

Beispiel: 

Wir betrachten die Ausgabe der Elemente einer nichtleeren 

Liste. Wir gehen davon aus, dass es einen 

Typ 

IntList mit Prozeduren head, tail und isempty gibt: 

IntList grades; 

int g; 

... // Zuweisung an die Variable noten 

// Ausgabe der nicht-leeren Notenliste 

do { 

g = head(grades); 

println(g); 

grades = tail(grades); 

} while( !isempty(grades) ); 

for-Anweisung (Zählanweisung): 

Die for-Anweisung dient vorrangig zur Bearbeitung 

von Vektoren und Matrizen, deren einzelne 

Komponenten über Indizes angesprochen werden. 

Wir betrachten zunächst ein Beispiel: 


33

Beispiel: (Zählanweisung) 

// Skalarprodukt 


int i; 

} 

// zwei Vektoren mit jeweils 3 Elementen 

int v1[] = new int[3]; 

int v2[] = new int[3]; 

int skalprod; 

v1[0] = 1; 

v1[1] = 3; 

v1[2] = 8; 

v2[0] = 2; 

v2[1] = 3; 

v2[2] = 4; 

skalprod = 0; 

for( i = 0; i


for( ; 

; 

) 

� = 

Semantik: 

Ausdrucksanweisung: 

1. Produktion: wie bei Zuweisung. 

| ++ 

| -- 

2./3. Produktion: Lese den Wert der Variablen. 

Erhöhe/erniedrige den Wert der Variablen um 1. 

Liefere den gelesenen Wert zurück. 

for-Schleife: 

Ausdrucksanweisung1 

boolescher 

Ausdruck 

true 

Anweisung 

Ausdrucksanweisung2 

false 


35

Verzweigungsanweisungen 

Verzweigungsanweisungen (engl. branch statements) 

stellen Bedingungen an die Ausführung einer 

Anweisung oder wählen einen von mehreren 

Zweigen zur Ausführung aus. 

Bedingte Anweisung: 


if( ) 

Semantik: 

Werte den Ausdruck aus. Ist das Ergebnis true, 

führe die Anweisung aus. Andernfalls ist die 

Ausführung sofort beendet. 

Beispiele: 

if( i != 0 ) { n = k/i; } 

if( gute_Idee_vorhanden 

{ 

} 

&& genug_Zeit_zur_Vorbereitung ) 

halte_anregende_Weihnachtsvorlesung(); 

mache_schneller_damit_frueher_fertig(); 


36

Fallunterscheidung: 


if( ) 

Semantik: 

else 

Werte den Ausdruck aus. Ist das Ergebnis true, 

führe Anweisung1, andernfalls Anweisung2 aus. 

Beispiel: 

if( i!=0 ) { 

n = k/i; 

n++; 

} else { 

} 

fehlerbehandlung(“Division durch Null“); 

Auswahlanweisung: 

Auswahlanweisungen erlauben es, in Abhängigkeit 

von dem Wert eines Ausdrucks direkt in einen von 

endlich vielen Fällen zu verzweigen. In Java 

gibt es dafür die switch-Anweisung. Wir verzichten 

hier auf eine genaue Beschreibung von Syntax und 

Semantik und betrachten ein Beispiel: 


37

Beispiel: (Auswahlanweisung) 

// AuswahlanweisungsTest 


} 

char c; 

boolean machWeiter = true; 

do { 

print("Ein Zeichen aus {a,b,c,e}:"); 

c = readChar(); 

switch( c ) { 

case 'a': proza(); break; 

case 'b': prozb(); break; 

case 'c': prozc(); break; 

case 'e': 

machWeiter = false; 

break; 

default: 

} 

print("Falsches Eingabezeichen"); 

} while( machWeiter ); 

wobei proza, prozb, prozc beliebige Prozeduren 

sind, zum Beispiel: 


38

void proza() { 

} 

/* hier könnte 'was Interessantes stehen */ 

println("Ich bin Prozedur A. Alles gut?"); 

println("Probleme mit dem Weina'stress?\n"); 

void prozb() { 

} 

/* hier natürlich auch */ 

println("Wer A sagt, muss auch B sagen."); 

println("Haben Sie schon A gesagt.\n"); 

void prozc() { 

} 

println("C wie no comment. Cool,oder?\n"); 


39

Sprunganweisungen 

Sprunganweisungen (engl. jump statements) legen 

eine Fortsetzungsstelle der Ausführung fest, die 

möglicherweise weit von der aktuellen Anweisung 

entfernt liegt. Wir betrachten hier nur Sprünge, die 

der Programmstruktur folgen. 

Abbruchanweisung: 


break; 

Semantik: 

Die Ausführung wird am Ende der umfassenden 

zusammengesetzen Anweisung fortgesetzt. 

Beispiele: 

1. In Auswahlanweisung: siehe oben. 

2. In Schleifenanweisungen: 


... 

if( ) break; 

... 

} 


40

Rückgabeanweisung: 


return ; 

return ; 

Semantik: 

1. Produktion: 

Nur in Prozeduren ohne Rückgabewert erlaubt. 

Beende die Ausführung der Prozedur. 

Setze die Ausführung an der Aufrufstelle fort. 

2. Produktion: 

Nur in Prozeduren mit Rückgabewert erlaubt. 

Werte den Ausdruck aus. 

Beende die Ausführung der Prozedur. 

Liefere den Wert des Ausdrucks als Ergebnis 

und setze die Ausführung an der Aufrufstelle fort. 

Beispiel: 


if( n>=0 ) { 

return n; 

} else { 

return -n; 

} 

} 


41

4.2.3 Prozeduren 

Prozeduren erlauben es, von konkreten Anweisungen 

bzw. Anweisungssequenzen zu abstrahieren. 

D.h. Prozeduren legen die Parameter einer zusammengesetzten 

Anweisung fest und geben ihr einen Namen. 

Dies ermöglicht: 

- Wiederverwendung, 

- Schnittstellenbildung und Information Hiding. 

Darüber hinaus ermöglichen Prozeduren die rekursive 

Ausführung von Anweisungen. 

Begriffsklärung: (Prozedur) 

Eine Prozedur ist eine Abstraktion einer Anweisung. 

Sie gibt der Anweisung einen Namen und legt fest, 

was die Parameter der Anweisung sind. Prozeduren 

können Ergebnisse liefern. 


42

Bemerkung: 

Prozeduren abstrahieren Anweisungen genauso, wie 

Funktionen Ausdrücke abstrahieren (vgl. Folie 108). 

Beispiel: (Prozedur als Abstraktion) 

Aufgabe: 

Berechne den Absolutbetrag einer ganzen Zahl 

gespeichert in Variable i und schreibe ihn in die 

Variable x. 

Algorithmus: 

Wenn i größer oder gleich 0, liefere i als Ergebnis; 

andernfalls –i. Weise das Ergebnis an x zu. 

void main(...){ 

int i; 

int x; 


int result; 

if( i>=0 ) { 

result = i; 

} else { 

result = -i; 

} 

x = result; 

} 

Abstraktion bzgl. i, 

result wird zum 

Ergebnis. 


43

Deklaration von Prozeduren/Methoden: 


( ) 

 

Semantik: 


if( n>=0 ) { 

return n; 

} else { 

return -n; 

} 

} 

void main(...){ 

int i; 

int x; 


} 

x = abs(i); 

Die Semantik ist durch den Aufrufmechanismus 

und den Anweisungsblock, den sogenannten 

Prozedurrumpf bestimmt (Genaueres siehe unten). 


44

Beispiele: 

1. Iterativer Algorithmus zur Berechnung vom ggT: 

int ggT ( int m, int n ) { 

int v; 

} 


v = n % m; 

n = m; 

m = v; 

} 

return n; 

2. Rekursiver Algorithmus zur Berechnung vom ggT: 

int ggT ( int m, int n ) { 

} 

if( m == 0 ) { 

return n; 

} else { 

} 

Bemerkung: 

return ggT(n%m,m); 

Ein- und Ausgabeoperationen sind typischerweise 

durch Prozeduren realisiert. 


45

Definition: (Funktionsprozedur) 

Prozeduren, die Ergebnisse liefern, heißen 

Funktionsprozeduren. 

Begriffsklärung: (Effekte) 

Die Ausführung von Prozeduren verändert den 

Speicherzustand und bewirkt Ein- und Ausgaben. 

Zusammenfassend sprechen wir von den Effekten 

der Ausführung einer Prozedur, aufgeteilt in: 

• Haupteffekte: Abliefern von Ergebnissen, 

Verändern von Variablenparametern; 

• Seiteneffekte: Ein- und Ausgabe, Verändern 

globaler Variablen, Erzeugen und Löschen 

dynamischer Variablen (z.B. Instanzvariablen). 

Bemerkung: 

• Variablenparameter und dynamische Variablen 

betrachten wir erst später. 

• Eine Funktionsprozedur kann benutzt werden, um 

eine Funktion zu implementieren (Beispiel ggT). 

Sie kann aber auch hauptsächlich zur Realisierung 

von Seiteneffekten benutzt werden. 


46

Beispiel: (Prozedur mit Seiteneffekt) 

Prozedur, die Zahlen von der Eingabe liest und 

addiert, bis eine Null eingegeben wird. Die Summe 

der eingegebenen Zahlen wird ausgedruckt, die 

Anzahl der Eingaben zurückgeliefert: 

// Summiere 

int summiere() { 

// Arbeitet nur bei korrekter Eingabe 

// der Zahlen durch Benutzer 

int anz = 0; 

int summe = 0; 

int eingabe; 

} 

do { 

print("Summand (0 beendet):"); 

eingabe = readInt(); 

summe += eingabe; 

anz++; 

} while( eingabe != 0 ); 

println( "Summe: " + summe ); 

return anz-1; 


47

Anwendung der Prozedur summiere: 

void main( String[] args ) { 

boolean b = true; 

} 

while( b ) { 

int anzahl; 

anzahl = summiere(); 

println("Es wurden "+ anzahl 

+ " Zahlen summiert"); 

} 

println("Beenden mit j/n:"); 

char c; 

c = readChar(); 

if( c == 'j' ) { 

b = false; 

} 

Bemerkung: 

• Die Hauptprozedur main wird vom Betriebssystem 

aufgerufen. Das Starten eines prozeduralen 

Programms entspricht dem Aufruf der Hauptprozedur. 

• Argumente vom Programmaufruf werden main als 

String-Feld mitgegeben. 


48

Definition: (rekursive Prozedurdekl.) 

Eine Prozedurdeklaration P heißt direkt rekursiv, 

wenn der Prozedurrumpf einen Aufruf von P enthält. 

Eine Menge von Prozedurdeklarationen heißen 

verschränkt rekursiv oder indirekt rekursiv 

(engl. mutually recursive), wenn die Deklarationen 

gegenseitig voneinander abhängen. 

Eine Prozedurdeklaration heißt rekursiv, wenn 

sie direkt rekursiv ist oder Element einer Menge 

verschränkt rekursiver Prozeduren ist. 

Bemerkung: 

Wir identifizieren Prozeduren mit ihren Prozedurdeklarationen. 

D.h. zwei Prozedurdeklarationen 

deklarieren immer zwei unterschiedliche Prozeduren. 

( Im Unterschied dazu konnten zwei Funktionsdeklarationen 

die gleiche Funktion deklarieren.) 

Beispiel: 

int p1 ( int n ) { return 1; } 

int p2 ( int n ) { return 1; } 

sind zwei unterschiedliche Prozeduren. 


49

Beispiel: (rekursive Prozeduren) 

// Aufrufbaum 

final int TAB = 4; 

int indent = 0 ; // Einruecktiefe 

void drucke_eingerueckt( String s ) { 

int i; 

for( i = 0; i

void p( int i ) { 

drucke_eingerueckt("Betrete p"); 

indent += TAB; 

if( i > 2 ) { 

p( 2 ); 

q( 2 ); 

r( 2 ); 

} 

indent -= TAB; 

drucke_eingerueckt("Verlasse p"); 

} 

void q( int iq ) { 

drucke_eingerueckt("Betrete q"); 


p(iq); 


drucke_eingerueckt("Verlasse q"); 

} 

- r und s sind nicht rekursiv. 

- q ist verschränkt rekursiv. 

- p ist direkt und verschränkt rekursiv. 

(Beachte: q wurde vor seiner Deklaration 

angewendet.) 


51

Mit der Hauptprozedur: 

public static void main( String[] args ) { 

drucke_eingerueckt("Betrete main"); 


p(3); 

r(1); 


drucke_eingerueckt("Verlasse main"); 

} } 

ergibt sich folgende Ausgabe: 

Betrete main 

Betrete p 

Betrete p 

Verlasse p 

Betrete q 

Betrete p 

Verlasse p 

Verlasse q 

Betrete r 

Verlasse r 

Verlasse p 

Betrete r 

Betrete s 

Verlasse s 

Verlasse r 

Verlasse main 

Ablauf 

Jeder Balken entspricht einer Prozedurinkarnation. 

Es gibt mehrere Inkarnationen der gleichen Prozedur. 


52

Bemerkung: 

Eine wichtige Struktur des Ablaufs prozeduraler 

Programme ist der Aufrufbaum. Am Beispiel: 

p.2 

p.1 

p.3 

main.1 

r.2 

q.1 r.1 s.1 

Die Lebensdauern von Inkarnationen der gleichen 

Prozedur können sich überlappen (z.B.: p.1 und p.3). 

Begriffsklärungen: (zur Prozedurausführung) 

Beim Aufruf einer Prozedur p wird eine neue 

Inkarnation von p erzeugt. Dabei wird: 

- Speicherplatz für die lokalen Variablen angelegt; 

- die Anweisung gemerkt, an der nach Ausführung 

der Prozedurinkarnation fortzusetzen ist. 

Die Lebensdauer einer Prozedurinkarnation beginnt 

mit deren Erzeugung und endet mit der Ausführung 

des Rumpfes zu dieser Inkarnation. Die Lebensdauer 

erstreckt sich über einen Teil des Programmablaufs. 


53

Der Prozeduraufrufbaum beschreibt die Prozeduraufrufstruktur 

in einem Programm- oder Prozedurablauf. 

Seine Baumknoten sind mit Prozedurinkarnationen 

markiert, so dass jede Inkarnation PI genau die 

Inkarnationen als Kinder hat, die von PI aus erzeugt 

wurden und zwar in der Reihenfolge des Ablaufs. 

Bemerkung: 

Die Lebensdauern von Inkarnationen der gleichen 

Prozedur können sich überlappen. Deshalb muss 

es ggf. mehrere Kopien/Instanzen der gleichen 

lokalen Variablen geben. 

Beispiel: 

// Lebensdauer 

void p( int i ){ //b(p) 

int a; 

a = i; //1(p) 

if( a == 2 ) { //2(p) 

p( a-1 ); //3(p) 

} 

println(i); //4(p) 

} //e(p) 

int c; 

void main(...){ //b(m) 

p(2); //1(m) 

} //e(m) 


54

4.2.4 Variablen in Programm und Speicher 

Jede Variablendeklaration definiert eine 

Programmvariable. Wir unterscheiden: 

- globale Variablen 

- (prozedur-)lokale Variablen 

- Klassenvariablen, Attribute, usw. 

Jeder Programmvariablen entsprechen zur 

Ausführungszeit/Laufzeit des Programms eine oder 

mehrere Speichervariablen: 

- Jeder globalen Variablen ist genau eine Speichervariable 

zugeordnet. 

- Ist v eine lokale Variable zur Prozedur p, dann gibt 

es zu jeder Inkarnation von p eine Speichervariable 

für v. 

- (andere Variablentypen behandeln wir später). 

Begriffsklärung: (statisch/dynamisch) 

Statisch bezeichnet man in der Programmiertechnik 

alle Aspekte, die sich auf das Programm beziehen und 

die man aus ihm ersehen kann, ohne es auszuführen. 

Statische Aspekte sind unabhängig von Eingaben. 

Dynamisch bezeichnet man alle Aspekte, die sich auf 

die Ausführungszeit beziehen. 


55

Beispiele: (statisch/dynamisch) 

Statisch: 

- Programmvariablen 

- Prozedurdeklarationen 

- Anweisung 

- Aspekte der Übersetzung 

Dynamisch: 

- Speichervariablen 

- Prozedurinkarnationen 

- Ablauf, Ausführung 

- Aufrufbäume 

- Lebensdauer (von Prozedurinkarnationen, usw.) 

Definition: (Lebensdauer von Variablen) 

Die Lebensdauer einer Speichervariable ist der 

Teil des Ablaufs, in dem sie für die Ausführung 

bereit steht. 

Die Lebensdauer globaler Variablen erstreckt sich 

über den gesamten Ablauf des Programms. 

Variablen zu lokalen Deklarationen leben solange 

wie die zugehörige Prozedurinkarnation bzw. über 

die Dauer der Ausführung ihres Blocks. 


56

Beispiel: (Lebensdauer von Variablen) 

Wir betrachten den Ablauf des obigen Programms 

mit den Markierungen und die Variablenlebensdauer: 

b(m.1) 

1(m.1) 

b(p.1) 

1(p.1) 

2(p.1) 

3(p.1) 

b(p.2) 

1(p.2) 

2(p.2) 

4(p.2) 

e(p.2) 

4(p.1) 

e(p.1) 

e(m.1) 

Bemerkung: 

c a.1 a.2 

Es gibt auch Variablen, deren Lebensdauer direkt 

über Anweisungen gesteuert werden kann. 


57

Beispiel: (Lebensdauer von Variablen, die 2.) 

Wir betrachten den Ablauf des folgenden 

C-Programmfragments: 

int k = 0; 

while( k

4.2.5 Felder 

Ein Feld (engl. Array) ist ein n-Tupel von Variablen 

des gleichen Typs T (vgl. Folie 159). 

Die genaue Syntax und Semantik von Feldern ist 

von Sprache zu Sprache verschieden. 

In Java sind Felder Objekte. Objekte veranschaulichen 

wir durch einen rechteckigen Kasten: 

- die Titelzeile enthält den Typ; 

- der Hauptteil enthält die Variablen/Komponenten 

mit ihren Namen bzw. Indizes. 

Variablen für Felder speichern Referenzen/Zeiger 

auf das Feldobjekt. 

Beispiel: (Veranschaulichung eines Felds) 

int[] a = new int[3] ; 

int[] b = a 

a: 

b: 

int[] 

length: 3 

0 : -7 

1 : 46 

2 : 0 


59

Feldtypen, Operationen auf Feldern: 

Mit T[] wird in Java der Typ von Feldern mit 

Komponenten vom Typ T bezeichnet. 

Deklaration einer Variablen 

T[] a; 

stellt nur den Speicherplatz für die Variable bereit; 

sie erzeugt kein Feld! 

Ein neues Feld mit n Komponenten vom Typ T 

wird von dem Ausdruck new T[n] erzeugt. 

Der Ausdruck liefert eine Referenz auf des Feld 

als Ergebnis. Initialisierung: 

- Die Variable length ist mit n initialisiert. 

- Alle anderen Komponenten sind mit dem 

Initialwert des Typs T initialisiert. (Für alle 

Zahltypen ist der Initialwert 0, für boolean ist 

er false.) 

Die Lebensdauer eines Felds 

- beginnt mit der Erzeugung und 

- endet mit der Terminierung des Programms. 


60

Beispiel: (Lebensdauer von Feldern) 

int[] erzeugeFeld( int n ) { 

int size = n < 0 ? 0 : n; 

return new int[size]; 

} 

void eineProz() { 

int[] a = erzeugeFeld(78); 

... 

} 

Sei im Folgenden exp ein Ausdruck von einem ganzzahligen 

Typ (byte, short, int, long), der sich zu k auswertet. 

Ausdrücke zum Lesen und Schreiben eines Felds a: 

- a.length liefert die Anzahl der Feldkomponenten 

- a[exp] erzeugt eine IndexOutOfBounds-Ausnahme 

falls k < 0 oder a.length ≤ k; andernfalls: 

R-Wert: der in der k-ten Feldkomponente 

gespeicherte Wert; 

L-Wert: die k-te Feldkomponente, d.h. z.B. weist 

a[exp] = 7 ; 

der k-ten Feldkompente den Wert 7 zu. 


61

Beispiel: (Programmieren mit Feldern) 

Das folgende Programm liest zwei Vektoren ein und 

gibt die Summe aus: 

void main(String[] args) { 

} 

int i; 

int[] a = new int[3]; // 3-elementiger Vektor 

int[] b = new int[3]; 

for( i=0; i

Beispiele: (2-dimensionale Felder & 

Initialisierung von Feldern) 

String[] argf; 

float [] vector_3d = new float[3]; 

int [][] matrix_3x3 = new int[3][3]; 

Folgendes Beispiel zeigt weitere Erzeugungs- und 

Initialisierungsmöglichkeiten bei Feldern: 

char[] vor = new char[3]; 

vor[0] = 'v'; 

vor[1] = 'o'; 

vor[2] = 'r'; 

char[] Fliegen = {'F','l','i','e','g','e','n'}; 

char[][] satz = { Fliegen, 

{'f','l','i','e','g','e','n'}, 

vor, 

Fliegen }; 

int i,j; 

String s = ""; 

for( i = 0; i < satz.length; i++ ) { 

for( j = 0; j < satz[i].length; j++ ) { 

s = s + satz[i][j]; 

} 

if( i+1 < satz.length ) s = s + " "; 

} 

println( s + "."); 


63

Nach der Zuweisung an satz entsteht folgendes 

Geflecht: 

satz: 

Fliegen: 

vor: 

char[] 

length: 3 

0 : ‘v‘ 

1 : ‘o‘ 

2 : ‘r‘ 

char[][] 

length: 4 

0 : 

1 : 

2 : 

3 : 

char[] 

length: 7 

0 : ‘F‘ 

1 : ‘l‘ 

2 : ‘i‘ 

3 : ‘e‘ 

5 : ‘e‘ 

6 : ‘n‘ 

char[] 

length: 7 

0 : ‘f‘ 

1 : ‘l‘ 

2 : ‘i‘ 

3 : ‘e‘ 

4 : ‘g‘ 4 : ‘g‘ 

5 : ‘e‘ 

6 : ‘n‘ 


64

4.2.6 Benutzerdefinierte Typen 

Die meisten prozeduralen Sprachen unterstützen 

benutzerdefinierte Typen, insbesondere 

Verbundtypen. 

Begriffsklärung: (Verbunde) 

Ein (Variablen-)verbund (engl. Record) ist ein 

n-Tupel von Variablen nicht notwendig des gleichen 

Typs. Die einzelnen Variablen nennt man die 

Komponenten des Verbunds. Die Komponenten 

werden über deklarierte Namen angesprochen. 

Die genaue Syntax und Semantik von Verbunden ist 

von Sprache zu Sprache verschieden. 

In Java lassen sich Verbunde nur als vereinfachte 

Objekte deklarieren und erzeugen. Als Ergebnis 

der Erzeugung erhält man dabei eine Referenz auf 

den Verbund. Die Referenz kann man in Variablen 

vom Verbundtyp speichern. Verbunde mit Referenzen 

nennen wir referenzierte Verbunde. 

Da wir im Folgenden nur referenzierte Verbunde 

betrachten, sprechen wir einfach von Verbunden. 


65

Beispiel: (Veranschaulichung eines 

referenzierten Verbunds) 

p: 

Sprachmittel für (referenzierte) Verbunde: 

- Deklaration eines Verbundtyps 

- Deklaration von Variablen für (Referenzen auf) 

Verbunde 

- Erzeugung von Verbunden 

Paar 

q: ersteKomp: 3 

zweiteKomp : -7 

- Lesen der Verbundkomponenten 

- Zuweisen an Verbundkomponenten 


66

Syntax anhand von Beispielen: 

Deklaration eines 

Verbundtyps Paar: 

Deklaration der Variablen 

p, q für Referenzen auf 

Verbunde vom Typ Paar: 

Erzeugung eines Verbunds 

vom Typ Paar und Zuweisung 

der Referenz an p: 

Weitergabe einer Referenz, 

hier von p an q: 

Lesen einer Komponente: 

class Paar { 

int ersteKomp; 

int zweiteKomp; 

} 

Paar p; 

Paar q; 

p = new Paar(); 

q = p; 

int a; 

a = p.ersteKomp; 

Schreiben einer Komponente: int a; 

p.ersteKomp = a+1; 

Der Initialwert für Verbundtypen 

ist null: 

class C { 

Paar pk; 

} 

new C().pk == null 


67

Verbunde zur Realisierung von Tupeln: 

Deklaration eines Verbundtyps Student mit 

Name und Matrikelnummer. 

class Student { 

String name; 

int matNr; 

} 

Deklaration einer Prozedur zum Drucken der 

Daten von Studenten: 

studentDrucken( Student s ) { 

println("Name: " + s.name ); 

println("Matriklenummer: " + s.matNr ); 

} 

Erzeugen eines Verbunds vom Typ Student, 

Zuweisung an eine Variable, Initialisieren der 

Komponenten und Ausdrucken: 

Student sv = new Student(); 

sv.name = "Max Planck"; 

sv.matNr = 12390573; 

studentDrucken( sv ); 


68

Rekursive referenzierte Verbunde: 

Verbunddeklarationen können rekursiv sein, z.B.: 

class IntList { 

int head; 

IntList tail; 

} 

Mit rekursiven Verbunden lassen sich Listen, 

Bäume und allgemeine Graphen realisieren. 

Beispiel: (Einfachverkettete Listen) 

Bei einfachverketteten Listen wird für jedes 

Listenelement ein Verbund mit zwei Komponenten 

angelegt: 

- zum Speichern des Elements 

- zum Speichern der Referenz auf den Rest der Liste. 

Die Liste [6,-3,84] erhält also folgende Repräsentation: 

IntList 

head: 6 

tail: 

IntList IntList 

head: -3 

tail: 

head: 84 

tail: 


69

Beispielprogramm: 

/* Prozedur sortiert prüft, ob die 

übergebenen List l sortiert ist. 

Vorbedingung: l darf keinen Zyklus enthalten 

*/ 

boolean sortiert( IntList l ){ 

if( l == null || l.tail == null ) { 

return true; 

} else if( l.head

Begriffsklärung: (Geflecht) 

Eine Menge von Verbunden, die sich gegenseitig 

referenzieren, nennen wir ein Geflecht. 

Insbesondere können Geflechte Zyklen enthalten. 

Beispiel: (Geflecht) 

: KA 

a1: 

a2: 8 

: KA 

a1: 

a2: 97 

: KA 

a1: 

a2: -6 

Notation: 

: KB 


71 

b: 

b: 

b: 

: KB 

: KB 

Graphisch stellen wir null durch einen ausgefüllten 

kleinen Kreis dar.

Verändern von Geflechten: 

Anders als die Datentypen in reinen funktionalen 

Programmierung lassen sich Geflechte lokal 

modifizieren. 

Veränderung an einem Verbund x wirken sich auf 

alle Verbunde und Variablen aus, die x direkt oder 

indirekt referenzieren. 

Als Beispiel für Veränderungen betrachten wir eine 

Implementierung binärer Suchbäume: 

/* Verbundtyp für Binärbäume mit 

Markierung vom Typ int 

*/ 

class BinTree { 

int elem; 

BinTree left, right; 

} 

Den leeren Binärbaum repräsentieren wir durch die 

Konstante null. Wir betrachten die folgenden 

Prozeduren: 

- Prüfen, ob ein Element in einem Baum enthalten ist. 

- Ausdrucken aller Markierungen eines Baumes. 

- Konstruktorprozedur mit Initialisierung 

- Sortiertes Einfügen 


72

* Prozedur contains prüft, ob Markierung e 

in b enthalten ist. 

Vorbedingung: b ist binärer Suchbaum 

*/ 

boolean contains( BinTree b, int e ) { 

if( b == null ) { 

return false; 

} else if( e < b.elem ){ 

return contains(b.left,e); 

} else if( b.elem < e ){ 

return contains(b.right,e); 

} else { 

return true; 

} 

} 

/* Prozedur printTree durchläuft den Baum in 

Inorder-Reihenfolge und druckt die Markierungen 

aus, jede in eine Zeile. 

*/ 

void printTree( BinTree b ) { 

if( b != null ) { 

if( b.left != null ) printTree(b.left); 

println(b.elem); 

if( b.right != null ) printTree(b.right); 

} 

} 


73

* Konstruktorprozedur 

*/ 

BinTree mkBinTree( int e ) { 

BinTree newbt = new BinTree(); 

newbt.elem = e; 

return newbt; 

} 

/* Sortiertes Einfügen. Erhält Suchbaumeigenschaft 

*/ 

BinTree sorted_insert( BinTree b, int e ) { 

if( b == null ) { 

return mkBinTree(e); 

} else { 

modifying_sorted_ins(b,e); 

return b; 

} } 

void modifying_sorted_ins( BinTree b, int e){ 

if( e < b.elem ) { 

if( b.left == null ) { 

b.left = mkBinTree(e); 

} else { 

modifying_sorted_ins(b.left,e); 

} 

} else if( b.elem < e ) { 

if( b.right == null ) { 

b.right = mkBinTree(e); 

} else { 

modifying_sorted_ins(b.right,e); 

} 

} } 


74

Hauptprozedur zum Testen: 

void main( String[] argf ){ 

} 

Bemerkung: 

BinTree bt = mkBinTree(12); 

sorted_insert(bt,3); 





sorted_insert(bt,-2343); 


printTree(bt); 

• Mit referenzierten Verbundstypen lassen sich 

nicht nur Listen und Bäume in unterschiedlicher 

Form realisieren, sondern auch allgemeine 

Graphen. 

• Anspruchsvollere Algorithmen werden in 

Abschnitt 4.3 behandelt. 


75

4.2.7 Sichtbarkeit von Bindungen 

Deklarationen binden Bezeichner an Programmelemente 

(z.B. an Variablen oder an Prozeduren). 

Die Sichtbarkeitsregeln bestimmen, welche Bindungen 

wo zulässig und benutzbar sind. 

Beispiel: (Sichtbarkeit von Bindungen) 

Folgender Programmtext ist kein Java-Programm, 

da nur eine Variablenbindung für den Bezeichner m 

erlaubt ist: 

public class Sichtbarkeiten { 

} 

static int m; 

static void p( int p ) { 

int m; 

int a = 7; 

{ 

int m = 0; // unzulässig 

if( p > 0 ) { 

p(p-1); 

} 

} 

} 

public static void main(String[] a ){ 

m = 1; 

p(m); 

} 


76

Begriffsklärung: (zur Sichtbarkeit) 

Programme sind in Deklarationsbereiche (engl. 

scopes) eingeteilt. In der betrachteten Java-Teilsprache 

gibt es die folgenden Deklarationsbereiche: 

- das gesamte Programm 

- jede Prozedur/Methode 

- jeder Anweisungsblock 

Die Deklarationsbereiche sind geschachtelt 

(engl. nested). Ein Deklarationsbereich darf auf 

seiner äußersten Schachtelungsebene für jeden 

Bezeichner nur eine Deklaration enthalten. 

Zu jeder Deklaration gibt es einen Gültigkeitsbereich. 

In der betrachteten Java-Teilsprache gilt: 

Der Gültigkeitsbereich einer Deklaration erstreckt 

sich bei 

- Prozeduren und globalen Variablen über den 

gesamten direkt umfassenden Deklarationsbereich; 

- lokalen Variablen von der Deklarationsstelle bis zum 

Ende des direkt umfassenden Deklarationsbereichs. 


77

Grundsätzlich gilt: 

Eine Bindung B, die in einem Deklarationsbereich D 

deklariert wurde, verschattet (engl. to shadow, to hide) 

andere Bindungen mit gleichem Bezeichner, die 

außerhalb von D vereinbart wurden, in dem 

Gültigkeitsbereich von B. 

Eine Bindung ist an den Stellen ihres Gültigkeitsbereichs 

sichtbar, an denen sie nicht verschattet ist. 

Den Bereich, in dem eine Bindung B sichtbar ist, 

nennt man den Sichtbarkeitsbereich von B. 

Bemerkung: 

• Statt von Deklarationsbereichen spricht man 

teilweise von Blöcken und dementsprechend von 

der Blockstruktur eines Programms. 

• Die Begriffe Sichtbarkeits-, Gültigkeitsbereich und 

Lebensdauer werden leider häufig auch anders 

verwendet. 

• Die erläuterten Bereiche sind Bereiche des Programmtexts. 

Dementsprechend beschreiben alle oben 

eingeführten Begriffe statische Aspekte. 

• Sichtbarkeitsregeln sind im Allg. sprachspezifisch. 


78

Beispiel: (Deklarationsbereiche) 

1 

1.1 

1.2 

1.1.1 

1.2.1 

int m; 

void p 

( int p ) 

{ 

int m; 

int a = 7; 

} 

{ 

} 

int m = 0; //unzulässig 

if( p > 0 ) 

{ 

p(p-1); 

} 

void main 

( String[] a ) 

{ 

m = 1; 

p(m); 

} 


79

Beispiel: (Sichtbarkeitsanalyse) 

1 

1.1 

1.2 

1.1.1 

1.2.1 

// Sichtbarkeiten2 

void p 

( int p ) 

{ 

} 

int a = 7; 

{ 

} 

{ 

} 

int m = 1; 

println("m:"+ m); 


int m = 2; 


int m = 0; 

void main 

( String[] p ) 

{ 

} 

int m = 3; 

p(m); 


80

Beispiel: (Gültigkeitsbereiche) 

Der Gültigkeitsbereich der globalen Variablen m 

erstreckt sich über das ganze Programm. 

Der Gültigkeitsbereich der lokalen Variablen m 

jeweils von der Deklarationstelle bis zum Ende des 

direkt umfassenden Anweisungsblocks: 


void p 

( int p ) 

{ 

} 

int a = 7; 

{ 

} 

{ 

} 

int m = 1; 



int m = 2; 


int m = 0; 

... 


81

Beispiel: (Sichtbarkeitsbereiche) 

Eine Bindung B, die in einem Deklarationsbereich D 

deklariert wurde, verschattet andere Bindungen mit 

gleichem Bezeichner, die außerhalb von D vereinbart 

wurden, im Gültigkeitsbereich von B. 

Also wird das globale m von den lokalen verschattet: 


void p 

( int p ) 

{ 

} 

int a = 7; 

{ 

} 

{ 

} 

int m = 1; 



int m = 2; 


int m = 0; 

... 


82

Bemerkung: 

• In realistischen Programmiersprachen können die 

Sichtbarkeitsregeln insgesamt recht komplex sein. 

• Die Kenntnis der Sichtbarkeitsregeln ist wichtig, 

um Fehlermeldungen vom Übersetzer zu verstehen 

und um Namensprobleme beim Importieren 

von Modulen geeignet behandeln zu können. 

• Sichbarkeitsregeln bieten eine erste Einführung in 

die Behandlung von Namensräumen. 


83

4.2.8 Iteration und Rekursion 

Rekursive Prozeduren lassen sich in vielen Fällen 

in iterative Programme transformieren, d.h. in 

Programme, die keine Rekursion, sondern nur 

Schleifen enthalten. 

Die Lösung mit rekursiven Prozeduren kann eleganter 

und einfacher sein. Demgegenüber ist eine iterative 

Lösung meist effizienter. 

Die Transformation rekursiver Prozeduren in iterative 

Programme ist ein klassisches Beispiel für 

optimierende Programmtransformationen. 

Wir verzichten auf eine allgemeine Behandlung 

und betrachten nur ein Beispiel (vgl. Goos, Band 3, 

S. 152 ff) 

Beispiel: 

Berechne das Maximum einer Liste ganzer Zahlen. 

Für die leere Liste liefere 0 als Ergebnis. 

Wir gehen davon aus, dass es einen Typ IntList mit 

Funktionsprozeduren head, tail und isempty gibt sowie: 

int max( int m, int n ) { 

return (m > n) ? m : n; 

} 


84

1. Rekursive Ausgangsfassung: 

int maxl( IntList il ) { 

} 

if( isempty(il) ) { 

return 0; 

} else if( isempty(tail(il)) ) { 

return head(il); 

} else { // (Laenge von il) >= 2 

} 

return max(head(il),maxl(tail(il))); 


} 

IntList l = ... ; 

println("maxl: "+ maxl(l) ); 

Die Funktionsprozedur maxl ist linear rekursiv, aber 

nicht repetitiv. Führe zur Einbettung einen zusätzlichen 

Parameter ein, der das Maximum des gesehenen 

Präfixes mitführt (vgl. Folien 3.39 ff). 


85

2. Repetitive Fassung durch Einbettung: 

int maxlrep( int aktmax, IntList il ) { 

} 


return aktmax; 

} else { 

} 

return maxlrep( max(aktmax,head(il)), 

int maxl( IntList il ) { 

} 


return 0; 

} else { 

} 

tail(il) ); 

return maxlrep( head(il), tail(il) ); 

void main( String[] arges ) { 

} 


println("maxl: "+ maxl(l) ); 

Die Funktionsprozedur maxl ist nicht mehr rekursiv 

und kann expandiert werden. 


86

3. Repetitive Fassung nach Expansion von maxl: 

int maxlrep( int aktmax, IntList il ) { 

} 


return aktmax; 

} else { 

} 

return maxlrep( max(aktmax,head(il)), 

tail(il) ); 


} 


int mx; 

if( isempty(l) ) { 

mx = 0; 

} else { 

} 

mx = maxlrep( head(l), tail(l) ); 

println("maxl: " + mx ); 

Transformiere die Funktionsprozedur maxlrep in eine 

Prozedur, die ihr Ergebnis in globaler Variable abliefert. 


87

4. Repetitive Fassung nach Einführung einer 

Ergebnisvariablen: 

int res; 

void maxlrep( int aktmax, IntList il ) { 

} 


res = aktmax; 

} else { 

} 

maxlrep( max(aktmax,head(il)), tail(il)); 


} 


int mx; 


mx = 0; 

} else { 

} 

maxlrep( head(l), tail(l) ); 

mx = res; 


Nun folgt der zentrale Schritt der Transformation der 

repetitiven Fassung in eine iterative Fassung: 


88

5. Iterative Fassung mit Prozeduraufruf: 

int res; 

void maxlrep( int aktmaxpar, IntList ilpar ){ 

} 

int aktmax = aktmaxpar; 

IntList il = ilpar; 

while( !isempty(il) ) { 

} 

aktmax = max(aktmax,head(il)); 

il = tail(il); 

res = aktmax; 


} 


int mx; 


mx = 0; 

} else { 

} 

maxlrep( head(l), tail(l) ); 

mx = res; 


Expansion von der Prozedur maxlrep: 


89

6. Iterative Fassung: 

int res; 


} 


int mx; 


mx = 0; 

} else { 

} 

int aktmax = head(l); 

IntList il = tail(l); 


} 



res = aktmax; 

mx = res; 


Vereinfachung durch Elimination unnötiger Variablen. 


90

7. Vereinfachte iterative Fassung: 


} 


int mx; 


mx = 0; 

} else { 

} 

mx = head(l); 

IntList il = tail(l); 


} 

mx = max(mx,head(il)); 



Bemerkung: 

• Formal kann man Programmtransformation mit 

Regelsystemen beschreiben. 

• Programmtransformationen sind nicht nur wichtig zur 

Effizienzsteigerung, sondern auch um Programme 

- verständlicher zu machen (Redesign); 

- an neue Anforderungen anzupassen. 


91

Beispiel: (Transformationsregel) 

Transformationsregel: repetitiv � iterativ 

Seien p ein Prozedurname, T1,...,Tn Typbezeichner, 

A1,..,An und B seiteneffektfreie-Ausdrücke, 

C und D Anweisungen, die keinen Aufruf 

von p enthalten: 

void p( T1 x1, ... , Tn xn) { 

if( B ) { 

C 

} else { 

D 

p( A1(x1,...xn),..., An(x1,...,xn) ); 

} 

} 

void p( T1 y1, ... , Tn yn) { 

T1 x1 = y1; 

... 

Tn xn = yn; 

while( !B ) { 

D 

x1 = A1(x1,...,xn); 

... 

xn = An(x1,...,xn); 

} 

C 

} 


92

Für obiges Transformationsbeispiel (Folie 4.88) 

ergibt sich mit der Regel: 

p ≡ maxlrep , 

T1 ≡ int, x1 ≡ aktmax, 

T2 ≡ IntList , x2 ≡ il, 

B ≡ isempty(il) 

C ≡ res = aktmax; 

D ≡ // leere Anweisung 

A1 ≡ max(aktmax,head(il)) 

A2 ≡ tail(il) 

A1, A2 und B sind seiteneffektfrei; 

C und D enthalten keinen Aufruf von maxlrep; 

die Regel ist also auf maxlrep anwendbar und 

liefert: 

void maxlrep( int y1, IntList y2) { 

int aktmax = y1; 

IntList il = y2; 




} 

res = aktmax; 

} 

Durch konsistente Parameterumbenennung erhält 

man die Prozedur von Folie 4.89. 


93

Bemerkung: 

• Im Prinzip lassen sich Programme mit 

Transformationsregeln genauso umformen wie 

mathematische Ausdrücke. 

• Die Transformationsregeln für realistische 

Programmiersprachen sind sehr komplex. 

Dies beginnt bereits bei einer präzisen Behandlung 

von Namen (vgl. Sichtbarkeitsregeln). 

4.2.9 Weitere prozedurale Sprachkonzepte 

Wir haben hier nur den Sprachkern prozeduraler 

Sprachen betrachtet. Weitere Sprachkonzepte: 

• Verbünde, variante Verbünde 

• Zeiger ggf. mit Zeigerarithmetik 

• Prozedurparameter 

• Generische/parametrische Typen 

• Modul-/Paketkonzepte 

• Kapselung/Schnittstellen 


94

4.3 Algorithmen in prozeduraler 

Formulierung 

Dieser Abschnitt behandelt Algorithmen in prozeduraler 

Formulierung und deren Analyse bzgl. 

- Speicherbedarf 

- Laufzeit 

Er liefert einen Einblick in die Speicherverwaltung 

bei prozeduralen Programmen und gibt eine 

Ausblick auf weitere algorithmische Problemstellungen 

und Methoden. 

Vorgehen: 

- Einführung in die Algorithmenanalyse 

- Speicherverwaltung 

- Laufzeitverhalten 

- Prozedurale Algorithmen und deren Analyse 

- Klassifizierung und Entwicklung von Algorithmen 


95

4.3.1 Einführung in die Algorithmenanalyse 

Zwei zentrale Größen zur Beurteilung von Effizienz: 

- Speicher(platz)bedarf (in kByte od. Speicherzellen) 

- Ausführungs-/Laufzeit (in Sekunden od. Anzahl 

ausgeführter Operationen) 

Bei einem installierten Programm kann man 

diese Größen zu gegebenen Eingaben messen 

bzw. berechnen. 

Wir betrachten im Folgenden nur den Fall, dass alle 

Eingaben am Anfang der Ausführung erfolgen und 

alle Ausgaben am Ende. 

Begriffsklärung: (Speicherbedarf/Laufzeit) 

Sei P ein installiertes Programm und M die Menge der 

zulässigen Eingaben von P. 

Der (max.) Speicherbedarf von P ist eine Funktion 

sb : M � kByte 

Man spricht von der Raumkomplexität von P. 

Die Laufzeit von P ist eine Funktion: 

lz : M � Sekunden 

Man spricht von der Zeitkomplexität von P. 


96

Bemerkung: 

In der Praxis ist die Bestimmung von Speicherbedarf 

und Laufzeit im Allg. nicht einfach: 

1. Messen: 

- kann nur endlich viele Funktionswerte liefern; 

- wird ggf. durch Systemgegebenheiten beeinflusst. 

2. Berechnen ausgehend vom Programm: 

- setzt Kenntnisse der Übersetzung und des 

Systems voraus. 

Beispiel: (Messen der Laufzeit) 

fun primfaktoren (n:int) = 

if n

Ausgewählte Messergebnisse: 

Eingabe Laufzeit in Sek. 

12345678 < 1 

10000000 < 1 

123456789 < 1 

100000000 < 1 

1234567890 < 1 

1000000000 < 1 

12345678901 ~ 2 

10000000000 < 1 

123456789012 > 20000 

100000000000 < 1 

1234567890123 ~ 15 

1000000000000 < 1 

12345678901234 > 20000 

10000000000000000000000 < 1 

Gemessen 

- unter PolyML 

- für Betriebssystem XX 

- auf einem Rechner der Bauart YY. 

Beobachtung: 

Laufzeit hängt im Allg. in komplexer Weise von 

der Eingabe ab. 


98

Begriffsklärung: (Kriterien zur Effizienz) 

Die Gesamteffizienz eines installierten Programms 

hängt ab von 

- der Speicherbedarfsfunktion sb, 

- der Laufzeitfunktion lz und 

- der Häufigkeit, mit der bestimmte Eingaben auftreten. 

Bei häufig auftretenden Eingabewerten ist effizientes 

Verhalten wichtiger als bei seltenen Eingabewerten. 

Bemerkung: 

• Ein präziser Umgang mit dem obigen Effizienzbegriff 

ist in der Praxis schwierig: 

- sb und lz sind kaum zu bestimmen; 

- die Häufigkeitsverteilung der Eingaben ist oft nicht 

genau bekannt; 

- meist möchte man die Effizienz eines Programms 

unabhängig von seiner Installation betrachten. 

• Die Kriterien bilden aber die Grundlage für: 

- den Effizienzvergleich von Programmen 

- die informelle Beurteilung von Effizienz 

- abstraktere Effizienzbegriffe 


99

Abstraktere Effizienzbegriffe: 

Statt ein installiertes Programm zu betrachten, 

sieht man üblicherweise von Details ab und 

betrachtet Effizienz nur näherungsweise. 

Vereinfachungen: 

1. Betrachte nicht die Eingabewerte selbst, sondern 

nur ihre Größe (z.B. Länge von Listen, Stellenanzahl 

bei Zahlen). 

2. Vernachlässige die Häufigkeitsverteilung der Daten. 

3. Vernachlässige konstanten Aufwand, also 

Aufwand, der unabhängig von den Eingabedaten 

entsteht. 

4. Betrachte nur das Wachstum von sb und lz und 

vernachlässige konstante Faktoren (Abstraktion 

von der Leistung eines Rechners und den 

Implementierungseigenschaften einer Programmiersprache). 

5. Betrachte nur obere und untere Schranken für 

sb und lz. 


100

Beispiel: (Analyse der Laufzeit) 

Wir analysieren eine Implementierung des Algorithmus 

„Sortieren durch Auswahl“ (engl. selection sort) . 

Eingabe: Feld f von ganzen Zahlen. 

Aufgabe: Sortiere das Feld f aufsteigend. 

Algorithmische Idee: 

- Bestimme eine Komponente mit Index ixmin von f, 

die ein minimales Element von f[1] ... f[f.length] 

enthält. 

- Vertausche f[ixmin] und f[1]. 

- Sortiere dann den Bereich f[2] ... f[f.length] analog. 

Mögliche Hauptprozedur: 

void main( String[] arg ) { 

int[] feld = new int[arg.length]; 

for( int i = 0; i

Rekursive Fassung des Sortierens durch Auswahl: 

void sortieren(/*nonnull*/ int[] f) { 

bereichsort(f,0,f.length-1); 

} 

void bereichsort( int[] f, int ug, int og) { 

if (ug >= og) return; 

int ixmin = auswaehlen(f,ug,og); 

// Vertauschen 

int temp = f[ug]; 

f[ug] = f[ixmin]; 

f[ixmin] = temp; 

// Sortieren des restlichen Felds: 

bereichsort(f, ug+1, og); 

} 

/* Liefert Index mit minimalem Element im 

Bereich f[ug] .. f[og] von Feld f */ 

int auswaehlen( int[] f, int ug, int og) { 

int ixmin = ug; 

for( int j = ug+1; j

Iterative Fassung des Sortierens durch Auswahl: 

void sortieren( /*nonnull*/ int[] f ) { 

} 

} 

for( int i = 0; i

Analyse der Laufzeit von sortieren: 

In Abhängigkeit von der Größe N des Feldes 

schätzen wir die Anzahl A(N) der Operationen/ 

Rechenschritte für den ungünstigsten Fall ab. 

Eine Operation ist: 

- ein Vergleich 

- eine Zuweisung 

- eine Addition/Subtraktion 

Vereinfachende Annahme: 

- Alle Operationen brauchen die gleiche Zeit. 

- Andere Aspekte der Ausführung werden 

vernachlässigt (Speicherverwaltung, Sprünge) 

Aufwand B(i,N) der inneren Schleife: 

B(i,N) ≤ (2+1) + (N-i-1) * (2+2) 

Aufwand A(N) des gesamten Rumpfes für N ≥ 2: 

A(N) = 3 + Σ (1 + B(i,N) + 3 + 2 ) 

N-1 

≤ 3 + Σ (9 + (N-i) * 4 ) = 3 + (N-1)*9 + 4* Σ i 

i=1 

N-2 

i=0 

= 9*N – 6 + 2*N*(N-1) = 2*N + 7*N – 6 

A(0) = A(1) = 3 


104 

2 

N-1 

i=1

O-Notation 

Häufig interessiert man sich nur für die 

Größenordnung des Wachstums der 

Aufwandsfunktion A(N), die den Aufwand an 

Speicher bzw. Zeit in Abhängigkeit von der 

Problemgröße N beschreibt. 

Begriffsklärung: (obere Schranke) 

Eine Funktion f: Nat � R heißt obere Schranke 

einer Aufwandsfunktion A, wenn gilt: 

Es gibt c,d in Nat, sodass für alle N in Nat gilt: 

A(N) ≤ c * f(N) + d 

Man sagt auch, A wächst wie f bzw. ist von der 

Größenordnung f. Die Menge aller Funktionen 

von der Größenordnung f bezeichnet man mit O(f) : 

O(f) = { g | ∃ c,d in Nat: ∀N in Nat: g(N) ≤ c* f(N) + d } . 

Bemerkung: 

• Entsprechend definiert man auch untere Schranken. 

• Vertiefung in „Entwurf und Analyse von Algorithmen“ 

• Meist schreibt man O(N) statt O(λN.N), O(N ) statt 

2 

O(λN.N ), O(log N) statt O(log), usw. 

+ 


105 

2

Beispiel: (Bestimmung oberer Schranken) 

Der Zeitaufwand A vom Sortieren durch Auswahl ist 

2 

A(N) ≤ 2*N + 7*N - 6 

und damit in O(N 2 ); denn mit c= 3 und d = 6 gilt: 

A(N) ≤ 3 * N + 6 

Wichtige Komplexitätsklassen: 

Kompl.klasse Bezeichnung Beispiel 

O(1) konstant Hashverfahren 

2 

O(log N) logarithmisch binäre Suche in Bäumen 

O(N) linear sequentielle Suche 

O(N * log N) n log n gute Sortierverfahren 

2 

O(N ) quadratisch einfache Sortierverfahren 

3 

O(N ) kubisch Matrixmultiplikation 

N 

O(2 ) exponentiell Optimierungverfahren 

Algorithmen mit einem Aufwand in O(N k 

) , k ≥ 2, 

nennt man polynomisch oder engl. polynomial. 


106

Diskussion der O-Notation: 

• Die O-Notation liefert eine grobe Klassifikation. 

• In der Praxis können konstante Faktoren 

und Programmiersprachen-spezifische Aspekte 

entscheidend sein (siehe Beispiel unten). 

• Weitere Aspekte für die Effizienzbetrachtung: 

- Antwortzeiten interaktiver Softwaresysteme 

- Kommunikationszeiten 

Beispiel: (zur obigen Diskussion) 

Wir betrachten zwei Versionen eines Programms, 

das eine Datei liest und wieder ausgibt. 

Die Versionen illustrieren insbesondere: 

• Abhängigkeit von programmiersprachlichen 

Aspekten (hier: Komplexität von scheinbaren 

und wirklichen Grundoperationen) 

• Notwendigkeit des Verständnisses technischer 

Aspekte zur Beurteilung nicht-funktionaler Eigenschaften 


107

Abstrakte Schnittstelle zum Lesen von Dateien: 

/* Ein Verbund vom Typ DateiLesePosition 

repräsentiert eine Position in einer Datei. 

An dieser Position kann man das nächste 

Zeichen lesen. 

*/ 

class DateiLesePosition { 

... 

} 

/* Öffnet Datei mit Namen dname und liefert 

Referenz vom Typ DateiLesePosition, die die 

Anfangsposition in der Datei repräsentiert. 

Gibt es Fehler beim Öffnen, wird null 

zurückgegeben. 

*/ 

DateiLesePosition oeffneDatei( String dname ){ 

... 

} 

/* Ist die aktuelle Position am Dateiende, wird 

das EOT-Zeichen ‘\4‘ geliefert. Andernfalls 

wird das Zeichen an aktueller Position geliefert 

und die Position eins weiter geschaltet. 

*/ 

char naechstesZeichen( DateiLesePosition d ) { 

... 

} 


108

Bemerkung: 

Obige Schnittstelle arbeitet nur für Dateien korrekt, 

die das EOT-Zeichen (end of transmission) nicht 

enthalten. 

Ineffiziente Programmversion: Datei-Lesen Version 1 

public static void main( String[] a ) { 

if( arg.length == 1 ) { 

DateiLesePosition dlp = oeffneDatei(a[0]); 

if( dlp == null ) { 

println("Fehler: Datei existiert nicht"); 

return; 

} 


char c = naechstesZeichen(dlp); 

int count = 1; 

while( c != '\4' ){ // '\4' ist EOT 

s = s + c; 

c = naechstesZeichen(dlp); 

count++; 

if( count%1000==0 ) println(count); 

} 

println("Datei Inhalt:"); 

println( s ); 

} else { 

println("Usage: java DateiLesen "); 

} 

} 


109

Effizientere Programmversion: Datei-Lesen Version 2 

public static void main( String[] a ) { 

if( arg.length == 1 ) { 

DateiLesePosition dlp = oeffneDatei(a[0]); 

if( dlp == null ) { 

println("Fehler: Datei existiert nicht"); 

return; 

} 

final int feldgroesse = 100000; 


char[] cfeld = new char[feldgroesse]; 

char c = naechstesZeichen(dlp); 


int index = 0; 

while( c != '\4' ){ // '\4' ist EOT 

cfeld[index] = c; 

c = naechstesZeichen(dlp); 

count++; 

index++; 

if( count%1000==0 ) println(count); 

if( index == feldgroesse ) { 

index = 0; 

s = s + new String(cfeld); 

} 

} 

println("Datei Inhalt:"); 

println( s ); 

} else { 

println("Usage: java DateiLesen "); 

} } 


110

Gemessene Zeit zum Lesen einer 150 kByte großen 

Datei auf einem AMD Opteron Dual Core 270 

Rechner: 

V1: 76,1 s 

V2: 0,4 s 

Grund: 

„+“ auf String kopiert Argumente; dadurch ergibt 

sich insgesamt für V1 eine quadratische Laufzeitkomplexität 

in Abhängigkeit von der Seitengröße. 

V2 hat zwar theoretisch die gleiche Komplexität, 

aber diese wirkt sich nur bei sehr großen Dateien 

aus. 

Bemerkung: 

Bei der Betrachtung der Komplexität vergisst man 

leicht, dass sich die Komplexitätsklassen nur auf 

das asymptotische Verhalten beziehen. 

Für kleine N (die man in der Realität oft hat) kann 

das ganz anders aussehen. 


111

4.3.2 Speicherverwaltung 

Speicher ist eine wichtige Ressource für 

Softwaresysteme. Viele nicht-funktionale 

Eigenschaften hängen vom angemessenen 

Umgang mit Speicher ab. 

Wir betrachten grundlegende Aspekte der 

Speicherverwaltung: 

- Einführung: Speicher in der Programmierung 

- Automatische Speicherbereinigung 

- Deallokation von Objekten 

Einführung 

Wir betrachten hier nur den Speicher, der für 

die Ausführung von Programmen benötigt wird, 

und zwar in Form eines Byte-adressierbaren 

virtuellen Adressraums. 

Wichtige Fragen: 

- Wofür wird Speicher benötigt? 

- Wie ist der Speicher organisiert? 

- Wie wird der Speicher verwaltet? 

- Wie viel Speicher braucht ein Programm? 


112

Wofür Speicher benötigt wird: 

Speicher wird benötigt für: 

- das Programm (unabhängig von Eingabedaten) 

- Konstanten 

- Variablen (global, prozedurlokal, objektlokal) 

- Verwaltung von Prozedur-/Methodenaufrufen 

Beispiele: (Verwendung von Speicher) 

1. Programm, Konstanten und globale Variable: 

String s; 

String ss; 

public class SpeicherIllustration1 { 

public static void main( String[] ins ) { 

s = ins[0] + " war die Eingabe"; 

ss = "Zu Seiteneffekten lesen " 

+ "Sie die Dokumentation\n" 

+ "und fragen Sie Ihren Tutor " 

+ "oder Professor"; 

println( s + "\n" + ss ); 

} 

} 

Speicherbedarf ist relativ einfach zu bestimmen, da 

unabhängig von der Eingabe. 


113

2. Verbundkomponenten/Objektlokale Variablen: 

class IntList { 

int fst; 

IntList rst; 

} 

IntList empty() { 

return new IntList(); 

} 

IntList append( int i, IntList xl ) { 

IntList il = new IntList(); 

il.fst = i; 

il.rst = xl; 

return il; 

} 

public class SpeicherIllustration2 { 

public static void main( String[] ins ) { 

IntList il = append(3,empty()); 

il = append( 134, il ); 

il = append( 9, il ); 

int i = Integer.parseInt( ins[0] ); 

while( i > 0 ) { 

il = append( i, il ); 

i--; 

} 

} } 

Speicherbedarf hängt von der Eingabe ab. Lebensdauer 

der Verbunde erstreckt sich von der Erzeugung 

bis zum Ende des Programmablaufs. 


114

3. Lokale Variablen und Prozeduraufrufverwaltung: 

Als Beispiel betrachten wir die rekursive Fassung 

des Sortierens durch Auswahl (vgl. Folie 4.102). 

Speicher wird benötigt für jede Prozedurinkarnation 

(vgl. Begriffsklärung auf Folie 4.53) und zwar 

- für den Rückgabewert und die aktuellen Parameter, 

- für die Aufrufverwaltung (z.B. Aufrufstelle), 

- für die lokalen Variablen. 

Speicherbereich für eine Prozedurinkarnation: 

Rückgabewert 

Aktuelle Parameter 

Verwaltungsinformation 

Lokale Variable 

Speicherbedarf hängt von der Eingabe ab. Lebensdauer 

der lokalen Variablen erstreckt sich vom 

Prozeduraufruf bis zum Ende der Prozedurausführung. 


115

Speicherorganisation: 

Die Speicherorganisation ist bei den meisten 

prozeduralen bzw. objektorientierten Programmiersprachen 

ähnlich: 

virtueller 

Adressraum 

BS-Kern 

Programm 

globale Größen 

Halde 

Laufzeitkeller 

globale, statische 

Variablen, Konstanten, ... 

(dynamische) Verbunde, 

Objekte, ... 

Zwischenergebnisse, 

prozedurlokale 

Größen, Objekte mit beschränkter 

Lebensdauer 


116

Wie Speicher verwaltet wird: 

1. Globaler Speicher und Keller werden automatisch 

verwaltet (der Übersetzer erzeugt dafür Code). 

2. Je nach Programmiersprache wird die Halde 

(engl. heap) unterschiedlich verwaltet: 

- mit automatischer Speicherbereinigung, 

- durch den Programmierer (Deallokation). 

Operationen zur Verwaltung der Halde: 

� Anfordern von Speicher bei Objekterzeugung: 

liefere Speicherbereich ausreichender Größe. 

� Freigabe von Speicher: 

- Wenn kein Speicher mehr verfügbar, gebe die 

Speicherbereiche von Objekten frei, die nicht 

mehr erreichbar sind. 

- Gebe Speicher von Objekten auf Anweisung 

des Programms frei (Deallokation). 

Beachte: 

Die Speicherverwaltung kostet auch Laufzeit. 


117

Fazit: 

1. Wie viel Speicher ein Programm in Abhängigkeit 

von der Eingabe genau braucht, hängt von Details 

der Sprachimplementierung und Plattform ab. 

2. Mit einem generellen Verständnis der relevanten 

Techniken lässt sich der Speicherbedarf aber 

gut abschätzen. 

Automatische Speicherbereinigung 

Begriffsklärung: (Autom. Speicherbereinigung) 

Verfahren zur automatischen Speicherbereinigung 

(engl. automatic garbage collection) ermitteln periodisch 

oder bei Bedarf, welche Objekte nicht mehr erreichbar 

(s.u.) sind und geben deren Speicherplatz frei. 

Weiteres Ziel ist es, den freien Speicher zu 

kompaktifizieren. 

Immer mehr Programmiersprachen bieten 

automatische Speicherbereinigung (insbesondere 

funktionale, logische und objektorientierte Sprachen): 

• Vereinfachung der Programmierung 

• Aufwand an Speicher und Zeit ist vertretbar. 

• Sicherheitsaspekte 


118

Beispiel: (Autom. Speicherbereinigung) 

1. Programm, das unerreichbare Objekte erzeugt: 

void main( String[] ins ) { 



int[] feld = new int[1000000]; 

println(count++); 

} 

} 

Dies Programm bekommt keine Speicherprobleme. 

2. Programm, dessen erzeugte Objekte erreichbar sind: 

class ListOfArray { 

int[] elem; 

ListOfArray next; 

} 

void main( String[] ins ) { 

ListOfArray la = null; 



ListOfArray tmp = new ListOfArray(); 

tmp.elem = new int[1000000]; 

tmp.next = la; 

la = tmp; 

println(count++); 

} } 

Dies Programm terminiert mit OutOfMemoryError. 


119

Begriffsklärung: (Erreichbarkeit) 

Ein Verbund bzw. Objekt X heißt von einer Variablen v 

direkt erreichbar, wenn v eine Referenz auf X enthält. 

X heißt von v erreichbar, wenn es von v direkt 

erreichbar ist oder wenn es einen Verbund/ ein Objekt 

Y mit Komponente w gibt, so dass X von w direkt 

erreichbar ist und Y von v erreichbar ist. 

Die Menge der Wurzelvariablen zu einem Ausführungszustand 

A umfasst alle globalen Variablen sowie 

die aktuell im Keller vorhandenen lokalen Variablen 

und Parameter. 

Ein Objekt heißt erreichbar in einem Ausführungszustand 

A, wenn es von einer Wurzelvariablen zu A 

erreichbar ist. 

Bemerkung: 

Verbunde/Objekte können nur von Wurzelvariablen 

oder von Verbundkomponenten/Instanzvariablen 

referenziert werden. 


120

Deallokation von Verbunden/Objekten 

Begriffsklärung: (De-/Allokation) 

Die Bereitstellung des Speicherbereichs bei der 

Erzeugung von Verbunden und Objekten nennt 

man Allokation (engl. allocation). Die Freigabe 

solcher Speicherbereiche Deallokation (engl. 

deallocation). 

Die meisten prozeduralen Programmiersprachen 

unterstützen De-/Allokation durch den Programmierer: 

• Vorteil: 

- ermöglicht effiziente Benutzung von Speicher 

• Nachteile: 

- zusätzlicher Programmieraufwand 

- potentielle Fehlerquelle 

- führt leicht zu Sicherheitslücken 

Wir betrachten hier De-/Allokation von Objekten 

in C++. 


121

Verbunde und Zeiger in C++: 

C++ unterscheidet zwischen Verbunden und 

und Zeigern/Referenzen auf Verbunde. 

Beispiel: (Verbunde und Zeiger) 

#include 

class Punkt { 

public: 

int x; 

int y; 

}; 

Punkt* puenktchen() { 

} 

Punkt* p = new Punkt(); 

p->x = 1; 

p->y = 2; 

Punkt q; 

q.x = 3; 

q.y = 4; 

return p; 

int main() { 

Punkt* r = puenktchen(); 

cout

Wie in Java, alloziert der Operator „new“ in C++ 

Speicher für neue Verbunde. Als Ergebnis 

liefert er einen Zeiger auf den neuen Verbund. 

Ist K ein Verbundtyp, dann bezeichnet in C++ 

K* den Typ der Zeiger auf Verbunde vom Typ K. 

Den Speicherplatz, den man mit new alloziert hat, 

kann man durch Aufruf des Operators delete wieder 

freigeben, wenn er nicht mehr gebraucht wird. 

Beispiel: (Verbunde und Zeiger, Fortsetzung) 

// ... wie auf Folie 4.122 

int main() { 

} 

Punkt* r = puenktchen(); 

cout

Beispiel: (Wirkung der Deallokation) 

Zum Vergleich mit Java (s. Folie 4.119) betrachten wir 

zwei Varianten eines C++ Programms mit und ohne 

Deallokation. Sei Klasse Vektor gegeben: 

class Vektor { 

public: 

int elems [1000000]; 

}; 

Folgendes Programm führt zu einem Abbruch wegen 

Speicherüberlaufs: 

int main() { 


Vektor* vp = new Vektor(); 

} 

return 0; 

} 

Deallokation der Vektorverbunde verhindert den 

Speicherüberlauf: 

int main() { 


Vektor* vp = new Vektor(); 

// mache irgendwas mit dem Vektor: 

delete vp; 

} 

return 0; 

} 


124

Verwendung von Deallokation: 

Ein Programmteil P kann einen Speicherbereich 

freigeben, wenn: 

- P den Speicherbereich nicht mehr benötigt, 

- P den Speicherbereich kontrolliert, d.h. sicher sein 

kann, dass er von keiner anderen Stelle benötigt wird. 

Weitere Aspekte der Deallokation: 

• Deallokation wird in einigen Sprachen durch weitere 

Sprachmittel unterstützt (z.B. Destruktoren in C++). 

• Deallokation und automatische Speicherbereinigung 

lassen sich kombinieren: 

- Anweisungen an den Garbage Collector 

- Soft und weak references in Java 

• Deallokation bezieht sich nicht nur auf Speicher-, 

sondern auch auf andere Ressourcen. 

• Ein systematischer Umgang mit einer Ressource 

bedeutet zu klären, 

- wer die Ressource kontrollieren soll, 

- wer Zugriff auf die Ressource erhält. 


125

4.3.3 Laufzeitverhalten 

Dieser Abschnitt ergänzt die in 4.3.1 vorgestellten 

Aspekte zum Laufzeitverhalten. 

Das Laufzeitverhalten eines Programms wird 

bestimmt durch: 

- die Anweisungen des Programms 

- den Übersetzer 

- die Laufzeitumgebung, insbesondere die 

die Speicherverwaltung 

- die Systemumgebung. 

Speicherverwaltung kostet Zeit: 

Speicherverwaltung ist aufwendig, wenn der verfügbare 

Speicher knapp wird: 

- Garbage Collector muss häufig aufgerufen werden. 

- Das Aufsuchen ausreichend großer freier Speicherbereiche 

wird aufwendiger. 


126

Insgesamt ist der Aufwand in der Praxis nicht 

leicht abzuschätzen, weil 

- der Speicherverbrauch der Bibliotheksklassen 

und anderer fremder Programmteile häufig nicht 

klar spezifiziert ist; 

- die Details der Speicherverwaltung eine wichtige 

Rolle spielen. 

Problematisch ist das insbesondere bei Echtzeitanforderungen. 

Systemumgebung beeinflusst das 

Laufzeitverhalten: 

Zur Gesamtbeurteilung des Laufzeitverhaltens eines 

Softwaresystems muss auch die Systemumgebung 

berücksichtigt werden: 

- Benutzerinteraktion 

- Anzahl von Benutzern 

- Kommunikationszeiten 

- Laufzeitverhalten der Plattform 

- Interaktion mit anderen Systemen 


127

Fazit: 

- Präzise Bestimmung der Effizienz ist im Allg. 

schwierig und von vielen technischen Aspekten 

abhängig; aber auch nur bei ausgewählten 

Anwendungen nötig. 

- Durch geeignete Abstraktion kann man nachvollziehbare 

Aussagen über die Effizienz eines 

Algorithmus‘, Programms oder Softwaresystems 

machen. 


128

4.3.4 Prozedurale Algorithmen und 

deren Analyse 

Vorgehen: 

Wir betrachten prozedurale Formulierungen und 

die Analyse von drei Sortieralgorithmen: 

- Sortieren durch Einfügen 

- Quicksort 

- Heapsort 

Bei allen Algorithmen gehen wir davon aus, dass 

die zu sortierenden Daten in einem Feld vorliegen, 

das verändert werden darf. 

Datensätze stellen wir durch folgenden 

Datentypen dar: 

class DataSet { 

int key; 

String data; 

} 

DataSet mkDataSet( int k, String s ) { 

DataSet ds = new DataSet(); 

ds.key = k; 

ds.data = s; 

return ds; 

} 


129

Bemerkung: 

Beachte bei den folgenden Beispielen: 

1. Die algorithmische Grundidee ist unabhängig 

vom verwendeten Programmierparadigma. 

2. Die Verwendung von Feldern statt Listen kann 

die Komplexität ändern. 

Sortieren durch Einfügen 

Algorithmische Grundidee: 

Sortiere zunächst eine Teilliste (Terminierungsfall: 

leere Liste). Füge dann die verbleibenden Elemente 

nacheinander in die bereits sortierte Teilliste ein. 

Funktionale Fassung: 

fun sortieren nil = nil 

| sortieren (x::xl) = 

einfuegen x (sortieren xl) 

and einfuegen x [] = [x] 

| einfuegen (kx,sx) ((ky,sy)::yl) = 

if kx

Nachteil der rekursiven Fassung: 

- Aufwand durch Listendarstellung 

- Aufwand durch rekursive Aufrufe 

Ideen zur prozeduralen Realisierung: 

- Speichere die Datensätze in einem Feld 

- Realisiere das Einfügen durch schrittweises 

Verschieben (ausgehend vom größten Element) 

- Eliminiere die Rekursion durch Beginn mit der 

einelementigen Liste in die nacheinander Elemente 

eingefügt werden. 

einfügen 

sortiert unsortiert 


131

Prozedurale Fassung in Java: 

void sortieren(/*nonnull*/ DataSet[] f) { 

DataSet tmp; // einzufuegender Datensatz 

for( int i = 1; i=1 && f[j-1].key > tmp.key ) { 

// Verschiebe groessere Saetze mit 

// groesseren Schluesseln 

f[j] = f[j-1]; 

j--; 

} 

// Setze tmp an neue Position 

f[j] = tmp; 

} 

} 

public static void main( String[] arg ) { 

DataSet[] feld = new DataSet[arg.length]; 

for( int i = 0; i

Laufzeitabschätzung: 

Wir betrachten die Anzahl der Schlüsselvergleiche 

C und der Zuweisungen M von Datensätzen in 

Abhängigkeit von der Anzahl N der Datensätze. 

Günstigster Fall: 

Liste ist bereits aufsteigend sortiert. 

� pro Schleifendurchlauf ein Schlüsselvergleich 

� pro Durchlauf zwei Datensatzzuweisungen 

Schlüsselvergleiche: C (N) = N -1; 

Datensatzzuweisungen: M (N) = 2*(N –1); 

Ungünstigster Fall: 

Liste ist absteigend sortiert. 

min 

min 

� pro Schleifendurchlauf i Schlüsselvergleiche 

� pro Durchlauf (i+2) Datensatzzuweisungen 

Schlüsselvergleiche: C (N) = Σ i ∈ O(N ) 

Datensatzzuweisungen: M (N) = Σ (i+2) ∈ O(N ) 

Durchschnitt: 

max 

N-1 

max i=1 

N-1 2 

Im Durchschnitt ergibt sich quadratische Komplexität. 


133 

i=1 

2

Quicksort 

Algorithmische Grundidee: 

• Wähle einen beliebigen Datensatz mit Schlüssel k 

aus, das sogenannte Pivotelement. 

• Teile die Liste in zwei Teile: 

- 1. Teil enthält alle Datensätze mit Schlüsseln < k 

- 2. Teil enthält die Datensätze mit Schlüsseln ≥ k 

• Wende quicksort rekursiv auf die Teillisten an. 

• Hänge die resultierenden Listen und das Pivotelement 

zusammen. 

Funktionale Fassung: 

fun qsort [] = nil 

| qsort ((pk,ps)::rest) = 

let val (below,above) = split pk rest in 

end 

qsort below @[(pk,ps)]@ qsort above 

and split p [] = ([],[]) 

| split p ((xk,xs)::xr) = 

let val (below, above) = split p xr in 

end 

if xk 

else (below,(xk,xs)::above) 


134

Umsetzung in prozedurale Fassung: 

- Speichere die Datensätze in einem Feld und 

bearbeite rekursiv Teilbereiche des Feldes 

- Realisiere das Teilen der Liste durch Vertauschen: 

� Indexzähler left, right laufen von links bzw. 

rechts bis f[left].key ≥ pivot.key 

&& f[right].key < pivot.key 

Es gilt: 

Für alle i in [ug,left-1] : f[i].key < pivot.key 

Für alle i in [right+1,og] : pivot.key ≤ f[i].key 

1. Fall: 

left > right : Teilung vollzogen: 

2. Fall: 

ug og 

left right 

left ≤ right : Vertausche f[left] und f[right], 

inkrementiere left und right und fahre fort. 

ug og 

left right 


135

Prozedurale Fassung in Java: 


quicksort(f,0,f.length-1); 

} 

void quicksort( DataSet[] f, int ug, int og){ 

if( ug < og ) { 

int ixsplit = partition(f,ug,og); 

/* ug

int partition( DataSet[] f, int ug, int og){ 

DataSet dtmp; 

int left = ug; 

int pk = f[og].key; 

int right = og-1; 

boolean b = true; 

while( b ) { 

while( f[left].key < pk ) { left++; } 

while( left=pk ){ 

right--; } 

if( left > right ) { 

b = false; 

} else { 

dtmp = f[left]; 

f[left] = f[right]; 

f[right] = dtmp; 

left++; 

right--; 

} 

} 

dtmp = f[left]; 

f[left] = f[og]; 

f[og] = dtmp; 

return left; 

} 


137

Grobe Laufzeitabschätzung von Quicksort: 

Seien C, M und N definiert wie auf Folie 4.133. 

Vorüberlegung: 

Betrachte die Ebenen gleicher Tiefe im Aufrufbaum 

von quicksort. Das Zerlegen aller Teillisten auf einer 

Ebene verursacht schlimmstenfalls linearen Aufwand: 

C (N) = O(N) 

part 

M (N) = O(N) 

part 


Beim Zerlegen der Listen ist jeweils eine der Teillisten 

leer. Dann hat der Aufrufbaum die Tiefe N, also gilt: 

C (N) = N * C (N) = O(N ) 

max 

M (N) = N * M (N) = O(N ) 

max 

Günstigster Fall: 

part 

part 

Beim Zerlegen der Liste entstehen jeweils zwei etwa 

gleich große Teillisten. Dann hat der Aufrufbaum die 

Tiefe log N, also gilt: 

C (N) = log N * C (N) = O(N log N) 

min 

M (N) = log N * M (N) = O(N log N) 

min 

part 

part 


138 

2 

2

Bemerkung: 

• Die mittlere Laufzeit von Quicksort ist auch von 

der Größenordnung O(N log N) (siehe Ottmann, 

Widmayer: Abschn. 2.2) 

• Die vorgestellte Quicksort-Fassung arbeitet 

schlecht auf schon sortierten Listen. 

• Verbesserungen der vorgestellten Variante ist 

möglich durch geeignetere Auswahl des Pivotelementes 

und durch Elimination der Rekursion. 

Heapsort 

Zur Einführung siehe Folie 3.105 ff. Zur Erinnerung: 

Heap wird verwendet, um schnell einen Datensatz 

mit maximalem Schlüssel zu finden. 

Algorithmische Idee: 

• 1. Schritt: Erstelle den Heap zur Eingabefolge. 

• 2. Schritt: 

- Entferne Maximumelement aus Heap ( O(1) ) 

und hänge es vorne an die schon sortierte Liste. 

- Stelle Heap-Bedingung wieder her ( O(log N) ). 


139

Vorgehen: 

- Entwicklung einer prozeduralen Datenstruktur 

FVBinTree für fast vollständige Binärbäume 

- Heapsort unter Nutzung von FVBinTree 

- Elimination der Schnittstelle 

Prozedurale Datenstruktur für fast vollstän- 

dige, markierte, indizierte Binärbäume: 

class FVBinTree { 

DataSet[] a; 

int currsize; 

} 

/* f ist nicht null; uebernimmt f, d.h. 

Modifikationen an dem Ergebnis ändern 

moeglicherweise auch f 

*/ 

FVBinTree mkFVBinTree( DataSet[] f ){ 

FVBinTree t = new FVBinTree(); 

t.a = f; 

t.currsize = f.length; 

return t; 

} 

/* liefert Groesse von t; lesend */ 

int size( FVBinTree t ){ return t.currsize; } 


140

* lesend */ 

DataSet get( FVBinTree t, int ix ) { 

return t.a[ix]; 

} 

/* modifizier t */ 

void swap( FVBinTree t, int ix1, int ix2 ) { 

DataSet dtmp = t.a[ix1]; 

t.a[ix1] = t.a[ix2]; 

t.a[ix2] = dtmp; 

} 

/* modifizier t */ 

void removeLast( FVBinTree t ){t.currsize--;} 

/* lesend */ 

boolean hasLeft( FVBinTree t, int ix ){ 

return left(t,ix) < t.currsize; 

} 

/* lesend */ 

boolean hasRight( FVBinTree t, int ix ) { 

return right(t,ix) < t.currsize; 

} 

/* lesend */ 

int left( FVBinTree t, int ix ) { 

return 2*(ix+1)-1; 

} 

/* lesend */ 

int right( FVBinTree t, int ix ) { 

return 2*(ix+1); 

} 


141

Bemerkung: 

Bei einer prozeduralen Datenstruktur muss man 

sich genau merken, welche Operationen 

- Referenzen übernehmen bzw. 

- Änderungen vornehmen. 

/* Stellt Heap-Eigenschaft her, wobei die 

Kinder des Knotens ix die Eigenschaft 

bereits erfuellen muessen; modifiziert t 

*/ 

void heapify( FVBinTree t, int ix ) { 

} } 

int ixk = get(t,ix).key; 

if( hasLeft(t,ix) && !hasRight(t,ix) ) { 

int lx = left(t,ix); 

if( ixk < get(t,lx).key ) { 

} 

swap(t,ix,lx); 

} else if( hasRight(t,ix) ) { 

int lx = left(t,ix); 

int rx = right(t,ix); 

int largerChild = 

get(t,lx).key > get(t,rx).key ? lx : rx; 

if( ixk < get(t,largerChild).key ) { 

} 

swap( t, ix, largerChild ); 

heapify( t, largerChild ); 


142


FVBinTree t = mkFVBinTree( f ); 

// Herstellen der Heap-Bedingung 

} 

for( int i = size(t)/2 - 1; i >= 0; i-- ){ 

heapify(t,i); 

} 

// Sortieren 

while( size(t) > 0 ) { 

} 

swap( t, 0, size(t)-1 ); 

removeLast(t); 

heapify(t,0); 

In einem Optimierungsschritt: 

- Eliminieren wir den Datentyp FVBinTree und 

arbeiten direkt auf dem übergebenen Feld, wobei 

wir die aktuelle Größe in einer lokalen Variable 

speichern. 

- Ersetzen wir die Operationen der Datenstruktur 

durch deren Rümpfe. 

- Benutzen wir eine swap-Prozedur für Felder: 

void swap( DataSet[] f, int i1, int i2 ){ 

DataSet dtmp = f[i1]; 

f[i1] = f[i2]; 

f[i2] = dtmp; 

} 


143

* Kommentar siehe oben; modifiziert f 

*/ 

void heapify( DataSet[] f, int size, int ix ){ 

int ixk = f[ix].key; 

int rx = 2*(ix+1); 

int lx = rx – 1; 

if( lx < size && rx >= size ) { 

if( ixk < f[lx].key ) { 

swap(f,ix,lx); 

} 

} else if( rx < size) { 

int largerChild = 

f[lx].key > f[rx].key ? lx : rx; 

if( ixk < f[largerChild].key ) { 

swap(f,ix,largerChild); 

heapify( f, size, largerChild ); 

} 

} } 


int size = f.length; 

// Herstellen der Heap-Bedingung 

for( int i = size/2 - 1; i >= 0; i-- ) { 

heapify(f,size,i); 

} 

// Sortieren 

while( size > 0 ) { 

size--; 

swap( f, 0, size ); 

heapify(f,size,0); 

} 

} 


144

Grobe Laufzeitabschätzung von Heapsort: 

Seien C, M und N definiert wie auf Folie 4.133. Wir 

betrachten nur den ungünstigsten Fall. 


1. Herstellen der Heap-Eigenschaft: 

Bezeichne j die Anzahl der Niveaus im Heap, 

also 2 ≤ N ≤ 2 -1. 

Dann gibt es auf Niveau k höchstens 2 Schlüssel 

und C und M sind proportional zu j-k . 

Insgesamt gilt dann für die Anzahl der Operationen 

zur Herstellung der Heap-Eigenschaft: 

j-1 k 

max 

Σ 2 * (j-k) = Σ i * 2 = 2 * Σ i ≤ 2*N*2 ∈O(N) 

i=1 

i=1 2 

k=1 

j-1 j 

max 

j-1 j-i j 

2. Auswahl des Wurzelelements und Versickern: 

Da die Höhe eines fast vollständigen Binärbaums 

von Ordnung O(log N) ist, führt heapify O(log N) 

Operationen aus. Damit ergibt sich für diese Teile 

die Komplexität O(N log N). 

3. Komplexität des gesamten Algorithmus: 

O(N) + O(N log N) = O(N log N) 

j-1 i 


145 

k

Übersicht über die Komplexität von 

Sortierverfahren: 

O(N k ) 

k ≤ 2 

Sortierverfahren 

intern (im HSP) extern (nicht im HSP) 

Auswählen 

Einfügen 

Bubblesort 

Shellsort 

Baumsortierung 

Quicksort 

O( N log N) 

2 

Baumsortierung (AVL) 

Heapsort 

Mergesort 

Mergesort 


146

4.3.5 Algorithmenklassen & -entwicklung 

Dieser Abschnitt skizziert: 

• wichtige weitere Problem- und Algorithmenklassen 

• einen Weg zur Entwicklung von Algorithmen 

anhand eines Beispiels 

Problem- und Algorithmenklassen 

Neben dem klassischen Bereichen des Sortierens 

und Suchens von Datensätzen gibt es eine Vielzahl 

von Algorithmen für unterschiedliche Aufgabenund 

Problembereiche. 

Beispiele: (Algorithmische Probleme) 

• Optimaler Einsatz der Flugzeugflotte einer 

Fluggesellschaft. 

• Ermittlung der Schnittfläche zweier Flächen gegeben 

durch ihre Punkte 

• Erfüllbarkeit/Allgemeingültigkeit logischer Formeln. 

• Auffinden aller Web-Seiten, die eine Menge von 

Schlüsselwörter enthalten 


147

Klassifikation der Algorithmen gemäß: 

• verwendeter Datenstrukturen 

• algorithmischer Kriterien (z.B. Art der Parallelität) 

• spezieller Aufgabenbereiche 

Datenstrukturen: 

Mengen, Listen, Warteschlangen, etc.: 

Ziele: 

Effiziente Speicherung und effiziente Operationen 

zum Einfügen, Suchen und Löschen. 

Zeichenreihen, Textsuche: 

Ziele: 

Effiziente Suche von Wort- oder Textmustern in 

Texten. 

Beispiel: 

Finde alle Vorkommen von „S%Haffner“ in den letzten 

5 Jahrgängen der Frankfurter Allgemeinen Zeitung. 


148

Graphen: 

Begriffsklärung: (Graph) 

Ein gerichteter Graph (engl. digraph) G = (V, E) 

besteht aus 

- einer endlichen Menge V von Knoten (engl. vertices) 

- einer Menge E ⊆ VxV von Kanten (engl. edges) 

Ist (va,ve) eine Kante, dann nennt man 

- va den Anfangs- oder Startknoten oder die Quelle 

- ve den Endknoten oder das Ziel 

der Kante. ve heißt von va direkt erreichbar und 

Nachfolger von va; va Vorgänger von ve. 

Graphen bieten für eine große Klasse von 

Problemen ein geeignetes abstraktes Modell. 

Beispiele: 

- Was ist die beste Verbindung von A nach B? 

- Wie transportiere ich Waren von mehreren Anbietern 

am billigsten zu mehreren Nachfragern? 

- Wie gestalte ich einen Arbeitsablauf mit mehreren 

Maschinen und Arbeitskräften optimal? 

- Welche Wassermenge kann maximal durch die 

Kanalisation von KL abgeleitet werden? 


149

Speicherdarstellungen von Graphen: 

Sei G = (V,E) ein gerichteter Graph, V = {1,...,n}. 

G lässt sich speichern als: 

- Adjazenzmatrix: boolesche nxn-Matrix, wobei 

das Element (x,y) true ist genau dann, wenn es 

in G eine Kante von x nach y gibt. 

- Adjazenzlisten: Speichere für jeden Knoten die 

Liste der durch eine Kante erreichbaren Knoten. 

Algorithmische Kriterien: 

Wir haben bisher nur sequentielle Algorithmen 

betrachtet, deren Daten alle im Hauptspeicher 

Platz finden. In der Praxis sind häufig komplexere 

Anforderungen zu berücksichtigen: 

- Daten auf anderen Speichermedien ohne wahlfreies 

Zugriffsverhalten 

- Parallelisierung für gegebene Rechner, um 

akzeptable Antwortzeiten zu erhalten bzw. große 

Datenmengen rechnen zu können. 

- Arbeiten mit verteilten, sich dynamisch 

entwickelnden Daten 


150

Aufgabenbereiche: 

Viele Teilgebiete der Informatik und anderer Fächer 

haben mittlerweile für ihre speziellen Aufgaben 

umfangreiches algorithmisches Wissen erarbeitet. 

Zwei Beispiele: 

- Algorithmische Geometrie 

- Übersetzertechnik/Compilerbau 

Algorithmische Geometrie: 

Beispielproblem: 

Gegeben eine Menge von Rechtecken; ermittle 

alle Paare von Rechtecken, die sich schneiden. 

Anwendungsbereiche: 

• Computergraphik, Visualisierung 

• Geometrische Modellierung, CAD 

• Schaltungsentwurf 

• Wegeplanung von Robotern 


151

Übersetzertechnik: 

Aufgabenbereiche: 

• Parsen gemäß einer kontextfreien Grammatik: 

- Eingabe: Zeichenreihe (Programm) 

- Ausgabe: Syntaxbaum 

• Optimierende Übersetzung, zum Beispiel: 

- Konstante Ausdrücke zur Übersetzungszeit 

berechnen 

- Prozeduraufrufe durch ihre Rümpfe ersetzen 

- Speicherbedarf verringern 

Beispiel: (Konstantenfaltung) 

Übersetze das Programmfragment 

int a = 7; 

int b = a * 3; 

int c = a + b; 

so als hätte der Programmierer geschrieben: 

int a = 7; 

int b = 21; 

int c = 28; 


152

Beispiel: (Escape-Analysis) 

Aufgabe: 

Ermittele die Objekte, die auf dem Keller alloziert 

werden können, da ihre Referenzen den Methodenaufruf, 

der sie erzeugt hat, nicht verlassen. 

Beispielfragment: 

void m( String s ) { 

String t = "" + s ; // neuer Verbund 

t = doSomething(t); // Modifikation von t 

println(t); 

} 

Der/das von t referenzierte Verbund/Objekt 

könnte auf dem Keller verwaltet werden. 

Ziel: 

Entlastung der Speicherbereinigung. 


153

Algorithmenentwicklung 

Abschließend zu 4.3 betrachten wir wichtige Phasen 

der Algorithmenentwicklung an einem Beispiel. 

Phasen der Algorithmenentwicklung: 

1. Problemabstraktion und -formulierung 

2. Entwickeln einer algorithmischen Idee 

3. Ermitteln wichtiger Eigenschaften des Problems 

4. Grobentwurf eines Algorithmus‘ mit Abstützung 

auf existierende Teillösungen 

5. Entwickeln bzw. Festlegen der Datenstrukturen 

6. Ausarbeiten des Algorithmus 

Algorithmenentwicklung an einem Beispiel: 

Wir erläutern die Phasen der Algorithmenentwicklung 

an einem Beispiel (vgl. Phasen der Softwareentwicklung). 

0. Problem: 

Routenplaner für Fahrradfahrer in einer Großstadt: 

Wie ist die beste Verbindung zwischen zwei 

Straßenkreuzungen? 


154

1. Problemabstraktion und -formulierung: 

Modelliere die Straßen und Wege durch einen 

gerichteten Graphen mit bewerteten Kanten: 

- Straßenkreuzungen entsprechen Knoten 

- Kante entspricht einer direkten Straßenverbindung 

zwischen Kreuzungen A und B, die von A nach B 

befahrbar ist (ggf. auch Kante für umgekehrte 

Richtung). 

- Jede Kante bekommt als Bewertung die Zeit in 

Sekunden, die man im Durchschnitt für den Weg 

von A nach B braucht. 

Die Bewertung ist eine Funktion c: E � R 

Bewertete gerichtete Graphen nennt man 

Distanzgraphen. 

Damit lässt sich das Problem wie folgt formulieren: 

- Gegeben ein Distanzgraph, der die Straßenverbindungen 

modelliert, sowie zwei Knoten s und z. 

- Gesucht ist ein Weg s, v1, ... , vn , z mit minimaler 

Länge lg : 

lg = c( (s,v1) ) + c( (v1,v2) ) + ... + c( (vn,z) ) 


155 

+

2. Entwickeln einer algorithmischen Idee: 

Eine verbreitete Strategie zur Algorithmenentwicklung 

versucht ein Problem auf ähnlich geartete 

Teilprobleme zu reduzieren. Hier: 

Reduziere die Suche des kürzesten Wegs von 

s nach z auf kürzeste Wege zwischen anderen 

Knotenpaaren. 

Ansatz: 

(a) Errechne schrittweise Knotenmengen B, sodass 

der kürzeste Weg von s zu allen Knoten von B 

bekannt ist. Anfangs ist B = { s }. 

(b) Betrachte alle Knoten R außerhalb von B, die von 

Knoten in B direkt erreichbar sind. (R wird meist 

der Rand von B genannt.) 

(c) Bestimme den kürzesten Weg zu einem Knoten 

in R und erweitere B entsprechend. 

Unter welchen Bedingungen lassen sich (a)-(c) 

algorithmisch lösen? Was sind die Einzelschritte? 

Sei r ∈ R ein Randknoten und w 1 ,...,w r ∈ B alle 

Knoten mit (w i 

,r) ∈ E . Lässt sich damit der 

kürzeste Weg von s nach r bestimmen und seine 

Länge spl(s,r) ? 


156

3. Ermitteln wichtiger Eigenschaften des Problems: 

Um unseren Ansatz umsetzen zu können, brauchen 

wir eine Eigenschaft, die es uns ermöglicht, 

B schrittweise um Randknoten zu erweitern. 

Verschärfung des Ansatzes: 

1. Bestimme für jeden Knoten r des Randes einen 

Vorgänger w r in B, so dass 

d(r) = spl( s, w ) + c((w ,r)) minimal ist. 

2. Wähle unter allen Knoten r von R denjenigen mit 

minimalem d(r) aus. Sei dieser Knoten mit p 

bezeichnet. Erweitere B um p. 

Behauptung: 

spl( s, w ) + c( (w ,p) ) = spl( s, p ) , d.h. der 

kürzeste Weg von s zu p wurde gefunden. 

Beweis: 

r 

p p 

Mit Induktion über den kürzesten Weg (siehe 

Vorlesung). 


157 

r

4. Grobentwurf eines Algorithmus‘ mit Abstützung 

auf existierende Teillösungen: 

Wir setzen die obigen Ansätze in einen Grobentwurf 

um, der auf Dijkstra zurückgeht (vgl. Ottmann, 

Widmayer: 8.5.1): 

Jeder Knoten erhält drei zusätzliche Komponenten: 

pred: Vorgänger auf dem kürzesten „Rückweg“ zu s. 

dist: die kürzeste bisher ermittelte Entfernung zu s. 

inB: Ist genau dann true, wenn Knoten in der 

Menge ist, für die der kürzeste Weg bekannt ist. 

Algorithmus: kürzeste Wege in bewerteten 

Graphen G = (V,E) mit Bewertungsfunktion c. 

Startknoten ist s. 

// Initialisieren der Knoten und von B: 

for all v∈V\{s} do { 

v.pred = null; 

v.dist = ∞ ; 

v.inB = false ; 

} 

s.pred = s ; 

s.dist = 0 ; 

s.inB = true ; 


158

Initialisieren des Randes R: 

R = ∅ ; 

// R initialisieren, d.h. die Nachfolger von s eintragen: 

ergänzeRand(s,R); 

// Auswählen von Knoten aus R und R ergänzen: 

while R != ∅ do { 

// wähle nächst gelegenen Randknoten aus: 

wähle v∈R mit v.dist minimal ; 

entferne v aus R ; 

v.inB = true ; 

ergänzeRand(v,R); 

} 

where 

procedure ergänzeRand( v, R ) { 

} 

for all (v,w)∈E do { 

} 

if not w.inB and 

} 

( v.dist + c((v,w)) < w.dist ){ 

// w ist (kürzer) über v erreichbar 

w.pred = v ; 

w.dist = v.dist + c((v,w)) ; 

R = R ∪ {w} ; 


159

5. Entwickeln bzw. Festlegen der Datenstrukturen: 

In dieser Phase ist zu entscheiden, welche 

Datenstrukturen für die Realisierung 

- des Graphen und 

- des Randes 

benutzt werden sollen. 

Benötigte Operationen auf der Graphdatenstruktur: 

- Iterieren über die Knotenmenge 

- Iterieren über die Kantenmenge zu einem Knoten 

- Bewertung der Kanten auslesen 

Benötigte Operationen auf dem Rand: 

- Rand als leer initialisieren 

- Prüfen, ob Rand leer ist 

- Wählen des Knotens mit minimaler Entfernung 

- Entfernen eines Knotens aus dem Rand 

- Knoten zum Rand hinzufügen bzw. Knoten im Rand 

modifizieren 

Als Graphdatenstruktur könnten z.B. Adjazenzlisten 

verwendet werden. Der Rand kann als Heap realisiert 

werden. 


160

6. Ausarbeiten des Algorithmus: 

Aus den Entscheidungen der 5. Phase entsteht 

ein Feinentwurf, der präzise zu formulieren und, 

wo möglich, zu optimieren ist. 

Schließlich kann der Feinentwurf ausprogrammiert 

und getestet werden. 

Bemerkung: 

• Bis auf den letzten Schritt sind alle Phasen der 

Algorithmenentwicklung unabhängig von 

Programmiersprachen. Üblicherweise rechnet man 

die Algorithmenimplementierung auch nicht mehr 

zum Bereich Algorithmen und Datenstrukturen. 

• Softwareentwicklung im Allg. hat viele Parallelen 

zur Algorithmenentwicklung. Auch hier hat die 

Programmierung eine nachgeordnete Bedeutung. 

Dafür liegt der Schwerpunkt nicht so sehr 

auf der Lösung gut eingrenzbarer Probleme, 

sondern stärker auf der Bewältigung der vielen 

Aspekte und des Umfangs der Aufgabenstellung. 


161

4. Prozedurales Programmieren

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?