Hilfsunterlagen zu Datenstrukturen und Algorithmen 708.031

Hilfsunterlagen zu
Datenstrukturen und Algorithmen
708.031
Helmut Hauser, Feb.2008
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
Pseudocodes ausgedrückt
werden. Ein Pseudocode ist eine an höhere Programmiersprachen angelehnte Formulierung. Der vorgeschlagene Algorithmus wird in der Fachliteratur
Insertion-Sort (Sortieren durch Einfügen ) genannt.
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
T
von der Inputgröÿe
der zu sortierenden Zahlen). Im obigen Zahlenbeispiel ist
n
(Anzahl
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 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 deshalb
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
wird geschaut, ob der Index
wird
i
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
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
(best, worst and averaged case ).
unterscheiden: der
und der
durchschnittliche Fall
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
Pn
n·(n+1)
1
1
i
Mit
)
=
erhält man wieder eine
(
i=2 (i) = − 2 +
i=2 2
2
4
Abhängigkeit der Laufzeit von der Inputgröÿe.
Hälfte der Elemente in
2 Die
≈
i
2.
quadratische
Pn
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 un-
3
tereinander 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. Es lässt sich aber jeder Logarithmus mit einer beliebigen Basis
b
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. Der Zugri
auf das
i-te
Element erfolgt in konstanter Zeit:
A[i]
in
angegeben, nehmen wir hier in der Vorlesung die Gröÿe
O(1). Falls nicht anders
n des Feldes als gegeben
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. Es existieren die Funktionen
NACH(p), VOR(p) und WERT(p) um auf das nachfolgende, das vorher-
gehende 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. rech-
ten 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: Die Rekursiongleichung dazu lautet T (n) ≤ O(1) + T ( n2 ). Die Lösung
ist
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
O(n · log n)
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
.
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): Speichere das lineare Feld A so um, dass alle Elemente
in
A[1..k]
7.1
kleiner als alle Elemente in
A[k + 1..n]
sind.
Partition
Das Teilfeld ausgehend vom linken (unteren) Index
Index
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 arbei-
8
tet , 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
25
HEAPSORT
sind worst-case optimal.
9
Gestreute Speicherung (Hashing)
Die Datenstrukur Hashtabelle wird zur Lösung des Wörterbuchproblems verwendet. Das Wörterbuchproblem ist durch die drei Funktionen
chen
und
9.1
Lösche n deniert.
Einfügen, Su-
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
T (n) = O(1)).
Suchen: Der Index j wird mithilfe der Hashfunktion aus dem Wert w des
•
Schlüssels berechnet. Die lokale Liste wird nach dem Wert durchsucht. Die
T (n)
O(lj ).
Laufzeit
liste
ist dabei abhängig von der Länge lj der lokalen Überläufer-
Löschen: 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. Diese Länge ist abhängig von der Anzahl
n
der eingefügten Werte und der Gröÿe
Sie wird durch den Belegungsfaktor
α
m
der Hashtabelle.
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,
i > 0)
einen freien Platz zu nden. Folgende drei Methoden werden dazu verwendet,
wobei jeweils eine erweiterte Hashfunktion
12 i
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
A[i] für 1 ≤ i ≤ n ist, und wir
= 21i ), dann verläuft die Suche
erhält man O(n).
die Zugriswahrscheinlichkeit auf
eine exponentielle Verteilung vorliegen haben (pi
in
O(1).
10.2
Bei einer Gleichverteilung (pi
=
1
n−1 )
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
k
j
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
232 ≈ 4.3 · 109
O(log(log n))
Werten benötigt dieser Algorithmus maximal 5
worst
case wäre eine extrem stark ansteigende, nichtlineare Verteilung: z.B.: A[k] = k!.
!! Schritte, wenn man eine vernünftige Verteilung annehmen kann. Der
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)
im schlechtesten Fall.
Die rekursive Version:
32
O(log log n) im mittleren Fall und
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)
10: RETURN -1
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. Arithmetische Ausdrücke werden als
Postx -
Notation ausgelesen.
11.4
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
CHE
w
im Binärbaum
B.
Der rekursive Algorithmus wird mit
(b,Wurzel) gestartet.
35
SU-
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 wer-
den, 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 de-
niert.
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örterbuchproblem 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
2. Fall:
α(k) = 5
nach dem Einfügen: Es liegt
eine sog.
kein (2,4)-Baum vor. Es muss
SPALT -Operation 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
2. Fall:
α(k) = 1
nach dem Entfernen: Ergebnis ist wieder ein (2-4)-Baum.
nach dem Entfernen: Es liegt nun
vor. Es muss entweder eine
STEHL-
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
O(Höhe)
durch-
geführt werden. 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 ), zu den drei Funktionen 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
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 speichert
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
worst-case optimal
als
zu sein. 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
durch-
zufü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 (der
2.24 Bits pro Buchstabe, was
eigentliche Informationsgehalt) beträgt aber nur
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
C(x1 ) = 10
für 'S' und
C(x2 ) = 100
für 'A' gegeben wäre, dann wäre das Kodestück ...100... nicht eindeutig deko-
16
dierbar!
13.2
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
Prioritä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
innerhalb der Schleife
n-mal
O(log n)
durchgeführt werden. Dabei werden sie
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 werden, 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
(2,4)-Baum ausgeführt werden
der Endkontostand maximal
Abbuchungen
m=i+j
Operationen auf einen anfangs leeren
19 . Der Anfangskontostand ist b(T
b(Tm ) =
m
2
=
0 ) = 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
LEN (Beobachtung 4a
→≥ 1)
oder STEH-
→≥ 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