Beispiel: Algorithmus von Euklid

Algorithmen und Datenstrukturen

Werner Struckmann

Wintersemester 2005/06

2. Imperative Algorithmen

2.1 Variable, Anweisungen und Zustände 2.2 Felder

2.3 Komplexität von Algorithmen 2.4 Korrektheit von Algorithmen 2.5 Konzepte imperativer Sprachen 2.6 Rekursionen

Paradigmen zur Algorithmenbeschreibung

In einem imperativen Algorithmus gibt es Variable, die

verschiedene Werte annehmen können. Die Menge aller Variablen und ihrer Werte sowie der Programmzähler beschreiben den

Zustand zu einem bestimmten Zeitpunkt. Ein Algorithmus bewirkt eine Zustandstransformation.

Ein funktionaler Algorithmus formuliert die Berechnung durch Funktionen. Die Funktionen können rekursiv sein; auch gibt es Funktionen höherer Ordnung.

Paradigmen zur Algorithmenbeschreibung

In einem objektorientierten Algorithmus werden Datenstrukturen und Methoden zu einer Klasse zusammengefasst. Von jeder

Klasse können Objekte gemäß der Datenstruktur erstellt und über die Methoden manipuliert werden.

Ein logischer (deduktiver) Algorithmus führt Berechnungen durch, indem er aus Fakten und Regeln durch Ableitungen in einem

logischem Kalkül weitere Fakten beweist.

Beispiel: Algorithmus von Euklid

Der folgende, in einer imperativen Programmiersprache formulierte Algorithmus von Euklid berechnet den größten gemeinsamen

Teiler der Zahlen x

,

y

∈

N _{mit x}

≥

0 und y

>

0:

a := x;

b := y;

while b # 0

do r := a mod b;

a := b;

b := r od

Anschließend gilt a

=

ggT

(

x

,

y

)

.

Beispiel: Algorithmus von Euklid

Variable z₂ z₅ z₈ z₁₁ z₁₄

r – 36 16 4 0

a 36 52 36 16 4

b 52 36 16 4 0

ggT

(

36

,

52

) =

4 Durchlaufene Zustände: z₀

,

z₁

,

z₂

, . . . ,

z₁₄ Zustandstransformation: z₀

7−→

_z14

Imperative Konzepte

◮ Variable: Abstraktion eines Speicherbereichs, ein Wert eines gegebenen Datentyps kann gespeichert und beliebig oft

gelesen werden, solange nicht ein neuer Wert gespeichert und der alte damit überschrieben wird.

◮ Zustand: Abstraktion des Speicherinhalts, Gesamtheit der momentanen Werte aller Variablen, ändert sich durch die Ausführung von Anweisungen.

◮ Anweisung: Vorschrift zur Ausführung einer Operation, ändert im Allgemeinen den Zustand.

Datentypen

◮ Datentyp: Die Zusammenfassung von Wertebereichen und Operationen zu einer Einheit.

◮ Abstrakter Datentyp: Schwerpunkt liegt auf den

Eigenschaften, die die Operationen und Wertebereiche besitzen.

◮ Konkreter Datentyp: Beschreibt die Implementierung eines Datentyps.

Grundlegende Datentypen

Oft werden mathematische Konzepte als Grundlage für einen Datentyp verwendet. Ein Datentyp besteht aus einem

Wertebereich und einer Menge von Operationen.

◮ bool: die booleschen Werte „wahr“ und „falsch“

Operationen: logische Verknüpfungen, wie zum Beispiel „und“

und „oder“.

◮ int: ganze Zahlen,

{

_minint

, · · · , −

₁

,

0

,

1

, · · · ,

maxint

} ⊆

Z minint und maxint besitzen etwa den gleichen Betrag.

Operationen: arithmetische und Vergleichsoperationen.

Die Rechengesetze gelten in der Regel nicht, wenn man über die Darstellungsgrenzen gerät.

Grundlegende Datentypen

◮ real, float: Näherungswerte für reelle Zahlen, dargestellt durch Gleitpunktzahlen:

r

=

m

·

_b^e

m

∈

Z _{Mantisse, b}

∈

N _{Basis, e}

∈

Z _Exponent Die Darstellung erschließt den Zahlenbereich mit konstanter relativer Genauigkeit.

Operationen: arithmetische und Vergleichsoperationen.

Die Rechengesetze gelten im Allgemeinen nur näherungsweise.

Gleitpunktzahlen sollten nicht auf Gleichheit überprüft

werden, stattdessen sollte

|

_x

−

_y

| < ε

für einen kleinen Wert

Grundlegende Datentypen

◮ char: Zeichen aus einem Alphabet

Mit Vergleichsoperationen und den Funktionen

ord

:

^char

→

int und chr

:

^int

→

char, die eine Zuordnung

zwischen den Zeichen aus dem Alphabet und ganzen Zahlen herstellen.

Variable

◮ Variable x : t: Abstraktion eines Speicherplatzes und Zuordnung eines Datentyps

X Menge der Variablen x

:

t x

∈

_X

t

= τ(

x

)

^{Typ von} x v

= σ(

x

)

Wert von x

v

∈

_W

(

t

)

Wertemenge von t

◮ Deklaration: Ein Variablenname wird einem Speicherbereich und einem Typ zugeordnet.

var i, j: int;

var r: real;

var c: char;

Zustand

Ein Zustand bezeichnet die Belegung aller Variablen zu einem Zeitpunkt.

◮ Modellierung:

σ :

x₁

7→

_v1

, . . . ,

x_n

7→

_vn x_i

∈

_X

,

v_i

∈

_W

(

t_i

) ∀

_i

∈ {

1

, . . . ,

n

}

◮ Tabellarisch: x₁

· · ·

_xn v₁

· · ·

_vn

◮ Mathematisch: Abbildung

σ :

X

→

_W

= {

_v1

, . . . ,

v_n

}

_{, wobei}

σ(

x_i

) ∈

_W

(

t_i

) ∀

_i

∈ {

₁

, . . . ,

n

}

σ(

x

)

ist die Belegung der Variablen x im Zustand

σ

.

Zuweisung

◮ Syntax: x

←

_{v v}

∈

_W

(τ(

x

))

◮ Zuweisung, Grundbaustein: Nach Ausführung der Zuweisung gilt

σ(

x

) =

v

.

Ist

σ :

X

→

_W ein Zustand und wählt man eine Variable x

∈

_X sowie einen Wert v vom passenden Typ, so ist der transformierte Zustand

σ

_<x←v> wie folgt definiert:

σ

_<x←v>

(

y

) =

( v falls x

=

y

σ(

y

)

^sonst

Semantik

Die Semantik beschreibt die Bedeutung eines Algorithmus.

Sie ist eine (partielle) Funktion, die jeder Anweisung eine Zustandsänderung zuordnet:

[ ] :

A

→ ((

X

→

_W

) → (

X

→

_W

))

mit

[

a

](σ) = σ

^′ Semantik einer Zuweisung:

[

x

←

_v

](σ) = σ

_<x←v>

Ausdrücke/Terme

Beispiele für Ausdrücke:

◮ Konstante: 3, 2

.

7182, ^′A^′

◮ Variable: x₁, x₂, y

◮ Operatoren und Funktionsaufrufe: x₁

+

3, f

(

x₁

)

◮ Zusammengesetzte Ausdrücke: f

(

x₁

+

3

) −

₂

.

7182

+

y

Falls ein Ausdruck t die Variablen x₁, . . . , x_n enthält, schreiben wir t

(

x₁

, . . . ,

x_n

)

^.

Beispiel eines booleschen Ausdrucks: x

≤

5

∧

_y

<

4

Wert eines Ausdrucks

Die Auswertung von Ausdrücken mit Variablen ist

zustandsabhängig. An die Stelle der Variablen wird ihr aktueller Wert gesetzt.

Beispiel: Für den Ausdruck 2

·

_x

+

1 ist sein Wert im Zustand

σ

durch 2

σ(

x

) +

1 gegeben.

Der so bestimmte Wert des Ausdrucks t

(

x₁

, . . . ,

x_n

)

^{im Zustand}

σ

wird mit

σ(

t

(

x₁

, . . . ,

x_n

))

bezeichnet.

Beispiel:

σ(

2

·

_x

+

1

) =

2

σ(

x

) +

1

Zuweisungen

Diese Festlegung erlaubt Wertzuweisungen mit Ausdrücken auf der rechten Seite

y

←

_t

(

x₁

, . . . ,

x_n

)

Der transformierte Zustand hierfür ist wie folgt definiert:

[

y

←

_t

(

x₁

, . . . ,

x_n

)](σ) = σ

_{<y←σ(t(x1,...,xn))>}

Zuweisungen

Beispiel: Semantik der Zuweisung

x

←

₂

·

_x

+

1

Transformation:

[

x

←

₂

·

_x

+

1

](σ) = σ

_{<x←2·σ(x)+1>}

Hier handelt es sich nicht um eine rekursive Gleichung für x, da auf der rechten Seite der „alte“ Wert von x benutzt wird.

Wertzuweisungen sind die einzigen elementaren Anweisungen imperativer Algorithmen. Aus ihnen werden zusammengesetzte Anweisungen gebildet, aus denen imperative Algorithmen

bestehen.

Zusammengesetzte Anweisungen

Elementare Anweisungen können auf unterschiedliche Arten zu komplexen Anweisungen zusammengesetzt werden:

1. sequenzielle Ausführung, 2. bedingte Ausführung,

3. wiederholte Ausführung,

4. Ausführung als Unterprogramm,

5. rekursive Ausführung eines Unterprogramms.

Diese Möglichkeiten werden als Kontrollstrukturen bezeichnet. Wir betrachten jetzt die ersten drei dieser zusammengesetzten

Anweisungen. Auf die anderen kommen wir am Schluss des Kapitels zu sprechen.

Sequenzielle Ausführung von Anweisungen

◮ Definition: Sind a₁ und a₂ Anweisungen, so auch a₁

;

a₂

◮ Informelle Bedeutung: „Führe erst a₁, dann a₂ aus.“

◮ Semantik:

[

a₁

;

a₂

](σ) = [

a₂

]([

a₁

](σ))

◮ Darstellung im Flussdiagramm:

a1

a2

Bedingte Ausführung von Anweisungen

◮ Definition: Sind a₁ und a₂ Anweisungen und P ein boolescher Ausdruck, so ist auch

if

P

then

a₁

else

a₂

fi

eine Anweisung.

◮ Voraussetzung:

σ(

P

)

kann ausgewertet werden (ansonsten ist die Anweisung undefiniert)

◮ Informelle Bedeutung: „Falls P gilt, führe a₁ aus, sonst a₂.“

Bedingte Ausführung von Anweisungen

◮ Semantik:

[ if

P

then

a₁

else

a₂

fi ](σ) =











[

a₁

](σ)

falls

σ(

P

) =

true

[

a₂

](σ)

^falls

σ(

P

) =

^false

◮ Darstellung im Flussdiagramm:

a1 a2

P

true false

Wiederholte Ausführung von Anweisungen

◮ Definition: Ist a eine Anweisung und P ein boolescher Ausdruck, so ist auch

while

P

do

a

od

eine Anweisung.

◮ Voraussetzung:

σ(

P

)

kann ausgewertet werden (ansonsten ist die Anweisung undefiniert)

◮ Informelle Bedeutung: „Solange P gilt, führe a aus.“

Wiederholte Ausführung von Anweisungen

◮ Semantik:

[ while

P

do

a

od ](σ) =











σ

falls

σ(

P

) =

false

[ while

P

do

a

od ]([

a

](σ))

sonst Diese Definition ist rekursiv.

While-

Schleifen müssen nicht terminieren.

◮ Darstellung im Flussdiagramm:

a P true

false

Flussdiagramme

Normierte Methode (DIN 66001) zur Darstellung von Programmen

◮ Beginn: ^Start

◮ Ende: ^Stop

◮ Elementare Anweisung: ^a

◮ Entscheidung durch booleschen Ausdruck:

P

◮ Eingabe nach n: ^{Eingabe n}

◮ Ausgabe von p: ^{Ausgabe p}

Konkrete Umsetzung

◮ Sprachen mit nur diesen Anweisungen sind bereits berechnungsuniversell.

◮ In existierenden Programmiersprachen gibt es fast immer diese Anweisungen, oft jedoch mehr.

Beispiel:

case-

oder

repeat

-Anweisung.

◮ Schlüsselwörter und Syntax der Kontrollstrukturen variieren von Sprache zu Sprache.

Beispiel:

end if

statt

fi

.

◮ Hierarchische Struktur der Anweisungen: Anweisungen können Bestandteil anderer Anweisungen sein.

Imperative Algorithmen

◮ Es werden die Datentypen int, real und bool verwendet.

◮ Aufbau imperativer Algorithmen (Syntax):

<Programmname>

var

_x,y,. . . :

int

; p,q:

bool

; Variablendeklarationen

input

: x₁

, . . . ,

x_n

;

Eingabevariablen

a; Anweisung(en)

output

: y₁

, . . . ,

y_m Ausgabevariablen

◮ Die Semantik wird durch eine Zustandsüberführungsfunktion beschrieben.

Imperative Algorithmen

Die Semantik eines imperativen Algorithmus ist eine partielle Funktion

[

PROG

] :

W₁

× · · · ×

_Wn

→

_V1

× · · · ×

_Vm

[

PROG

](

w₁

, . . . ,

w_n

) = (σ(

y₁

), . . . , σ(

y_m

)) σ = [

a

](σ

₀

)

σ

₀

(

x_i

) =

w_i

∈

_Wi für i

=

1

, . . . ,

n wobei

PROG: <Programmname>

W_i

:

Wertebereich des Typs von x_i, für i

=

1

, . . . ,

n V_j

:

Wertebereich des Typs von y_j, für j

=

1

, . . . ,

m

Imperative Algorithmen

◮ Der Algorithmus legt eine Zustandstransformation fest. Die Eingabe befindet sich im Zustand

σ

₀.

◮ Die Ausführung imperativer Algorithmen besteht aus einer Abfolge von Zuweisungen. Diese Folge wird mittels

„Sequenz“, „bedingter Ausführung“ und „wiederholter Ausführung“ aus den Zuweisungen gebildet.

◮ Jede Zuweisung definiert eine Transformation des Zustands.

Die Semantik des Algorithmus ist durch die Kombination all dieser Zustandstransformationen festgelegt.

◮ Falls die Auswertung von a nicht terminiert, ist die Funktion

[

PROG

]

nicht definiert.

Algorithmus von Euklid

Der Algorithmus von Euklid lautet in dieser Notation:

EUKLID

var a, b, r, x, y: int;

input x, y;

a ← x;

b ← y;

while b # 0 do r ← a mod b;

a ← b;

b ← r;

od;

output a;

Fakultätsfunktion

k

! =

1

·

₂

·

₃

· · ·

_k

FAK

var x, y: int;

input x;

y ← 1;

while x > 1 do y ← y * x;

x ← x - 1;

od;

output y;

Es gilt:

[

FAK

](

w

) =

(w

!

für w

>

0 1 sonst

Start Eingabe x

y ← 1

x > 1 true

y ← y · x x ← x − 1

false

Ausgabe y Stop

Auswertung der Fakultätsfunktion

◮ Signatur der Semantikfunktion:

[

FAK

] : int → int

◮ Das Ergebnis der Berechnung ist die Belegung der Variablen y im Endzustand:

σ(

y

)

.

◮ Der Endzustand

σ

ist laut Definition

σ = [

a

](σ

₀

)

, wobei a die Folge aller Anweisungen des Algorithmus ist.

◮

σ

₀ ist der Startzustand. Die Eingabe befindet sich in

σ

₀

(

x

)

^.

◮ Da nur die zwei Variablen x und y auftreten, können wir einen Zustand

σ

als Paar

(σ(

x

), σ(

y

))

schreiben.

◮

⊥

bedeutet, dass der Wert der Variablen keine Rolle spielt bzw. undefiniert ist.

Auswertung der Fakultätsfunktion

Gesucht:

[

FAK

](

3

)

σ = [

a

](σ

₀

) = [

a

](

3

, ⊥ )

= [

y

←

1

; while

x

>

1

do

y

←

_y

∗

_x

;

x

←

_x

−

1

od ](

3

, ⊥ )

= [ while

x

>

1

do

y

←

_y

∗

_x

;

x

←

_x

−

1

od ]([

y

←

1

](

³

, ⊥ ))

=: [ while

B

do β od ]([

y

←

1

](

³

, ⊥ ))

= [ while

B

do β od ](

³

,

1

)

=

(

σ

falls

σ(

B

) =

^false

[ while

B

do β od ]([β](σ))

sonst

=

(

(

3

,

1

)

falls

σ(

x

>

1

) =

false

[ while

_B

do β od ]([

y

←

_y

∗

_x

;

x

←

_x

−

₁

](σ))

sonst

Auswertung der Fakultätsfunktion

· · · = [ while

B

do β od ]([

y

←

_y

∗

_x

;

x

←

_x

−

1

](

3

,

1

))

= [ while

B

do β od ]([

x

←

_x

−

1

]([

y

←

_y

∗

_x

](

³

,

1

)))

= [ while

B

do β od ]([

x

←

_x

−

1

](

³

,

3

))

= [ while

B

do β od ](

²

,

3

)

= [ while

B

do β od ]([

y

←

_y

∗

_x

;

x

←

_x

−

1

](

²

,

3

))

= [ while

B

do β od ](

¹

,

6

)

=

(

(

¹

,

6

)

^falls

σ(

x

>

1

) =

^false

[ while

B

do β od ]([

y

←

_y

∗

_x

;

x

←

_x

−

₁

](

1

,

6

))

sonst

= (

1

,

6

)

[FAK](3) = 6

Fibonacci-Zahlen (iterativ)

f₀

=

0

,

f₁

=

1

,

f_n

=

f_n−1

+

f_n−2

,

n

>

1 FIB:

var x,a,b,c: int;

input x;

a ← 0;

b ← 1;

while x > 0 do c ← a + b;

a ← b;

b ← c;

x ← x - 1;

od;

output a;

[

FIB

](

x

) =

( die x-te Fibonacci-Zahl, falls x

>

0

,

Fibonacci-Zahlen (rekursiv)

Einzelheiten zu rekursiven Programmen werden später behandelt!

f₀

=

0

,

f₁

=

1

,

f_n

=

f_n−1

+

f_n−2

,

n

>

1 FIB:

var n, x: int;

input n;

if n = 0 then x ← 0 fi;

if n = 1 then x ← 1 fi;

if n > 1 then x ← FIB(n - 1) + FIB(n - 2) fi;

output x;

Ein rekursiv ausgedrückter Algorithmus ist häufig eleganter als sein iteratives Äquivalent. Nachteil ist evtl. eine längere Laufzeit.

Felder

◮ Definition: Ein Feld ist eine indizierte Menge von Variablen des gleichen Typs. Felder sind generische Datentypen.

◮ Deklaration:

var x[I]: T;

var coords[1..3]: real;

var str[0..4095]: char;

◮ Indexmenge: I endlich, häufig I

⊆

N, aber andere Indexmengen sind möglich.

◮ Zugriff: x

[

i

]

sowohl lesend als auch schreibend, wobei i

∈

_I. Längenänderungen von Feldern sind nicht in allen

Programmiersprachen möglich.

Verbreitete Spezialfälle von Feldern

◮ Vektor:

var v[1..3]: real;

◮ Matrix:

var v[1..4, 1..4]: real;

◮ Strings:

var str[0..102]: char;

For-Schleife

Die For-Schleife ist eine weitere Kontrollstruktur zur Wiederholung von Anweisungen.

Es seien j

,

k

∈

N _Konstante,

var

i

: int

eine Variable und a eine Anweisung.

for i ← j to k do a; od

entspricht

i ← j; while i ≤ k do a; i ← i + 1; od

i wird Laufvariable der Schleife genannt.

Viele Programmiersprachen enthalten Varianten dieser Schleife.

Maximale Summe eines Teilfelds

Die folgenden Programme berechnen die maximale Summe aufeinanderfolgender Zahlen in einem Feld

var

x

[

¹

..

n

] : int

.

m

=

max











j

X

k=i

x

[

k

] |

₁

≤

_i

≤

_j

≤

_n











x sei das Feld:

1 2 3 4 5 6 7 8 9 10

31

−

_{41 59 26}

−

_{53 58 97}

−

₉₃

−

_{23 84} Die maximale Summe aufeinanderfolgender Zahlen ist

x

[

³

] +

x

[

⁴

] +

x

[

⁵

] +

x

[

⁶

] +

x

[

⁷

] =

187. Keine andere Summe besitzt einen höheren Wert. Beispielsweise ist

x

[

¹

] +

x

[

²

] +

x

[

³

] +

x

[

⁴

] =

^75.

Maximale Summe eines Teilfelds

Idee: Berechne alle möglichen Summen.

MaxSum1

var x[1..n]: int;

var i,j,k,s,m: int;

input x;

m ← 0; // Wert der leeren Summe for i ← 1 to n do

for j ← i to n do s ← 0;

for k ← i to j do s ← s + x[k];

od;

m ← max(m, s);

od;

od;

output m;

Maximale Summe eines Teilfelds

Idee: Einsparen der inneren Schleife durch Wiederverwenden bereits bekannter Summen.

MaxSum2

var x[1..n]: int;

var i,j,s,m: int;

input x;

m ← 0; // Wert der leeren Summe for i ← 1 to n do

s ← x[i];

m ← max(m, s);

for j = i+1 to n do s ← s + x[j];

m ← max(m, s);

od;

od;

output m;

Dieser Algorithmus besitzt zwei ineinandergeschachtelte Schleifen.

Maximale Summe eines Teilfelds

Idee: Genau überlegen, was eine hohe Summe ausmacht. Diese Lösung stammt von M. Shamos (1977).

MaxSum3

var x[1..n]: int;

var i,s,m: int;

input x;

m ← 0;

s ← 0;

for i ← 1 to n do

s ← max(0, s + x[i]);

m ← max(m, s);

od;

output m;

Dieser Algorithmus hat nur noch eine Schleife.

Einführung

◮ In der Regel lässt sich ein Problem durch verschiedene Algorithmen lösen (zum Beispiel „maximale Summe aufeinanderfolgender Elemente“).

◮ Welcher Algorithmus soll gewählt werden?

◮ Die Algorithmen müssen hinsichtlich ihres Verhaltens verglichen werden.

◮ Man benötigt ein Maß für den Aufwand eines Algorithmus.

Komplexität von Algorithmen und Problemen

◮ Unter der Komplexität eines Algorithmus versteht man den Aufwand, den der Algorithmus zur Lösung des Problems benötigt. Typischerweise ist hier die

◮ Laufzeit des Algorithmus oder der

◮ Speicherbedarf des Algorithmus gemeint. Man unterscheidet die

◮ Komplexität im günstigsten Fall (best-case), die

◮ Komplexität im mittleren Fall (average-case) und die

◮ Komplexität im ungünstigsten Fall (worst-case).

◮ Unter der Komplexität eines Problems versteht man die

Komplexität des besten Algorithmus zur Lösung des Problems im ungünstigsten Fall.

Komplexität eines Algorithmus

◮ Umfang n eines Problems:

„Anzahl der Eingabewerte“ oder „Größe der Eingabewerte“

oder . . .

◮ Aufwand T(n) eines Algorithmus:

„Anzahl der Schritte“ oder „Anzahl bestimmter Operationen“

oder „Anzahl der benötigten Speicherplätze“ oder . . . , die der Algorithmus braucht, um ein Problem vom Umfang n zu lösen.

Um sinnvolle Aussagen über die Komplexität eines Algorithmus zu treffen, müssen n und T

(

n

)

mit Bedacht gewählt werden.

Beispiel: Im Algorithmus „Sortieren durch Einfügen“ war n die Anzahl der zu sortierenden Zahlen und T

(

n

)

die Anzahl der benötigten Vergleiche.

Wachstum von Funktionen

◮ In der Regel stellt die Wachstumsrate der Laufzeit ein

einfaches und geeignetes Kriterium zur Messung der Effizienz eines Algorithmus dar.

◮ Die Wachstumsrate erlaubt es uns, die relative

Leistungsfähigkeit alternativer Algorithmen zu vergleichen.

◮ Die Wachstumsrate von Algorithmen wird meistens mithilfe der asymptotischen Notation angegeben.

◮ Die asymptotische Notation lässt konstante Faktoren unberücksichtigt.

Asymptotische Notation

Es sei eine Funktion g

:

N

−→

R _gegeben.

Θ(

g

) = {

_f

:

N

−→

R

| ∃

_c1

>

0

,

c₂

>

0

,

n₀

>

0

∀

_n

≥

_n0

.

0

≤

_c1g

(

n

) ≤

_f

(

n

) ≤

_c2g

(

n

) }

O

(

g

) = {

_f

:

N

−→

R

| ∃

_c

>

0

,

n₀

>

0

∀

_n

≥

_n0

.

0

≤

_f

(

n

) ≤

_cg

(

n

) } Ω(

g

) = {

_f

:

N

−→

R

| ∃

_c

>

0

,

n₀

>

0

∀

_n

≥

_n0

.

0

≤

_cg

(

n

) ≤

_f

(

n

) }

o

(

g

) = {

_f

:

N

−→

R

| ∀

_c

>

0

∃

_n0

>

0

∀

_n

≥

_n0

.

0

≤

_f

(

n

) <

cg

(

n

) }

ω(

g

) = {

_f

:

N

−→

R

| ∀

_c

>

0

∃

_n0

>

0

∀

_n

≥

_n0

.

0

≤

_cg

(

n

) <

f

(

n

) }

Gebräuchliche Wachstumsklassen

Θ(

1

)

konstantes Wachstum

Θ(

log

(

n

))

logarithmisches Wachstum

Θ(

n

)

lineares Wachstum

Θ(

n log

(

n

))

„fast lineares“ Wachstum

Θ(

n²

)

quadratisches Wachstum

Θ(

n^k

)

polynomiales Wachstum

Θ(

2ⁿ

)

exponentielles Wachstum

O

(

n²

)

höchstens quadratisches Wachstum

Ω(

n

)

mindestens lineares Wachstum

Beispiel: Die Laufzeit beim „Sortieren durch Einfügen“ beträgt im günstigsten Fall

Θ(

n

)

und im ungünstigsten Falls

Θ(

n²

)

. Die

Laufzeit kann also durch

Ω(

n

)

nach unten und durch O

(

n²

)

nach oben abgeschätzt werden. Die Laufzeit wird auch durch O

(

n³

)

nach oben abgeschätzt! In der Praxis werden häufig möglichst

Graphen einiger Funktionen

1 log(n) nlog(n)

n

Graphen einiger Funktionen

n² n³

2ⁿ

Exemplarische Werte

n

=

1 10 100 1000 10000

log₂

(

n

) ≈

0 3 7 10 13

n log₂

(

n

) ≈

0 33 664 9966 132877 n²

=

1 100 10000 1000000 100000000 2ⁿ

≈

2 10³ 10³⁰ 10³⁰¹ 10³⁰¹⁰

Maximales n bei gegebener Zeit, Ann.: 1 Schritt benötigt 1

µ

s 1 Min. 1 Std. 1 Tag 1 Woche 1 Jahr n 6

·

₁₀⁷ ₃

.

6

·

₁₀⁹ ₈

.

6

·

₁₀¹⁰ ₆

·

₁₀¹¹ ₃

·

₁₀¹³ n² 7750 6

·

10⁴ 2

.

9

·

10⁵ 7

.

9

·

10⁵ 5

.

6

·

10⁶

n³ 391 1530 4420 8450 31600

2ⁿ 25 31 36 39 44

Asymptotische Notationen in Gleichungen

◮ 2n²

+

³n

+

¹

= Θ(

n²

)

^{heißt 2}n²

+

³n

+

¹

∈ Θ(

n²

)

^.

◮ 2n²

+

3n

+

1

=

2n²

+ Θ(

n

)

heißt: Es gibt eine Funktion f

(

n

) ∈ Θ(

n

)

^{mit 2}n²

+

³n

+

¹

=

²n²

+

f

(

n

)

^.

◮ 2n²

+ Θ(

n

) = Θ(

n²

)

heißt: Für jede Funktion f

(

n

) ∈ Θ(

n

)

gibt es eine Funktion g

(

n

) ∈ Θ(

n²

)

^{mit 2}n²

+

f

(

n

) =

g

(

n

)

^.

◮ In Gleichungsketten

2n²

+

3n

+

1

=

2n²

+ Θ(

n

) = Θ(

n²

)

werden die Gleichungen einzeln gelesen: Die erste Gleichung besagt, dass es eine Funktion f

(

n

) ∈ Θ(

n

)

mit

2n²

+

³n

+

¹

=

²n²

+

f

(

n

)

gibt. Die zweite Gleichung sagt aus, dass es für jede Funktion g

(

n

) ∈ Θ(

n

)

eine Funktion h

(

n

) ∈ Θ(

n²

)

mit 2n²

+

g

(

n

) =

h

(

n

)

gibt. Aus der

Eigenschaften der asymptotischen Notation

Eine Funktion f

:

N

−→

R _heißt asymptotisch positiv, wenn gilt:

∃

_n0

>

0

∀

_n

≥

_n0

.

f

(

n

) >

0

.

Für alle asymptotisch positiven Funktionen f

,

g

:

N

−→

R _gelten die folgenden Aussagen.

Transitivität:

f

(

n

) = Θ(

g

(

n

)) ∧

_g

(

n

) = Θ(

h

(

n

)) = ⇒

_f

(

n

) = Θ(

h

(

n

)),

f

(

n

) =

O

(

g

(

n

)) ∧

_g

(

n

) =

O

(

h

(

n

)) = ⇒

_f

(

n

) =

O

(

h

(

n

)),

f

(

n

) = Ω(

g

(

n

)) ∧

_g

(

n

) = Ω(

h

(

n

)) = ⇒

_f

(

n

) = Ω(

h

(

n

)),

f

(

n

) =

o

(

g

(

n

)) ∧

_g

(

n

) =

o

(

h

(

n

)) = ⇒

_f

(

n

) =

o

(

h

(

n

)),

f

(

n

) = ω(

g

(

n

)) ∧

_g

(

n

) = ω(

h

(

n

)) = ⇒

_f

(

n

) = ω(

h

(

n

)).

Eigenschaften der asymptotischen Notation

Reflexivität:

f

(

n

) = Θ(

f

(

n

)),

f

(

n

) =

O

(

f

(

n

)),

f

(

n

) = Ω(

f

(

n

)).

Symmetrie:

f

(

n

) = Θ(

g

(

n

)) ⇐⇒

_g

(

n

) = Θ(

f

(

n

)).

Austausch-Symmetrie:

f

(

n

) = Θ(

g

(

n

)) ⇐⇒

_f

(

n

) =

O

(

g

(

n

)) ∧

_f

(

n

) = Ω(

g

(

n

)),

f

(

n

) =

O

(

g

(

n

)) ⇐⇒

_g

(

n

) = Ω(

f

(

n

)),

f

(

n

) =

o

(

g

(

n

)) ⇐⇒

_g

(

n

) = ω(

f

(

n

)).

Beispiele

8

= Θ(

¹

)

3n²

−

_5n

+

8

= Θ(

n²

)

3n²

−

_5n

+

8

=

O

(

n²

)

3n²

−

5n

+

⁸

= Ω(

n²

)

log_a

(

n

) =

^logb

(

n

)

log_b

(

a

) Θ(

log_a

(

n

)) = Θ(

log_b

(

n

))

12 log₁₀

(

n

) = Θ(

log

(

n

))

12 log₂

(

n

) = Θ(

^log

(

n

))

Laufzeit von imperativen Algorithmen

Folgende Annahmen werden zur Analyse der Laufzeit von imperativen Algorithmen getroffen:

◮ Zuweisung: Die Laufzeit ist konstant.

◮ Sequenz: Die Laufzeit ist die Summe der Laufzeiten der Einzelanweisungen.

◮ Alternative: Die Laufzeit ist im ungünstigsten Fall die Laufzeit der Bedingungsauswertung plus dem Maximum der

Laufzeiten der Alternativen.

◮ Iteration: Die Laufzeit errechnet sich aus dem Produkt der Laufzeit der inneren Anweisung und der Anzahl der

Iterationen. Hinzu kommt die Laufzeit für einen weiteren Test.

Sortieren durch Einfügen

Code Kosten Anzahl

insertionSort(A)

j ← 2;

c₁ 1

while j ≤ length(A) do

c₂ n

key ← A[j];

c₃ n

−

1

i ← j - 1;

c₄ n

−

1

while i > 0 und A[i] > key

c₅ Pn j=2 t_j

do

A[i + 1] ← A[i];

c₆ Pn

j=2

(

t_j

−

1

)

i ← i - 1;

c₇ Pn

j=2

(

t_j

−

1

) od;

A[i + 1] ← key;

c₈ n

−

₁

j ← j + 1;

c₉ n

−

₁

od;

Abschätzung durch die O-Notation

Code Kosten

insertionSort(A)

j ← 2;

O

(

1

)

while j ≤ length(A) do

O

(

n

)

key ← A[j];

O

(

n

)

i ← j - 1;

O

(

n

)

while i > 0 und A[i] > key;

O

(

n²

) do

A[i + 1] ← A[i];

O

(

n²

)

i ← i - 1;

O

(

n²

)

od;

A[i + 1] ← key;

O

(

n

)

j ← j + 1;

O

(

n

)

od;

Korrektheit von Softwaresystemen

In vielen Situationen ist eine korrekte Funktionsweise eines

Softwaresystems von großer Bedeutung. Dies gilt insbesondere, wenn das System

◮ sicherheitskritisch (z. B. Atomreaktor),

◮ kommerziell kritisch (z. B. massenproduzierte Chips) oder

◮ politisch kritisch (z. B. Militär) ist.

Korrektheit von Softwaresystemen

Es gibt mehrere Möglichkeiten, die Zuverlässigkeit von Softwaresystemen zu erhöhen:

◮ Software Engineering:

Maßnahmen während des gesamten Softwareentwicklungsprozesses.

◮ Programmierung:

Beispiel: Ausnahmebehandlung, Zusicherungen.

◮ Validation:

Systematische Tests unter Einsatzbedingungen; Tests zeigen die Anwesenheit, aber nicht die Abwesenheit von Fehlern.

◮ Verifikation:

Mathematischer Nachweis der Korrektheit von Algorithmen.

Korrektheit von Softwaresystemen

Um ein System zu verifizieren zu können benötigt man Methoden, Werkzeuge und Sprachen, zur

◮ Modellierung von Systemen auf hoher Abstraktionsebene,

◮ Spezifikation nachzuweisender Eigenschaften dieser Systeme (Terminierungsverhalten, berechnete

Funktionswerte, . . . ) und zur

◮ Verifikation, d. h. zum formalen Beweis, dass ein

implementiertes System die spezifizierten Eigenschaften hat.

In diesem Abschnitt behandeln wir eine Möglichkeit zur

Spezifikation und Verifikation imperativer Algorithmen.

Hoaresche Logik

Es seien ein Algorithmus S sowie Bedingungen p und q gegeben.

◮ Wir schreiben in diesem Fall

{p} S {q}

und nennen

◮ p Vorbedingung,

◮ q Nachbedingung und

◮ (p,q) Spezifikation von S.

Hoaresche Logik

◮ S heißt partiell-korrekt bezüglich der Spezifikation (p,q), wenn jede Ausführung von S, die in einem Zustand beginnt, der p erfüllt und die terminiert, zu einem Zustand führt, der q erfüllt.

| =

{p} S {q}

◮ S wird total-korrekt bezüglich der Spezifikation (p,q) genannt, wenn jede Ausführung von S, die in einem Zustand beginnt, der p erfüllt, terminiert und zu einem Zustand führt, der q erfüllt.

Beispiele

◮

| = {

_true

}

_x

←

1

{

_x

=

1

}

◮

| = {

_x

=

1

}

_x

←

_x

+

1

{

_x

=

2

}

◮

| = {

_y

=

a

}

_x

←

_y

{

_x

=

a

∧

_y

=

a

}

◮

| = {

_x

=

a

∧

_y

=

b

}

_z

←

_x

;

x

←

_y

;

y

←

_z

{

_x

=

b

∧

_y

=

a

}

◮

| = {

_false

}

_x

←

1

{

_x

=

⁴²

}

◮

| = {

_true

} while

0

=

⁰

do

x

←

1

od {

_x

=

²³

}

◮

| = {

_x

>

0

} while

x , ₀

do

x

←

_x

−

1

od {

_x

=

⁰

}

◮

| = {

_true

} while

x , ₀

do

x

←

_x

−

1

od {

_x

=

⁰

}

◮

| = {

_true

} while

p

(

x

) do α od {¬

_p

(

x

) }

◮

| = {

_x

+

y

=

a

} while

x , ₀

do

x

←

_x

−

1

;

y

←

_y

+

¹

od {

_x

=

0

∧

_x

+

y

=

a

}

Hoarescher Kalkül

Zuweisung:

{

_px^t

}

_x

←

_t

{

_p

}

Sequenz:

{

_p

}

_S1

{

_r

} , {

_r

}

_S2

{

_q

} {

_p

}

_S1

;

S₂

{

_q

}

If:

{

_p

∧

_e

}

_S1

{

_q

} , {

_p

∧ ¬

_e

}

_S2

{

_q

} {

_p

}

if e then S₁ else S₂ fi

{

_q

}

While:

{

_p

∧

_e

}

_S

{

_p

}

{

_p

}

while e do S od

{

_p

∧ ¬

_e

}

Anpassungsregel: p

⊃

_q

, {

_q

}

_S

{

_r

} ,

r

⊃

_s

{

_p

}

_S

{

_s

}

Hoarescher Kalkül

◮ Der hoaresche Kalkül besteht aus dem Axiomenschema für die Zuweisung und Ableitungsregeln.

◮ Falls {p} S {q} mithilfe des hoareschen Kalküls hergeleitet werden kann, schreibt man

⊢

{p} S {q}.

Schleifeninvariante

Die Bedingung p in der While-Regel heißt Schleifeninvariante.

{

_p

∧

_e

}

_S

{

_p

}

{

_p

}

_{while e do S od}

{

_p

∧ ¬

_e

}

Eine Schleifeninvariante gilt vor jedem Schleifendurchlauf und damit auch nach jedem Schleifendurchlauf, speziell also nach Beendigung der Wiederholungsanweisung. Dann gilt zudem

¬

_e.

Schleifeninvariante

Beispiel: Für den folgenden Algorithmus ist q

=

k

−

1 eine Schleifeninvariante.

{

_q

=

0

∧

_k

=

1

}

while

k , _n

+

¹

do q ← q + 1;

k ← k + 1;

od;

{

_q

=

n

}

Nach Ausführung der Schleife gilt: q

=

k

−

1

∧ ¬ (

k , _n

+

¹

)

Daraus folgt: q

=

n

Eigenschaften des Kalküls

Korrektheit:

⊢ {

_p

}

_S

{

_q

} = ⇒ | = {

_p

}

_S

{

_q

}

relative Vollständigkeit:

⊢ {

_p

}

_S

{

_q

} ⇐ = | = {

_p

}

_S

{

_q

}

Beispiel: Division mit Rest

◮ Es sollen zwei ganze Zahlen x

,

y

∈

Z _{mit x}

≥

_{0 und y}

>

0 durcheinander dividiert werden.

◮ Das Ergebnis der Division x

/

y ist der Quotient q und der Rest r mit x

=

qy

+

r

∧

0

≤

_r

<

y

.

var x, y, q, r: int;

input x, y;

q ← 0;

r ← x;

while r >= y do r = r - y;

q = q + 1;

od;

output q, r;

Beispiel: Division mit Rest

◮ Mithilfe des hoareschen Kalküls leiten wir jetzt den Ausdruck

{

_x

≥

₀

}

_S

{

_x

=

qy

+

r

∧

₀

≤

_r

<

y

}

her, wobei S der obige imperative Algorithmus ist.

◮ Wegen der Korrektheit des Kalküls können wir dann

schließen, dass der Algorithmus bezüglich der angegebenen Vor- und Nachbedingung partiell-korrekt ist.

◮ Die Bedingung y

>

0 wird zum Nachweis der totalen Korrektheit benötigt.

Beispiel: Division mit Rest

Wir zeigen zuerst, dass

x

=

qy

+

r

∧

0

≤

_r

eine Schleifeninvariante ist. Dies ergibt sich aus:

x

=

qy

+

r

∧

0

≤

_r

∧

_r

≥

_y

= ⇒

_x

= (

q

+

¹

)

y

+ (

r

−

_y

) ∧

0

≤

_r

−

_y

Beispiel: Division mit Rest

Die Behauptung folgt dann aus den beiden Aussagen x

≥

₀

= ⇒

₀

≤

_x

und

x

=

qy

+

r

∧

0

≤

_r

∧ ¬ (

r

≥

_y

) = ⇒

_x

=

qy

+

r

∧

0

≤

_r

<

y

.

Beispiel: Division mit Rest

◮ Da nach Voraussetzung y

>

0 gilt, durchläuft die Variable r eine monoton streng fallende Folge natürlicher Zahlen:

r₀

,

r₁

,

r₂

, . . .

◮ Da y konstant ist, wird deshalb für ein i die Bedingung r_i

<

y

wahr. Das heißt, das Programm terminiert schließlich und ist deshalb total-korrekt bezüglich der angegebenen

Bedingungen.

Bemerkung: Es gibt auch Kalküle zum Nachweis der totalen Korrektheit.

Beispiel: Division mit Rest

Vor- und Nachbedingung, Schleifeninvariante als Annotation:

static private int remainder (int x, int y) {

assert x >= 0 && y > 0;

int q = 0, r = x;

assert x == q * y + r && 0 <= r;

while (r >= y) { r = r - y;

q = q + 1;

assert x == q * y + r && 0 <= r;

}

assert x == q * y + r && 0 <= r && r < y;

return r;

}

Wunschtraum

Es ist ein Algorithmus gesucht, der für beliebige p, S und q beweist oder widerlegt, dass

⊢

{p} S {q}

gilt.

Solch ein Algorithmus kann nicht existieren!

Dann existiert natürlich erst recht kein analoger Algorithmus für die totale Korrektheit.

Totale Korrektheit

◮ Zum Nachweis der totalen Korrektheit muss zusätzlich zur partiellen Korrektheit die Terminierung gezeigt werden.

◮ Um die Terminierung von Schleifen nachzuweisen, gibt es keine allgemeine Methode, oft funktioniert aber die

Vorgehensweise vom obigen Beispiel:

1. Man suche einen Ausdruck u, dessen Wert eine natürliche Zahl ist.

2. Man beweise, dass u bei jedem Schleifendurchlauf echt kleiner wird.

3. Da die natürlichen Zahlen wohlgeordnet sind, muss die Schleife terminieren.

Beispiel: Insertionsort

P

(

j

)

: Das Feld A

[

1

· · ·

_j

]

ist eine Permutation des Ausgangsfeldes A

[

1

· · ·

_j

]

.

S

(

j

)

^{: Das Feld} A

[

¹

· · ·

_j

]

ist sortiert.

A^∗

[

j

]

: Der ursprünglich in A

[

j

]

enthaltene Wert.

P_k^∗

(

j

)

: Das Feld A

[

1

· · ·

_k

−

₁

,

k

+

1

· · ·

_j

]

ist eine Permutation des Ausgangsfeldes A

[

1

· · ·

_j

−

₁

]

.

S_k^∗

(

j

)

^{: Das Feld} A

[

¹

· · ·

_k

−

1

,

k

+

¹

· · ·

_j

]

ist sortiert.

Beispiel: Insertionsort

{

_n

≥

1

}

{

_P

(

¹

) ∧

_S

(

¹

) ∧

_n

≥

1

} j ← 2;

{

_P

(

j

−

₁

) ∧

_S

(

j

−

₁

) ∧

₂

≤

_j

≤

_n

+

1

} while j ≤ n do

key ← A[j];

i ← j - 1;

while i > 0 ∧ A[i] > key do A[i+1] ← A[i];

i ← i - 1;

od;

A[i+1] ← key;

j ← j + 1;

od;

{

_P

(

j

−

1

) ∧

_S

(

j

−

1

) ∧

2

≤

_j

≤

_n

+

1

∧

_j

>

n

}

{

_P

(

n

) ∧

_S

(

n

) }

Beispiel: Insertionsort

{

_P

(

j

−

1

) ∧

_S

(

j

−

1

) ∧

2

≤

_j

≤

_n

+

1

∧

_j

≤

_n

} {

_P^∗

j

(

j

) ∧

_S^∗

j

(

j

) ∧

0

≤

_j

−

1

} key ← A[j];

i ← j - 1;

{

_Pi^∗₊₁

(

j

) ∧

_Si^∗₊₁

(

j

) ∧

_key

<

A

[

i

+

2

], . . . ,

A

[

j

]

∧

0

≤

_i

≤

_j

−

1

∧

_key

=

A^∗

[

j

] }

while i > 0 ∧ A[i] > key do A[i+1] ← A[i];

i ← i - 1;

od;

A[i+1] ← key;

j ← j + 1;

{

_P

(

j

−

₁

) ∧

_S

(

j

−

₁

) ∧

₂

≤

_j

≤

_n

+

1

}

Konzepte imperativer Sprachen

◮ Anweisungen

◮ primitive Anweisungen: Zuweisung, Block, Prozeduraufruf

◮ zusammengesetzte Anweisungen: Sequenz, Auswahl, Iteration

◮ Ausdrücke

◮ primitive Ausdrücke: Konstante, Variable, Funktionsaufruf

◮ zusammengesetzte Ausdrücke: Operanden/Operatoren

◮ Datentypen

◮ primitive Datentypen: Wahrheitswerte, Zeichen, Zahlen, Aufzählung

◮ zusammengesetzte Datentypen: Felder, Verbund, Vereinigung, Zeiger

Konzepte imperativer Sprachen

◮ Abstraktion

◮ Anweisung: Prozedurdeklaration

◮ Ausdruck: Funktionsdeklaration

◮ Datentyp: Typdeklaration

◮ Weitere Konzepte

◮ Ein- und Ausgabe

◮ Ausnahmebehandlung

◮ Bibliotheken

◮ Parallele und verteilte Berechnungen

◮ . . .

Blöcke

◮ Motivation: Ein Block fasst mehrere Anweisungen und Deklarationen zu einer Einheit zusammen.

◮ Syntax: Die Abgrenzung erfolgt durch syntaktische Elemente, wie z. B. Schlüsselwörter (

begin

,

end

), Klammerung oder

Einrückung. Blöcke dürfen überall statt einer einzelnen Anweisung stehen.

◮ Kontrollfluss: Die Ausführung eines Blocks beginnt mit der ersten Anweisung und wird im Normalfall nach der letzten beendet. Es gibt auch Anweisungen zum Verlassen des Blocks:

break, return

.

◮ Lokale Variablen: Innerhalb eines Blocks können Variablen deklariert werden, die nur in diesem Block verfügbar sind.

Blöcke

◮ Globale Variable: Innerhalb eines Blocks sind alle

Bezeichner aus den umschließenden Blöcken sichtbar, soweit sie nicht von einer inneren Deklaration überdeckt werden.

◮ Gültigkeitsbereich (scope): Ein Bezeichner ist innerhalb des Blocks gültig, in dem er deklariert wurde, nicht aber

außerhalb. Die Gültigkeit ist eine statische Eigenschaft, die sich aus dem Programmtext ableitet.

◮ Lebensdauer: Ist eine dynamische Eigenschaft und

bezeichnet den Zeitraum der Verfügbarkeit eines Wertes

während der Laufzeit. Werte von überdeckten Variablen sind nach Beendigung des überdeckenden Blocks wieder

verfügbar.

Blöcke

Code Gültig Sichtbar

var x,y: int; | | | |

· · · do | | | |

var x: int; | | | | |

· · · | | | | |

· · · | | | | |

od; x | | x | |

· · · | | | |

y x y x

Einzelheiten lernen Sie in der Vorlesung „Programmieren“.

Prozeduren

◮ Abstraktion: Eine Prozedur fasst mehrere Anweisungen zusammen und gibt ihnen einen Namen. Der Aufruf einer

Prozedur führt die Anweisungen aus und wirkt dabei wie eine elementare Anweisung. Über Parameter können die

Anweisungen gesteuert werden.

◮ Wiederverwertung: Eine Prozedur wird nur einmal deklariert und kann beliebig oft verwendet werden.

◮ Modularisierung: Die Implementation der Prozedur muss dem aufrufenden Programm nicht bekannt sein.

Veränderungen innerhalb der Prozedur erfordern keine Änderung des aufrufenden Programms.

Deklaration von Prozeduren

◮ Deklaration:

proc P(

_p1

, . . . ,

p_n

) begin a; end

◮ Name: P ist der Name der Prozedur und frei wählbar.

◮ Parameter: p₁

, . . . ,

p_n sind die Parameter der Prozedur. Sie sind lokale Variablen mit eigenem Typ (formale Parameter), denen beim Aufruf der Prozedur Werte (aktuelle Parameter) zugewiesen werden. Die Gültigkeit der Parameter ist auf den Rumpf der Prozedur beschränkt.

◮ Rumpf: a ist der Rumpf der Prozedur. Er enthält die auszuführenden Anweisungen.

Werte- und Referenzparameter

Werteparameter (call by value):

◮ Der aktuelle Parameter kann ein Ausdruck oder speziell auch eine Variable sein.

◮ Es wird der Wert des Ausdrucks übergeben.

◮ Die Deklaration erfolgt (zum Beispiel) ohne das Präfix

var

.

Werte- und Referenzparameter

Referenzparameter (call by reference):

◮ Der aktuelle Parameter muss eine Variable sein.

◮ Es wird die Variable (Adresse) übergeben.

◮ In der Deklaration werden Referenzparameter (zum Beispiel) mit

var

bezeichnet.

Es gibt weitere Arten der Parameterübergabe.

Beispiel

Aufgabe: Vertausche die Inhalte der Variablen x und y und addiere zu beiden den Wert a.

proc vertausche(a: int; var x, y: int) begin var z: int; // lokale Variable

z ← x;

x ← y;

y ← z;

x ← x + a;

y ← y + a;

end

Die Wirkung ist die „simultane“ Ersetzung.

(

x

,

y

) ← (

y

+

a

,

x

+

a

)

Beispiel

Aufrufen lässt sich die Prozedur in unterschiedlichen Umgebungen mit verschiedenen aktuellen Parametern:

vertausche(0, i, j);

vertausche(3, a[1], a[2]);

vertausche(a[3], a[1], a[2]);

vertausche(i, i, j);

Funktionen

◮ Abstraktion: Funktionen sind Abstraktionen von Ausdrücken.

Der Aufruf einer Funktion berechnet einen Wert eines Typs

τ

.

◮ Deklaration:

func F(

p₁

, . . . ,

p_n

): τ begin a; end

◮ Auswertung: Der Rückgabewert der Funktion wird (zum

Beispiel) durch eine spezielle

return

-Anweisung angegeben.

Diese Anweisung verlässt den Funktionsblock mit sofortiger Wirkung. Häufig wird auch der letzte Term innerhalb einer

Funktion als Rückgabewert genommen, oder eine Zuweisung zum Funktionsnamen legt den Rückgabewert fest.

◮ Seiteneffekt: Wenn der Aufruf einer Funktion den Wert einer globalen Variablen verändert, spricht man von einem

Seiteneffekt.

Beispiel

func EUKLID(x, y: int): int begin var a,b,r: int

a ← x;

b ← y;

while b # 0 do r ← a mod b;

a ← b;

b ← r;

od;

return a;

end

Für negative Werte der Parameter x und y hängt das Verhalten der Funktion von der Implementierung des mod-Operators ab.