Sie sind auf Seite 1von 34

Zusammenfassung Algorithmen und Datenstrukturen

Definition Algorithmus
- präzise Verarbeitungsvorschrift für mechanische und elektronische Geräte

Eigenschaften Algorithmus
- löst Klasse von Problemen, Auswahl über Parameter
- determiniert (gleiche Vorbedingung = gleiches Ergebnis)
- statische Finitheit (endliche Länge)
- dynamische Finitheit (endlicher Speicherplatz)
- terminiert (nach endlichen Schritten Ergebnis)
- deterministisch (nur eine Möglichkeit der Ausführung)

Konkatenation
- zwei Strings zusammengeschrieben
- z. B. ‚DAS’ / ‚ENDE’ => ‚DASENDE’

Beispiele von Datenstrukturen Operationen auf Datenstrukturen


- lineare Liste (eindimensionales Feld(Array)) - Suchen (Durchsuchen)
- Array (Feld) - Einfügen
- verkettete Liste - Löschen
- Baum (Tree) - Sortieren
- Stapel (Stack) (LIFO
LIFO = last in first out)
- Schlange (queue) (FIFO
FIFO = first in first out)
- Graph
Funktionsklassen
nn > 10n > 3n > en > n10 > n3 > n2logn > n2 > 3n > n > √n > ∛n > log2n > lnn > log3n > lgn

(Größter gemeinsamer Teiler)


Teiler)
alter Beispiel: p = 44 , q = 12
p := 44 - 12 = 32
while q ≠ 0
p := 32 – 12 = 20
if p > q then p := p – q
p := 20 – 12 = 8
else q := q – p
q := 12 – 8 = 4
return p
p := 8 – 4 = 4
q := 4 – 4 = 0
return 4

Beispiel: p = 44 , q = 12
neuer
r := 44 % 12 = 8
while q ≠ 0 p := 12
r := p mod q q := 8
p := q r := 12 % 8 = 4
q := r p := 8
return p q := 4
r := 8 % 4 = 0
return 4
(Potenzen/Logarithmen)
Potenzen/Logarithmen)

Beispiele
Mittelwerte
Mittelwerte
es gibt zum Beispiel:
→ arithmetisches Mittel → (a+b)/2
Weitspringer springt beim ersten Mal 5,00 Meter, beim zweiten Mal 4,00 Meter.
Durchschnittliche Weite beider Sprünge?
(5+4)/2 = 4,50
→ geometrisches Mittel → (2√ab)
Bank gewährt im 1. Jahr 1%, im 2. Jahr 2 %, im 3. 3 %, 4. 4 & und im 5. %.
Wie viel Prozent durchschnittlich über die 5 Jahre?
(5√1,01*1,02*1,03*1,04*1,05) = 2,99 %
→ harmonisches Mittel → 2/((1/a)+(1/b))
Auto fährt 100km mit 150, weiter 100km mit 50km/h.
Wie war die Durchschnittsgeschwindigkeit der 200km?
ACHTUNG: unterschiedliche Zeit beider 100km-Strecken
200/((100/150)+(100/50)) = 75

Ungleichungskette arith. M. ≧ geom. M. ≧ harm. M.


wenn: n = 2 → (a+b)/2 ≧ (2√ab) ≧ 2/((1/a)+(1/b))

ISBN Prüfverfahren
wenn: ISBN = A-BCD-EFGHI-P
dann: 10*A + 9*B + 8*C + 7*D + 6*E + 5*F + 4*G + 3*H + 2*I + P ≡ 0 (mod 11)
Komplexität
... eines Algorithmus
→ Aufwand an Rechenzeit bei Realisierung eines Algorithmus
... einer Funktion
→ Komplexität des bestmöglichen Algorithmus der Menge aller Algorithmen

Ordnung des qualitativen Verlaufes:


- best case
- average case
- worst case

Berechnung Komplexität
wenn:
Ein Algorithmus mit quadratischer Komplexität c(n) = n2 benötigt für die Lösung eines
Problems mit 1.000.000 Elementen eine Rechenzeit von 2 min.
min Wie wäre die Rechenzeit
bei zehnfacher Menge der Elemente.
dann: n = Elemente
Elemente ⇒ Komplexität ≙ Rechenzeit
n ⇒ n2 ≙ m(n) min
1.000.000 ⇒ 1.000.0002 ≙ 2 min
10*1.000.000 ⇒ (10*1.000.000)2 ≙ ((100n2)/ n2)*2 = 200 min
= 100*(1.000.0002)
wenn:
... c(n) = 3n...
... 5 Elemente ...
... 1 sec...
sec
... verdreifacht...
verdreifacht
dann:
n ⇒ 3n ≙ s(n) sec
5 ⇒ 35 ≙ 1 sec
3*5 ⇒ 33*5 ≙ (315/35)*1 ≈ 60.000 sec
wenn:
... c(n) = nlog2n...
... 1024 Elemente ...
... 1 msec...
msec
... 64 x mal ...
dann:
n ⇒ nlog2n ≙ s(n) sec
1.024 ⇒ 1.024log21.024 ≙ 1 msec
= 1.024 * 10
64*1.204 ⇒ (64*1.024)log2(64*1.024) ≙ (64 * 1.024 * 16)*1 = 102 msec
= 64 * 1024 * 16 1.024 * 10
wenn:
... c(n) = kubischer Aufwand (n3)...
... 17.000 Elemente ...
... 1 min...
min
... verachtfacht...
verachtfacht
dann:
n ⇒ n3 ≙ s(n) sec
17.000 ⇒ 17.0003 ≙ 1 min
8*17.000 ⇒ (8*17.000)3 ≙ (136.0003)*1 = 512 min
= 136.0003 17.0003
wenn:
... c(n) = 3n...
... 4 Elemente ...
... 2 min...
min
... versechsfacht...
versechsfacht
dann:
n ⇒ 3n ≙ m(n) min
4 ⇒ 34 ≙ 2 min
6*4 ⇒ 36*4 ≙ (324/34)*2 = 320*2 min ≈ 13.267 Jahre
wenn:
... c(n) = n2log2n...
... 1.024 Elemente ...
... 1 sec...
sec
... 1.024 x mal größer...
größer
dann:
n ⇒ n2log2n ≙ s(n) sec
1.024 ⇒ 1.0242log21.024 ≙ 1 sec
= 1.0242*10
1.024*1.024 ⇒ 1.0244log21.0242 ≙ 1.0244*20*1 = 1.0242*2*1 sec ≈ 24 Tage
= 1.0244*20 1.0242*10

O-Notation
= Vereinfachung zur Sicht der wesentlichen Komplexität
wenn:
wenn:

dann:
Komplexität von Algorithmen
Suchalgorithmen
binäre Suche ! Vorraussetzung: Elemente sind sortiert

O(log
log2n) - best: O(log
log2n) Suchfeld wird immer
effizient →
- average: = O(log
log2n) halbiert
log2n)
- worst: O(log
sequentielle Suche
weniger O(n
n) - best: = O(1
1) Element für Element

effizient - average: O(n
n/2)
/2 verglichen
- worst: O(n
n)

Sortieralgorithmen

Quicksort
1. Element wandert
O(n
nlog2n) - best: O(n
nlog2n) (Teillisten gleich lang)
effizient → an richtige Stelle,
- average: O(n
nlog2n) (1,4nlog2n)
linke, rechte Teilliste
- worst: O(n
n2) (sortiert)

Bubblesort
Paarweise wird
weniger O(n
n2 ) - best: O(n
n) (sortiert)
→ verglichen und evt.
effizient - average: O(n
n2 )
getauscht
n2) (umgekehrt sortiert)
- worst: O(n

Mustererkennung (String Matching)

BM (Boyer-
(Boyer-Moore)
letzter Buchstabe
O(n
n/m)
/m - best: O(m
m) →
wird verglichen
- average: O(n/m
n/m)
n/m
- worst: O(n*m
n*m)
n*m
effizient
KMP (Knuth-
(Knuth-Morris-
Morris-Pratt) (Automatenalgorithmus)
O(n
n+m)
+m - best: O(m
m) erster Buchstabe

- average: O(n+m
n+m)
n+m wird verglichen
- worst: O(n+m
n+m)
n+m

naiver Algorithmus
weniger O(n
n*m)
*m - best: O(m
m) alle Buchstaben

effizient - average: O(n*m
n*m)
n*m werden verglichen
- worst: O(n*m
n*m)
n*m
Umsetzung/Herleitung
Umsetzung/Herleitung von Algorithmen
Suchalgorithmen
binäre Suche ! Vorraussetzung: Elemente sind sortiert

O(log
log2n) - best: O(log
log2n)
effizient
- average: = O(log
log2n)
log2n)
- worst: O(log
sequentielle
sequentielle Suche
weniger O(n
n) - best: = O(1
1)
effizient - average: O(n
n/2)
/2
- worst: O(n
n)
Beispiel binäre Suche O(log
log2n)
Telfonbuch
wenn:
Telfonbuch, 631 Seiten, 4 Spalten a 72 Namen, ergo ca. 180.000 Einträge
gesucht: Müller
dann:
Fragen: ≈ log2180.000 = 18 (nach oben gerundet)
Seite 1 – 315 JA
Seite 1 – 157 NEIN also 158 – 315
Seite 158 – 229 NEIN also 230 – 315
Seite 230 – 272 NEIN also 273 – 315
Seite 273 – 294 NEIN also 294 – 315
Seite 294 – 304 NEIN also 305 – 315
Seite 305 – 310 NEIN also 311 – 315
Seite 311 – 313 JA
Seite 311 – 312 JA
Seite 311 NEIN also 312
rechte oder linke Spaltenhälfte RECHTE
dritte oder vierte VIERTE
obere oder untere Hälfte OBERE also 1 – 36
oberes oder unteres Viertel OBERES also 1 – 18
oberes oder unteres Achtel OBERES also 1 – 9
oberes oder unteres 16tel UNTERES also 5 – 9
oberes oder unteres 32tel OBERES also 5 – 7
Name 6 NEIN also Name 5
Herleitung binäre Suche O(log
log2n)
n = Elemente
k = Anzahl der Teilungsschritte für die Intervallschachtelung
n ≈ 2k
k = log2n

z. B.
n = 1024 Elemente
n = 210 ≙ 10 Teilungsschritte
10 = log21024
Suchalgorithmen
binäre Suche ! Vorraussetzung: Elemente sind sortiert

O(log
log2n) - best: O(log
log2n)
effizient
log2n)
- average: = O(log
- worst: O(log
log2n)
sequentielle Suche
weniger O(n
n) - best: = O(1
1)
effizient - average: O(n
n/2)
/2
- worst: O(n
n)

Beispiel sequentielle Suche O(n


n)
Einladung
wenn:
Einladung mit 10 Leuten: Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
gesucht: Kai
dann:
Fragen ≈ n ≈ 10 (maximal)
Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
NEIN
Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
NEIN
Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
NEIN
Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
NEIN
Klaus, Hans, Petra, Sandra, Kai, Lilli, Uli, Franz, Michi, Micha
JA

Herleitung sequentielle Suche O(n


n)
1+2+3+...(n-1)+n = (n(n+1))/2 = O(n)
n+1
n+1
Sortieralgorithmen

Quicksort
O(n
nlog2n) - best: O(n
nlog2n) (Teillisten gleich lang)
effizient
nlog2n) (1,4nlog2n)
- average: O(n
- worst: O(n
n2) (sortiert)

Bubblesort
weniger n2 )
O(n - best: O(n
n) (sortiert)
effizient - average: O(n
n2 )
n2) (umgekehrt sortiert)
- worst: O(n

Beispiel Quicksort O(n


nlog2n)
Liste mit Elementen
Elementen
wenn:
unsortierte Liste mit verschiedenen Zahlen: 18, 2, 99, 47, 64, 4, 3, 19, 7
dann:
Fragen: 9log29 ≈ 30 (maximal)
18,
18 2, 99, 47, 64, 4, 3, 19, 7 für 18 richtige Stelle gesucht, von rechts
7, 2, 99,
99 47, 64, 4, 3, 19, 18 geguckt, welche Zahl kleiner und
7, 2, 18,
18 47, 64, 4, 3, 19, 99 getauscht, dann von links Zahl größer
7, 2, 3, 47,
47 64, 4, 18,
18 19, 99 usw.
7, 2, 3, 18,
18 64, 4, 47, 19, 99
7, 2, 3, 4, 64,
64 18,
18 47, 19, 99
7, 2, 3, 4, 18,
18 64, 47, 19, 99 18 an richtiger Stelle

7, 2, 3, 4 64,
64 47, 19,
19 99 linke und rechte Teilliste
4, 2, 3, 7 19, 47, 64,
64 99 7, 64 an richtiger Stelle

4, 2, 3 ∅ 19,
19 47 99 7, 19, 47, 99 an richtiger Stelle
3, 2, 4 4 an richtiger Stelle
linke und rechte Teilliste
3, 2 ∅
2, 3 3, 2 an richtiger Stelle
2, 3, 4, 7, 18, 19, 47, 64, 99 von links nach rechts
Sortieralgorithmen

Quicksort
nlog2n)
O(nlog - best: O(nl
nlog
nlog2n) (Teillisten gleich lang)
effizient
- average: O(nlog
nlog2n) (1,4nlog2n)
n2) (sortiert)
- worst: O(n

Bubblesort
weniger O(n
n2 ) - best: O(n
n) (sortiert)
effizient n2 )
- average: O(n
- worst: O(n
n2) (umgekehrt sortiert)
Beispiel Bubblesort O(n
n2 )
Liste mit Elementen
wenn:
unsortierte Liste mit verschiedenen Zahlen: 7, 2, 5, 1, 3, 10, 9
dann: Fragen: n2 = 72 = 49 (maximal)
7, 2, 5, 1, 3, 10, 9 von links nach rechts paarweise vergleichen
2, 7, 5, 1, 3, 10, 9
2, 5, 7, 1, 3, 10, 9
2, 5, 1, 7, 3, 10, 9
2, 5, 1, 3, 7, 10,
10 9
2, 5, 1, 3, 7, 10,
10 9
2, 5, 1, 3, 7, 9, 10 1. Schritt: größtes Element an letzter Stelle
2, 5, 1, 3, 7, 9
2, 5, 1, 3, 7, 9
2, 1, 5, 3, 7, 9
2, 1, 3, 5, 7, 9
2, 1, 3, 5, 7, 9 2. Schritt: zweitgrößtes Element an vorletzter Stelle
2, 1, 3, 5, 7
1, 2, 3, 5, 7
1, 2, 3, 5, 7
1, 2, 3, 5, 7 ... 3. Schritt: drittgrößtes ...
1, 2, 3, 5 ... 4. Schritt: viertgrößtes ...
1, 2, 3 ... 5. Schritt: fünftgrößtes ...
1, 2 2, 3, 5, 7, 9, 10 6. Schritt: sechstgrößtes ...
Mustererkennung (String Matching)

BM (Boyer-
(Boyer-Moore)
O(n
n/m)
/m - best: O(m
m)
- average: O(n/m
n/m)
n/m
- worst: O(n*m
n*m)
n*m
effizient
KMP (Knuth-
(Knuth-Morris-
Morris-Pratt) (Automatenalgorithmus)
O(n+m
n+m)
n+m - best: O(m
m)
- average: O(n+m
n+m)
n+m
- worst: O(n+m
n+m)
n+m

naiver Algorithmus
weniger O(n*m
n*m)
n*m - best: O(m
m)
effizient - average: O(n*m
n*m)
n*m
- worst: O(n*m
n*m)
n*m

Beispiel BM O(n
n/m)
/m
wenn:
Text: HEUTE_IST_MONTAG
Muster: MONT
dann:
HEUTE_IST_MONTAG letzter Buchstabe verglichen,
MONT wenn im Musterteil im Text, dann
MONT rutscht bis dahin
MONT
MONT
Mustererkennung (String Matching)

BM (Boyer-
(Boyer-Moore)
O(n/m
n/m)
n/m - best: O(m
m)
- average: O(n/m
n/m)
n/m
- worst: O(n*m
n*m)
n*m
effizient
KMP (Knuth-
(Knuth-Morris-
Morris-Pratt) (Automatenalgorithmus)
O(n
n+m)
+m - best: O(m
m)
- average: O(n+m
n+m)
n+m
- worst: O(n+m
n+m)
n+m

naiver Algorithmus
weniger O(n*m
n*m)
n*m - best: O(m
m)
effizient - average: O(n*m
n*m)
n*m
- worst: O(n*m
n*m)
n*m

Beispiel KMP O(n


n+m)
+m
wenn:
Text: HEUTE_IST_DIENSTAG
Muster: DIEN
dann:
HEUTE_IST_DIENSTAG erster Buchstabe verglichen, wenn
DIEN false, eins nach rechts
DIEN
DIEN
DIEN
DIEN
........
DIEN
DIEN
Mustererkennung (String Matching)

BM (Boyer-
(Boyer-Moore)
O(n/m
n/m)
n/m - best: O(m
m)
- average: O(n/m
n/m)
n/m
- worst: O(n*m
n*m)
n*m
effizient
KMP (Knuth-
(Knuth-Morris-
Morris-Pratt) (Automatenalgorithmus)
O(n+m
n+m)
n+m - best: O(m
m)
- average: O(n+m
n+m)
n+m
- worst: O(n+m
n+m)
n+m

naiver Algorithmus
weniger O(n
n*m)
*m - best: O(m
m)
effizient - average: O(n*m
n*m)
n*m
- worst: O(n*m
n*m)
n*m

Beispiel naiver Algorithmus O(n


n*m)
*m
wenn:
Text: HEUTE_IST_MITTWOCH
Muster: MITT
dann:
HEUTE_IST_MITTWOCH alle Buchstaben verglichen, wenn
MITT false, eins nach rechts
MITT
MITT
MITT
MITT
........
MITT
MITT
Zustandstabelle
Zustandstabelle/Matrix und Übergangsgraphen für Mustererkennung
wenn:
Muster: ANANAS
dann:
Zustandstabelle/Matrix
Zustandstabelle/Matrix
Mustererkennung Muster: Mustererkennung:
ANANAS
Q0 A Q0
A N S x Q1 AN Q1 A
Q2 ANA Q2 AN
Q0 Q1 Q0 Q0 Q0 Q3 ANAN Q3 ANA
Q1 Q1 Q2 Q0 Q0 Q4 ANANA Q4 ANAN
Q5 ANANAS Q5 ANANA
Q2 Q3 Q0 Q0 Q0
Muster

P6 ANANAS
Q3 Q1 Q4 Q0 Q0
Text: ANANAN
Q4 Q5 Q0 Q0 Q0
Q4: ANAN
Q5 Q1 Q4 P Q0

Übergangsgraph
Übergangsgraph
ANANAS

N, S A

A N A N A S
Q0 Q1 Q2 Q3 Q4 Q5 P

S A N

A
N, S

N, S
A, B = Operanden
Arithmetische Ausdrücke
+, - = Operantenzeichen
es gibt:
Infix-
Infix-Notation A+B Klammern, anschaulich, nicht hardwarenah
Postfix-
Postfix-Notation
Suffix-
Suffix-Notation AB+ Klammerfrei, unanschaulich, hardwarenah
umgekehrte polnische Notation (UPN)
Präfix-
Präfix-Notation
+AB Klammerfrei, unanschaulich
polnische Notation

wenn:
Infix:

dann:
Postfix-
Postfix-Notation/Suffix-
Notation/Suffix-Notation/UPN:
Notation/UPN:
ab-3↑c-2d*e-/
Präfix-
Präfix-Notation/polnische Notation
/-↑-ab3c-*2de
Baum
Wurzel
Bäume A

wenn:
Aber von hinten anfangen
B F aufzuschreiben! (NR)

C D G Kante

H Endknoten/Blätter
dann:
Hauptreihenfolge (HR): A B C D E F G H (Präfix)
Symmetrische Reihenfolge (SR): C B D A F H G (Infix)
Nebenreihenfolge (NR): C D B H G F A (Postfix)

>> m Knoten >> m-1 Kanten


Rekursionen
Rekursionen
bekannte sind:
Ackermann-
Ackermann-Funktion
n+1 m=0
A(m, n) = A(m-1, 1) m ≠ 0, n = 0
A(m-1, A(m, n-1) m ≠ 0, n ≠ 0

wenn: A(1, 3) wenn: A(1, 1)


dann: dann:
A(1, 3) = A(0, A(1, 2)) A(1, 1) = A(0, A(1, 0))
A(0, A(0, A(1, 1))) A(0, A(0, 1))
A(0, A(0, A(0, A(1, 0)))) A(0, 2)
A(0, A(0, A(0, A(0, 1)))) =3
A(0, A(0, A(0, 2)))
A(0, A(0, 3))
A(0, 4)
=5

McCarthy-
McCarthy-Funktion
mc(n) = n-10 n > 100
mc(mc(n + 11)) sonst.

wenn: mc(97) wenn: mc(110)


dann: dann:
mc(97) = mc(mc(108)) mc(110) = 100
mc(98)
mc(mc(109))
mc(99)
mc(mc(110))
mc(100)
mc(mc(111))
mc(101)
= 91
ULAM-
ULAM-Funktion
1 x=1
ULAM(n) = ULAM(n/2) x > 1, gerade
ULAM(5n+1) x > 1, ungerade

wenn: ULAM(3) wenn: ULAM(5)


dann: dann:
ULAM(3) = ULAM(16) ULAM(5) = ULAM(26)
ULAM(8) ULAM(13)
ULAM(4) ULAM(66)
ULAM(2) ULAM(33)
ULAM(1) ULAM(166)
=1 ULAM(83)
ULAM(416)
ULAM(208)
ULAM(104)
ULAM(52)
ULAM(26)

weitere sind:
Reverse-
Reverse-Funktion / = Konkatenation von Strings
REV(S, N) = S N=1
TEIL(S, N, 1) / REV(TEIL(S, 1, N-1), N-1) sonst.

dazu nötig: S = String


TEIL(S, J, L) = J = Position/Beginn des Teilstrings
L = Länge des Strings
wenn: REV(abc, 3)
dann:
REV(abc, 3) = TEIL(abc, 3, 1) / REV(TEIL(abc, 1, 2), 2)
c / REV((ab, 2), 2)
c / TEIL(ab, 2, 1) / REV(TEIL(ab, 1, 1), 1)
c /b / REV(a, 1)
c /b /a
= cba
Long-
Long-Funktion
Long(S, N) = S N=1
TEIL(S, N, 1) / TEIL(S, N, 1) / Long(TEIL(S, 1, N-1), N-1) sonst.

dazu nötig: S = String


TEIL(S, J, L) = J = Position/Beginn des Teilstrings
L = Länge des Strings
wenn: Long(abc, 3)
dann:
Long(abc, 3) = TEIL(abc, 3, 1) / TEIL(abc, 3, 1) / Long(TEIL(abc, 1, 2), 2)
c /c / Long(ab, 2)
c / c / TEIL(ab, 2, 1) / TEIL(ab, 2, 1) / Long(TEIL(ab, 1, 1), 1)
c/c/b /b / Long(a, 1)
c / c / b / b/ /a
c/c/b/b/a
= ccbba
Terminologie
Knoten
u
e Kante

v Knoten 2. Grades

Graph

e = (U, V) = e führt von u nach v

Falk’sches Schema
wenn, dann:
w x y z
w x
w 0 1 1 1
x 0 0 1 1
A= y 0 0 0 0 Senke
z y
z 0 0 0 0
A = Adjazenzmatrix 4 Knoten = A4
Quelle

oben links Kästchen: 0 1 1 1 0 1 1 1 0 1 1 1


0*0+1*0+1*0+1*0 = 0 0 0 1 1 0 0 1 1 0 0 1 1
A2=
oben rechts Kästchen: 0 0 0 0 0 0 0 0 0 0 0 0
0*1+1*1+1*0+1*0 = 1 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0
A=
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
A A2 A3 A4

0 1 2 2 0 1 1 1
0 0 1 1 0 0 1 1
B= E=
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

B = Bewertungsmatrix E = Erreichbarkeitsmatrix
Warshall
es gibt:
→ Pk[i, j] = Pk-1[i, j] ∨ (Pk-1[i, k] ∧ Pk-1[k, j]) → ob Weg vorhanden
→ Qk[i, j] = MIN(Qk-1[i, j], Qk-1[i, k] + Qk-1[k, j]) → ob Weg vorhanden und welcher kürzer

wenn:
A B
A B C D
A 0 1 1 1

C D B 0 0 0 1

A=E0= C 0 1 0 1
dann:
D 0 0 1 0

weil keine Gewichtung:


Ek[i, j] = Ek -1[i, j] ∨ (Ek -1[i, k] ∧ Ek -1[k, j]) i = Zeile, j = Spalte, k = Knoten

direkter Weg Umweg über Knoten k

0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 1 1 1
E1= E2= E3= E4=
0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 1
0 0 1 0 0 0 1 0 0 1 1 1 0 1 1 1
mit Umweg A mit Umweg A, B mit Umweg A, B, C mit Umweg A, B, C, D

E2[2, 3] = E1[2, 3] ∨ (E1[2, 2] ∧ E1[2, 3]) i = 2, j = 3, k = 2


E2[2, 3] = 0 ∨ (0∧0) = 0 ∨ 0 = 0
E3[4, 3] = E2[4, 3] ∨ (E2[4, 3] ∧ E2[3, 3])
E3[4, 3] = 1 ∨ (1∧0) = 1 ∨ 0 = 1
E4[3, 3] = E3[3, 3] ∨ (E3[3, 4] ∧ E3[4, 3])
E4[3, 3] = 0 ∨ (1∧1) = 0 ∨ 1 = 1
wenn:
A 1 B
7
4 1 A B C
2 2
A 0 7 4
C B= B 1 0 1
dann: C 2 2 0

weil Gewichtung:
Qk[i, j] = MIN(Qk-1[i, j], Qk-1[i, k] + Qk-1[k, j]) i = Zeile, j = Spalte, k = Knoten

direkter Weg Umweg über Knoten k

kürzester Weg

∞ 7 4 ∞ 7 4 8 7 4 6 5 4
Q0= 1 ∞ 1 Q1= 1 8 1 Q2= 1 8 1 Q3= 1 3 1
2 2 ∞ 2 2 6 2 2 3 2 2 3
ohne Umweg mit Umweg A mit Umweg A, B mit Umweg A, B, C

Q1[2, 2] = MIN(Q0[2, 2], Q0[2, 1] + Q0[1, 2])


Q1[2, 2] = MIN(∞, 1+7) = 8
Q2[3, 3] = MIN(Q1[3, 3], Q1[3, 2] + Q0[2, 3])
Q2[3, 3] = MIN(6, 2+1) = 3
Q3[1, 3] = MIN(Q2[1, 3], Q2[1, 3] + Q2[3, 1])
Q3[1, 3] = MIN(4, 4+2) = 4
Breitensuche/Schlange
Breitensuche/Schlange & Tiefensuche/Stapel
wenn:
A B

E C D

F G H

J K

dann: Tiefensuche/Stapel
wenn: Welche Knoten von C erreichbar?
dann: Stapel
C G D H K
C D H K G
C, D, H, H, K, G

dann: Breitensuche/Schlange
Breitensuche/Schlange
wenn: kürzester Weg
E→K
dann: Schlange
E F G C J H D K
∅ E E E F G C J

E→F→J→K
Lösungen Probeklausur 2009
Aufgabe 1
Definition:
- präzise Verarbeitungsvorschrift für mechanische und elektronische Geräte
Eigenschaften:
- löst Klasse von Problemen, Auswahl über Parameter
- determiniert (gleiche Vorbedingung = gleiches Ergebnis)
- statische Finitheit (endliche Länge)
- dynamische Finitheit (endlicher Speicherplatz)
- terminiert (nach endlichen Schritten Ergebnis)
- deterministisch (nur eine Möglichkeit der Ausführung)

Konkatenation von abcdef und 123456


abcdef123456

Aufgabe 2
a)
Suchalgorithmen:
- Binäre Suche > log2n
- Sequentielle Suche > n
Sortieralgorithmen:
- Quicksort > nlog2n
- Bubblesort > n2
b)
Binäre Suche > log2n
n = Elemente
k = Anzahl der Teilungsschritte für die Intervallschachtelung
n ≈ 2k
k = log2n
c)
best: n sortiert
average: n2
worst: n2 umgekehrt sortiert (bei jedem Vergleich eine Vertauschung)
Aufgabe 3
mit: Bubblesort (n2) und Quicksort (nlog2n)
a)
n2 n
=
nlog2n log2n
b)
4000000 ≈ 4000000
log24000000 22

= 181818 x effektiver

Aufgabe 4
a)
n2, 8000000 Elemente, 2 min, 10x
n ⇒ n2 ≙ m(n) min
8000000 ⇒ 80000002 ≙ 2 min
80000000 ⇒ 800000002 ≙ 800000002*2/80000002 = 200 min
b)
4n, 5 Elemente, 1 sec, 3x
n ⇒ 4n ≙ s(n) sec
5 ⇒ 45 ≙ 1 sec
15 ⇒ 415 ≙ 415*1/45 = 1048576 sec
c)
n2log2n, 1024 Elemente, 1 ms, 128x
n ⇒ n2log2n ≙ ms(n) ms
1024 ⇒ 10242log21024 ≙ 1 ms
131072 ⇒ 1310722log2131072 ≙ 1310722log2131072 *1 = 27852,8 ms
10242log21024
Aufgabe 5
a)
Q(3, 5) = 0
Q(27, 4) = Q(23, 4) + 1
Q(19, 4) + 2
Q(15, 4) + 3
Q(11, 4) + 4
Q(7, 4) + 5
Q(3,4) + 6
0+6
=6
b)
Die Funktion berechnet wie oft a in b passt.
Also 2008/5 = 401 (ganzzahlige Division)

Aufgabe 6

C
B

D H

E J

F K

G L

M
Aufgabe 7
LIFO = last in first out ≙ FILO = first in last out ≙ Stapel
FIFO = first in first out ≙ LILO = last in last out ≙ Schlange
Aufgabe 8

f9(n) = nn > f1(n) = 2n > f2(n) = n3 > f4(n) = n2 > f3(n) = nlog2n > f5(n) = n > f7(n) = √n >
f10(n) = ∛n > f6 (n) = log2n > f8 (n) = log10n

Aufgabe 9

Gleichheit für alle a1 = a2 = an


Aufgabe 10

Aufgabe 11

Infix
((a-b)3-c)/(2d-e)2
Postfix-
Postfix-Notation/Suffix-
Notation/Suffix-Notation/UPN:
ab-3↑c-2d*e-2↑/
Präfix-
Präfix-Notation/polnische Notation
/-↑-ab3c↑-*2de2
Aufgabe 12
mc(110) = 100
mc(90) = mc(mc(101))
mc(91)
mc(mc(102))
mc(92)
mc(mc(103))
mc(93)
mc(mc(104))
mc(104)
mc(mc(105))
mc(95)
mc(mc(106))
mc(96)
mc(mc(107))
mc(97)
mc(mc(108))
mc(98)
mc(mc(109))
mc(99)
mc(mc(110))
mc(100)
mc(mc(111))
mc(101)
= 91

Aufgabe 13
Terminiert, weil in jedem Schritt eines der Argumente verkleinert wird.
(> dritte und zweite Beziehung)
erste Beziehung > ergibt eine Zahl
Aufgabe 14
a)
Boyer-Moore (BM), Knuth-Morris-Pratt (KMP), naiver Algorithmus
b) baababaab a b
b a a b a b a a b

Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 P
b a

oder: b

a b x b

b
Q0 Q0 Q1 Q0
a
Q1 Q2 Q1 Q0
a
Q2 Q3 Q1 Q0
Q3 Q0 Q4 Q0
Q4 Q5 Q1 Q0
Q5 Q4 Q6 Q0
Q6 Q7 Q1 Q0
Q7 Q8 Q1 Q0
Q8 Q0 P Q0
c)
BM
HANS_HANSEN_IST_EIN_HANSEL
HANSEL
HANSEL
HANSEL
HANSEL
HANSEL
HANSEL
Letzter Buchstabe wird verglichen, dann nach links weiter. Wenn ungleich wird geschaut,
ob Buchstabe aus Text im Muster ist. Entweder wird bis dahin oder eins weiter rechts vom
Muster geschoben.

KMP
HANS_HANSEN_IST_EIN_HANSEL
HANSEL
HANSEL
HANSEL
..................
HANSEL
Erster Buchstabe wird verglichen, dann nach rechts weiter. Wenn ungleich wird Muster
eins nach rechts geschoben.
Aufgabe 15
60

30 70

20 55 90

35 80 95

45

40 50

Nebenreihenfolge: 20 40 50 45 35 55 30 80 95 90 70 60
Aufgabe 16
a) 3*10 + 8*9 + 9*8 + 0*7 + 2*6 + 8*5 + 9*4 + 0*3 + 3*2 + 7*1 = 275
275/11 = 25 (kein Rest) > gültig
b) 0*10 + 8*9 + 9*8 + 8*7 + 7*6 + 1*5 + 3*4 + 4*3 + 2*2 + 1*1 = 276
276/11 = 25, 09 ... (Rest) > ungültig
c) 3*10 + 5*9 + 4*8 + 0*7 + 9*6 + 7*5 + 6*4 + 7*3 + 3*2 + 6*1 = 253
253/11 = 23 (kein Rest) > gültig

Aufgabe 17 „Obergrenze – Untergrenze + 1“


A(-2 : 2; 2 : 22) → A((2+2+1) * (22-2+1)) → A(5 * 21) → 105
B(1 : 8, -5 : 5; -10 : 5) → B((8-1+1) * (5+5+1) * (5+10+1)) → B(8 * 11 * 16) → 1408