Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen
Prof. Dr. Sibylle Schwarz
Westsächsische Hochschule Zwickau
Dr. Friedrichs-Ring 2a, RII 263
http://www.fh-zwickau.de/~sibsc/
[email protected]
SS 2013
1
Algorithmen – Beispiel ggT
(einfacher) Euklidischer Algorithmus zur Bestimmung des ggT
zweier natürlicher Zahlen
Algorithmus : Größter gemeinsamer Teiler
N
Eingabe : a ∈ , b ∈
Ausgabe : ggT(a, b)
N
solange a 6= b :
wenn a > b dann
a←a−b
sonst
b ←b−a
Rückgabe a
2
Algorithmus
I
endlich beschriebene
I
schrittweise ausgeführte
Arbeitsvorschrift
zur Lösung eines Berechnungsproblemes,
d.h. zur Transformation einer Eingabe in eine Ausgabe
3
Beispiele für Algorithmen
I
historisch (Mathematik):
I
I
I
I
I
im Alltag:
I
I
I
I
I
Euklidischer Algorithmus
Sieb des Erathostenes
schriftliche Addition, Multiplikation usw.
Gauß-Algorithmus
Suchen eines Wörterbucheintrages
Bauanleitung
Kochrezept
Orchester-Partitur
in der Informatik:
I
I
I
I
Programm-Quelltext
Programm-Ablaufplan, Struktogramm
Suchverfahren
Sortierverfahren
4
Algorithmen und Datenstrukturen
Informatik Wissenschaft von der Darstellung und
Verarbeitung symbolischer Information
Darstellung der Information als (strukturierte) Daten
Verarbeitung der Information durch Algorithmen
5
Abstraktionsstufen
Mathematik:
Implementierung:
Funktion
|
Algorithmus
|
Funktion, Methode
Abstrakter DT
|
(konkreter) DT
algebraische Struktur
|
Datenstruktur
|
Typ, Klasse
6
Einordnung in die Informatik
Teilgebiete der Informatik:
theoretisch
I
I
I
technisch
I
I
Formalismen zur Darstellung von Daten und
Algorithmen
Möglichkeiten und Grenzen
der Berechenbarkeit durch Algorithmen
Grundlagen für technische und praktische
(und angewandte) Informatik
maschinelle Darstellung von Information
Mittel zur Ausführung von Algorithmen
praktisch Modellierung (Datenstrukturen)
Entwurf von Algorithmen
Programmierung, Softwaretechnik
angewandt
I
I
Modellierung durch geeignete
Datenstrukturen
Anwendung von Algorithmen (z.B. Suchen,
Sortieren, . . . )
7
Inhalt der Lehrveranstaltung
I
Algorithmen
I Spezifikation
I Laufzeitabschätzungen
I rekursive Algorithmen
I Beispiele, z.B. Sortieralgorithmen
I
abstrakte Datentypen mit häufigen Operationen:
I Mengen
I Folgen
I Zuordnungen (Wörterbücher)
I Relationen
I
Datenstrukturen zu deren Realisierung:
I lineare Datenstrukturen
(Listen, Stack, Queue, Hash-Tabellen)
I hierarchische Datenstrukturen (Bäume, Heaps)
I Graphen
I
Algorithmen auf Graphen
I
Pattern-Matching-Algorithmen
8
Literatur
I
Cormen, Leiserson, Rivest, Stein:
Algorithmen - Eine Einführung (Oldenbourg, 2007)
I
Güting, Dieker:
Datenstrukturen und Algorithmen (Teubner, 2004)
I
Solymosi, Grude:
Grundkurs Algorithmen und Datenstrukturen : eine
Einführung in die praktische Informatik mit Java
(Vieweg, 2000)
I
Preiss:
Data Structures and Algorithms with Object-Oriented
Design Patterns in Java (Online-Version unter
http://www.brpreiss.com/books/opus5/)
9
Organisation
http://www.fh-zwickau.de/~sibsc/lehre/ss13/ad
Montag
11:20-12:50 in R304
Donnerstag Z1 15:05-16:35 in R308
Hausaufgaben I schriftliche Aufgaben
(Prüfungsvorbereitung)
I Vorbereitung des Praktikums (Entwurf)
I Autotool-Aufgaben
Übung für alle gemeinsam (Hörsaalübung)
Donnerstag Z1 9:35-11:05 in PBS 203
I Fragen zum Vorlesungsstoff
I Besprechung der schriftlichen
Übungsaufgaben
Praktika 2 Gruppen (Eintragen im Autotool):
Montag 9:35-11:05 in Pool 242 (14-tägig)
I (einige) Autotool-Aufgaben
I Programmieraufgaben (Implementierung)
Prüfung: Klausur ca. 60 min
(Hälfte von 120 min für Modul PTI621)
Vorlesung
10
Algorithmen in der Informatik
Algorithmus:
in Schritte geordnete Arbeitsvorschrift
I
endliche Beschreibung
I
eines schrittweise ausgeführten Verfahrens
I
in einer formalen Beschreibungssprache.
zur Ausführung eines Algorithmus ist nötig:
Akteur / Maschine, welche den Beschreibungsformalismus
interpretieren kann
11
Algorithmen – Eigenschaften
notwendige Eigenschaften:
endliche Beschreibung
schrittweise Ausführung
oft wird außerdem gefordert
(meist sinnvoll für auf Computer ausgeführten Algorithmen):
deterministischer Ablauf : bei wiederholter Ausführung mit
denselben Eingaben wird immer derselbe Ablauf
ausgeführt
terminierend (Endlichkeit der Ausführung):
Berechnungsvorschrift terminiert gdw. jede
Ausführung bei jeder erlaubten Eingabe nach
endlich vielen Schritten endet
determiniertes Ergebnis : bei wiederholter Ausführung mit
denselben Eingaben wird immer dieselbe
Ausgabe erzeugt
allgemeingültig : löst eine ganze Klasse von Aufgaben
12
Beispiele
Algorithmus : A1
Z
Eingabe : y ∈
Ausgabe : y − x
Wähle beliebige Zahl x ∈
y ←x +4
Algorithmus : A2
Eingabe : x ∈
Ausgabe : y
Z
Z
Algorithmus : A3
Eingabe : n ∈
Ausgabe : n
N
solange n > 1 :
wenn n ≡2 0 dann
n ← n/2
sonst
n ← 3n + 1
y ←1
solange x 6= 0 :
y ← yx
x ←x −1
Welche dieser Algorithmen sind deterministisch, terminierend, haben
determiniertes Ergebnis?
13
Algorithmen zur Lösung eines Berechnungsproblemes
Berechnungsproblem:
Transformation von Eingaben in Ausgaben
Anforderungen an Algorithmen zur Lösung eines speziellen
Berechnungsproblemes:
Korrektheit Algorithmus löst alle Instanzen des gegebenen
Problems (fehlerfrei):
bestimmt für jede Eingabe korrekte Ausgabe.
Berechenbarkeit Zu jeder Eingabe ist eine eindeutige Ausgabe
definiert und wird vom Algorithmus erzeugt.
Nicht alle formulierbaren Algorithmen sind
berechenbar.
(hängt vom Problem und der
Beschreibungssprache ab).
mehr dazu in LV Theoretische Informatik
Effizienz möglicht geringer Ressourcen-Verbrauch
(Speicherplatz, Laufzeit)
14
Algorithmen-Entwicklung
1. informale Aufgabenstellung
2. formale Spezifikation:
Was (welches Berechnungsproblem) soll gelöst werden?
exakte (formale) Beschreibung des Problemes:
I Eingabe des Algorithmus
I Ausgabe des Algorithmus
I Zusammenhang zwischen Ein- und Ausgabe
3. Entwurf des Algorithmus:
Wie soll es gelöst werden?
I formale Darstellung der Arbeitsschritte
I zu jedem Schritt:
I
I
I
Was wird getan? (Aktionen, Anweisungen)
Womit wird es getan? (Daten)
Wie geht es weiter? (nächster Schritt)
4. Verifikation:
Nachweis der Korrektheit des Algorithmenentwurfes
5. Realisierung (Implementierung)
15
Algorithmen – Spezifikation
Problemanalyse: Was soll gelöst werden?
Ausgangspunkt:
Ergebnis:
umgangssprachlich formulierte und oft
ungenaue Aufgabenbeschreibung
exakte und vollständige Definition des
Problemes
Spezifikation eines Berechnungsproblemes:
korrekte formale Beschreibung des Zusammenhanges
zwischen Eingaben und Ausgaben
Spezifikation eines Berechnungsproblemes enthält
Vorbedingung: Forderung an die Eingaben
Nachbedingung: Forderung an die Ausgaben
Instanz eines Berechnungsproblemes: spezielle Eingabe
16
Beispiel: Spezifikation des Sortier-Problems
informale Aufgabenstellung:
Entwurf eines Verfahrens, welches jede Folge (x1 , . . . , xn )
natürlicher Zahlen sortiert
formale Spezifikation dieses Sortier-Problemes:
Vorbedingung: Eingabe (x1 , x2 , . . . , xn ) mit
∀i ∈ {1, . . . , n} : xi ∈
N
Nachbedingung: Ausgabe (y1 , y2 , . . . , yn ) ist
1. y1 ≤ y2 ≤ · · · ≤ yn+1 (aufsteigend geordnet)
und
2. eine Permutation (Umordnung) der Eingabe
(x1 , x2 , . . . , xn )
Instanz dieses Sortier-Problemes: (34, 6, 72, 3, 4, 15)
17
Algorithmen – Korrektheit
“ . . . there are two ways of constructing a software design: One
way is to make it so simple that there are obviously no
deficiencies and the other way is to make it so complicated that
there are no obvious deficiencies. The first method is far more
difficult.”
Tony Hoare, 1980 ACM Turing Award Lecture
Ist der entworfene Algorithmus korrekt?
Erfüllt der entworfene Algorithmus die Spezifikation?
Verifikation: Nachweis, dass Entwurf die Spezifikation erfüllt
sicherer (aber mitunter aufwendiger) als Testen
Es gibt Verfahren / Systeme, die Verifikation automatisch
ausführen oder unterstützen.
mehr dazu im Master-Studium:
LV Spezifikations- und Verifikationsmethoden
18
Effizienz von Algorithmen
Aufwandsanalyse von Algorithmen
I
abhängig von der Größe der Instanz
I
unabhängig von konkreter Hardware
I
im
günstigsten Fall (best case)
ungünstigsten Fall (worst case)
Mittel (average case)
Abschätzungen von Resourcenbedarf bei Ausführung des
Algorithmus
Zeitaufwand: Anzahl elementarer Rechenschritte auf einem
idealisierten Rechnermodell (RAM)
Speicherplatzbedarf
19
Algorithmenentwurf
Algorithmus = in Schritte geordnete Arbeitsvorschrift
I
endliche Beschreibung
I
eines schrittweise von einem Aktuer ausgeführten
Verfahrens
I
in einer formalen Beschreibungssprache.
Ziele beim Entwurf von Algorithmen:
I
I
Korrektheit
geringer Ressourcenverbrauch
I
I
I
Laufzeit
Speicherplatz
sinnvoll strukturierte einfache formale Beschreibung
(z.B. kurzer, lesbarer Programmcode)
20
Beispiel – Summe der ersten n natürlichen Zahlen
informale Aufgabenstellung:
Addiere alle natürlichen Zahlen von 1 bis n.
Spezifikation:
Vorbedingung: Eingabe n ∈
NP
Nachbedingung: Ausgabe s =
n
i=1 i
Algorithmus : A1
Eingabe : n ∈
Ausgabe : s
N
s←0
für jedes i ← 1, . . . , n :
s ←s+i
Algorithmus : A2
Eingabe : n ∈
Ausgabe : s
N
s ← n(n + 1)/2
21
(Idealisiertes) Rechnermodell
Random-Access-Maschine (RAM)
I
I
unendlich viele Speicherzellen für je eine natürliche Zahl
(Alternative: Real-RAM für reelle Zahlen)
Befehle:
I
I
I
I
Laden
Speichern
Operationen (logisch, arithmetisch, Vergleiche)
Unterprogrammaufrufe
I
Ausführung jedes Befehles (elementare Anweisung,
Schritt) dauert (kostet) genau eine Einheit
I
sequentielle Ausführung aller Befehle
22
Laufzeitanalyse
Laufzeit eines Algorithmus auf der Eingabe x:
Anzahl der zur Ausführung des Algorithmus bei Eingabe x
benötigten Einheiten (Schritte)
Laufzeit T eines Algorithmus ist eine Funktion der Größe der
Eingabe x
Definition der Größe hängt vom Berechnungsproblem ab,
z.B. Länge einer zu sortierenden Liste,
Länge der Binärdarstellung zweier zu addierender Zahlen
worst-case Maximum der Laufzeiten des Algorithmus über
alle Eingaben
obere Schranke für die Laufzeit
best-case Minimum der Laufzeiten des Algorithmus über alle
Eingaben
untere Schranke für die Laufzeit
average-case Durchschnitt der Laufzeiten des Algorithmus
über alle Eingaben
23
Beispiel: Durchsuchen einer Folge
Spezifikation des Suchproblemes:
V: Eingaben x = (x1 , . . . , xn ), y
N: Ausgabe:
I Ja, falls ein i ∈ {1, . . . , n} mit xi = y existiert,
I sonst Nein
Algorithmus : Suche 1
Eingabe : (x1 , . . . , xn ), y
Ausgabe : gefunden
gefunden ← Nein
i ←1
solange i ≤ n :
wenn xi = y dann
gefunden ← Ja
i ←i +1
Laufzeit (Tafel)
24
Mathematische Grundlagen: Wachstumsklassen
präzise Laufzeitfunktion meist nicht relevant, nur die
Größenordnung des Wachstums
Ziel:
Abschätzung der Größenordnung der Wachstumsfunktion
durch Vergleich mit einfachen Funktionen
Abschätzungen des asymptotischen Wachstums gelten nur für
hinreichend große Werte
25
Wachstumsklassen
Funktionenklassen zu einer gegebenen Funktion g :
N R
N
N R
N
N R
N
N R
N
N → R≥0
O(g) = {f : → ≥0 | ∃n0 ∈ ∃c > 0∀n ≥ n0 : f (n) ≤ cg(n)}
f wächst höchstens so schnell wie g
(asymptotische obere Wachstumsschranke)
o(g) = {f : → ≥0 | ∃n0 ∈ ∃c > 0∀n ≥ n0 : f (n) < cg(n)}
f wächst langsamer als g
Ω(g) = {f : → ≥0 | ∃n0 ∈ ∃c > 0∀n ≥ n0 : 0 ≤ cg(n) ≤ f (n)}
f wächst mindestens so schnell wie g
(asymptotische untere Wachstumsschranke)
ω(g) = {f : → ≥0 | ∃n0 ∈ ∃c > 0∀n ≥ n0 : 0 ≤ cg(n) < f (n)}
f wächst schneller als g
Θ(g) = O(g) ∩ Ω(g)
(asymptotisch gleiches Wachstum)
Gilt genau dann, wenn f ∈ O(g) und g ∈ O(f )
26
Asymptotische obere Schranke
O(g) = {f :
N → R≥0 | ∃n0 ∈ N∃c > 0∀n ≥ n0 : f (n) ≤ cg(n)}
Beispiele:
I
3/2n2 + 3/2n + 2 ∈ O(n2 )
I
n ∈ O(n3 )
I
2n 6∈ O(n3 )
geeignete Abschätzung für worst-case-Analyse
27
Vereinfachungen in O-Notation
I
O(cf ) = O(f ), konstante Faktoren irrelevant
I
O(f + g) = max(O(f ), O(g)),
Summanden mit kleinerem Wachstum irrelevant,
z.B. Polynome kleineren Grades
I
O(loga n) = O(logb n)
28
Berechnung durch Grenzwerte
1000n5 − 5463524n4 + 13n3 + n2 ∈ O(n5 ) wegen
1000n5 − 5463524n4 + 13n3 + n2
n→∞
n5
5
1000n
= lim
= 1000 < ∞
n→∞
n5
lim
Beispiele:
I
O(n/2) = O(134n) = O(n + 5000) = O(n − 5000) =
O(17n − 5000) = O(n/5000) = O(n)
I
O(log n) ⊆ O(n) ⊆ O(n2 ) ⊆ O(2n )
29
Beispiele
I
n + 1000 ∈ O(n)
I
1000n ∈ O(n)
I
I
1000n ∈ O(n2 )
√
1000n 6∈ O( n)
I
1000n5 + 3524n2 ∈ O(n5 )
I
1000n5 + 3524n2 ∈ O(n6 )
I
n/1000 + 3524 ∈ O(n)
I
loga n ∈ O(logb n)
30
Wichtige Funktionenklassen
I
O(1) konstantes Wachstum
I
O(n) lineares Wachstum
I
O(n2 ) quadratisches Wachstum
I
O(n3 ) kubisches Wachstum
I
O(nk ) polynomielles Wachstum
I
O(log n) logarithmisches Wachstum
I
O(n log n)
I
O(log log n) doppelt logarithmisches Wachstum
I
O(2n ) exponentielles Wachstum
31
Laufzeitabschätzungen für Ablaufstrukturen
elementare Operationen A
(Zuweisung, Berechnung eines arithmetischen
Ausdruckes, Vergleich)
T (A) = 1 ∈ O(1)
sequentielle Verknüpfung (Nacheinanderausführung)
Algorithmus A = A_1; A_2
Laufzeit T (A) = T (A1 ) + T (A2 )
Verzweigung (Alternative)
Algorithmus A = if C then A_1 else A_2
Laufzeit
T (A) = max(T (A1 ), T (A2 )) ∈ O(T (A1 ) + T (A2 ))
Wiederholung (Schleife)
Algorithmus A = for i = 1 to n A_i
Laufzeit T (A) = T (A1 ) + T (A2 ) + . . . + T (An )
oft für jeden Durchlauf gleiche Laufzeit, dann
T (A) = nT (A1 )
32
Beispiel: Suche 2
Spezifikation des Suchproblemes:
V: Eingaben x = (x1 , . . . , xn ), y
N: Ausgabe:
I Ja, falls ein i ∈ {1, . . . , n} mit xi = y existiert,
I sonst Nein
Algorithmus : Suche 2
Eingabe : (x1 , . . . , xn ), y
Ausgabe : gefunden
gefunden ← Nein
i ←1
solange gefunden = Nein und i ≤ n :
wenn xi = y dann
gefunden ← Ja
i ←i +1
33
Laufzeiten
I
Suche 1
best falls y = x1 : T (n) ∈ O(n)
worst falls y nicht in x vorkommt: T (n) ∈ O(n)
average T (n) ∈ O(n)
I
Suche 2
best falls y = x1 : T (n) ∈ O(1)
worst falls y nicht in x vorkommt: T (n) ∈ O(n)
average T (n) ∈ O(n)
34
Beispiel Minimum-Suche
Spezifikation:
I
I
Eingabe x = (x1 , . . . , xn )
Ausgabe y mit
1. y ∈ {x1 , . . . , xn } und
2. ∀z ∈ {x1 , . . . , xn } : y ≤ z
Algorithmus : Minimum-Suche
Eingabe : (x1 , . . . , xn )
Ausgabe : y
y ← x1
für jedes i ← 2, . . . , n :
wenn y > xi dann
y ← xi
Laufzeit: O(n)
35
Beispiele – Laufzeiten
Für alle Algorithmen:
Eingabe : n
Ausgabe : s
Algorithmus : A
Algorithmus : B
k ← 52; s ← 5
für jedes i ← 1, . . . , n :
für jedes j ← 1, . . . , k :
s ← n + ij
k ← 52; s ← 5
für jedes i ← 1, . . . , n :
für jedes j ← 1, . . . , n :
s ← n + ij
Algorithmus : C
k ← 52; s ← 5
für jedes i ← 1, . . . , n :
für jedes j ← 1, . . . , i :
s ←i +j
T (A) ∈ 0(n)
T (B) ∈ 0(n2 )
T (C) ∈ 0(n2 )
36
Rekursive Algorithmen
Basisfall (Induktionsanfang): direkte Lösung
Rekursionsschritt (Induktionsschritt):
Funktionswert wird aus den Funktionswerten derselben
Funktion mit anderen (einfacheren) Argumenten berechnet
Beispiele:
I Fakultät
1
falls n = 0
n! =
n(n − 1)! sonst
I
I
I
Fibonacci-Funktion

falls n = 0
 0
1
falls n = 1
f (n) =

f (n − 1) + f (n − 2) sonst
I
Ackermann-Funktion

falls x = 0
 y +1
a(x − 1, 1)
falls y = 0 und x > 0
a(x, y ) =

a(x − 1, a(x, y − 1)) sonst
37
Laufzeit-Berechnung für n!
Algorithmus : fac
Eingabe : x
Ausgabe : y
Spezifikation:
V: x ∈
N
wenn x = 0 dann y ← 1
sonst y ← x fac(x − 1)
N: y = x!
T (n)
Rekurrenz T (0)
=
1
T (n)
=
T (n − 1) + 1
=
T (n − 1) + 1
=
(T (n − 2) + 1) + 1 = T (n − 2) + 2
=
T (n − 3) + 3
...
=
T (n − n) + n = T (0) + n = 1 + n
Laufzeit O(n)
38
Divide-and-Conquer-Verfahren
(teile und herrsche)
Idee: rekursive Zerlegung des Problemes in Teilprobleme
bis zum Basisfall
Grundprinzip:
Teilung des Problems P in n Teilprobleme Pi
Lösung aller Teilprobleme Pi (Rekursion)
Kombination der Lösungen der Teilprobleme Pi zu einer
Lösung des Problems P
(Baumstruktur)
39
Beispiel: Suche in geordneten Folgen
Spezifikation des Suchproblemes in geordneten Folgen:
V: Eingaben
I totale Ordnung (M, ≤),
I x = (x1 , . . . , xn ) ∈ M ∗ aufsteigend geordneten
(d.h. x1 ≤ x2 ≤ · · · ≤ xn )
I y ∈M
N: Ausgabe:
I Ja, falls ein i ∈ {1, . . . , n} mit xi = y existiert,
I sonst Nein
40
Algorithmus: Suche in geordneten Folgen
Algorithmus : Suche3
Eingabe : (x1 , . . . , xn ), y und l, r ∈ {1, . . . , n} (Bereichsgrenzen)
Ausgabe : gefunden
wenn l > r dann gefunden ← Nein
sonst
m ← b(l + r )/2c
wenn xm = y dann gefunden ← Ja
sonst
wenn xm < y dann Suche3(x, y , m + 1, r )
sonst Suche3(x, y , l, m − 1)
41
Laufzeit: Suche in sortierten Folgen
T (0) = T (1) = a
T (n) = T (bn/2c) + b
mit Konstanten a, b
für n = 2k , also k = log n:
T (n)
=
T (n/21 ) + b
=
T (n/22 ) + b + b
=
T (n/23 ) + 3b
...
=
T (n/2k ) + kb = T (n/n) + kb = a + k b = a + b log n
Laufzeit: O(log n)
42
Häufig vorkommende Rekurrenzen
T (n) = T (n − 1) + 1
T (n) = T (n − 1) + n
T (n) = T (n/2) + 1
T (n) = T (n/2) + n
T (n) = 2T (n/2) + 1
T (n) = 2T (n − 1) + 1
. . . = T (0) + n
. . . = T (0) + n2
. . . = T (0) + log n
. . . = T (0) + n log n
. . . = 2log n T (0) + 2log n log n
O(n)
O(n2 )
O(log n)
O(n log n)
O(n log n)
O(2n )
Allgemeines Verfahren zum Lösen von Rekurrenzen:
Master-Theorem
43
Klassisches Beispiel: Türme von Hanoi
I
Positionen A, B.C
I
n Scheiben {1, . . . , n} der Größen 1, . . . , n
I
Bedingung:
Scheibe i darf nur dann auf Scheibe j liegen, wenn i < j
zulässige Bewegungen (zusammen ein Zug):
I
I
I
Nimm die obere Scheibe i von Position x ∈ {A, B, C} und
Lege diese Scheibe i auf Position y ∈ {A, B, C}, sofern
damit auf Position y die Bedingung nicht verletzt wird
I
Startsituation:
Auf Position A ein Turm aus n (zulässig) gestapelten
Scheiben, Positionen B, C leer
I
Zielsituation:
Auf Position B ein Turm aus n (zulässig) gestapelten
Scheiben, Positionen A, C leer
gesucht: Folge von Schritten vom Start- zum Zielzustand
44
Türme von Hanoi: rekursiver Algorithmus
Verschiebe einen Hanoi-Turm der Höhe n von Position A zu
Position B, falls nötig, unter Verwendung der Position C:
Spezifikation:
V: (x : n, y : 0, z : 0), l = ()
N: (x : 0, y : n, z : 0),
l enthält die Folge aller Züge
(Start- und Zielposition der bewegten Scheibe)
Algorithmus Hanoi(x, y , z):
Basisfall: n = 0 (keine Bewegung)
Rekursionsschritt: 1. die oberen n − 1 Scheiben von Position
x zu Position z verschieben, falls nötig, unter
Verwendung der Position y (rekursiv),
2. Verschiebe die größte Scheibe von Position x
zu Position y ,
Zug (x → y ) an l anhängen
3. die n − 1 Scheiben von Position z zu Position
y verschieben, falls nötig, unter Verwendung
der Position x (rekursiv).
45