Hilfsunterlagen zu Datenstrukturen und Algorithmen 708.031/032

Hilfsunterlagen zu
Datenstrukturen und Algorithmen
708.031/032
Helmut Hauser, Feb.2007
1
Inhaltsverzeichnis
1 Einführung
5
1.1
Ein erstes Beispiel
. . . . . . . . . . . . . . . . . . . . . . . . . .
1.2
Analyse der Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . .
5
1.2.1
Bester Fall (best case) . . . . . . . . . . . . . . . . . . . .
7
1.2.2
Schlechtester Fall (worst case) . . . . . . . . . . . . . . . .
7
1.2.3
Durchschnittlicher Fall (average case)
7
. . . . . . . . . . .
2 Asymptotische Schranken
5
8
2.1
O-Notation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3
Ω-Notation
Θ-Notation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.4
Rechen-Regeln für die O-Notation . . . . . . . . . . . . . . . . .
9
2.5
Häug vorkommende Funktionen . . . . . . . . . . . . . . . . . .
10
2.6
Anmerkung zum Logarithmus . . . . . . . . . . . . . . . . . . . .
10
3 Rekursionen
3.1
3.2
3.3
Erstes Beispiel
11
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1
Iterative Version
3.1.2
Rekursive Version
11
. . . . . . . . . . . . . . . . . . . . . . .
11
. . . . . . . . . . . . . . . . . . . . . .
11
Methoden zur Lösung von Rekursionsgleichungen . . . . . . . . .
12
3.2.1
Lösen durch Einsetzen . . . . . . . . . . . . . . . . . . . .
12
3.2.2
Lösen durch Induktion . . . . . . . . . . . . . . . . . . . .
12
Zweites Beispiel - Fibonacci-Zahlen . . . . . . . . . . . . . . . . .
12
3.3.1
Iterative Version
. . . . . . . . . . . . . . . . . . . . . . .
13
3.3.2
Rekursive Version
. . . . . . . . . . . . . . . . . . . . . .
13
3.4
Die Ackermann-Funktion
. . . . . . . . . . . . . . . . . . . . . .
13
3.5
Türme von Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
4 Elementare Datenstrukturen
15
4.1
Lineares Feld
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.2
Lineare Liste
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.3
Stapel (Stack) . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.4
Schlange (Queue) . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
5 Sortieren durch Verschmelzen - Mergesort
17
6 Halde (Heap)
19
6.1
Verhalden (Heapify)
. . . . . . . . . . . . . . . . . . . . . . . . .
6.2
Aufbau einer Halde . . . . . . . . . . . . . . . . . . . . . . . . . .
20
6.3
Sortieren mit Halden (Heap Sort) . . . . . . . . . . . . . . . . . .
20
6.4
Wartschlange (Priority Queue)
21
2
. . . . . . . . . . . . . . . . . . .
20
7 Quicksort
22
7.1
Partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
7.2
Quicksort
22
7.3
Randomisierter Quicksort
. . . . . . . . . . . . . . . . . . . . . .
23
7.4
Quicksort (iterativ) . . . . . . . . . . . . . . . . . . . . . . . . . .
23
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8 Untere Schranke für vergleichende Sortierverfahren
8.1
Herleiten der unteren Schranke
8.2
worst-case optimal
Ω (n log n)
24
. . . . . . . . . . . . .
24
. . . . . . . . . . . . . . . . . . . . . . . . . .
25
9 Gestreute Speicherung (Hashing)
26
9.1
Grundidee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
9.2
Gute Hashfunktionen . . . . . . . . . . . . . . . . . . . . . . . . .
26
9.3
9.2.1
Divisionsmethode . . . . . . . . . . . . . . . . . . . . . . .
26
9.2.2
Multiplikationsmethode
26
. . . . . . . . . . . . . . . . . . .
Behandlung von Kollisionen . . . . . . . . . . . . . . . . . . . . .
26
9.3.1
Kollisionsbehandlung mit Überlauferliste (Chaining) . . .
27
9.3.2
Oene Adressierung
27
. . . . . . . . . . . . . . . . . . . . .
10 Suchen in linearen Feldern
30
10.1 Ohne Vorsortierung . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1.1 Sequentielle Suche
30
. . . . . . . . . . . . . . . . . . . . . .
30
10.1.2 Seq.Suche mit Wahrscheinlichkeitsverteilung . . . . . . . .
30
10.2 Mit Vorsortierung
. . . . . . . . . . . . . . . . . . . . . . . . . .
10.2.1 Binärsuche (Binary Bisection Search)
. . . . . . . . . . .
30
31
10.2.2 Interpolationssuche . . . . . . . . . . . . . . . . . . . . . .
31
10.2.3 Fastsearch . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
10.2.4 Zusammenfassung
33
. . . . . . . . . . . . . . . . . . . . . .
11 Binärbäume
34
11.1 Grundlagen - Denitionen . . . . . . . . . . . . . . . . . . . . . .
11.2 Nötige Funktionen
. . . . . . . . . . . . . . . . . . . . . . . . . .
11.3 Reihenfolge der Knoten
34
34
. . . . . . . . . . . . . . . . . . . . . . .
35
11.3.1 Symmetrische Reihenfolge (SR) . . . . . . . . . . . . . . .
35
11.3.2 Haupreihenfolge (HR)
. . . . . . . . . . . . . . . . . . . .
35
11.3.3 Nebenreihenfolge (NR) . . . . . . . . . . . . . . . . . . . .
35
11.4 Sortierte Binärbäume
. . . . . . . . . . . . . . . . . . . . . . . .
11.4.1 Suchen in Binärbäumen
. . . . . . . . . . . . . . . . . . .
11.4.2 Finden des Maximus in einen Binärbaum
11.4.3 Finden des Minimums in einen Binärbaum
35
35
. . . . . . . . .
36
. . . . . . . .
36
11.4.4 Finden des Vorgängers eines Knotens
. . . . . . . . . . .
36
11.4.5 Finden des Nachfolger eines Knotens
. . . . . . . . . . .
37
11.4.6 Einfügen in den Binärbaum . . . . . . . . . . . . . . . . .
37
11.4.7 Löschen eines Werts
37
. . . . . . . . . . . . . . . . . . . . .
3
12 (2-4)-Bäume
39
12.1 Implementierbare Funktionen . . . . . . . . . . . . . . . . . . . .
39
12.1.1 Suchen in (2-4)-Bäumen . . . . . . . . . . . . . . . . . . .
39
12.1.2 Einfügen in (2-4)-Bäumen . . . . . . . . . . . . . . . . . .
40
. . . . . . . . . . . . . . . . .
40
12.2 Beweis der logarithmischen Höhe . . . . . . . . . . . . . . . . . .
12.1.3 Entfernen in (2-4)-Bäumen
41
. . . . . . . . . . . . . .
41
12.4 Sortieren mit (2-4)-Bäumen . . . . . . . . . . . . . . . . . . . . .
12.3 Anwendung: Mischbare Warteschlangen
42
12.4.1 Analyse des Sortierens mit (2,4)-Bäumen
. . . . . . . . .
13 Optimales Kodieren
42
44
13.1 Nötige Denitionen . . . . . . . . . . . . . . . . . . . . . . . . . .
44
13.2 Darstellung des Kodierers
. . . . . . . . . . . . . . . . . . . . . .
45
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
13.3.1 Implementierung . . . . . . . . . . . . . . . . . . . . . . .
46
13.3 Human
14 Amortisierte Kosten bei (2,4)-Bäumen
47
14.1 Denitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.1.1 minimaler, maximaler Kontostand
14.1.2 Einfügen, Entfernen
14.1.3 Spalten
b(T )
47
. . . . . . . . . .
48
. . . . . . . . . . . . . . . . . . . . .
48
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
14.1.4 Stehlen und Verschmelzen . . . . . . . . . . . . . . . . . .
48
14.2 Abrechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
4
1
Einführung
1.1
Ein erstes Beispiel
Eine ungeordnete Folge von Zahlen soll aufsteigend sortiert werden. Ein erster
intuitiver Ansatz wäre, von links nach rechts gehend, jede einzelne Zahl so weit
nach links zu verschieben, bis sie am richtigen Platz angelangt ist.
Die verbale Formulierung kann auch in Form eines
werden.
Pseudocodes ausgedrückt
Ein Pseudocode ist eine an höhere Programmiersprachen angelehnte
Formulierung . Der vorgeschlagene Algorithmus wird in der Fachliteratur
Sort (Sortieren durch Einfügen ) genannt.
Insertion-
INSERTION_SORT (A)
1: FOR i=2 TO n DO
2:
h=A[i]
3:
j=i-1
4:
WHILE A[j]>h AND j>0 DO
5:
A[j+1]=A[j]
6:
j=j-1
7:
A[j+1]=h
1.2
Analyse der Laufzeit
Wir suchen nun die Abhängigkeit der Laufzeit
der zu sortierenden Zahlen)
n.
T
von der Inputgröÿe (Anzahl
Im obigen Zahlenbeispiel ist
n = 6.
Die Grundidee ist einfach die einzelnen Schritte zu zählen, sie mit konstanten
Zeitfaktoren
ci
(als Platzhalter für die Zeit die sie benötigen) zu versehen und
sie in Abhängigkeit von der Inputgröÿe
n
darzustellen. Die Zeitfaktoren
ci
sind
je nach Implementierung (Sprache, Hardware, etc.) unterschiedlich. Sie können
aber dann immer als konstant angesehen werden.
5
Pseudocode
Insertion_Sort (A)
Zeitkonstante
Anzahl der Wiederholungen
c0
c1
c2
c3
c4
c5
c6
c7
1
1: FOR i=2 TO n DO
2:
h=A[i]
3:
j=i-1
4:
WHILE A[j]>h AND j>0 DO
5:
A[j+1]=A[j]
6:
j=j-1
7:
A[j+1]=h
(n − 1)
(n − 1)
(n − 1)
P
n
Pn i=2 ti
(ti − 1)
Pi=2
n
i=2 (ti − 1)
n−1
Bemerkungen: Die Zeit um den Algorithmus aufzurufen wird als unabhängig von
der Inputgröÿe angenommen.
In den zukünftigen Betrachtungen wird sie de-
shalb nie berücksichtigt. Als optisches Kennzeichen trägt der Algorithmuskopf
daher auch keine eigene Zeilennummer.
Weitere Bemerkungen zu den einzelnen Zeilen:
1. In der Schleife werden die einzelnen Elemente abgearbeitet. Pro Schleife
i
wird geschaut, ob der Index
wird
i
schon
n
um eins erhöht. Benötigte Zeit:
erreicht hat oder nicht. Falls nicht
c1
2. Die Zuweisung benötigt eine konstante Zeit
c2 .
3. Ebenfalls eine Zuweisung mit einer Subtraktion:
4. Die Konstante
c4
c3
beinhaltet die beiden Vergleiche als auch deren logische
Verknüpfung. Wenn man sich ein Zahlenbeispiel genauer anschaut, sieht
man, dass es von der Verteilung der Zahlen abhängt, wie oft man die
while -Schleife durchlaufen und damit die Abfrage durchführen muss. Man
deniert eine allgemeine Variable ti : ti ist die Anzahl der while -Abfragen,
1
die der Algorithmus für das i-te Element des Inputs machen muss .
5. ,6. und 7. sind ebenfalls Zuweisungen:
c5 , c6
und
c7
Wenn man nun einfach alle Zeiten zusammenzählt, erhält man die Laufzeit
in Abhängigkeit der Inputgröÿe
T
n:
n
n
n
X
X
X
T (n) = c1 (n−1)+c2 (n−1)+c3 (n−1)+c4 ·
ti +c5 · (ti −1)+c6 · (ti −1)+c7 (n−1)
i=2
Oensichtlich hängt die Laufzeit
Zeitkonstanten
Folge
A
ci
T
i=2
nicht nur von der Inputgröÿe
n
und den
ab, sondern auch davon wie die Zahlen in der ungeordneten
vorliegen (= Einuss von
ti ).
Dadurch kann man drei wichtige Fälle
beste Fall, der schlechteste Fall
Fall (best, worst and averaged case ).
unterscheiden:
i=2
der
und der
durchschnittliche
1 Bemerkung: Man könnte auch eine Variable w denieren, welche zeigt wie oft die Schleife
i
für das i-te Element durchlaufen werden muss. Der Zusammenhang wäre dann wi = ti − 1.
6
1.2.1 Bester Fall (best case)
Der beste (schnellste) Fall liegt vor, wenn der Algorithmus
nie in die WHILE-
A[j] > h and j > 0 in
Zeile 5 wird jeweils nur einmal pro Element durchgeführt: ti = 1, ∀i = 2, 3..., n.
Pn
Pn
Mit
i=2 ti =
i=2 1 = (n − 1) und c1 + c2 + c3 + c4 + c7 = cGesamt ergibt sich
Schleife hineingehen muss. Das heiÿt, die logische Abfrage
für die Laufzeit:
T (n) = (n − 1) · (c1 + c2 + c3 + c4 + c7 ) = (n − 1) · cGesamt = n · cGesamt − cGesamt
Das heiÿt, die Laufzeit nimmt
linear mit der Inputgröÿe zu.
1.2.2 Schlechtester Fall (worst case)
i-te
ti = i
Der schlechteste (langsamste) Fall liegt vor, wenn der Algorithmus das
2
Element um
i−1
∀i = 2, 3, ..n.
Die Laufzeit beträgt:
Plätze nach vorne verschieben muss .
Das heiÿt:
n
n
n
X
X
X
T (n) = c1 (n−1)+c2 (n−1)+c3 (n−1)+c4 ·
i+c5 · (i−1)+c6 · (i−1)+c7 (n−1)
i=2
Mit
Pn
i=2
i=
n·(n+1)
2
−1
und
Pn
i=2 (i − 1)
=
i=2
i=2
n·(n−1)
erhält man folgende Form:
2
T (n) = cquad n2 + clin n + crest
Das heiÿt, die Laufzeit nimmt
quadratisch mit der Inputgröÿe zu.
1.2.3 Durchschnittlicher Fall (average case)
Alle
n
Zahlen sind zufällig verteilt (gleichtverteilt).
Im Durchschnittt ist die
A[1..i − 1] gröÿer als das i-te Element. Das heiÿt ti ≈ 2i .
Pn
Pn i
n·(n+1)
1
1
Mit
erhält man wieder eine quadratische
i=2 (i) = − 2 +
i=2 ( 2 ) = 2
4
Hälfte der Elemente in
Abhängigkeit der Laufzeit von der Inputgröÿe.
2 Die
Eingabefolge ist umgekehrt (absteigend) sortiert!
7
2
Asymptotische Schranken
Sowohl die Laufzeit
T (n)
asymptotische Schranken
ci ,
Die Konstanten
als auch der Speicherbedarf
S(n)
werden meist durch
angegeben.
welche in der Einführung deniert wurden, sind direkt von
der Implementation (Taktfrequenz, Hardware allgemein,....)
abhängig.
Man
will aber ein davon unabhängiges Kriterium nden, um Algorithmen objektiv
3
untereinander zu vergleichen .
Die Grundidee ist, dass bei einem immer gröÿer werdenden Input
n
die Kon-
stanten vernachlässigbar werden. Weiters können Terme mit niederer Ordnung
als verschwindend angesehen werden.
T (n) = c1 n3 + c2 n2 + c3 n + c4 kann man,
Konstanten c1 , c2 und c3 als auch die Terme
Zum Beispiel mit einer Laufzeit von
bei sehr groÿem
c2 n2 + c3 n + c4
n
, sowohl die
vernachlässigen.
Wenn man das ganze in mathematische Denitionen verfasst, erhält man die
sogenannte
2.1
O-, Θ-
und
Ω-Notation.
O-Notation
f (n), g(n) : N → R+
f (n) = O (g(n)) ⇔ c ∈ R, c > 0, n0 ∈ N : f (n) ≤ c · g(n)
3 Deshalb
∀n ≥ n0
(Ohh)
benützt man auch einen Pseudocode, um den Algorithmus zu analysieren.
8
2.2
Ω-Notation
f (n), g(n) : N → R+
f (n) = Ω (g(n)) ⇔ c ∈ R, c > 0, n0 ∈ N : f (n) ≥ c · g(n)
2.3
∀n ≥ n0
(Omega)
Θ-Notation
f (n), g(n) : N → R+
f (n) = Θ (g(n)) ⇔ c1 , c2 ∈ R, c1 , c2 > 0, n0 ∈ N : c1 · g(n) ≤ f (n) ≤ c2 · g(n)
(Theta)
2.4
Rechen-Regeln für die O-Notation
O (f (n)) + O (g(n)) = O (max {f (n), g(n)})
O (f (n)) · O (g(n)) = O (f (n) · g(n))
f (n) = O (g(n)) ∧ g(n) = O (h(n)) ⇒ f (n) = O (h(n))
O (f (n)) − O (f (n)) = O (f (n))
9
∀n ≥ n0
2.5
Häug vorkommende Funktionen
Name
O-Notation
Bsp.-Funktion
Bsp.-Algorithmus
konstant
O(1)
O(log n)
O(nc ),0 < c < 1
O(n)
O(n · log n)
O(nc ), c > 1
O(cn ), c > 1
O(n!)
3
Addition
logarithmisch
Wurzelfunktion
linear
linearlogarithmisch
polynominal
exponential
Fakultät
2.6
ld (n), ln (n)
√
Suchen
1
3
n, n
3n + 4
2n · ld(n)
4n2 + 7n + 10
2n , 10n
n!
Primzahltest
Maximum nden
Sortieren
Matrizenoperationen
NP-vollständige Alg.
Anmerkung zum Logarithmus
Es kommt sehr häug vor, dass bei der Laufzeitanalyse der Logarithmus zur
Basis 2 verwendet wird.
liebigen Basis
b
Es lässt sich aber jeder Logarithmus mit einer be-
in einen anderen Logarithmus mit der Basis
b0
folgendermaÿen
umrechnen:
logb0 (x) =
1
· logb (x)
logb (b0 )
Die beiden Versionen unterscheiden sich nur durch einen konstanten Faktor, der
natürlich asymptotisch gesehen vernachlässigbar wird. Das heiÿt:
O(logb0 n).
10
O(logb n) =
3
Rekursionen
Viele Algorithmen besitzen sowohl eine
iterative
als auch eine
rekursive
Lösung.
Sie unterscheiden sich darin, dass die iterative Version meist einen etwas längeren Kode besitzt, während die rekursive Version mehr Speicher benötigt, um
alle Rekursionsschritte zwischen zu speichern.
3.1
Erstes Beispiel
Der Algorithmus soll die Fakultät
n!
berechnen.
3.1.1 Iterative Version
FAKULTÄT_ITERATIV(n)
1: f=1
2: FOR i=1 to n
3:
f=f*i
4: RETURN f
Die Laufzeit beträgt
T (n) = O(n), da nur eine Schleife durchlaufen werden
O(1) unabhängig von der Inputgröÿe.
muss. Der Speicherbedarf ist mit
3.1.2 Rekursive Version
FAKULTÄT_REKURSIV(n)
1: IF n=1 THEN
2:
RETURN 1
3: ELSE
4:
RETURN (n*FAKULTÄT_REKURSIV(n-1))
In Zeile 1 bendet sich die
Abbruchbedingung
für die Rekursion. Zur Analyse
benötigt man die Laufzeit für den Fall, wenn abgebrochen wird. Hier benötigt
der Algorithmus im Abbruchfall
n=1
eine Laufzeit von
O(1).
Im Normalfall (während der Rekursionen) kann man folgende Rekursionsgleichung aufstellen:
T (n) = O(1) + T (n − 1)
| {z } | {z }
1
2
1. Beinhaltet die konstante Zeit, die die Zeilen 1-3 benötigen
2. Ist die Laufzeit um ein Element verringert, da
mit (n-1) aufgerufen wird.
11
FAKULTÄT_REKURSIV
3.2
Methoden zur Lösung von Rekursionsgleichungen
3.2.1 Lösen durch Einsetzen
Es wird ein Rekursionsschritt tiefer
T (n − 1) = O(1) + T (n − 2)
in die Orginalgleichung
T (n) = O(1) + T (n − 1)
eingesetzt:
T (n) = O(1) + O(1) + T (n − 2)
Analog erhält man durch weiteres Einsetzen eine allgemeine Formel in Abhängigkeit der Rekursionstiefe
k
= O(1) + O(1) + T (n − 2)
T (n)
= O(1) + O(1) + O(1) + T (n − 3)
= ...
= k · O(1) + T (n − k)
Die Rekursion verläuft bis zur Abbruchbedingung
n = 1, dass heiÿt, bis T (1)
k . Mit T (1) = T (n − k)
auftritt. Man will nun eine Lösung unabhängig von
bekommt man
n−k =1⇒k =n−1
T (n)
und setzt in die Gleichung ein:
=
(n − 1) · O(1) + T (n − n + 1)
=
(n − 1) · O(1) + T (1)
= (n − 1) · O(1) + O(1)
T (n) = O(n)
3.2.2 Lösen durch Induktion
Zur Lösen der Rekursionsgleichung durch Induktion muss zuerst eine Lösung
geschätzt und diese Annahme durch Induktion bewiesen werden.
3.3
Zweites Beispiel - Fibonacci-Zahlen
Die Denition der Fibonacci-Zahlen:
fn = fn−1 + fn−2 ; n ≥ 3 ; f1 = 1, f2 = 1
Die ersten Zahlen lauten
1, 1, 2, 3, 5, 8, 13, 21, ...
Die Folge ist monton wachsend und besitzt folgende Schranken:
fn = fn−1 + fn−2 = fn−2 + fn−3 +fn−2
| {z }
≥ 2 · fn−2 ⇒
≤ 3 · fn−2 ⇒
n
fn = Ω(2 2 )
n
fn = O(3 2 )
≤fn−2
Mit den Anfangswerten
2
n−1
2
≤ fn ≤ 3
f1 = f2 = 1 folgt:
√
√
⇔ c1 · ( 2)n ≤ fn ≤ c2 · ( 3)n ⇒ fn = Θ (cn )
n−1
2
12
3.3.1 Iterative Version
Es wird die
n-te
Fibonacci-Zahl gesucht:
FIBONACCI(n)
1: fib = 1
2: fib_1 = 1
3: FOR i = 3 to n
4:
fib_2 = fib_1
5:
fib_1 = fib
6:
fib = fib_1 + fib_2
7: RETURN fib
3.3.2 Rekursive Version
Es wird die
n-te
Fibonacci-Zahl gesucht:
FIBONACCI_R(n)
1: IF n≤2 THEN
2:
RETURN 1
3: ELSE
4:
RETURN (FIBONACCI_R(n-1)+FIBONACCI_R(n-2))
Die Rekursiongleichung lautet T (n) = O(1) + T (n − 1) + T (n − 2) mit T (1) =
O(1). Die Lösung ist Θ(cn ). Der Speicheraufwand beträgt S(n) = O(1) +
max{S(n − 1), S(n − 2)} = S(n).
Die rekursive Version ist einfacher zu implementieren, besitzt jedoch exponentielle Laufzeit und linearen Speicherbedarf.
3.4
Die Ackermann-Funktion
Es gibt zahlreiche Arten dieser rekursiven Funktion. Zum Beispiel:
ACKER(n,x,y)
1: IF n=0 THEN
2:
RETURN x+1
3: ELSE IF y=0 THEN
4:
IF n=1 THEN RETURN x
5:
IF n=2 THEN RETURN 0
6:
IF n=3 THEN RETURN 1
7:
IF n≥4 THEN RETURN 2
8: RETURN ACKER(n-1, ACKER(n,x,y-1),x)
13
3.5
Türme von Hanoi
Regeln:
•
3 Stäbe A, B und C
•
Am Stab A liegen zu Beginn
•
Diese sollen am Ende auf Stab B liegen
•
Es darf jeweils nur eine Scheibe bewegt werden
•
Es darf nie eine gröÿere auf einer kleineren Scheibe liegen
n unterschiedliche groÿe Scheiben
Zum Beispiel mit 7 Scheiben:
Rekursiver Algorithmus zur Lösung:
HANOI(n,x,y,z)
1: IF n=1 THEN
2:
Lege Scheibe von 'x' nach 'y'
3: ELSE
4:
HANOI(n-1,x,z,y)
5:
HANOI(1,x,y,z)
6:
HANOI(n-1,z,y,x)
Der Aufruf erfolgt zum Beispiel mit
HANOI (7,'A','B','C')
und fordert den Al-
gorithmus auf die 7 obersten Scheiben von A auf B unter Verwendung von C zu
legen.
14
4
Elementare Datenstrukturen
4.1
Lineares Feld
Benachbarte Elemente stehen im Speicher direkt nebeneinander.
i-te
Element erfolgt in konstanter Zeit:
A[i]
Der Zugri
O(1). Falls nicht anders
angegeben, nehmen wir hier in der Vorlesung die Gröÿe n des Feldes als gegeben
auf das
in
an.
4.2
Lineare Liste
Benachbarte Elemente sind miteinander verkettet.
Die Datenstruktur eignet
sich besonders, wenn die Länge in vorhinein nicht bekannt ist.
Die Verkettung erfolgt durch Pointer auf die Nachfolger.
Funktionen
NACH(p), VOR(p)
und
WERT(p)
Es existieren die
um auf das nachfolgende, das
vorhergehende Elemente oder den Wert direkt zuzugreifen. Weiters gibt es die
Möglichkeit die Liste doppelt zu verketten.
4.3
Stapel (Stack)
Der Stapel ist ein spezielles lineares Feld, bei dem das Einfügen und Entfernen
nur an der Spitze erlaubt ist.
Dadurch wird die LIFO-Strategie (last-in, rst-out) implementiert. Die Funktionen STAPEL_LEER, PUSH und POP werden verwendet um zu überprüfen,
ob der Stapel leer ist, um ein Element auf den Stapel zu werfen bzw. vom Stapel
S
zu entfernen.
15
STAPEL_LEER(S)
1: IF t=0
2:
RETURN TRUE
3: ELSE FALSE
PUSH (S,x)
1: IF t=n THEN 'overflow'
2: ELSE
3:
t=t+1
4:
S[t]=x
POP (S)
1: IF STACK_LEER THEN 'underflow'
2: ELSE
3:
x=S[t]
4:
t=t-1
Alle Operationen benötigen nur
O(1)
Zeit!
Anwendung: Abarbeiten von Rekursionen, umkehren einer Reihenfolge, Umwandlung von Inx-Ausdrücken in Postx-Ausdrücken,...
4.4
Schlange (Queue)
Implementiert die FIFO-Strategie (rst-in, rst-out). Die Schlange
die Funktionen
PUT
und
Q verwendet
GET, um Werte in die Schlange zu schreiben und sie
wieder auszulesen.
PUT (Q,x)
1: IF anzahl=n THEN 'overflow'
2: ELSE
3:
anzahl=anzahl+1
4:
IF ende<n THEN ende=ende+1
5:
ELSE ende=1
6:
Q[ende]=x
GET (Q)
1: IF anzahl=0 THEN 'underflow'
2: ELSE
3:
anzahl=anzahl-1
4:
x=Q[anfang]
5:
IF anfang<n THEN anfang=anfang+1
6:
ELSE anfang=1
7:
RETURN x
Alle Operationen benötigen
O(1)
Zeit!
16
5
Sortieren durch Verschmelzen - Mergesort
Das Sortierverfahren arbeitet auf der Basis der
gehend von einem linearen Feld
1.
2.
3.
A
der Gröÿe
divide&conquer -Strategie.
Aus-
n:
Teile das Feld in 2 gleich groÿe Hälften
Sortiere die Teilfelder rekursiv mit demselben Verfahren
Verschmelze die sortierten Teilfelder zu einem sortierten Gesamtfeld
Der Pseudocode dazu (wobei die Indizes
i
und
j
jeweils auf die Grenzen des
aktuellen Teilfeldes verweisen):
MERGESORT(A,i,j)
1: IF i<j THEN
2:
k = b(i+j)/2c
3:
MERGESORT (A,i,k)
4:
MERGESORT (A,k+1,j)
5:
VERSCHMELZE (A,i,k,j)
Der Aufruf erfolgt mit
MERGESORT(A,1,n).
4
Der Verschmelzungsprozess schaut folgendermaÿen aus :
VERSCHMELZE(A,i,k,j)
1: FOR l=i TO k DO B[l]=A[l]
2: FOR r=k+1 TO j DO C[r]=A[r]
3: B[k+1]=∞
4: C[j+1]=∞
5: l=i r=k+1
6: FOR m=i TO j
7:
IF B[l]<C[r] THEN
8:
A[m]=B[l] , l=l+1
9:
ELSE A[m]=C[r] , r=r+1
Der Verschmelzungsprozess besitzt eine Laufzeit von
T (n) = O(j−i+1) = O(n).
MERGESORT : T (n) =
Daraus ergibt sich folgende Rekursionsgleichung für
2T ( n2 ) + O(n),
4∞
deren Lösung
T (n) = O(n · log n)
ist.
wird in der Praxis mit der gröÿten darstellbaren Zahl implementiert.
17
Ein Beispiel mit der Zahlenfolge
< 5, 2, 4, 6, 1, 3 >
baum.
18
ergibt folgenden Rekursions-
6
Halde (Heap)
Die Halde ist eine lineares Feld, welches die sogenannte
Haldenbedingung:
Haldenbedinung
A[i]≥ max {A[2i], A[2i + 1]}, ∀i = 1, 2, . . . ≈
Direkt aus der Denition ergibt sich, dass
erfüllt:
n
2.
A[1] das Maximum des linearen Feldes
ist. Beispiel einer Halde:
Die Halde lässt sich auch als voller binärer Baum darstellen.
Mit den Funktionen
LINKS(i) und RECHTS(i) kann auf den linken bzw.
rechten
Nachfolger des i-ten Elements in der Baumstruktur zugegrien werden, analog
mit VATER(i) auf den Vorgänger.
LINKS (i)
1: RETURN 2i
RECHTS(i)
1: RETURN 2i + 1
VATER (i) 1: RETURN 2i
Wichtige Beobachtungen:
•
Das Maximum sitzt in der Wurzel des Baums
•
In jedem Knoten ist die Haldenbedingung erfüllt
•
Die Maximale Tiefe des Baums ist
•
In einem Teilbaum sind alle darunter liegenden Knoten kleiner oder maximal gleich groÿ.
19
blog nc
6.1
Verhalden (Heapify)
Verhalden ist der zentrale Prozess für alle Anwendungen der Haldenstruktur.
Mit
n
als Gröÿe der Halde (Die Länge des linaren Feldes).
VERHALDE (A,i)
1: l=LINKS(i), r=RECHTS(i)
2: index = i
3: IF l≤n AND A[l]>A[i] THEN index=l
4: IF r≤n AND A[r]>A[index] THEN index=r
5: IF i6=index THEN
6:
VERTAUSCHE (A[i], A[index])
7:
VERHALDE (A,index)
Analyse:
ist
Die Rekursiongleichung dazu lautet
T (n) ≤ O(1)+T ( n2 ).
Die Lösung
T (n) = O(log n).
6.2
Aufbau einer Halde
Eine Halde kann aus einem beliebigen linearen Feld
A
aufgebaut werden:
BAUE_HALDE (A)
1: FOR i=n/2 DOWNTO 1
2:
VERHALDE (A,i)
Analyse:
n
2 -mal durchgeführt. D.h. T (n) = O(n·log n).
Bei genauerer Betrachtung sieht man aber, dass eben nicht alle Elemente durch
Das Verhalden wird
die ganze Baumhöhe durch verhaldet werden müssen. Die Schranke
ist nicht scharf.
Pbldnc
Pbldnc h
n
)=
h=0 2h O(h) = O(n
h=0
P∞2h h
(Die Summe kann durch eine unendliche Summe
h=0 2h
werden.)
Ein genauerer Ansatz ist
O(n)
= 2
O(n · log n)
.
abgeschätzt
Damit kann eine Halde in linearer Zeit aus einem linearen Feld gebaut werden.
6.3
Sortieren mit Halden (Heap Sort)
Mit Hilfe des
VERHALDE -Algorithmus kann man auch einen Sortieralgoritmus
konstruieren.
HEAP_SORT(A)
1: BAUE_HALDE(A)
2: FOR i = n DOWNTO 2 DO
3:
VERTAUSCHE (A[1],A[i])
4:
n = n-1
5:
VERHALDE (A,1)
Die Laufzeit beträgt
T (n) = O(n · log n).
20
Der Algorithmus arbeitet
in-place.
6.4
Wartschlange (Priority Queue)
Eine weitere Anwendung dieser Datenstruktur ist die Warteschlange mit Prioritäten: Eine Warteschlange liegt vor, wenn folgende drei Operationen durchgeführt werden können:
•
EINFÜGEN (A,x)
•
MAX (A)
•
ENTFERNE_MAX (A)
Die Funktionen mit Hilfe einer Halde umgesetzt in Pseudocode:
MAXIMUM (A)
1: RETURN A[1]
ENTFERNE_MAX (A)
1: A[1] = A[n]
2: n = n-1
3: VERHALDE (A,1)
EINFÜGEN (A,x)
1: n = n+1 , A[n]=x , i=n
2: WHILE i>1 AND A[i]>A[VATER(i)] DO
3:
VERTAUSCHE (A[i],A[VATER(i)])
4:
i = Vater(i)
Die Laufzeiten betragen für MAXMIMUM, ENTFERNE_MAX und EINFÜGEN respektiv
O(1), O(log n)
und
O(log n).
21
7
Quicksort
Quicksort ist einer der meist verwendeten Sortieralgorithmen. Die Idee beruht
divide&conquer -Prinzip5 .
auf dem
Der Kern des Algorithmus ist die Zerlegung
des Feldes (Partition).
Zerlegen (Partition):
in
A[1..k]
7.1
Speichere das lineare Feld
kleiner als alle Elemente in
A[k + 1..n]
A so um,
Partition
Das Teilfeld ausgehend vom linken (unteren) Index
Index
dass alle Elemente
sind.
r
wird partitioniert.
A
l
bis zum rechten (oberen)
bezeichnet das bearbeitete lineare Feld.
PARTITION (A,l,r)
1: p = A[l]
2: j=l-1 , k=r+1
3: LOOP
4:
REPEAT j=j+1 UNTIL A[j]≥p
5:
REPEAT k=k-1 UNTIL A[k]≤p
6:
IF j<k THEN
7:
VERTAUSCHE (A[j],A[k])
8:
ELSE
9:
RETURN k
Die Laufzeit beträgt
7.2
O(r − l) = O(n).
Quicksort
Auf der Basis von
PARTITION
kann der Sortieralgorithmus
QUICKSORT
kon-
struiert werden.
QUICKSORT (A,l,r)
1: IF l<r THEN
2:
k = PARTITION(A,l,r)
3:
QUICKSORT (A,l,k)
4:
QUICKSORT (A,k+1,r)
Die Rekusionsgleichung dazu ist
T (n) = T (k) + T (n − k) + O(n).
Im besten
Fall (balancierte Aufteilung des Rekursionsbaums) beträgt die Laufzeit
5 Dabei
wird das Problem in kleinere Teilprobleme zerlegt und rekursiv aufgelöst.
22
T (n) =
O(n · log n).
Im schlechtesten Fall (das Feld ist genau umgekehrt sortiert - der
Rekursionsbaum ist entartet) beträgt sie
7.3
T (n) = O(n2 ).
Randomisierter Quicksort
Durch eine randomisierte Version von Quicksort kann man eine gute durchschnittliche Performance erreichen.
Das Pivotelement wird dabei zufällig mit
6
einer Gleichverteilung aus allen möglichen Werten ausgewählt . Es werden dazu
ein paar Zeilen (jetzt 1 und 2) eingefügt. Die Funktion
RANDOM(l,r)
einen zufälligen (Gleichverteilung) Integerwert im Bereich
l
bis
liefert
r.
RANDOM_PARTITION (A,l,r)
1: ind = RANDOM(l,r)
2: VERTAUSCHE(A[ind],A[l])
3: p = A[l]
4: j = ....
5: .
6: .
T (n) = O(n · log n).
O(n2 ) kann natürlich immer
Die erwartete Laufzeit beträgt dann
Bemerkung: Der schlechteste Fall
7.4
Quicksort (iterativ)
Der Algorithmus steigt immer in die
die
noch auftreten!
gröÿere
Hälfte auf einem Stack
kleinere
S7.
der beiden Hälften ein und stapelt
QUICKSORT_ITERATIV (A)
1: l=1 , r=n
2: PUSH(1,n)
3: REPEAT
4:
IF l<r THEN
5:
k = PARTITION(A,l,r)
6:
IF (k-l) < (r-k) THEN
7:
PUSH(k+1,r)
8:
r = k
9:
ELSE PUSH(l,k)
10:
l = k+1
11:
ELSE POP(l,r)
12: UNTIL STAPEL_LEER(S)
Der Speicherbedarf
mehr
S(n) beträgt im Gegensatz zum rekursiven Algorithmus nur
O(log n).
6 Der
worst-case, dass bei jedem Rekursionschritt der schlimmste Fall auftritt, wird dann
extrem unwahrscheinlich !
7 PUSH(a,b) entspricht dabei der Funktion PUSH(S,x={a,b}), welche bei den elementaren
Datenstrukturen deniert worden ist. Analoges gilt für POP(l,k), wobei auch gleichzeitig die
vom Stapel geholten Werte die aktuellen l und k Werte überschreiben.
mit
1
n!
23
8
Untere Schranke für vergleichende Sortierverfahren
Viele verwendete schnelle Sortierverfahren (z.B.:
besitzen eine Laufzeit von
O(n log n).
MERGESORT, HEAPSORT )
Die Frage, die sich dabei stellt lautet:
Geht es besser?
Man kann beweisen, das jedes Sortierverfahren, das mittels Vergleichen ar-
8
beitet , braucht mindestens
c · n log n
Vergleiche im
worst case (wobei c > 0
und konstant ist).
8.1
Herleiten der unteren Schranke
Ω (n log n)
Der Kontrolluss eines vergleichenden Sortierverfahrens kann mittels eines sogenannten
Entscheidungsbaummodells
dargestellt werden. Darin scheinen alle
möglichen und nötigen Entscheidungen auf, um ein sortiertes lineares Feld zu
erhalten. Beispiel: Es liegt eine Sequenz von 3 Zahlen vor
< 5, 8, 2 >).
< a1 , a2 , a3 >(z.B.
Dann schaut der zugehörige Entscheidungsbaum folgendermaÿen
aus:
9
Die Blätter stellen alle möglichen Permutationen dar . Im allgemeinen Fall ist
die Anzahl der Blätter gleich
n!.
Das worst-case Verhalten entspricht dem längsten Ast im Entscheidungsbaum
(Anzahl der inneren Knoten = Anzahl der Vergleiche). Der ideale Sortieralgorithmus enspricht einem vollständigen, da ausgeglichen, Baum. Dadurch wird
der längste Ast ( = worst case) minimiert. Die Höhe beträgt
Hilfe der Stirling-Approximation
h ≥ log
n n
e
n! > ( ne )n
h ≥ log(n!).
erhält man:
= n · log n − n · log e = Ω(n · log n)
8 D.h. bei dem jeweils einzelne Elemente direkt
9 Die Permutation über alle möglichen Inputs.
miteinander verglichen werden.
z.B.:<a1 , a2 , a3 > ,<a1 , a3 , a2 >,<a2 , a1 , a3 > , usw.
24
Mit
Ω(n · log n) ist die untere Schranke für die Anzahl der zum Sortieren notwendigen Vergleiche (und somit für die Laufzeit vergleichender Sortierverfahren).
8.2
worst-case optimal
Im Zusammenhang der unteren Schranke kann einen Sortieralgorithmus als
worst-case optimal bezeichnen, wenn er für jede Eingabefolge in O(n · log n)
sortiert. Zum Beispiel
MERGESORT
und
mal.
25
HEAPSORT
sind worst-case opti-
9
Gestreute Speicherung (Hashing)
Die Datenstrukur Hashtabelle wird zur Lösung des Wörterbuchproblems verwendet. Das Wörterbuchproblem ist durch die drei Funktionen
und
Lösche n deniert.
9.1
Einfügen, Suchen
Grundidee
Hashfunktion
Die Idee ist direkt aus dem Schlüssel mithilfe einer
die Adresse
zur Speicherung der Daten zu berechnen.
9.2
Gute Hashfunktionen
Die Hashfunktion
sum
U)
auf
m
h
bildet dabei Werte
w
aus der Menge der Schlüssel (Univer-
verschiedene Indizes der Hashtabelle
T
ab.
h : U → {0, 1, . . . m − 1}
Die ideale Hashfunktion sollte für alle Werte
alle Indizes
j = 0, 1, . . . m − 1
w∈U
eine Gleichverteilung über
10 .
der Hashtabelle haben
9.2.1 Divisionsmethode
m
Dividiere den Wert durch
und nimm den Rest:
h(w) = w mod m
Vorteil: Schnell berechenbar
Nachteil: nicht für alle
m
geeignet.
9.2.2 Multiplikationsmethode
Multipliziere den Wert
w
mit einer xen Konstante
multipliziere den gebrochenen Teil
f rac(.)
A,
0 < A < 1,
m.11
wobei
des Resultats mit
und
h(w) = bm · f rac(w · A)c
Vorteil:
9.3
m
ist unkritisch
Behandlung von Kollisionen
h(w) für zwei verschiedene Werte
h(w) = h(w0 )
Eine Kollision liegt vor, wenn die Hashfunktion
w
und
w0
denselben Index
j
liefert:
10 P = P rob {h(w) = j} = 1
j
m
j
d.h. die Wahrscheinlichkeit, dass ein Wert w genau den Index
1
zugewiesen bekommt ist m
für eine Hashtabelle der Gröÿe m.
11 Anmerkung: f rac(.) ∈[0, 1)
26
9.3.1 Kollisionsbehandlung mit Überlauferliste (Chaining)
Die Idee liegt darin, Werte, die zum gleichen Index führen, als verkette Liste
zu organisieren.
Das heiÿt, dass in der Hash-Tabelle jeweils nur eine Pointer
(Adresse) steht, welcher auf den ersten Datensatz in der Liste zeigt. Die drei
nötigen Funktionen zur Lösung des Wörterbuchproblems können folgendermaÿen
implementiert werden:
Einfügen:
•
w
Der Index
j
wird mithilfe der Hashfunktion aus dem Wert
des Schlüssels berechnet. Falls es zu einer Kollision kommt, wird der
Datensatz an die erste Stelle der Liste eingefügt (Laufzeit
Suchen:
•
Der Index
j
wird mithilfe der Hashfunktion aus dem Wert
des Schlüssels berechnet.
T (n)
O(lj ).
Löschen:
•
w
Die lokale Liste wird nach dem Wert durchist dabei abhängig von der Länge lj der lokalen
sucht. Die Laufzeit
Überläuferliste
T (n) = O(1)).
Das Löschen basiert auf dem Suchen. Sobald das Element ge-
funden wurde, werden einfach der davor liegende und der danach liegende
Datensatz dementsprechend verknüpft.
Die Laufzeit beträgt ebenfalls
O(lj ).
Falls man eine ideale Hashfunktion vorliegen hat, werden alle eingefügten Werte
gleichverteilt über die Hashtabelle gestreut. Über alle Möglichkeiten gemittelt
ergibt sich eine durchschnittliche Überläuferlistenlänge.
hängig von der Anzahl
n
Diese Länge ist ab-
der eingefügten Werte und der Gröÿe
belle. Sie wird durch den Belegungsfaktor
α=
α
m
der Hashta-
ausgedrückt:
n
m
Die Laufzeit zum Suchen eines Elements beträgt im schlimmsten Fall (worst
case)
O(n),
falls alle
Dagegen ist die
n
eingefügten Werte sich in einer Überläuferliste benden.
erwartete Suchzeit
Θ(1 + α),
n
entspricht, wenn man das Verhältnis zwischen
was einer Laufzeit von
und
m
O(1)
als konstant ansehen
kann.
9.3.2 Oene Adressierung
Bei der oenen Adressierung werden keine Pointer verwendet.
Der dadurch
frei gewordene Speicher kann dazu verwendet werden die Hashtabelle gröÿer zu
gestalten. Die Werte werden dabei direkt in die Hashtabelle gespeichert. Bei
einer Kollision wird der
nächste
freie Platz gesucht. Dabei wird zuerst immer
mithilfe einer herkömmlichen Hashfunktion ein Index berechnet, um dann, falls
diese Stelle schon besetzt ist (Kollision!), mit weiteren Versuchen (Probing,
0) einen freien Platz zu nden.
wobei jeweils eine erweiterte Hashfunktion
12 i
i>
Folgende drei Methoden werden dazu verwendet,
h(w, i)
12 :
verwendet wird
ist die sogenannte Versuchs- oder Sondierungszahl mit i = 0, 1, 2, . . . m − 1
27
•
Linear Probing:
Falls es zu einer Kollision kommt, wird einfach der
danach liegende Wert genommen:
h(w, i) = [h0 (w) + i] mod m
Nachteil: Es kommt zu einem primären Ballungseekt (primary clustering).
•
Quadratic Probing:
Indem man die Sprünge beim Versuch eine freie
Stelle zu nden polynomiell ansteigen lässt, kann man den primären Ballungseekt verhindern.
h(w, i) = [h0 (w) + f (i)] mod m
Wobei
f (i)
zum Beispiel eine quadratische Funktion (f (i)
= c1 i2 + c2 i)
sein kann.
Nachteil: Sobald es zu einer Kollision zwischen Werten
w
und
w0
kommt,
sind auch die nachfolgenden Indizes alle gleich. Das wird der sekundäre
Ballungseekt (secondary clustering) genannt.
•
Double Hashing:
Um auch den sekundären Ballungseekt zu verhin-
dern, werden die Sprünge mithilfe einer zweiten Hashfunktion vom Wert
w
abhängig gemacht.
h(w, i) = [h1 (w) + i · h2 (w)] mod m
Der Pseudocode ist für diese drei Methoden analog aufgebaut.
EINFÜGEN(T,w)
1: i=0
2: REPEAT
3:
ind = h(w,i)
4:
IF T[ind] = frei THEN
5:
T[ind] = w
6:
RETURN 'Okay'
7:
i = i+1
8: UNTIL i=m
9: RETURN 'Tabelle voll'
SUCHE(T,w)
1: i=0
2: REPEAT
3:
ind = h(w,i)
4:
IF T[ind] = w THEN RETURN ind
5:
i = i+1
6: UNTIL T[ind]=frei OR i=m
7: RETURN 'nicht gefunden'
28
erwartete Suchaufwand in einer Hash-Tabelle T mit oener Adressierung
1
Θ( 1−α
), falls der gesuchte Wert w nicht in der Tabelle vorhanden ist (w ∈
/ T ).
Im Fall, dass der gesuchte Wert w in der Hash-Tabelle T vorhanden ist (w ∈ T ),
h
i
1
1
beträgt der erwartete Suchaufwand Θ
ln
+
1
.
α
1−α
Der
ist
29
10
Suchen in linearen Feldern
Will man in einer Datenmenge (sie liegt als lineares Feld
A[1..n] vor) nur
suchen,
dann gibt es mehrere Möglichkeiten. Generell kann unterschieden werden, ob
das Feld in
sortierter
oder in
unsortierter
Form vorliegt.
Beim Suchen kann
der schlechteste Fall, dass sich das gesuchte Element gar nicht in den Daten
bendet, relativ oft vorkommen.
10.1
Ohne Vorsortierung
10.1.1 Sequentielle Suche
Erste Idee: Einfach von Anfang bis Ende alles durchsuchen.
SUCHE (A,x)
1: i = 0
2: WHILE i<n
3:
i = i+1
4:
IF A[i]=x THEN RETURN i
5: ELSE RETURN -1
Die Laufzeit
case O(n).
T (n) beträgt im worst case O(n), im best case O(1) und im averaged
10.1.2 Sequentielle Suche bei bestimmter Wahrscheinlichkeitsverteilung
13 bekannt sind, dann kann die
Wenn die Zugriwahrscheinlichkeitsverteilung
Suche schneller gehen. Voraussetzung ist, dass die Werte nach diesen Wahrscheinlichkeiten geordnet sind. Das heiÿt, der am häugst gesuchte Wert steht am Anfang des Feldes, während der am wenigsten oft gesuchte Wert am Ende steht.
Wenn
pi
1 ≤ i ≤ n ist, und wir eine
1
),
dann verläuft die Suche in
2i
1
) erhält man O(n).
n−1
die Zugriswahrscheinlichkeit auf
A[i]
=
für
exponentielle Verteilung vorliegen haben (pi
O(1).
Bei einer Gleichverteilung (pi
10.2
Mit Vorsortierung
=
Für die folgenden Suchalgorithmen gilt jeweils, dass sie mit
Funktionsname(A,1,n)
aufgerufen werden, und als Rückgabewert den Index des zu ndenden Elements
zurückgeben. Falls das Element nicht in der Datenmenge vorhanden ist, wird
−1
retourniert. Weiters geht man davon aus, dass die Werte in aufsteigender
Reihenfolge sortiert sind.
13 Die Zugriswahrscheinlichkeit ist die Wahrscheinlichkeit,
dass auf ein bestimmtes Element
zugegrien werden will, bzw. nach einem bestimmten Element gesucht wird.
30
10.2.1 Binärsuche (Binary Bisection Search)
Idee: Teile das Feld in zwei gleich groÿe Hälften. Vergleiche den gesuchten Wert
mit dem mittleren Element. Falls sie gleich sind, dann ist man fertig. Wenn der
gesuchte Wert kleiner ist, dann suche in der unteren Hälfte, sonst in der oberen
Hälfte.
Die rekursive Version:
BINSUCH (von,bis,x)
1: IF von≤bis THEN
2:
m = b(von + bis)/2c
3:
IF x=A[m] THEN
4:
RETURN m
5:
ELSE
6:
IF x<A[m] THEN m=BINSUCH(von,m-1,x)
7:
ELSE THEN m=BINSUCH(m+1,bis,x)
8: ELSE m = -1
Die Laufzeit beträgt
T (n) ≤ O(1) + T ( n2 ) = O(log n).
Zum Beispiel bei einer
Gröÿe von 1 Million Werte, benötigt der Algorithmus im schlechtesten Fall (der
Wert ist nicht enthalten) nur 20 Schritte!
Die iterative Version:
BINSUCH_ITERATIV (von,bis,x)
1: pos = -1
2: REPEAT
3:
m = b(von + bis)/2c
4:
IF x=A[m] THEN pos = m
5:
ELSE
6:
IF x<A[m] THEN bis=m-1
7:
ELSE von=m+1
8: UNTIL (pos 6=-1) OR (von>bis)
9: RETURN pos
10.2.2 Interpolationssuche
Idee: Man sucht nicht jeweils in der Mitte, sondern dort, wo das Element sein
sollte. Die Annahme ist, dass die Werte linear ansteigen. Mit Hilfe der Werte
des ersten Elements
A[1] und des letzten Elements A[n] wird linear interpoliert,
welchen Index der gesucht Wert haben sollte.
31
Die rekursive Version:
INTSUCH(von,bis,x)
1: IF A[von] < A[bis]
THEN
j
k
x−A[von]
2:
t = von + (bis − von) · A[bis]−A[von]
3:
IF x=A[t] THEN RETURN t
4:
ELSE IF x<A[t] THEN
5:
RETURN INTSUCH(von,t-1,x)
6:
ELSE
7:
RETURN INTSUCH (t+1,bis,x)
8: ELSE IF x=A[von] THEN RETURN von
9: ELSE RETURN -1
Die erwartete Suchzeit ist extrem gut:
Zum Beispiel bei
5 !!
232 ≈ 4.3 · 109
O(log(log n))
Werten benötigt dieser Algorithmus maximal
Schritte, wenn man eine vernünftige Verteilung annehmen kann.
worst case
A[k] = k!.
Der
wäre eine extrem stark ansteigende, nichtlineare Verteilung: z.B.:
Die Laufzeit beträgt dann
Θ(n).
10.2.3 Fastsearch
Idee: Man könnte die beiden Vorteile aus Binärsuche und Interpolationssuche
kombinieren. Der neue Algorithmus hat dann
O(log n)
O(log log n) im mittleren Fall und
im schlechtesten Fall.
Die rekursive Version:
FASTSEARCH (von,bis,x)
1: IF von≤bis THEN
2:
mB = b(von +j bis)/2c
k
x−A[von]
3:
mI = von + (bis − von) · A[bis]−A[von]
4:
IF mB >mI THEN VERTAUSCHE (mB ,mI )
5:
IF x = A[mB ] THEN RETURN mB
6:
ELSE IF x = A[mI ] THEN RETURN mI
7:
ELSE IF x<A[mB ] THEN RETURN FASTSEARCH(von,mB -1,x)
8:
ELSE IF x<A[mI ] THEN RETURN FASTSEARCH(mB +1,mI -1,x)
9:
ELSE RETURN FASTSEARCH(mI +1,bis,x)
8: RETURN = -1
32
10.2.4 Zusammenfassung
Laufzeitverhalten der Suchverfahren in sortierten Feldern:
Binärsuche
Interpolationssuche
Fastsearch
Beispiel mit
109
Mittlere Fall
Schlechtester Fall
O(log n)
O(log log n)
O(log log n)
O(log n)
O(n)
O(log n)
14
Werte - Anzahl der Vergleiche:
Mittlere Fall
Binärsuche
Interpolationssuche
Fastsearch
14 Es
Schlechtester Fall
30
30
5
1.000.000.000
10
60
wird der Logarithmus zur Basis 2 zur Berechnung verwendet. Die Werte sind gerundet.
33
11
11.1
Binärbäume
Grundlagen - Denitionen
Denition:
Ein
Baum
ist eine Menge, die durch eine sog. Nachfolgerrelation
strukturiert ist.
In einem Baum gilt:
1
w
ohne VATER(w ), das ist die Wurzel
(I)
∃
(II)
∀ Knoten k 6= w ∃ Knotenfolge k0 , k1 , . . . , kt mit k0 = k , kt = w und
ki =VATER(ki−1 ) für i = 1, 2, ..., t (Ast zwischen k und w, Länge t)
Knoten
1
Ein Binärbaum ist ein spezieller Baum, in dem jeder Knoten maximal zwei
Söhne besitzt.
11.2
Nötige Funktionen
Ausgehend von einem Pointer
k auf einen beliebigen Knoten sind folgende FunkB implementiert werden kann:
tionen nötig, damit eine Binärbaum
•
LINKS(k): zeigt auf den linken Sohn des
•
RECHTS(k): zeigt auf den rechten Sohn des
•
VATER(k): zeigt auf den Vaterknoten des
•
WERT(k): liefert den Wert des Knotens
•
WURZEL(B): zeigt auf die Wurzel des Baumes
k -ten
k
Knotens
k -ten
k -ten
Knotens
Knotens
zurück
Anmerkung: Falls keine Sohnknoten oder Vaterknoten existiert wird
geliefert.
34
nil zurück-
11.3
Reihenfolge der Knoten
Die Knoten können in verschiedener Art und Weise eingefügt bzw. ausgelesen
werden.
11.3.1 Symmetrische Reihenfolge (SR)
Die Knoten werden in folgender Reihenfolge ausgelesen: Linker Teilbaum rekursiv in SR, Wurzel, rechter Teilbaum rekursiv in SR. Arithmetische Ausdrücke
werden als
SR(k)
1: IF
2:
3:
4:
Inx -Notation ausgelesen.
k6=nil THEN
SR(LINKS(k))
SCHREIBE k
SR (RECHTS(k))
11.3.2 Haupreihenfolge (HR)
Analog die Auslesefolge: Wurzel, linker Teilbaum rekursiv in HR und rechter
Teilbaum rekursiv in HR.
11.3.3 Nebenreihenfolge (NR)
Analog die Auslesefolge:
linker Teilbaum rekursiv in NR, rechter Teilbaum
rekursiv in NR und die Wurzel.
x -Notation ausgelesen.
11.4
Arithmetische Ausdrücke werden als
Post-
Sortierte Binärbäume
Im weiteren Abschnitt wird die SR verwendet.
Der Binärbaum ist eine sehr
mächtige Datenstruktur, mit der viele Funktionen eektive implementiert wer-
SUCHEN, EINFÜGEN, LÖSCHEN, MINIMUM, MAXIMUM,
VORGÄNGER, NACHFOLGER.
den können:
Alle Funktionen können in
O(Höhe
des Baumes) implementiert werden.
Vorteil: Es kann das Wörterbuchproblem dynamisch gelöst werden
Nachteil: Laufzeiten bis
Θ(n)
11.4.1 Suchen in Binärbäumen
Suche den Wert
SUCHE
w
im Binärbaum
B.
(b,Wurzel) gestartet.
35
Der rekursive Algorithmus wird mit
SUCHE(w,k)
1: IF k=nil OR w=WERT(k)THEN
2:
RETURN k
3: ELSE
4:
IF w<WERT(k) THEN
5:
SUCHE(w,LINKS(k))
6:
ELSE
7:
SUCHE(w,RECHTS(k))
11.4.2 Finden des Maximus in einen Binärbaum
Liefert den gröÿten Wert des Binärbaumes zurück. Der Algorithmus wird mit
Baum_Maximum(Wurzel(B))
aufgerufen.
BAUM_MAXIMUM(k)
1: WHILE RECHTS(k)6=nil
2:
k=RECHTS(k)
3: RETURN WERT(k)
11.4.3 Finden des Minimums in einen Binärbaum
Liefert den kleinsten Wert des Binärbaumes zurück. Der Algorithmus wird mit
Baum_Minimum(Wurzel(B))
aufgerufen.
BAUM_MINIMUM(k)
1: WHILE LINKS(k)6=nil
2:
k=LINKS(k)
3: RETURN WERT(k)
11.4.4 Finden des Vorgängers eines Knotens
Es wird der nächst kleinere Wert zum
WERT(k)
VORGÄNGER(k)
1: IF LINKS(k)6=nil
2:
RETURN BAUM_MAXIMUM(LINKS(k))
3: y=VATER(k)
4: WHILE y6=nil AND k=LINKS(y)
5:
k=y
6:
y=VATER(y)
7: RETURN(WERT(y))
36
gefunden.
11.4.5 Finden des Nachfolger eines Knotens
Es wird der nächst höhere Wert zum
WERT(k)
gefunden.
NACHFOLGER(k)
1: IF RECHTS(k)6=nil
2:
RETURN BAUM_MINIMUM(RECHTS(k))
3: y=VATER(k)
4: WHILE y6=nil AND k=RECHTS(y)
5:
k=y
6:
y=VATER(y)
7: RETURN(WERT(y))
11.4.6 Einfügen in den Binärbaum
In den Binärbaum
B
wird der Wert
w
eingefügt.
EINFÜGEN(B,w)
1: y=nil
2: x=WURZEL(B)
3: WHILE x6=nil
4:
DO y = x
5:
IF w<WERT(x) THEN
6:
x=LINKS(x)
7:
ELSE x=RECHTS(x)
8: VATER[w]=y
9: IF y=nil
10:
THEN WURZEL(B)=w
11: ELSE IF w<WERT(y)
12:
THEN LINKS(y)=w
13: ELSE RECHTS(y)=w
11.4.7 Löschen eines Werts
Der Knoten
k
soll gelöscht werden.
Dabei müssen drei Fälle unterschieden
werden, da die Sortierung in SR erhalten bleiben muss:
1.
k
ist ein Blatt: einfach entfernen
2.
k
hat nur einen Sohn: Den Sohn von
k
3.
k
hat zwei Söhne: Finde den Knoten
k0
37
an den Vater von
k
anhängen
mit dem nächst gröÿten Wert
LÖSCHEN(k)
1: IF LINKS(k)=nil OR RECHTS(k)=nil
2:
THEN y=k
3:
ELSE y = NACHFOLGER(k)
4: IF LINKS(y)6=nil
5:
THEN x=LINKS(y)
6:
ELSE x=RECHTS(y)
7: IF x6=nil
8:
THEN VATER(x)=VATER(y)
9: IF VATER(y)=nil
10:
THEN WURZEL(B)=x
11:
ELSE IF y = LINKS(VATER(y))
12:
THEN LINKS(VATER(y))=x
13:
ELSE RIGHT(VATER(y))=x
14: IF y6=k
15:
THEN WERT(k)=WERT(y)
16:
IF ('andere Felder vorhanden, mitkopieren')
17: RETURN y
38
12
(2-4)-Bäume
(2-4)-Bäume sind durch folgende Eigenschaften deniert:
1. Alle Äste sind gleich lang
2. Die Ordnung (maximale Anzahl der Söhne eines Knotens) ist gleich 4
3. Innere Knoten haben
≥
2 Söhne
4. Die Blätter enhalten von links nach rechts die Werte aufsteigend sortiert
5. Jeder innere Knoten mit
tionen
x1 , ..., xt−1
wobei
t Söhnen (2 ≤ t ≤ 4) speichert t − 1 Hilfsinformaxi = gröÿter Wert im Teilbaum des i-ten Sohnes
von links
Dadurch kann eine logarithmische Höhe garantiert werden (12.2).
Beispiel eines (2,4)-Baums:
Weiters wird die Ordnung
α(k)
eines Knotens
k
als die Anzahl der Söhne
deniert.
12.1
Implementierbare Funktionen
Die Funktionen SUCHEN, EINFÜGEN und ENTFERNEN entsprechen dem
Wörterbuchproblem.
Man kann mithilfe von (2,4)-Bäumen das Wörterbuch-
problem bestehende aus
n Elementen in O(log n) pro Funktion und S(n) = O(n)
Speicher lösen.
12.1.1 Suchen in (2-4)-Bäumen
Mit Hilfe der Information in den inneren Knoten kann von der Wurzel ausgehend
nach unten der entsprechende Wert gesucht werden. Pro Knoten benötigt der
O(1). Die gesamte
Tsuchen (n) = O(Höhe)
Suchprozess eine konstante Zeit
der Höhe des Baumes ab:
39
Laufzeit hängt direkt von
12.1.2 Einfügen in (2-4)-Bäumen
Zuerst wird der richtige Knoten gesucht und dort das neue Element eingefügt.
Dabei müssen zwei Fälle unterschieden werden:
1. Fall:
α(k) ≤ 4
nach dem Einfügen: Ergebnis ist wieder ein (2-4)-Baum
α(k) = 5
2. Fall:
nach dem Einfügen: Es liegt
SPALT -Operation
muss eine sog.
kein
(2,4)-Baum vor.
Es
durchgeführt werden, um wieder einen
(2,4)-Baum zu erhalten.
SPALTEN: Der Knoten
k.
von
k erhält einen Bruderknoten k 0
unmittelbar rechts
Dabei werden die zwei rechtesten (gröÿten) Söhne von
k
auf
k0
umgehängt.
Bemerkung: Dabei muss die
führt werden (siehe
v, v 0 ),
SPALT -Operation
auch potentiell öfters durchge-
maximal aber nur logarithmisch oft.
12.1.3 Entfernen in (2-4)-Bäumen
Auch hier wird zuerst der entsprechende Knoten gesucht. Nach dem Entfernen
muss man wieder zwei Fälle unterscheiden:
1. Fall:
α(k) ≥ 2
nach dem Entfernen: Ergebnis ist wieder ein (2-4)-Baum.
2. Fall:
α(k) = 1
nach dem Entfernen: Es liegt nun
vor.
STEHL-
Es muss entweder eine
oder eine
kein (2,4)-Baum mehr
VERSCHMELZUNGS -
Operation durchgeführt werden, um wieder einen (2,4)-Baum zu erhalten.
Sei
k0
ein direkter Bruder von
k
(a)
α(k 0 ) ≥ 3,
dann muss man einen Sohn von
(b)
α(k 0 ) = 2,
dann muss
k
mit
k 0 STEHLEN
k 0 VERSCHMOLZEN
40
werden
Bemerkung: Auch hier muss die
VERSCHMELZUNGS -Operation auch poten-
tiell öfters durchgeführt werden, maximal aber nur logarithmisch oft.
12.2
Beweis der logarithmischen Höhe
Alle erwähnten Funktionen können im schlimmsten Fall mit
führt werden.
O(Höhe)
durchge-
Die Datenstruktur (2-4)-Bäume garantiert eine logarithmische
Höhe (d.h. die Höhe hängt logarithmisch von der Datenmenge
n
ab).
Beweis:
2h ≤
≤ 4h = 22h
n
h ≤ log2 n
Also kann man die Höhe
h
≤ 2h
abschätzen mit
log2 n
≤ h ≤ log2 n
2
was der Denition der
12.3
Θ-Notation
entspricht:
h = Θ (log n)
Anwendung: Mischbare Warteschlangen
Eine Anwendung der (2-4)-Bäume sind sogenannte mischbare Warteschlangen,
Halde ),
EINFÜGEN(S,x), MAXIMUM(S) und ENTFERNE_MAX(S)
auch noch die Funktion MISCHE(S,S') implementiert.
die im Gegensatz zu den Warteschlangen mit Prioritäten (siehe Kapitel
zu den drei Funktionen
Die Struktur des (2-4)-Baums für mischbare Warteschlangen ist die folgende:
Die Blätter speichern
S
in beliebiger Reihenfolge und jeder innere Knoten spe-
ichert das Maximum seines Teilbaums, plus einen Zeiger, der auf das entsprechende
Maximum-Blatt zeigt.
41
Alle 4 Funktionen EINFÜGEN, MAXIMUM, ENTFERNE_MAX und MISCHEN können damit in
12.4
O(log n)
15 .
implementiert werden
Sortieren mit (2-4)-Bäumen
Sortieren mit (2-4)-Bäumen besitzt den Vorteil sowohl
auch
adaptiv zu sein.
worst-case optimal
als
Die inneren Knoten des (2-4)-Baums besitzen dabei nur die
Information des Maximums des jeweiligen Teilbaums. Die Idee beruht darauf
in einen anfangs leeren (2-4)-Baum die Werte einzufügen.
Folgende Schritte
werden durchgeführt (bottom-up):
•
Man startet mit dem Blatt ganz links (das aktuelle Minimum)
•
Man läuft bis zur Wurzel
der
•
w0
des Teilbaums
T 0 (w0
x
und man macht
ist der erste Knoten,
> ai )
Man läuft von
w0
zu Blatt
ai
wählt immer den ersten Teilbaum von links mit
Bemerkung: Es sind potentiell logarithmisch viele
zum linken Bruder (man
w(T B) > ai )
SPALT -Operationen durchzuführen.
Wie aber gezeigt werden kann, amortisieren sich diese im Laufe des Sortiervorgangs.
12.4.1 Analyse des Sortierens mit (2,4)-Bäumen
Dazu benötigt man ein Maÿ für die Unsortierheit einer Folge ( 'Die Anzahl der
Fehlstände), welches folgendermaÿen deniert ist:
Sei
ai
a1 , a2 , ..., an
eine (unsortierte) Zahlenfolge.
, d.h. Anzahl der Zahlen die rechts von
15 Eine
O(n)
Implementierung mit der Datenstruktur
möglich machen.
42
ai
fi
= Anzahl der Fehlstände für
stehen und aber kleiner als
Halde
ai
sind.
würde das Mischen nur teuer mit
fi = |{aj | j > i , aj < ai }|
Die Summe aller Fehlstände
F
ist dann ein Maÿ der Unsortiertheit der Zahlen-
folge:
F =
n
X
fi
i=1
Die Laufzeit
T (n)
beim Einfügen des
beträgt mit
i-ten
si = Anzahl
ai :
der nötigen
SPALT -Operationen
Elements
T (n) = O
n
X
!
(log fi + si )
i=1
Mit der obigen Denition, der Abschätzung aus der Amoritisierungsanalyse
Pn
n
3
i=1 si ≤ 2 n und der Abschätzung
· log Fn erhält man für die Laufzeit:
Pn
i=1
log fi = log Πni=1 fi ≤ log
F
T (n) = O n · log + n
n
43
F n
n
=
13
Optimales Kodieren
Es soll ein optimaler Kodierer
(z.B. Text
T)
C(T ) entworfen werden, welcher eine Information
mit möglichst geringer Bitanzahl eindeutig überträgt.
Die Anforderungen an den optimalen Kodierer
•
sollte schnell kodieren
•
sollte eindeutig dekodieren (präx-frei)
•
minimale Kodelänge
13.1
C(T )
sind:
Nötige Denitionen
Als Beispiel soll der Text='Susanne' kodiert werden.
Folgende Denitionen
werden benötigt:
• T =
'SUSANNE' ist der zu kodierende Text (im allg. eine Information,
welche kodiert werden sollte)
• Z = {S, U, A, N, E}
• |Z| = 5
das Alphabet
ist die Gröÿe des Alphabets
• fi
ist die Auftrittsfrequenz. z.B.:
• pi
ist die Auftrittswahrscheinlichkeit - z.B.:
•
Die Entropie
der Text
T
fS = 2, fU = 1
pS =
2
7 , oder
pU =
1
7
H(T ) (Pseudoeinheit 'bit') ist die eigentlich Information, die
pro Zeichen enthält:
H(T ) = −
|Z|
X
pj · log2 pj
j=1
Wenn man den Text 'SUSANNE' naiv kodiert, dann benötigt man 3 Bits pro
Buchstabe. Für den ganzen Text benötigt man
3 · 7 = 21 Bits. Die Entropie
2.24 Bits pro Buchstabe,
(der eigentliche Informationsgehalt) beträgt aber nur
was auch die theoretische untere Grenze darstellt.
44
Idee: Zeichen die häuger vorkommen, werden mit weniger Bits belegt.
Ein Problem, dass dabei auftritt, ist das Präx-Problem.
Damit der Kode
eindeutig interpretierbar bleibt, darf kein Buchstabe kodiert ein Präx eines
anderen Buchstaben sein. Zum Beispiel wenn
100
C(x1 ) = 10
für 'S' und
für 'A' gegeben wäre, dann wäre das Kodestück ...100...
dekodierbar!
13.2
16
C(x2 ) =
nicht eindeutig
Darstellung des Kodierers
Mit der Darstellung des Kodieres (und gleichzeitig des Dekodierers) als Binärbaum kann man präx-Freiheit garantieren. Die Datenstruktur hat dabei folgende Eigenschaften:
•
Binärbaum (sog. Kodebaum)
•
Werte sind blattorientiert (daher präxfrei)
•
Die Wortlänge entspricht der Astlänge li
Eine Methode einen solchen Kodebaum zu generieren ist die Methode nach
Human.
13.3
Human
Die Methode nach Human liefert garantiert einen optimalen Kodebaum. Mit
folgender Vorgangsweise wird der Kodebaum konstruiert:
•
Erstelle einen 'Wald' mit jeweils einen Baum pro Zeichen.
•
Suche die beiden Bäume mit den kleinsten Wahrscheinlichkeiten und verbinde
sie zu einen neuen Baum, welche nun die Summe der Wahrscheinlichkeiten
der Unterbäume besitzt.
•
16 In
Wiederhole den Vorgang, bis nur noch ein Baum übrig ist.
der Literatur wird oft der Begri 'prex codes' verwendet. Damit sind aber genau
präx-freie Kodes gemeint sind.
45
13.3.1 Implementierung
Der Human-Algorithmus kann sehr eektiv mit einer Warteschlange
Q mit Pri-
oritäten implementiert werden, und zwar mit der Datenstruktur Halde. Dabei
wird inverse geordnet - d.h. das Minimum liegt an der Wurzel der Halde.
Dem Algorithmus wird das Alphabet
fi 's
Z
mit den zugehörigen Auftrittsfrequenzen
übergeben .
HUFFMAN (Z,f)
1: n=|Z|
2: INIT_Q (Z)
3: FOR i=1 TO (n-1)
4:
z=NEUER_KNOTEN
5:
LINKS(z) = MINIMUM(Q), ENTFERNE_MIN
6:
RECHTS(z)= MINIMUM(Q), ENTFERNE_MIN
7:
f(z) = f(x)+f(y)
8:
EINFÜGEN(Q,z)
9: RETURN MINIMUM(Q)
Analyse: Alle Operationen der Warteschlange mit Prioritäten (mit einer Halde
implementiert) können in
nerhalb der Schleife
n-mal
O(log n)
durchgeführt werden. Dabei werden sie in-
aufgerufen, d.h.
46
T (n) = O(n · log n).
14
Amortisierte Kosten bei (2,4)-Bäumen
Mithilfe der Amortisierungsanalyse ermittelt man die nötige durchschnittliche
Zeit über alle Operationen im schlimmsten Fall.
Damit kann gezeigt wer-
den, dass man auch mit z.B. relativ teuren Umstrukturierungsoperationen (hier
Spalten, Stehlen und Verschmelzen) die Gesamtlaufzeit verbessern kann, wenn
die übrigen Funktionen (Einfügen, Entfernen, Suchen) dank dieser Umstrukturierungen weniger Zeit benötigen.
14.1
Denitionen
Orientiert am Begri Amortisierung deniert man eine
und entsprechend ein Konto
Die Balance
b
b(T)
Balance b(k) für Knoten
für den gesamten Baum
17 .
k ist folgendermaÿen deniert:


−1
1








 0
 2
1
3
b(k) =
α(k) =




0
4






−1
5
für einen Knoten
Der Kontostand eines Baums
T
ist deniert als die Summe der Balancen aller
inneren Knoten:
b(T ) =
X
b(k)
18 :
Folgende Variablen werden im Lauf der Analyse verwendet
i
Anzahl der Einfügeoperationen
j
Anzahl der Löschoperationen
m
Anzahl aller Operationen: m=i+j
S
Anzahl der Spaltungen
V
Anzahl der Verschmelzungen
D
Anzahl der Stehlvorgänge
Satz (1):
D≤j
Beweis: Stehloperationen können nur bei Löschvorgängen auftreten und dann
höchsten einmal.
Satz (2):
S+V ≤m+
i−j
2
17 Zur Dierenzierung zu den Binärbäumen wird hier T als Bezeichnung für den (2,4)-Baum
verwendet.
18 In der Analyse wird SUCHEN nicht berücksichtigt, da es keine Strukturänderung des
Baums zur Folge hat (keine Kontostandsänderung).
47
Der 2.Satz wird mithilfe des Kontostandes und den Beobachtungen 1-4 bewiesen
(siehe weiter unten).
Falls Satz(1) und Satz(2) richtig sind, dann kann man zeigen, das alle Spalt-,
Verschmelz- und Stehloperationen zusammen nur linear mit den Einfüge- und
Löschoperationen (m
S+V +D ≤m+
= j + i)
anwachsen.
i−j
2i + 2j + i − j + 2j
3i + 3j
3
+j =
=
= m = O(m)
2
2
2
2
14.1.1 minimaler, maximaler Kontostand b(T )
Beobachtung 1: Ein (2,4)-Baum
T
mit
n
Blätter ist stets begrenzt in seinem
Kontostand durch:
0 ≤ b(T ) ≤
n
2
14.1.2 Einfügen, Entfernen
Beobachtung 2: Sei
T 0 aus
einem (2,4)-Baum
T
durch EINFÜGEN oder ENT-
FERNEN eines Blattes enstanden, dann gilt:
b(T 0 ) ≥ b(T ) − 1
14.1.3 Spalten
Beobachtung 3: Sei
T 0 aus einem Baum T
durch SPALTEN enstanden, dann gilt:
b(T 0 ) ≥ b(T ) + 1
14.1.4 Stehlen und Verschmelzen
Beobachtung 4a: Sei
T 0 aus
T
einem Baum
durch STEHLEN enstanden, dann
gilt:
b(T 0 ) ≥ b(T )
Beobachtung 4b: Sei
T 0 aus einem Baum T
durch VERSCHMELZEN enstanden,
dann gilt:
b(T 0 ) ≥ b(T ) + 1
14.2
Abrechnung
Man nimmt an, dass ingesamt
m=i+j
Operationen auf einen anfangs leeren
19 . Der Anfangskontostand ist b(T )
0
(2,4)-Baum ausgeführt werden
der Endkontostand maximal
Abbuchungen
b(Tm ) =
m
2
=
= 0, während
i−j
(Beobachtung 1) sein kann.
2
(Kontostand erniedrigt sich) geschehen nur durch ENTFER-
NEN oder EINFÜGEN von Blättern - (Beobachtung 2
19 Es
→≤ m).
wird vorausgesetzt, dass mehr Elemente eingefügt als entfernt werden i > j .
48
Einzahlungen (Kontostand erhöht sich) geschehen nur durch SPALTEN (Beobachtung 3→≥
1)
, VERSCHMELZEN (Beobachtung 4b
(Beobachtung 4a
→≥ 1)
oder STEHLEN
→≥ 0).
Die Kontoabrechnung schaut dann folgendermaÿen aus:
Anfangszustand - Abbuchungen + Einzahlungen = Endzustand
und damit erhält man den Beweis zu Satz (2)
0 − m + (S + V ) ≤
49
i−j
2