Dynamische Programmierung

(1)

1

Datenstrukturen und Algorithmen

Christian Sohler

FG Algorithmen & Komplexität

(2)

2

Dynamische Programmierung

Stand der Dinge:

• Dynamische Programmierung vermeidet

Mehrfachberechnung von Zwischenergebnissen

• Bei Rekursion einsetzbar

• Häufig einfache bottom-up Implementierung möglich

Das Subset Sum Problem:

• Algorithmus für schwieriges Problem

• Laufzeit hängt von Eingabewert ab

(3)

3

Dynamische Programmierung

Das Rucksackproblem:

• Rucksack mit begrenzter Kapazität

• Objekte mit unterschiedlichem Wert und unterschiedlicher Größe

• Wir wollen Objekte von möglichst großem Gesamtwert mitnehmen

(4)

4

Dynamische Programmierung

Beispiel:

• Rucksackgröße 6

Größe 5 2 1 3 7 4

Wert 11 5 2 8 14 9

(5)

5

Dynamische Programmierung

Beispiel:

• Objekt 1 und 3 passen und haben Gesamtwert 13

• Optimal?

Größe 5 2 1 3 7 4

Wert 11 5 2 8 14 9

(6)

6

Dynamische Programmierung

Beispiel:

• Objekt 1 und 3 passen und haben Gesamtwert 13

• Optimal?

• Objekt 2, 3 und 4 passen und haben Gesamtwert 15 !

Größe 5 2 1 3 7 4

Wert 11 5 2 8 14 9

(7)

7

Dynamische Programmierung

Das Rucksackproblem (Optimierungsversion):

• Eingabe: n Objekte {1,…,n};

Objekt i hat ganzz. pos. Größe g[i] und Wert v[i];

Rucksackkapazität W

• Ausgabe: Menge S⊆{1,…,n} mit

Σ

^{g[i] ≤} ^{W und}

maximalem Wert

Σ

^v[i]

i∈S

(8)

8

Dynamische Programmierung

Herleiten einer Rekursion:

• Sei O optimale Lösung

• Bezeichne Opt(i,w) den Wert einer optimalen Lösung aus Objekten 1 bis i bei Rucksackgröße w

Unterscheide, ob Objekt n in O ist:

• Fall 1(n nicht in O):

Opt(n,W) = Opt(n-1,W)

• Fall 2(n in O):

Opt(n,W) = v[n] + Opt(n-1,W-g[n])

(9)

9

Dynamische Programmierung

Rekursion:

• Opt(i,0)= 0 für 0≤i≤n

• Opt(0,i)= 0 für 0≤i≤W

• Wenn w<g[i] dann Opt(i,w) = Opt(i-1,w)

• Sonst,

Opt(i,w) = max{Opt(i-1,w), v[i] + Opt(i-1,w-g[i])}

(10)

10

Dynamische Programmierung

Rekursion:

• Opt(i,0)= 0 für 0≤i≤n

• Opt(0,i)= 0 für 0≤i≤W

• Sonst,

Kein Objekt passt in den

Rucksack

(11)

11

Dynamische Programmierung

Rekursion:

• Opt(i,0)= 0 für 0≤i≤n

• Opt(0,i)= 0 für 0≤i≤W

• Sonst,

Kein Objekt steht zur Auswahl

(12)

12

Dynamische Programmierung

Rekursion:

• Opt(i,0)= 0 für 0≤i≤n

• Opt(0,i)= 0 für 0≤i≤W

• Sonst,

Passt aktuelles Objekt in den

Rucksack?

(13)

13

Dynamische Programmierung

Rekursion:

• Opt(i,0)= 0 für 0≤i≤n

• Opt(0,i)= 0 für 0≤i≤W

• Sonst,

Sonst, verwende Rekursion

(14)

14

Dynamische Programmierung

Rucksack(n,W)

1. Initialisiere Feld A[0,..,n][0,..,W] mit A[0,i] =0 für alle 0≤i≤n und A[j,0]=0 für alle 0≤i≤W

2. for i ← 1 to n do 3. for j ← 1 to W do

4. Berechne A[i,j] nach Rekursion 5. return A[n,W]

(15)

15

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(16)

16

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0

0 0 0 0 0

0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

g[1]>W:

Also Opt(i,w) = Opt(i-1,w)

1

0 n

0 1 W

(17)

17

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0

0 0 0 0 0 2

0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2 Opt(i,w) = max{Opt(i-1,w),

v[i] + Opt(i-1,w-g[i])}

1

0 n

0 1 W

(18)

18

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0

0 0 0 0 0 2 2

0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(19)

19

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0

0 0 0 0 0 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(20)

20

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0 0

0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(21)

21

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0

0 0 0

0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(22)

22

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0

0 0 0 4 4

0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(23)

23

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0

0 0 0 4 4 4 4 4 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(24)

24

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0 0

0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(25)

25

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0

0 1 1

0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(26)

26

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0

0 1 1 4

0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(27)

27

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0

0 1 1 4 5 5 5 5 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(28)

28

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0 0

0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(29)

29

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0 0

0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v

0 1 W

0 1

n

5 2

n

3 4 1 1 2 3 1 2 7 3 4 7 3 3

1 2

(30)

30

Dynamische Programmierung

Größe Wert

Beispiel:

0 0 0

0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(31)

31

Dynamische Programmierung

Größe Wert

Beispiel:

0 0

0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(32)

32

Dynamische Programmierung

Größe Wert

Beispiel:

0

0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v

0 1 W

0 1

n

5 2

n

3 4 1 1 2 3 1 2 7 3 4 7 3 3

1 2

(33)

33

Dynamische Programmierung

Größe Wert

Beispiel:

0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v

0 1 W

0 1

n

5 2

n

3 4 1 1 2 3 1 2 7 3 4 7 3 3

1 2

(34)

34

Dynamische Programmierung

Optimaler Lösungswert für

W=8

Größe Wert

Beispiel:

0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

g v

0 1 W

0 1

n

5 2

n

3 4 1 1 2 3 1 2 7 3 4 7 3 3

1 2

(35)

35

Dynamische Programmierung

Beispiel:

0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 7 9 ¹⁰ ¹² ¹³ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 2 3 5 6 7 9 ¹⁰ ¹⁰ 0 1 3 4 5 7 8 8 8 0 1 1 4 5 5 5 5 6 0 0 0 4 4 4 4 4 6 0 0 0 0 0 2 2 2 2 0 0 0 0 0 0 0 0 0

Optimaler Lösungswert für

W=8

Größe Wert

g v 5 2 3 4 1 1 2 3 1 2 7 3 4 7 3 3

n

1 2

1

0 n

0 1 W

(36)

36

Dynamische Programmierung

Satz 20

Algorithmus Rucksack berechnet in Θ(nW) Zeit den Wert einer optimalen Lösung, wobei n die Anzahl der Objekte ist und W die Größe des Rucksacks.

(37)

37

Algorithmische Techniken

Teile & Herrsche:

• Aufteilen der Eingabe in mehrere Unterprobleme

• Rekursives lösen der Unterprobleme

• Zusammenfügen

Gierige Algorithmen:

• Konstruiere Lösung Schritt für Schritt

• In jedem Schritt optimiere einfaches, lokales Kriterium

Dynamische Programmierung:

• Formuliere Problem rekursiv

• Vermeide mehrfache Berechnung von Teilergebnissen

• Verwende „bottom-up“ Implementierung

(38)

38

Datenstrukturen und Algorithmen

• Einleitung

• Algorithmische Techniken

- Teile und Herrsche - Gierige Algorithmen

- Dynamische Programmierung

• Datenstrukturen

- ein grundlegendes Datenbank Problem - Datenstrukturen und Algorithmen

• Graphalgorithmen

- grundlegende Graphalgorithmen - kürzeste Wege in Graphen

- Spannbäume

• Sonstiges

- evtl. Pagerank, Clustering oder lineare Programmierung

(39)

39

Datenstrukturen und Algorithmen

• Einleitung

• Algorithmische Techniken

- Teile und Herrsche - Gierige Algorithmen

- Dynamische Programmierung

• Datenstrukturen

- ein grundlegendes Datenbank Problem - Datenstrukturen und Algorithmen

• Graphalgorithmen

- grundlegende Graphalgorithmen - kürzeste Wege in Graphen

- Spannbäume

• Sonstiges

- evtl. Pagerank, Clustering oder lineare Programmierung

(40)

40

Datenstrukturen

Ein grundlegendes Datenbank-Problem

• Speicherung von Datensätzen

Beispiel:

• Kundendaten (Name, Adresse, Wohnort, Kundennummer, offene Rechnungen, offene Bestellungen,…)

Anforderungen:

• Schneller Zugriff

• Einfügen neuer Datensätze

• Löschen bestehender Datensätze

(41)

41

Ein Datenbank-Problem

Zugriff auf Daten:

• Jedes Datum (Objekt) hat einen Schlüssel

• Eingabe des Schlüssels liefert Datensatz

• Schlüssel sind vergleichbar (es gibt totale Ordnung der Schlüssel)

Beispiel:

• Kundendaten (Name, Adresse, Kundennummer)

• Schlüssel: Name

• Totale Ordnung: Lexikographische Ordnung

(42)

42

Ein Datenbank-Problem

Zugriff auf Daten:

• Jedes Datum (Objekt) hat einen Schlüssel

• Eingabe des Schlüssels liefert Datensatz

• Schlüssel sind vergleichbar (es gibt totale Ordnung der Schlüssel)

Beispiel:

• Kundendaten (Name, Adresse, Kundennummer)

• Schlüssel: Kundennummer

• Totale Ordnung: ‚≤‘

(43)

43

Ein Datenbank-Problem

Problem:

• Gegeben sind n Objekte O ,.., O mit zugehörigen Schlüsseln s(O )

Operationen:

• Suche(x); Ausgabe O mit Schlüssel s(O) =x;

nil, falls kein Objekt mit Schlüssel x in Datenbank

• Einfügen(O); Einfügen von Objekt O in Datenbank

• Löschen(O); Löschen von Objekt O mit aus der Datenbank

1 n

i

(44)

44

Ein Datenbank-Problem

Vereinfachung:

• Schlüssel sind natürliche Zahlen

• Eingabe nur aus Schlüsseln

Analyse von Datenstrukturen

• Platzbedarf in Θ- bzw. O-Notation

• Laufzeit der Operationen in Θ- bzw. O-Notation

(45)

45

Ein Datenbank-Problem

Unsere erste Datenstruktur:

• Feld A[1,…,max]

• Integer n, 1≤ n ≤ max

• n bezeichnet Anzahl Elemente in Datenstruktur

13 7 11 6 4 nil nil nil A

n

(46)

46

Ein Datenbank-Problem

Einfügen(s)

1. if n=max then Ausgabe „Fehler: Kein Platz in Datenstruktur“ 2. else

3. n ← n+1 4. A[n] ← s

n

(47)

47

Ein Datenbank-Problem

Einfügen(s)

3. n ← n+1 4. A[n] ← s

n Einfügen(2)

(48)

48

Ein Datenbank-Problem

Einfügen(s)

3. n ← n+1 4. A[n] ← s

13 7 11 6 4 nil nil nil n

A

Einfügen(2)

(49)

49

Ein Datenbank-Problem

Einfügen(s)

3. n ← n+1 4. A[n] ← s

A

Einfügen(2)

(50)

50

Ein Datenbank-Problem

Einfügen(s)

3. n ← n+1 4. A[n] ← s

13 7 11 6 4 2 nil nil

n A

Einfügen(2)

(51)

51

Ein Datenbank-Problem

Einfügen(s)

3. n ← n+1 4. A[n] ← s

Laufzeit:

• Θ(1)

13 7 11 6 4 2 nil nil

A

n

(52)

52

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

3. if A[i] = x then return i 4. return nil

13 7 11 6 4 2 nil nil

A

n

(53)

53

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

13 7 11 6 4 2 nil nil

A

n Suche(11)

(54)

54

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

13 7 11 6 4 2 nil nil

n A

Suche(11) i

(55)

55

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

13 7 11 6 4 2 nil nil

n A

Suche(11) i

(56)

56

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

13 7 11 6 4 2 nil nil

n A

Suche(11)

i

(57)

57

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

13 7 11 6 4 2 nil nil

n A

Suche(11)

i=3

(58)

58

Ein Datenbank-Problem

Suche(x)

1. for i ← 1 to n do

Laufzeit:

• Θ(n)

13 7 11 6 4 2 nil nil

n A

(59)

59

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 11 6 4 2 nil nil

A

n

(60)

60

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 11 6 4 2 nil nil

n A

Annahme:

Wir bekommen Index i des zu

löschenden Objekts

(61)

61

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 11 6 4 2 nil nil

A

n Löschen(3)

(62)

62

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 11 6 4 2 nil nil

n A

Löschen(3)

(63)

63

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 2 6 4 2 nil nil

n A

Löschen(3)

(64)

64

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

13 7 2 6 4 nil nil nil

n A

Löschen(3)

(65)

65

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

n A

Löschen(3)

(66)

66

Ein Datenbank-Problem

Löschen(i)

1. A[i] ← A[n]

2. A[n] ← nil 3. n ← n-1

Laufzeit:

A

n

• Θ(1)

(67)

67

Ein Datenbank-Problem

Datenstruktur Feld:

• Platzbedarf Θ(max)

• Laufzeit Suche: Θ(n)

• Laufzeit Einfügen/Löschen: Θ(1)

Vorteile:

• Schnelles Einfügen und Löschen

Nachteile:

• Speicherbedarf abhängig von max (nicht vorhersagbar)

• Hohe Laufzeit für Suche

(68)

68

Ein Datenbank-Problem

Datenstruktur „sortiertes Feld“:

• Sortiertes Feld A[1,…,max]

• Integer n, 1≤ n ≤ max

• n bezeichnet Anzahl Elemente in Datenstruktur

n

(69)

69

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

n

(70)

70

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

Einfügen(10) n

(71)

71

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

A

Einfügen(10)

(72)

72

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

A

Einfügen(10)

i

(73)

73

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 13 13 nil nil

n A

Einfügen(10)

i

(74)

74

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 13 13 nil nil

n A

Einfügen(10)

i

(75)

75

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 13 13 nil nil

n A

Einfügen(10)

i

(76)

76

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 11 13 nil nil

n A

Einfügen(10)

i

(77)

77

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 11 13 nil nil

n A

Einfügen(10)

i

(78)

78

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 11 11 13 nil nil

n A

Einfügen(10)

i

(79)

79

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

4 6 7 10 11 13 nil nil

n A

Einfügen(10)

i

(80)

80

Ein Datenbank-Problem

Einfügen(s)

1. n ← n+1 2. i ← n

3. while s < A[i-1] do 4. A[i] ← A[i-1]

5. i ← i -1 6. A[i] ← s

Laufzeit:

Θ(n)

4 6 7 10 11 13 nil nil

A

n

(81)

81

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

4 6 7 10 11 13 nil nil

A

n

(82)

82

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

4 6 7 10 11 13 nil nil

n A

Parameter ist der Index des zu löschenden Objekts

(83)

83

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

4 6 7 10 11 13 nil nil

n A

i

Löschen(4)

(84)

84

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

4 6 7 11 13 13 nil nil

n A

i

Löschen(4)

(85)

85

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

A

i

Löschen(4)

(86)

86

Ein Datenbank-Problem

Löschen(i)

1. for j ← i to n-1 do 2. A[j] ← A[j+1]

3. A[n] ← nil 4. n ← n-1

Laufzeit:

Θ(n)

n

(87)

87

Ein Datenbank-Problem

Suchen(x)

• Binäre Suche

• Laufzeit O(log n)

n

(88)

88

Ein Datenbank-Problem

Datenstruktur sortiertes Feld:

• Platzbedarf Θ(max)

• Laufzeit Suche: Θ(log n)

• Laufzeit Einfügen/Löschen: Θ(n)

Vorteile:

• Schnelles Suchen

Nachteile:

• Speicherbedarf abhängig von max (nicht vorhersagbar)

• Hohe Laufzeit für Einfügen/Löschen

(89)

89

Ein Datenbank-Problem

Doppelt verkettete Listen:

• Listenelement x ist Objekt bestehend aus Schlüssel und zwei Zeigern prev und next

• next verweist auf Nachfolger von x

• prev verweist auf Vorgänger von x

• prev/next sind nil, wenn Vorgänger/Nachfolger nicht existiert

• head[L] zeigt auf das erste Element

nil 5 7 4 nil

prev next

Schlüssel head[L]

(90)

90

Ein Datenbank-Problem

Einfügen(L,x)

1. next[x] ← head[L]

2. if head[L] ≠ nil then prev[head[L]] ← x 3. head[L] ← x

4. prev[x] ← nil

nil 7 4 nil

head[L]

(91)

91

Ein Datenbank-Problem

Einfügen(L,x)

nil 7 4 nil

head[L]

5 x

(92)

92

Ein Datenbank-Problem

Einfügen(L,x)

7 4 nil

head[L]

5 x

(93)

93

Ein Datenbank-Problem

Einfügen(L,x)

7 4 nil

head[L] 5

x

(94)

94

Ein Datenbank-Problem

Einfügen(L,x)

7 4 nil

head[L] nil 5 x

(95)

95

Ein Datenbank-Problem

Einfügen(L,x)

Laufzeit:

• O(1)

7 4 nil

head[L] nil 5 x

(96)

96

Ein Datenbank-Problem

Löschen(L,x)

1. if prev[x] ≠ nil then next[prev[x]] ← next[x]

2. else head[L] ← next[x]

3. if next[x] ≠ nil then prev[next[x]] ← prev[x]

7 4 nil

nil 5

head[L]

(97)

97

Ein Datenbank-Problem

Löschen(L,x)

7 x

4 nil nil 5

head[L]

(98)

98

Ein Datenbank-Problem

Löschen(L,x)

7

4 nil

head[L] nil 5 x

(99)

99

Ein Datenbank-Problem

Löschen(L,x)

7

4 nil

head[L] nil 5

x

(100)

100

Ein Datenbank-Problem

Löschen(L,x)

Laufzeit:

• O(1)

7

4 nil nil 5

head[L]

x

(101)

101

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

2. while x≠nil and key[x]≠k do 3. x ← next[x]

4. return x

4 nil nil 5

head[L]

(102)

102

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

4 nil x

head[L] nil 5 Suche(L,4)

(103)

103

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

4 nil x

(104)

104

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

4 nil

head[L] nil 5

x

Suche(L,4)

(105)

105

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

4 nil

head[L] nil 5

x

Suche(L,4)

(106)

106

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

4 nil

head[L] nil 5

x

Suche(L,4)

(107)

107

Ein Datenbank-Problem

Suche(L,k)

1. x ← head[L]

4. return x

Laufzeit:

• O(n)

4 nil

x

(108)

108

Ein Datenbank-Problem

Datenstruktur Liste:

• Platzbedarf Θ(n)

• Laufzeit Suche: Θ(n)

• Laufzeit Einfügen/Löschen: Θ(1)

Vorteile:

• Schnelles Einfügen/Löschen

• O(n) Speicherbedarf

Nachteile:

• Hohe Laufzeit für Suche

(109)

109

Ein Datenbank-Problem

Drei grundlegende Datenstrukturen

• Feld

• sortiertes Feld

• doppelt verkettete Liste

Diskussion

• Alle drei Strukturen haben gewichtige Nachteile

• Zeiger/Referenzen helfen beim Speichermanagement

• Sortierung hilft bei Suche ist aber teuer aufrecht zu erhalten