Präsentation - Torsten Finke

Überblick 

Ankündigungen 

Algorithmen 

(Revision 183) 

Prof. Dr.-Ing. Torsten Finke 

FOM 

2013-12-01 

Einführung 

Datenstrukturen 

Algorithmen – Konzepte und Analyse 

Sortieren 

Zeichenketten 

Kompression 

Kryptologie 

Geometrie 

Graphen 

Prof. Dr.-Ing. Torsten Finke (FOM) Algorithmen 2013-12-01 1 / 235 



Inhalte 


Klausur 

Algorithmen – Folien 

Klausur 

http://www.dr-torsten-finke.de/lehre/algorithmen/bachelor/algorithmen.pdf 

http://www.dr-torsten-finke.de/lehre/algorithmen/bachelor/algorithmen-print.pdf 

◮ Formalia 

◮ Dauer 120 Minuten 

◮ keine Hilfsmittel 

◮ Formvorschriften 

◮ Inhalt 

◮ Inhalt komplett relevant 

◮ kein Repetitorium 

◮ Auswahlklausur 

◮ Schwerpunkt auf Verständnis 


Prof. Dr.-Ing. Torsten Finke (FOM) Algorithmen 2013-12-01 4 / 235

Algorithmik – Literatur 


Literatur 

Arndt, Jörg: Matters Computational – Ideas, Algorithms, Source Code. 

Autor, 2010. 

http://www.jjj.de/fxt/. 

Cormen, Thomas H., Charles E. Leiserson und Ronald L. Rivest: 

Introduction to Algorithms. 

The MIT Press, 3. Auflage, 2009. 

ISBN: 978-0262533058. 

Engeln-Müllges, Giesela und Frank Uhlig: Numerical Algorithms with C. 

Springer-Verlag, 1997. 

ISBN: 3540605304. 

Knuth, Donald E.: The Art of Computer Programming – Fascicles 0–4. 

Addison-Wesley, 2009. 

ISBN: 978-0321637130. 

Sedgewick, Robert: Algorithms in C. 

Addison-Wesley, 1990. 

ISBN: 978-0201514254. 


Algorithmik – Quelltexte 


Literatur 

◮ Quelltexte sind weitgehend in Anlehnung an [Sed90] wiedergegeben. 

◮ Die dargestellten Programme dienen primär der Illustration der 

diskutierten Algorithmen. Korrekte Funktion und praktische 

Verwendbarkeit sind ausdrücklich nicht garantiert. 

◮ Die Beispiele sollen Anregungen zu eigenen Programmierübungen in 

beliebigen Programmiersprachen sein. 

◮ Programmbeispiele sind herzlich willkommen – bitte einsenden mit 

Angaben zur Urheberschaft und einer Lizenz (MIT, BSD, GPL etc.) 


Einführung 

Begriffe 

Einführung 

Programmcodes – C 

Begriffe 

Programmcodes – C 

◮ Al Chwarizmi – Algorithmus 

◮ Verarbeitungsvorschrift (finit, determiniert(?)) 

◮ Darstellung: 

◮ Programmablaufplan (DIN 66001/ISO 5807) 

◮ Struktogramm (Nassi/Shneidermann, DIN 66261) 

◮ Pseudocode 

◮ maschinennah, Rechenaufwand gut bestimmbar 

◮ Typen: int, char, double 

◮ globale Variable (kompakter Code) 

◮ Felder: Zeiger auf erstes Element, Länge separat 

◮ Strukturen: struct entry { int x, y; } 

◮ Pointer: struct entry *p; ...; a = p->x; 

◮ Kontrollstrukturen 

◮ Operatoren 

◮ Ein-/Ausgabe: c = getchar(); printf("n = %d\n", n) 

◮ Zip-Archiv 

◮ andere Programmiersprachen 



Einführung 

Größter gemeinsamer Teiler 

Beispiel – ggT 

Einführung 

ggT – Idee: Primfaktorzerlegung 


◮ ggT(84, 231) 

Beispiel: 

◮ ggT(84, 231) =? 

◮ Idee? 

84 = 2 · 2 · 3 · 7 

231 = 3 · 7 · 11 

⇒ ggT(84, 231) = 3 · 7 

= 21. 

◮ Erforderlich: 

◮ Primzahlenverzeichnis 

◮ Listen für Faktoren 



Einführung 


Primzahlen – Sieb des Eratosthenes 

Einführung 


Sieb des Eratosthenes – Implementation 

2 3 4 5 6 7 8 9 10 11 12 

13 14 15 16 17 18 19 20 21 22 23 24 

25 26 27 28 29 30 31 32 33 34 35 36 

37 38 39 40 41 42 43 44 45 46 47 48 

49 50 51 52 53 54 55 56 57 58 59 60 

61 62 63 64 65 66 67 68 69 70 71 72 

73 74 75 76 77 78 79 80 81 82 83 84 

85 86 87 88 89 90 91 92 93 94 95 96 

97 98 99 100 101 102 103 104 105 106 107 108 

109 110 111 112 113 114 115 116 117 118 119 120 

121 122 123 124 125 126 127 128 129 130 131 132 

eratos(int s[], int n) 

{ 

int i, k; 

/* prepare sieve: 1 - prime, 0 - no prime */ 

for ( s[1] = 0, i = 2; i

Einführung 


Einführung 


Euklid – ggT: Idee 

Fläche: 30 × 21 – maximale Kachelgröße? 

Euklid – ggT: Pseudo-Code 

1: procedure gcd(u, v) 

2: while u > 0 do 

3: if u < v then 

4: (u, v) ← (v, u) ⊲ let u always be the greater value 

5: end if 

6: u ← u − v ⊲ try mod 

7: end while 

8: return v ⊲ gcd is v 

9: end procedure 



Einführung 


Einführung 


Euklid – ggT: Beispiel 

Euklid – ggT: Programmablaufplan 

◮ ggT(84, 231) =?, ggT(233, 144) =? 

◮ 231 

84 

147 

84 

63 

21 

42 

21 

21 ⇒ ggT(84, 231) = 21 

0 

233 

144 

89 

55 

34 

21 

13 

8 

5 

3 

2 

1 

1 ⇒ ggT(233, 144) = 1 

0 

n 

Start 

read(u,v) 

u,v > 0? 

j 

n 

u > 0? 

j 

n 

u < v? 

j 

(u,v) := (v, u) 

u := u − v 

print(v) 



Einführung 


Einführung 


Euklid – ggT: Struktogramm 

Euklid – ggT: Implementation 

Loop: 

Input: u, v 

j 

u, v > 0 

while: u > 0 

j 

u < v 

n 

(u,v) := (v,u) 

u := u − v 

Output: v 

n 

int gcd(int u, int v) 

{ 

int t; 

while (u > 0) { 

if (u < v) { 

t = u; u = v; v = t; 

} 

u = u - v; 

} 

return v; 

} 



Einführung 


Einführung 


Euklid – Fazit 

Übungen 

◮ einfache Methode 

◮ einfache Operationen (Addition, Subtraktion, Vergleich) 

◮ einfache Datentypen 

◮ Beschreiben Sie die behandelten Algorithmen so, dass ein Mensch sie 

ausführen kann! Testen Sie Ihre Beschreibung mit einer 

Versuchsperson! 

◮ Implementieren Sie die dargestellten Algorithmen in einer 

Programmiersprache Ihrer Wahl! 




Elementare Datenstrukturen 


Speicherzellen und Felder 

Elementare Datenstrukturen 


◮ einfache Datenstrukturen 

◮ Ganzzahl – int (long int, unsigned int) 

◮ Fließpunkt – float, double 

◮ Zeichen(-kette) – char 

◮ aggregierte Datenstrukturen 

◮ 

◮ 

Feld 

Struktur 

◮ Arrays 

◮ Matrizen 

◮ Indizes (effizientes Vertauschen) 

Index i[n] Array a[m][n] 

/* swap rows p, q by index */ 

t = i[p]; 

i[p] = i[q]; 

i[q] = t; 

/* now access first element */ 

x = a[i[p]][0]; 






Lineare Datenstrukturen 

Feld – Operationen 

Liste 

◮ n Elemente – Problemumfang 

◮ Aufwand A = A(n) 

◮ Einfügen an gegebener Position 

◮ Aufbau 

Head 

Value 

ptr 

Node 

Value 

ptr 

Value 

ptr 

Tail 

A insert = O(n). 

◮ Löschen an gegebener Position: A remove = O(n). 

◮ Suchen 

◮ 

◮ 

günstigster Fall: A = O(1) 

ungünstigster Fall: A = O(n) 

◮ 

◮ 

◮ 

◮ 

Kopf 

Knoten 

Ende 

doppelte Verkettung 

◮ Funktionen 

◮ Initialisierung 

◮ Einfügen 

◮ Löschen 

◮ Traversieren(Suchen/Modifizieren) 





Liste – Implementation/Initialisierung 

Liste – Element einfügen 



struct node { 

int key; 

struct node *next; 

}; 

struct node *head, *z, *t; 

void listinitialize() 

{ 

head = malloc(sizeof *head); /* get memory from OS */ 

z = malloc(sizeof *z); 

head->next = z; 

z->next = z; 

} 

struct node *insertafter(int v, struct node *n) 

{ 

struct node *x; 

x = (struct node *) malloc(sizeof *x); 

x->key = v; /* 1. insert value */ 

x->next = n->next; /* 2. connect successor */ 

n->next = x; /* 3. connect predecessor - why last? */ 

return x; 

} 



Liste – Element löschen 



void deletenext(struct node *n) 

{ 

t = n->next; 

n->next = n->next->next; /* memory leak */ 

free(t); /* release memory */if ( t != z ) free(t); 

} 


Liste traversieren – Element suchen 

◮ Suche bis Listenende 


struct node *search(int v, struct node *n) { 

while ( n != n->next ) { /* until end of list */ 

if ( n->key == v ) break; /* found */ 

n = n->next; /* otherwise continue */ 

} 

return n; 

} 

◮ Suche bis Sentinel 

struct node *search(int v, struct node *n) { 

z->key = v; /* sentinel */ 

while ( n->key != v ) n = n->next; /* will find */ 

return n; 

} 







Listen – Übungen 

Stack/Stapel 

◮ LiFo 

push 

pop 

◮ Implementation Modifizieren 

◮ Aufwand der Suche nach einem Element? 

◮ Optimierungsstrategie für die Suche? 

Stackpointer 

◮ Stackpointer 

◮ Operationen 

◮ Initialisierung 

◮ Push 

◮ Pop 




Stack – Implementation/Aufbau 

struct node { 

int key; 


}; 


static struct node *head, *z, *t; 

stackinit() { 

head = (struct node *) malloc(sizeof *head); 

z = (struct node *) malloc(sizeof *z); 

head->next = z; 

z->next = z; head->key = z->key = 0; 

} 


Stack – Implementation/Operation 


push(int v) { 

t = (struct node *) malloc(sizeof *t); 

t->key = v; t->next = head->next; 

head->next = t; 

} 

int pop() { 

int x; 

t = head->next; head->next = t->next; 

x = t->key; 

if ( ! stackempty() ) free(t); 

return x; 

} 

int stackempty() { 

return head->next == z; 

} 





Stack – Anwendung: UPN (̷Lukasiewicz) 

int b = 10, c, n, t, x; 

stackinit(); 

do { 

x = n = 0; /* prepare to read number */ 

for (c=getchar(); c>=’0’ && c 0) { push(x); /* got number */ } 

if (c == ’+’) { push(pop() + pop()); } 

else if (c == ’-’) { t = pop(); push(pop() - t); } 

else if (c == ’~’) { push(-pop()); } 

else if (c == ’*’) { push(pop() * pop()); } 

else if (c == ’/’) { if (t = pop()) push(pop()/t); } 

} while ( c != EOF ) 

printf("%d\n", pop()); 

Queue(Schlange) 

◮ FiFo 

get 

◮ Operationen an beiden Enden: 

◮ 

◮ 

Put 

Get 

Datenstrukturen Lineare Datenstrukturen 

◮ Anwendung: Schieberegister, Warteschlange 

put 







Ringspeicher 

Lineare Datenstrukturen – Übung 

Head 

◮ Implementieren Sie einen Stack mit einem Array! 

◮ Implementieren Sie die Funktionen get und put für eine Queue! 

◮ Implementieren Sie sinnvolle Funktionen zum Aufbau und zur 

Anwendung von Ringspeichern! 

◮ Implementieren Sie einen Infix-Parser (Hinweis: Shunting Yard 

Algorithmus) 







Hash 

Hash – Beispiel 

◮ Hash-Funktion: z.B. modulo 

h(k) = k mod M 

◮ k komplex (große Zahl): Stellensystem (Basis b) 

k = 

◮ Modulo-Rechnung: 

n∑ 

k i b i 

(a + b) mod M = (a mod M + b mod M) mod M 

(a · b) mod M = (a mod M · b mod M) mod M 

◮ Horner-Schema (mit impliziter Modulorechnung) 

i=0 

Hashkodes zum schnellen Finden von Schlüssel/Wert-Paaren 

◮ gegeben: Schlüssel k (kompliziert) 

◮ berechne h(k) (eventuell nicht eindeutig) 

◮ Aufwand der Suche A = O(1) 

◮ verwende h(k) als Index in einem Feld 

◮ jeder Feldeintrag ist ein Listenkopf 

◮ jede Liste enthält alle Schlüssel gleicher Hashcodes 

◮ Knoten tragen komplette Schlüssel und Verweise auf Werte 

◮ Vorteil: kurze Listen, effiziente Suche 

a 3 x 3 + a 2 x 2 + a 1 x + a 0 = ((a 3 x + a 2 ) · x + a 1 ) · x + a 0 





Hashing – Schlüssel/Wert-Verwaltung 

k 

h(k) 

h(k 1 ) 

k 1 

v 2 v’ 2 

h(k 2 ) 

k2 

k’ 2 

v 3 

h(k 3 ) 

k 3 

M Einträge 


v 1 



Hash – Wörter zählen: Initialisierung 

int M = 101; /* chose prime */ 

struct node { 

char *key; int val; 


} **heads, *z; 

unsigned hash(char *k) { 

for (int h=0; *k!=’\0’; k++) h=((hnext = z; 

} 

} 






Hash – Wörter zählen: eintragen und finden 

Hash – Anwendung 

void hashinsert(char *k, int h, int v) { 

struct node *new = malloc(sizeof *z); 

new->key = k; new->val = v; 

new->next = heads[h]->next; 

heads[h]->next = new; 

} 

struct node *hashfind(char *k, int h, int *v) 

{ 

struct node *t = heads[h]; 

z->key = k; 

do { 

t = t->next; 

} while ( strcmp(t->key, k) ); 

*v = t->val; 

return t; 

} 

◮ sinnvolle Wahl der Hashgröße 

◮ Modul M prim 

◮ Objekte mit gleichem Hashcode: Listen 

◮ Identität: 

◮ Hashcodes verschieden: Objekte verschieden 

◮ Hashcodes gleich: Objekte möglicherweise gleich 






Bäume 

Hash – Übung 

Bäume – Aufbau 

Wurzel 

◮ Zeigen Sie, dass die Modulorechnung distributiv hinsichtlich Addition 

und Multiplikation ist! 

◮ Gegeben: Kodierungstabelle: A – 1, B – 2, C – 3, ... Z – 26 

b = 30, M = 97 

Gesucht: Hashcode der Zeichenkette ALGORITHMUS 

◮ Implementieren Sie ein Programm, das die vorstehende Aufgabe löst. 

Kante 

Knoten 

Blatt 

Pfad 




Bäume 


Bäume 

Binär-Bäume 

Verzeichnis-Bäume 

n Knoten 

Tiefe t 

n = 2 t − 1 

t = log 2 (n + 1) 




Bäume 


Bäume 

Bäume – Traversierung 

Suche im Baum 

* 

M 

+ - 

H 

T 

3 4 7 2 

D K P W 

◮ Pre-Order: (* (+ 3 4) (- 7 2)) 

◮ In-Order: ((3 + 4) * (7 - 2)) 

◮ Post-Order: 3, 4 + 7, 2 - * 

◮ Level-Order: * + - 3 4 7 2 

B F I L 

A C E G 

N R U Y 

Q S X Z 




Bäume 


Bäume 

Binäre Such-Bäume 

◮ Sortiertes Einfügen 

◮ Suche: A = O(log n) 

A 

100 

80 

60 

40 

20 

0 

O(n) 

O(log n) 

10 20 30 40 50 60 70 80 90 100 

n 

Baum-Implementation: Aufbau 

static struct node { 

int key, info; 

struct node *l, *r; 

}; 

static struct node *t, *head, *z; 

treeinitialize() 

{ 

z = (struct node *) malloc(sizeof *z); 

z->l = z; 

z->r = z; 

z->info = -1; 

head = (struct node *) malloc(sizeof *head); 

head->r = z; 

head->key = 0; 

} 




Bäume 


Bäume 

Baum-Implementation: Suchen und Ausgeben 

int treesearch(int v) 

{ 

struct node *x = head->r; 

z->key = v; /* sentinel */ 

while (v != x->key) 

x = (v < x->key) ? x->l : x->r; 

return x->info; 

} 

treeprint(struct node *x) 

{ 

if (x != z) { 

treeprint(x->l); 

printnode(x); /* visit In-Order */ 

treeprint(x->r); 

} 

} 


Baum-Implementation: Einfügen 

treeinsert(int v, int info) 

{ 

struct node *p, *x; 

p = head; 

x = head->r; 

while (x != z) { 

p = x; x = (v < x->key) ? x->l : x->r; 

} 

x = (struct node *) malloc(sizeof *x); 

x->key = v; 

x->info = info; 

x->l = x->r = z; 

if (v < p->key) p->l = x; 

else p->r = x; 

} 



Knoten löschen – einfache Fälle 

Bäume 


Bäume 

Knoten löschen – komplizierter Fall 

A 

ein NF 

C 

E 

H 

NF ohne NF 

N 

R 

S 

kein NF 

C 

E 

H 

R 

P 

A 

C 

E 

H 

re. NF(E) 

N 

R 

A 

C 

H 

N 

R 

M 

P 

M 

M 

P 

M 

P 

L 

L 

L 

L 




Baum-Implementation: Löschen 

Bäume 

treedelete(int v) { 

struct node *c, *p, *x; 

z->key = v; p = head; x = head->r; 

while (v != x->key) { /* search node */ 

p = x; x = (v < x->key) ? x->l : x->r;} 

t = x; /* t to be deleted */ 

if (t->r == z) x = x->l; /* node is leaf, cut off */ 

else if (t->r->l == z) { /* node’s child is leaf */ 

x = x->r; x->l = t->l;} 

else { c = x->r; 

while (c->l->l != z) c = c->l; /* substitute */ 

x = c->l; c->l = x->r; 

x->l = t->l; x->r = t->r;} 

if (v < p->key) p->l = x; 

else p->r = x; 

} 


Datenstrukturen Bäume 

Baum-Implementation: Operationen 

◮ Suchen: effizient 

◮ Einfügen: nach erfolgloser Suche 

◮ Risiko: Degenaration 

◮ Abhilfe: Balancierte Bäume (Red-Black-Trees, AVL-Trees) 

◮ Löschen: schwierig – Alternative: 

◮ 

◮ 

Löschung markieren, 

Baum gelegentlich neu aufbauen 



Rekursion 


Rekursion 

Einfache Rekursion – Fakultät 

Einfache Rekursion – Fibonacci-Folge 

Iteration: 

Rekursion: 

n! = n · (n − 1) · . . . · 1 

int fact(int n) { 

int f = n -- ; 

while (n) f *= n --; 

return f; 

} 

1. Abbruchbedingung für das triviale Problem; 

2. rekursive Verkleinerung des Problems 

n! = n · (n − 1)! 

int fact(int n) { 

if (n < 2) return 1; 

return n * fact(n-1); 

} 

◮ 

f n = f n−2 + f n−1 

f 0 = f 1 = 1 

Übung: Implementation eines Programms zur Berechnung der 

Fibonacci-Folge; 

◮ Problem der Rekursion: überflüssige Berechnungen – schlechte 

Performanz 

◮ Verstecktes Problem: Speicherbedarf 




Rekursion 


Rekursion 

Rekursion – Teile und Herrsche 

Rekursion – Türme von Hanoi 

◮ Beispiel: Türme von Hanoi; 

◮ Aufgaben delegieren 

◮ mehrfache Anwendung der rekursiven Funktion 

◮ Bewege Turm von Säule A nach Säule B 

◮ Ziehe jeweils nur eine Scheibe 

◮ Immer muss die kleinere Scheibe über der größeren liegen 




Rekursion – Türme von Hanoi 

1: procedure Hanoi(n, a, b, c) 

2: if n = 1 then 

3: Write a → b 

4: else 

5: Hanoi(n − 1, a, c, b) 

6: Hanoi(1, a, b, c) 

7: Hanoi(n − 1, c, b, a) 

8: end if 


Rekursion 


Rekursion 

Türme von Hanoi – Auflösung der Rekursion 

shiftn(int n, int a, int b, int c) { 

push(a); push(b); push(c); push(n); 

while ( 1 ) { 

while ( n > 1 ) { /* nested while instead of goto */ 

push(a); push(b); push(c); push(n); 

n --; swap(c, b); /* shift(n-1, a, c, b) */ 

} 

show(a, b); 

n = pop; c = pop; b = pop; a = pop; 

if ( stackempty ) break; 

show(a, b); 

n --; swap(a, c); /* shift(n-1, c, b, a) */ 

} 

} 




Iteration statt Rekursion 

Rekursion 


Rekursion 

Rekursion – Ackermann 1 -Funktion 

◮ Rekursion kann immer durch Iteration ersetzt werden; 

◮ durch formale Auflösung der Rekursion 

◮ durch Algorithmenanalyse 

◮ Iteration: 

◮ in der Regel performanter; 

◮ erfordert oft explizite Speicherverwaltung (meist per Stack) 

◮ Implementation meist komplizierter; 

◮ Rekursive Algorithmen rekursiv implementieren 

◮ meist leichter zu verstehen und zu warten, 

◮ iterative Realisierung durch optimierende Compiler. 

a(0, n) = n + 1 

a(m, 0) = a(m − 1, 1) 

a(m, n) = a(m − 1, a(m, n − 1)) 

m/n 0 1 2 3 4 5 6 

0 1 2 3 4 5 6 7 

1 2 3 4 5 6 7 8 

2 3 5 7 9 11 13 15 

3 5 13 29 61 125 253 509 

4 13 65533 

5 65533 

1 Variante von Rózsa Péter 




Rekursion 

Ackermann-Funktion – Eigenschaften 


Rekursion – Übungen 

Rekursion 

◮ theoretische Informatik 

◮ stark anwachsend – Aufwand? 

◮ wiederholte Berechnung – Memoization 

◮ Benchmarks 

◮ Iterative Programme für Fakultät und Fibonacci-Folge 

◮ Iteratives Programm für Türme von Hanoi – schwieriger 

◮ Iteratives Programm für die Ackermann-Funktion (mit/ohne 

Memoization) 




Aufwandskalkulation 




Aufwandskalkulation rekursiver Algorithmen 

◮ Aufwand A; 

◮ Problemgröße n; 

◮ Komplexität: A = A(n) 

◮ Ordnungsfunktion A = O(f (n)) (asymptotisch für große n) 

◮ Typische Ordungsfunktionen: 

◮ A = O(1) 

◮ A = O(log n) 

◮ A = O(n) 

◮ A = O(n log n) 

◮ A = O(n 2 ) 

◮ A = O(2 n ) (schwierig) 

Pro Rekursionsschritt wird vom Eingabefeld: 

◮ jedes Element bearbeitet, 

◮ ein Element entfernt und der Rest verarbeitet 

A n = A n−1 + n 

= A n−2 + (n − 1) + n 

. 

= 1 + 2 + . . . + (n − 1) + n 

= n n + 1 

2 

= O(n 2 ) 





Aufwandskalkulation rekursiver Algorithmen 

Pro Rekursionsschritt wird vom Eingabefeld: 

◮ jedes Element behandelt, 

◮ das Feld in Hälften zerlegt, 

◮ beide Hälften verarbeitet. 


Aufwandskalkulation – Übung 


A n = 2 A n/2 + n, n = 2 k 

A 2 k = 2 A 2 k−1 + 2 k 

A 2 k 

2 k = A 2 k−1 

2 k−1 + 1 

= A 2 k−2 

2 k−2 + 1 + 1 

. 

= k 

A 2 k = k 2 k 

A n = O(n log n) 


◮ Bestimmen Sie die Ordnungen der Aufwandsfunktionen der bislang 

behandelten Algorithmen! 

◮ Stellen Sie die in Aufwandskalkulation 

grafisch dar! 

genannten Ordnungsfunktionen 


Sortieren 

Elementares Sortieren 

Sortieren 

Elementares Sortieren 

Sortieren – Grundkonzepte 

Sortieren – Vertauschen 

◮ vergleichen/vertauschen 

◮ intern/extern 

◮ Aufwand: N log N ... N 2 

◮ Speicherplatz 

◮ am Ort 

◮ Zusatzspeicher 

◮ stabil 

◮ Index 

◮ Einfluss Vorsortierung 

void swap (int a[], int i, int j) 

{ 

int t; 

t = a[i]; 

a[i] = a[j]; 

a[j] = t; 

} 

/* exchange without buffer variable */ 

#define swap(p, q) do { p ^= q; q ^= p; p ^= q; } while (0) 



Sortieren 

Selection Sort 

Sortieren 



1: procedure SelectionSort(Feld) 

2: suche das kleinste Element im Feld 

3: vertausche es mit dem ersten Element des Feldes 

4: sortiere den Rest des Feldes 


◮ A excg (n) = O(n) =⇒ linear; vorteilhaft, wenn Vertauschen aufwendig 

◮ A comp (n) = O(n 2 /2) 

◮ relativ unempfindlich gegenüber Anordnung der Eingabedaten 

Selection Sort – Implementation 

selection(int a[], int n) 

{ 

int i, j, imin; 

for (i = 1; i < n; i++) { 

imin = i; 

for (j = i + 1; j

Sortieren 

Insertion Sort 

Sortieren 

Insertion Sort 

Insertion Sort – Implementation 

insertion(int a[], int n) 

{ 

int i, j, v; 

for (i = 2; i v) { 

a[j] = a[j - 1]; 

j--; 

} 

a[j] = v; 

} 

} 

Insertion Sort – Verlauf 

500 

450 

400 

350 

300 

250 

200 

150 

100 

50 

’-’ 

0 

0 50 100 150 200 250 300 350 400 450 500 



Sortieren 

Bubble Sort 

Sortieren 

Bubble Sort 

Bubble Sort 

Bubble Sort – Implementation 

1: procedure BubbleSort(Feld) 

2: vergleiche aufsteigend je zwei folgende Elemente des Feldes 

3: vertauschen wenn unsortiert ⊲ extremes Element nun auf Pos. N 

4: wiederhole die obigen Schritte für die Elemente bis N − 1 


◮ A excg (n) = O(n 2 /2) 

◮ A comp (n) = O(n 2 /2) 

◮ ineffizient 

◮ leicht zu verstehen 

◮ Optimierung: beenden, wenn Durchlauf ohne Vertauschung 

bubble(int a[], int n) 

{ 

int i, j; 

for (i = n; i >= 1; i--) { 

for (j = 2; j a[j]) { 

swap(a, j, j-1); 

} 

} 

} 

} 



Sortieren 

Performantes Sortieren 

Sortieren 

Merge Sort 

Performantes Sortieren 

Mergesort 

◮ Komplexität elementarer Sortierverfahren etwa quadratisch 

◮ Existieren effizientere Verfahren mit A < O(n 2 ) ? 

◮ Idee: teile und herrsche! 

1: procedure MergeSort(Feld) 

2: teile Feld in Hälften 

3: sortiere Hälften per MergeSort 

4: verschmelze sortierte Hälften 




Sortieren 

Merge Sort 

Sortieren 

Merge Sort 

Mergesort – Eigenschaften 

Mergesort – Implementation 

◮ Teile und Herrsche 

◮ benötigt zusätzlichen Speicher 

◮ A = O(n log n) 

◮ stabil 

◮ unempfindlich gegenüber Vorsortierung 

mergesort(int a[], int b[], int l, int r) 

{ 

int i, j, k, m; 

if (r > l) { 

m = (r+l)/2; 

mergesort(a, b, l, m); 

mergesort(a, b, m+1, r); 

for (i = m+1; i > l; i--) b[i-1] = a[i-1]; 

for (j = m; j < r; j++) b[r+m-j] = a[j+1]; 

for (k = l; k

Sortieren 

Merge Sort 

Sortieren 

Merge Sort 

Mergesort – Präparation 

Mergesort – Verlauf 

500 

’−’ 

450 

/* wrapper */ 

msort(int a[], int n) 

{ 

int i, *b; 

/* additional memory */ 

b = (int *) malloc((n+1) * sizeof(int)); 

mergesort(a, b, 1, n); 

} 

400 

350 

300 

250 

200 

150 

100 

50 

0 

0 50 100 150 200 250 300 350 400 450 500 



Sortieren 

Quicksort 

Sortieren 

Quicksort 

Quicksort (C.A.R. Hoare) 

Quick Sort – Eigenschaften 

1: procedure QuickSort(Feld) 

2: wähle ein Element P des Feldes, das einsortiert werden soll 

3: partitioniere das Feld (unten alle kleineren, oben alle größeren) 

4: füge das Element zwischen den Partitionen ein 

5: sortiere beide Partitionen 


1: procedure Partition(Feld, P) 

2: Index i l startet von links 

3: i l stoppt, wenn sein Element größer als P 

4: Index i r läuft entsprechend von rechts 

5: Wenn beide Indizes gestoppt sind, vertausche ihre Werte 

6: fahre fort, bis die Indizes sich treffen 


◮ A(n) = O(n log n) 

◮ gutes Allzweckverfahren 

◮ nicht stabil 

◮ empfindlich, wenn Partitionierung dauerhaft asymmetrisch 



Sortieren 

Quick Sort – Implementation 

Quicksort 

quicksort(int a[], int l, int r) 

{ 

int i; 

if (r > l) { 

i = partition(a, l, r); /* lower, upper section */ 

quicksort(a, l, i - 1); /* divide and conquer */ 

quicksort(a, i + 1, r); 

} 

} 

/* wrapper -- call this */ 

qsort(int a[], int n) 

{ 

/* wrapper */ 

quicksort(a, 1, n); 

} 


Sortieren 

Quick Sort – Partitionierung 

Quicksort 

int partition(int a[], int l, int r) 

{ 

int i, j, v, s; 

s = a[l - 1]; /* sentinel */ 

i = l - 1; j = r; /* indexes */ 

a[i] = v = a[r]; /* to be put to final position */ 

while (1) { 

while (a[++i] < v); 

while (a[--j] > v); 

if (i >= j) break; /* pointers have met */ 

swap(a, i, j); /* exchange among sections */ 

} 

swap(a, i, r); /* final position */ 

a[l - 1] = s; 

return (i); 

} 


Sortieren 

Quicksort 

Sortieren 

Quicksort 

Quick Sort – Verlauf 

Quick Sort – Optimierung 

500 

’-’ 

450 

400 

350 

300 

250 

200 

150 

100 

◮ Beseitigung der Rekursion 

◮ expliziter Stapel 

◮ Endrekursion 

◮ jeweils das größere Teilfeld auf Stapel 

◮ das kleinere Teilfeld direkt bearbeiten 

◮ Steigerung der Partitionssymmetrie (Median, Random) 

◮ Kombination mit Insertion Sort 

◮ kleine Teilfelder (n < 20) per Insertion Sort 

◮ kleine Teilfelder ignorieren – anschließend Insertion Sort 

50 

0 

0 50 100 150 200 250 300 350 400 450 500 



Sortieren 

Heap Sort 

Sortieren 

Heap Sort 

Diskurs – Datenstruktur Heap 

Heap – Einfügen 

◮ Binärbaum mit n Knoten 

◮ Speicherung in Array 

◮ Heap-Bedingung: alle Pfade 

sortiert 

◮ schnelle Operationen – 

A = O(log n): 

◮ Einfügen eines Knotens 

◮ Entfernen der Wurzel 

◮ automatisch balanciert 

◮ Verwendung in 

Prioritätswarteschlangen 

A 

E 

G 

I M N O 

P R S T X 

upheap(int k) /* heap repair */ 

{ 

int c; /* assume >= 0 */ 

c = a[k]; /* to be moved */ 

a[0] = -1; /* sentinel */ 

while (a[k/2] > c) { 

a[k] = a[k/2]; /* up */ 

k = k/2; /* next level */ 

} 

a[k] = c; /* insert */ 

} 

insert(int c) 

{ 

a[++N] = c; /* append */ 

upheap(N); 

} 

A 

E 

G 

I M N O 

P R S T X L 

A 

E 

G 

I M L O 

P R S T X N 



Sortieren 

Heap Sort 

Heap – Entfernen der Wurzel (Remove) 

Sortieren 

Heap-Remove Implementation 

Heap Sort 

X 

A E 

I 

G 

P M L O 

R S T N 

/* entry k lower child */ 

downheap(int k) 

{ /* ascending */ 

int j, c; 

c = a[k]; 

while (k

Sortieren 

Heap Sort 

Sortieren 

Heap Sort 

Heap-Sort 

Heap-Sort – Implementation 

1: procedure HeapSort(array) 

2: for all n in nodes do ⊲ build heap 

3: downheap(n) 

4: end for 

5: while nodes in heap do 

6: n ← remove() ⊲ reduce heap 

7: sorted ← (n, sorted) 

8: end while 


downheap(int a[], int n, int k) 

{ /* descending */ 

int j, v = a[k]; 

while ( k 1 ) { 

/* remove maximum */ 

swap(a, 1, n); 

downheap(a, --n, 1); 

} 

} 



Sortieren 

Heap Sort 

Sortieren 

Heap Sort 

Heap-Sort – Komplexität 

Heap-Sort – Eigenschaften 

◮ A build = O(N), 

◮ A comp = O(N log N) 

◮ nicht stabil 

◮ unempfindlich gegen Vorsortierung 



Sortieren 

Heap Sort 

Zeichenketten 

Suchen in Zeichenketten 

Heap-Sort – Verlauf 

Suchen von Wörtern in Texten 

500 

’-’ 

450 

400 

350 

300 

250 

200 

150 

100 

◮ gegeben: 

◮ Text gespeichert in Feld, Länge n 

◮ Zeichenfolge (Wort/Muster, Länge m), die im Text gesucht werden soll 

◮ m ≪ n 

◮ systematische Suche ab Textanfang 

◮ gesucht: Position der Zeichenfolge im Text 

◮ eventuelle Probleme bei externer Text-Speicherung: 

◮ langsamer Zugriff 

◮ Rücksetzen schwierig/unmöglich 

50 

0 

0 50 100 150 200 250 300 350 400 450 500 



Zeichenketten 

Wortsuche – Brute Force/Naiv 

Suchen in Zeichenketten – Naiv 

1: procedure NaiveSearch(Word, Text) 

2: Text ← Text + Word ⊲ sentinel 

3: i ← start(Text) 

4: Pos: for all j in Word do ⊲ compare all characters 

5: if Text(i + j) ≠ Word(j) then ⊲ mismatch 

6: i ← i + 1 ⊲ next position in Text 

7: next Pos 

8: end if 

9: end for 

10: return i − 1 ⊲ match found at position 


A = O(m · n) 


Zeichenketten 

Suchen in Zeichenketten – Naiv 

Brute Force Wortsuche – Implementation 

int brutesearch (char *p, char *a) 

/* a: text, p: word*/ 

{ 

int i, j, M = strlen (p); 

strcat(a, p); /* sentinel */ 

for (i = 0, j = 0; j < M; i++, j++) { 

while ( a[i] != p[j] ) { 

i += 1 - j; 

j = 0; 

} 

} 

return i - M; 

} 

◮ Beispiel: suche aaaab in aaaaaaaaaaaaaaaaaaaab 

◮ wieviele Vergleiche? 


Zeichenketten 

Knuth Morris Pratt – KMP 

Suchen in Zeichenketten – Knuth, Morris, Pratt 

Zeichenketten 

Knuth Morris Pratt – Wortanalyse 


◮ Idee: wiederholte Vergleiche an derselben Textstelle vermeidbar? 

◮ Vorteil: Wort ist bekannt 

◮ Beispiel: suche abend 

◮ Annahme: scheitern am d 

◮ Schlussfolgerung: 

◮ Wort kann an aktueller Stelle nicht stehen 

◮ erneute Wortsuche vor der Position von d sinnlos, da dort kein a 

◮ =⇒ nächste Wortsuche ab Textposition von d 

◮ Problem: Selbstähnlichkeit im Wort, Beispiel gegen 

◮ Beispiel: suche gegen 

◮ Annahme: scheitern am n 

◮ Schlussfolgerung: 

◮ Wort kann an aktueller Stelle nicht stehen; 

◮ aber: Wort könnte ab dem zweiten g stehen; 

◮ =⇒ nächste Wortsuche ab Textposition vom 2. g 

◮ Vorteil: 

◮ gegen – rot markierte Zeichen bereits gefunden 

◮ Wortvergleich ab Position 3 fortsetzen 

◮ kein Rücksetzen im Text 



Zeichenketten 


Knuth Morris Pratt – Wortanalyse Selbstähnlichkeit 

◮ Bestimme Position next im Wort, bei der nach Scheitern an Position 

j die Suche fortgesetzt wird 

◮ Beispiel: gegend 

j next[j] 

0 -1 sinnvoll zur Implementation 

1 gegend 

0 gegend 

2 gegend 

0 gegend 

3 gegend 

1 gegend 

4 gegend 

2 gegend 

5 gegend 

0 gegend 

Zeichenketten 


Knuth Morris Pratt – Implementation Suche 

int next[len]; 

int kmpsearch (char *p, char *a) 

{ 

int i, j, M = strlen (p); 

initnext (p); 


for (i = 0, j = 0; j < M; i++, j++) { 

while ((j >= 0) && (a[i] != p[j])) { 

j = next[j]; 

} 

} 

return i - M; 

} 



Zeichenketten 


Knuth Morris Pratt – Implementation Voranalyse 

int next[len]; 

initnext (char *p) 

{ 

int i = 0, j = -1, m = strlen (p); 

next[0] = -1; 

while ( i < m ) { 

while ((j >= 0) && (p[i] != p[j])) { 

j = next[j]; 

} 

i++; j++; 

next[i] = j; 

} 

} 

Zeichenketten 

Knuth Morris Pratt – Zustandsautomat 

◮ Wortsuche per Automat 

◮ Automat spezifisch für das gesuchte Wort 

◮ Zustandsübergang aus Selbstähnlichkeitstabelle 


g(0) e(1) g(2) e(3) n(4) d(5) 

j next[j] 

0 -1 

1 0 

2 0 

3 1 

4 2 

5 0 

Beachte Ähnlichkeit zur eigentlichen Suche! 



Zeichenketten 


Knuth Morris Pratt – Simulation Automat 

◮ aus Selbstähnlichkeitstabelle C-Quellen erzeugen 

◮ nahezu identische Statements 

int kmpauto(char *a) 

{ 

int i = -1; 

sm: i ++; 

s0: if(a[i] != ’g’) goto sm; i++; 

s1: if(a[i] != ’e’) goto s0; i++; 

s2: if(a[i] != ’g’) goto s0; i++; 

s3: if(a[i] != ’e’) goto s1; i++; 

s4: if(a[i] != ’n’) goto s2; i++; 

s5: if(a[i] != ’d’) goto s0; i++; 

return i-6; 

} 

j next[j] 

0 -1 

1 0 

2 0 

3 1 

4 2 

5 0 

Zeichenketten 


Knuth Morris Pratt – Simulation Automat 

◮ Beobachtung: Sprünge können zusammengefasst 

werden 

◮ Beispiel: s3 → s1 → s0 

g(0) e(1) g(2) e(3) n(4) d(5) 

j next[j] 

0 -1 

1 0 

2 -1 

3 0 

4 2 

5 0 



Zeichenketten 


Zeichenketten 


Knuth Morris Pratt – Laufzeitautomat 

◮ Idee: Laufzeit-Maschinencode analog zu C-Programm 

◮ Hex-Dump Maschinencode (Beispiel Pentium): 

0: 55 push %ebp 

1: 89 e5 mov %esp,%ebp 

3: 8b 55 08 mov 0x8(%ebp),%edx 

6: b8 ff ff ff ff mov $0xffffffff,%eax 

... 

b: 40 inc %eax 

c: 80 3c 10 67 cmpb $0x67,(%eax,%edx,1) # ’g’ 

10: 75 f9 jne b 

12: 40 inc %eax 

13: 80 3c 10 65 cmpb $0x65,(%eax,%edx,1) # ’e’ 

17: 75 f3 jne c 

19: 40 inc %eax 

... 

43: 83 e8 07 sub $0x7,%eax # position found 

46: 5d pop %ebp 

47: c3 ret 


Knuth Morris Pratt – Laufzeitimplementation 

void *kmpauto(char *p) { 

char h[]={0x55,0x89,0xe5,0x8b,0x55,0x08,0xb8,0xff,0xff,0xff,0xff}; 

char z[]={0x83,0xe8,0x00,0x5d,0xc3}; 

char n[]={0x40,0x80,0x3c,0x10,0x00,0x75,0x00}; 

int sh = sizeof(h), sn = sizeof(n), sz = sizeof(z); 

int i, j, l; 

char *c, *s, *t; 

l = initnext(p); /* word length */ 

s = c = (char *) malloc(sh + sz + l * sn); /* code memory */ 

memcpy(s, h, sh); s += sh; /* head code */ 

for( t = p, i = 0; *t != ’\0’; t++, i++ ) { 

n[4] = *t; /* character to compare */ 

n[6] = sn * (next[i] - i) - (sn-1) * (next[i]>=0); /* jump */ 

memcpy(s, n, sn); s += sn; /* append next state */ 

} 

z[2] = l-1; /* return address found */ 

memcpy(s, z, sz); /* append rest of code */ 

return((void *) c); } /* code’s address */ 


Zeichenketten 


Zeichenketten 


Knuth Morris Pratt – Laufzeitaufruf 

Knuth Morris Pratt – Zusammenfassung 

... 

int n; 

int (*c)(); 


c = kmpauto(p); /* Zeiger auf Automaten */ 

n = c(a); /* Suche */ 

... 

◮ Voranalyse des Suchwortes 

◮ Kein Rücksetzen im Text 

◮ Implementation über Automaten 

◮ Aufwand A = O(n + m) 



Zeichenketten 

Suchen in Zeichenketten – Boyer, Moore 

Zeichenketten 


Boyer Moore – BM 

Boyer Moore – Konzept 

◮ Idee: Vergleich beim letzten Zeichen beginnen 

◮ Vorteil: meist keine Übereinstimmung 

◮ Folge: große Sprünge vorwärts 

◮ Voraussetzung: Rückwärtspositionierung erlaubt 

Prinzipien: 

◮ Vergleich am Wortende 

◮ bad/missing character 

◮ optimal: Textzeichen fehlt in Wort =⇒ Sprung um Wortlänge 

◮ sonst Wort verschieben bis Übereinstimmung mit Textzeichen 

◮ good suffix 

◮ ohne Selbstähnlichkeit große Sprünge 

◮ Selbstähnlichkeit am Ende (analog KMP) 

Beispiel zu bad character: 

◮ Suche gegen in gegeben 

◮ b fehlt im Wort 

◮ =⇒ Sprung um Wortlänge voraus 



Zeichenketten 

Boyer Moore – Analyse Bad Character 


#define ASCII_LEN 256 

int skip[ASCII_LEN]; 

void initskip(char *p) 

{ 

int m, j; 

char c; 

m = strlen(p); 

for ( j = 0; j < ASCII_LEN; j++) 

skip[j] = m; /* normally skip word length */ 

for ( j = 0; p[j] != ’\0’; j++ ) 

skip[(int) p[j]] = m - j - 1; 

/* skip to rightmost character */ 

} 


Zeichenketten 

Boyer Moore – Implementation 


/* Bad Character */ 

bmsearch (char *p, char *a) 

{ 

int i, j, t, M = strlen (p); 

initskip (p); 


for (i = M - 1, j = M - 1; j >= 0; i--, j--) { 

while (a[i] != p[j]) { 

t = skip[a[i]]; 

/* equivalent to naive method for t = 0 */ 

i += (M - j > t) ? M - j : t; 

j = M - 1; 

} 

} 

return i; 

} 


Zeichenketten 


Zeichenketten 

Suchen in Zeichenketten – Rabin, Karp 

Boyer Moore – Fazit 

Rabin Karp – RK 

◮ optimal: Kombination aus 

◮ good suffix 

◮ bad character 

◮ erfordert Rücksetzen im Text 

◮ Aufwand: 

worst case: A = O(n + m) 

durchschnittlich: A = O( n m ) 

◮ extrem performant 

◮ Idee: Hashcode-Vergleich 

◮ Vorbereitung: Hash für Wort 

◮ Suche: Texthash an Wortposition vergleichen 

◮ Trick: Hash-Berechnung per Schiebeoperation 



Zeichenketten 

Rabin Karp – Algorithmus 


Zeichenketten 

Rabin Karp – Hashberechnung 


1: procedure RKSearch(Word, Text) 

2: h ← hash(Word) 

3: w ← length(Word) 

4: for i, TextLength do 

5: if hash(Text[i . . . i + w]) = h then 

6: break ⊲ match 

7: end if 

8: end for 

9: return i ⊲ text position of match 


◮ Nachprüfung 

◮ effiziente Hash-Berechnung? 

◮ Hashrechnung per Modulorechnung über Polynom (Horner-Schema) 

◮ implizite Modulorechnung (Modul q) 

◮ Basis b entsprechend Anzahl verschiedener Symbole 

◮ Position i in Text a, Hash h i über m Zeichen 

h i = a i b m−1 + a i+1 b m−2 + a i+2 b m−3 + . . . + a i+m−1 

h i+1 = a i+1 b m−1 + a i+2 b m−2 + . . . + a i+m−1 b + a i+m 

=⇒ h i+1 = (h i − a i b m−1 )b + a i+m 

h i+1 = h i b − a i B + a i+m 

B = b m 

◮ Prinzip der Teleskopsumme 



Zeichenketten 

Rabin Karp – Implementation 


#define b 256 /* Base, Alphabet’s size */ 

#define q 8388593 /* Modulus, b q without overrun */ 

int rksearch (char *p, char *a) /* assume strcat(a, p) */ 

{ 

unsigned int i, B = 1, hp = 0, ha = 0, M = strlen (p); 

for (i = 1; i < M; i++) B = (b * B) % q; 

for (i = 0; i < M; i++) { 

hp = (hp * b + p[i]) % q; /* prepare word hash */ 

ha = (ha * b + a[i]) % q; /* prepare text hash */ 

} 

for (i = 0; hp != ha; i++) { /* run through all text */ 

ha = (ha + b * q - a[i] * B) % q; /* b q - ai B > 0 */ 

ha = (ha * b + a[i + M]) % q; 

} 

return i; 

} 


Rabin Karp – Fazit 

Zeichenketten Suchen in Zeichenketten – Rabin, Karp 

◮ keine komplizierte Voranalyse 

◮ Hash-Berechnung erfordert Nachvergleich 

◮ Aufwand: A = O(n + m) (ähnlich KMP) 

◮ kein Rücksetzen 


Zeichenketten Zeichenkettenklassifikation 

Phonetische Klassifikation – Soundex-Algorithmus 

Idee: Wörter von ähnlichem Klang klassifizieren 

◮ Phonetik – Code → Phonem 

◮ Vokale 

◮ Konsonanten – Anatomie/Lautbildungshorizonte: 

◮ Kehlkopf 

◮ Rachen 

◮ Gaumen (weich/hart) 

◮ Zähne/Zahndamm 

◮ Lippen 

◮ Nase 

◮ Artikulation: 

◮ Verschlusslaute, Dauerlaute 

◮ stimmhaft, stimmlos, behaucht 

Knuth: The Art of Computer Programming 

Soundex-Algorithmus 

Zeichenketten 

1: procedure Soundex(word) 

2: notiere Anlaut (Anfangsbuchstabe) 

3: ignoriere Vokale (und H, W) 

4: vereinzele Zeichen 

5: klassifiziere bis zu drei Zeichen 

6: fülle ggf. mit Nullen auf 


Zeichenkettenklassifikation 

Soundex-Klassifikation 

Code Phoneme Zeichen 

1 Labiale B, F, P, V 

2 Gutturale, Frikative C, G, J, K, Q, S, X, Z 

3 Dentale D, T 

4 laterale Approximanten L 

5 Nasale M, N 

6 Vibranten R 



Zeichenketten 


Soundex-Algorithmus – Implementierung 

#include /* isalpha() */ 

char *soundex(char *str) 

{ /* ABCDEFGHIJKLMNOPQRSTUVWXYZ */ 

char *tbl = "01230120022455012623010202"; 

static char sndx[] = "A000"; 

int cnt = 0; 

sndx[cnt++] = (char)toupper(*str++); /* first character */ 

while(*str != ’\0’ && cnt < sizeof(sndx)-1) { 

if(isalpha(*str) && *str != *(str-1)) { 

sndx[cnt] = tbl[toupper(*str) - ’A’]; 

if(sndx[cnt] != ’0’) ++cnt; 

} 

++str; 

} 

return(sndx); 

} 


Soundex – Anwendung 

Zeichenketten Zeichenkettenklassifikation 

◮ Soundex-Werte: 

◮ Soundex(’Heidelberg’) = H341 

◮ Soundex(’Hotel’) = H340 

◮ Soundex(’Meier’) = M600 

◮ Soundex(’Mayr’) = M600 

◮ orientiert am Englischen 

◮ extrem einfach 

◮ A = O(1) 


Zeichenketten 


Kompression 

Verlustlose Kompression 

Markov-Ketten 

Lauflängenkompression – Run Length Encoding (RLE) 

◮ Häufigkeit von Zeichen in Texten sprachabhängig 

◮ Häufigkeit von Digrammen, Trigrammen, N-Grammen 

◮ Beispiel – im Deutschen: 

◮ -s-c-h-, sehr wahrscheinlich 

◮ -s-c-e-, eher unwahrscheinlich 

◮ Wahrscheinlichkeit abhängig von vorangehenden Zeichen 

◮ Anwendung: 

◮ Spracherkennung 

◮ OCR (Optical Character Recognition) 

◮ Passwortgenerierung 

◮ Idee: manchmal tritt ein Zeichen mehrfach in Folge auf 

◮ Verdichten: Angabe von Zeichen und Anzahl 


◮ kontraststarke Raster-Grafiken 

◮ Fax 

◮ Text mit Wiederholungszeichen (Leerzeichen) 

Jon Bentley: Programming Pearls, 2nd Ed., section 15.3 



Kompression 

Lauflängenkompression – Varianten 


Kompression 

Lauflängenkompression – Bitmuster 


Text: AAAABBBAABBBBBCCCCCCCCABCQAAA 

◮ einfach: Paare (Anzahl/Zeichen) 

◮ 4A3B2A5B8C1A1B1C1Q3A 

◮ Aufblähen durch einfache Zeichen 

◮ Einzelzeichen ohne Zählung: 

◮ 4A3B2A5B8CABCQ3A 

◮ Ziffern können nicht kodiert werden 

◮ Abhilfe: Escape-Zeichen (Q – selten!) 

◮ QDABBBAAQEBQHCABCQ@AAA 

◮ Codes repräsentieren Zeichen oder Anzahlen 

◮ Kodierung Escape-Zeichen 

................ 

.....XXXXXXX.... 

....X.....XX.... 

...XX......X.... 

...X.......X.... 

..XX............ 

..XX............ 

..XX............ 

...X............ 

...XX........... 

....XX.....X.... 

.....XXXXX...... 

................ 

................ 

◮ nur Anzahlen speichern 

◮ Zeile beginnt mit 0-Bit 

◮ 16 

5 7 4 

4 1 5 2 4 

3 2 6 1 4 

3 1 7 1 4 

2 2 12 

... 

◮ alternativ: Zeilenlänge angeben 



Kompression 


Lauflängenkompression – Implementierung 

#define out(z, k) do { fputc(k, ENC); fputc(z, ENC); \ 

i = 1; n += 2; } while(0) 

int rlenc(FILE *F, FILE *ENC) 

{ 

int i = 1, n = 0; 

char c0, c; 

if ( ( c0 = fgetc(F) ) == EOF ) return 0; 

while ( ( c = fgetc(F) ) != EOF ) { 

if ( c == c0 ) 

if ( ++i > 255 ) out(c, 255); 

else out(c0, i); 

c0 = c; 

} 

out(c0, i); 

return n; 

} 


Kompression Verlustlose Kompression 

Lauflängenkompression – Übung 

◮ Programme mit: 

◮ Bitmusterkompression 

◮ Escape-Zeichen 

◮ Zeichenfolgenwiederholungen 

◮ Programme zur Lauflängendekodierung 


Kompression 


Kompression 

Entropiekodierung 

Huffman-Kompression – Entropiekodierung 

◮ Idee: häufige Zeichen durch kurze Codes speichern 

◮ Voraussetzung: Häufigkeitsauswertung 

◮ Günstig bei unterschiedlichen Zeichenhäufigkeiten 

◮ Informationsgehalt 

◮ Entropie 

Entropie (Shannon) 

Zeichen z 

Alphabet mit n Zeichen z i , i = 1 . . . n 

Häufigkeit/Wahrscheinlichkeit p: 

p = p(z) 

Informationsgehalt I eines Zeichens z (Anzahl erforderlicher Bits): 

I (z) = log 2 

1 

p(z) = − log 2 p(z) 

Entropie H für einen Datensatz mit m verschiedenen Zeichen: 

m∑ 

H = − p i log 2 p i 

i=1 



Kompression 


Kompression 


Entropie – Information 

◮ Beispiel: Text mit drei verschiedenen Zeichen 

◮ Häufigkeiten: 

n 1 n 2 n 3 H 

1 4 100 0,31 

5 10 90 0,72 

10 30 65 1,27 

35 35 35 1,59 

◮ Entropie H steigt mit Gleichmäßigkeit der Verteilung 

◮ Thermodynamik: Entropie als Maß für Unordnung 

◮ Information vs. Chaos 


Entropie-Bestimmung – Implementation 

#include 

#include 

#define ALEN 256 

int main() { 

int k[ALEN] = {}; 

int c, i, n = 0, z = 0; 

double h = 0.0, p, f; 

while ( ( c = getchar() ) != EOF ) { 

k[c] ++; n ++; /* count characters frequency and total */ 

} 

f = 1.0 / n; /* use double precision arithmetic */ 

for ( i = 0; i < ALEN; i ++ ) { 

if ( k[i] ) { 

p = f * k[i]; h -= p * log2(p); 

} 

} 

printf("%lg\n", h); 

} 


Kompression 

Huffman-Kompression 

Kompression 


Huffman-Kompression – Baumkodierung 

Huffman-Kodierung 

Text: ABRACADABRA (11 Zeichen × 8 bit = 88 bit) 

(11) 

Beispiel-Code: 

A 

( 6) 

5 A: 0 

0 

1 

2 B: 10 

1 C: 1110 

1 D: 1111 

B 

( 4) 

0 

1 

2 R: 110 R 

( 2) 

0 

1 

1. zähle Häufigkeit aller Zeichen 

2. sortiere Zeichen nach Häufigkeit (Binärbaum – Heap) 

3. bilde Huffman-Codes durch Traversierung 

4. Speichere Coding 

5. Speichere Codes aller Zeichen 

0 

1 

Code: 0 10 110 0 1110 0 1111 0 10 110 0 (23 Bit) 

C 

D 



Huffman-Baum – Beispiel 

Kompression 


Kompression 

Aufbau Huffman-Baum – Beispiel 


Zeichenhäufigkeit (Beispiel) 

Zeichen Anzahl 

a 94 

b 51 

c 155 

d 100 

e 257 

f 124 

g 25 

h 78 

i 212 

j 14 

Frequency Heap 

(1110) 

Huffman Code Tree 

(1110) 

1 0 

(641) (469) 

1 0 1 0 

(362) (279) e(257) i(212) 

1 0 1 0 

(194) (168) c(155) f(124) 

0 1 0 1 

a(94) d(100) h(78) (90) 

1 0 

b(51) (39) 

1 0 

g(25) j(14) 



Kompression 


Kompression 


Aufbau Huffman-Baum – Beispiel 

Coding-Tabelle des Beispiels 

Zeichen Anzahl Code 

a 94 1110 

b 51 11011 

c 155 101 

d 100 1111 

e 257 01 

f 124 100 

g 25 110101 

h 78 1100 

i 212 00 

j 14 110100 

11111110 11011010 01101010 11111000 11100010 00100111 10101 ? 


Huffman-Codierung – Implementation 

#define ALEN 256 /* symbols in alphabet */ 

#define BLKSIZE 0x10000 

compress(FILE *F, FILE *C) 

{ 

int M, N; 

char a[BLKSIZE]; /* buffer */ 

int sym[2*ALEN], cnt[2*ALEN], pnt[2*ALEN]; 

int code[ALEN], len[ALEN]; 

M = input(F, a, BLKSIZE); /* read block */ 

N = frequency(a, cnt); /* N different symbols */ 

initheap(sym, cnt, ALEN); /* construct heap */ 

hufftree(N, sym, cnt, pnt); /* coding tree */ 

huffcode(pnt, code, len); /* codes and lengths */ 

output(C, code, len, a, M); 

} 


Kompression 


Kompression 


Huffman-Codierung – indirektes Einfügen Heap 

/* move symbol k in heap (size N) down to */ 

/* appropriate position - given by it’s count */ 

void idownheap(int sym[], int cnt[], int N, int k) 

{ 

int j, c; 

c = sym[k]; 

while (k

Kompression 


Kompression 


Huffman-Codierung – Baum 

void hufftree(int N, int sym[], int cnt[], int pnt[]) 

{ 

int t; 

while (N > 1) { 

t = sym[1]; sym[1] = sym[N--]; /* remove heap root */ 

idownheap(sym, cnt, N, 1); /* and reorder heap */ 

cnt[ALEN+N] = cnt[sym[1]] + cnt[t]; /* join lowest */ 

pnt[t] = ALEN + N; /* old root: parents lower child */ 

pnt[sym[1]] = -ALEN - N; /* new root: upper child */ 

sym[1] = ALEN + N; /* replace root by lowest pair */ 

idownheap(sym, cnt, N, 1); /* reorder heap */ 

} 

pnt[ALEN + N] = 0; /* tree’s root */ 

} 


Huffman-Codierung – Code-Bestimmung 

void huffcode(int pnt[], int code[], int len[]) 

{ 

int i, j, k, t, x; 

for (k = 0; k set bit */ 

x += j; t = -t; 

} 

t = pnt[t]; /* move up tree */ 

j += j; i++; /* next bit, increase code length*/ 

} 

code[k] = x; len[k] = i; 

} 

} 


Kompression 


Kompression 


Kompletter Huffman-Baum (für Programm-Quelltext) 

Huffman-Codierung – Fazit 

N(45) 

(7846) 

1 

0 

(4477) 

(3369) 

0 1 

1 

0 

0x20(1934) (2543) 

(1852) 

(1517) 

1 

0 

1 0 

1 0 

(1360) 

(1183) 

(998) 

(854) 

(785) 

(732) 

1 

0 

1 0 

1 

0 

1 

0 

1 0 0 1 

(702) 

(658) 

(605) (578) 

(527) 

(471) 

(431) 

(423) 

(406) (379) 0xA(365) (367) 

1 

0 0 1 

1 0 1 0 

1 0 

1 0 0 1 1 0 0 1 0 1 0 1 

(361) 

(341) e(317) n(341) 

(315) (290) i(289) t(289) (272) 

(255) 

(240) (231) ((212) r(219) )(212) (211) ,(198) ;(208) c(189) (190) o(183) (184) 

1 0 

1 0 

1 0 1 0 0 1 0 1 0 1 1 0 

1 0 0 1 1 0 

f(183) (178) 

(173) (168) 

(162) (153) =(147) (143) d(135) s(137) a(123) (132) *(119) (121) l(117) (114) 

(108) (103) 

0x9(94) (96) p(93) (91) 

1 0 1 0 0 1 0 1 

1 0 

1 

0 1 0 0 1 1 0 0 1 0 1 0 1 1 0 

(90) (88) h(87) u(86) [(84) (84) E(78) ](84) (78) (75) 

(73) 

(70) 0x22(66) (66) 

b(60) (61) m(57) (57) {(54) }(54) +(50) (53) 

0(47) (49) L(46) (45) 

1 0 

0 1 0 1 1 0 0 1 1 0 0 1 1 0 0 1 

1 0 1 0 0 1 1 0 

T(45) (44) (44) 

1(42) (42) 

k(39) (39) /(37) x(38) z(37) (36) >(34) A(36) -(34)

Kompression 

Verlustbehaftete Kompression – DCT 

Diskrete Kosinus-Transformation – DCT (JPEG) 

Kompression 


Diskrete Kosinus-Transformation – DCT 

Abbildung: 

◮ Idee: Signal-Approximation durch Überlagerung von Schwingungen 

◮ äquidistantes Signal x i über n Samples (z.B. Farbwerte in Pixelfolge) 

◮ Mittelwert + Oberschwingungen 

◮ Frequenz Grundschwingung: halbe Periode 

◮ Amplituden A k = ? 

X 0 = 

√ 

1 

n 

i=0 

X = dct(x), R → R 

∑n−1 

√ 

2 ∑n−1 

x i , X k = x i cos 

n 

i=0 

π(2i + 1)k 

, k = 1 . . . n − 1 

2n 

A 0 = 

√ 

1 

n X 0, A k = 

√ 

2 

n X k, k = 1 . . . n − 1 

http://www.faqs.org/faqs/compression-faq 


Vorteil: 

◮ rein reelle Rechnung 

◮ sehr performant berechenbar (ähnlich Fast Fourier Transformation, 

A = O(n log n)) 


Kompression 


Kompression 


DCT – Signalapproximation 

DCT – Approximation 

DCT - Signalapproximation 

140 

120 

Signal 

11. Oberschwingung 

Approximation 

◮ Inverse DCT approximiert Ursprungssignal x 

◮ Amplituden fallen oft mit steigender Frequenz 

Grauwert 0-255 

100 

80 

60 

√ √ 

1 2 

x i = 

n X 0 + 

n 

x = idct(X) 

∑n−1 

X k cos 

k=1 

π(2i + 1)k 

, i = 0 . . . n − 1 

2n 

0 2 4 6 8 10 12 14 

Pixel xi 



DCT – Kompression 

Kompression Verlustbehaftete Kompression – DCT 

◮ Idee: Quantisierung 

◮ untere Bits der Amplituden ausblenden 

◮ z.B. 0xb9 & ~7 = 0xb8 

◮ Anzahl Ausblendungs-Bits variabel 

◮ Ausblendung ↑ Qualität ↓ Kompression ↑ 

◮ Amplituden entropie-kodieren 

◮ optional: statt Amplituden ihre Differenzen kodieren 


Kompression 

DCT-Kompression – Beispiel 

Folge von 16 Pixeln (Grauwerte 0–255) 

x i X k X c x a 

101 380 380 102 

69 7 0 62 

64 -66 -64 69 

140 

82 -19 -16 81 

120 

89 46 48 80 

114 20 16 114 

140 11 16 140 

100 

130 6 0 129 

126 6 0 121 

80 

111 9 16 114 

90 12 16 97 60 

81 10 16 85 

76 -5 0 72 

75 -3 0 74 

86 -1 0 90 

86 2 0 91 

Grauwert 0-255 


DVT - Quantisierung 4/8 bit 

Signal 

Approximation 

0 2 4 6 8 10 12 14 

Pixel xi 


Kompression 


Kryptologie 

Kryptologie – Prinzipien 

DCT – Anwendung JPEG 

Kryptologie – Prinzip 

1. Farbraumkonvertierung RGB → YCbCr 

2. Blockbildung 8 × 8 Pixel 

3. zweidimensionale DCT über Block 

4. Quantisierung (skalierbar) 

5. Entropiekodierung 

6. Artefakte 

◮ Nachricht M 

◮ Schlüssel K 

◮ Verschlüsselungsverfahren E 

◮ Chiffre C = E(M, K) 

◮ Entschlüsselungsverfahren D (oft ähnlich E) 

◮ Entschlüssel K ′ (oft leicht aus K zu ermitteln) 

◮ M = D(C, K ′ ) 

◮ Kerckhoff-Prinzip 

◮ Problem: Sicherheit der Schlüssel 

JPEG 

PNG 



Kryptologie 

Kryptologie – Elementarverfahren 

Kryptologie 

Kryptologie – Elementarverfahren 

Kryptologie – Typen 

Caesar-Chiffre 

◮ Klassische Verfahren 

◮ Caesar-Chiffre (Verschiebung) 

◮ Substitutionschiffre (A, B, C, . . . → P, D, G, . . . ) 

◮ Vigenere-Chiffre (unterschiedliche Verschiebung) 

◮ Vernam-Chiffre 

◮ Schlüssellänge = Nachrichtenlänge 

◮ One-Time-Pad (Zufall) 

◮ XOR 

◮ Symmetrische Verfahren 

◮ DES (Data Encryption Standard), 3DES (Blockchiffre) 

◮ AES (Advanced Encryption Standard), Serpent, Twofish 

◮ Asymmetrische Verfahren 

◮ RSA (Rivest, Shamir, Adleman) 

◮ Elgamal 

◮ Alphabet A, n = |A| 

◮ Verschiebung k 

◮ Zeichen z ′ ← (z + k) mod n 

◮ k leicht zu erraten 

Beispiel: Rot13 (in Perl): 

#!/usr/bin/perl -p 

y/a-zA-Z/n-za-mN-ZA-M/; 

Übung: Rot13 in beliebiger Programmiersprache 



Kryptologie 

Symmetrische Kryptologie – DES 

Symmetrische Verschlüsselung – DES (IBM) 

Kryptologie 

Public Key – Diffie Hellman 

Asymmetrische Kryptologie 

◮ blockweise (64 bit) Verschlüsselung (56 Bit) 

◮ iteratives Vertauschen in 19 Schritten 

C = E(M, K) 

M = D(C, K) 

◮ verbessert als Triple-DES (3DES mit 112 Bit Key K) 

K = (K 1 , K 2 ) 

C = E(D(E(M, K 1 ), K 2 ), K 1 ) 

M = D(E(D(C, K 1 ), K 2 ), K 1 ) 

Idee: 

◮ jeder Teilnehmer verwendet ein Schlüsselpaar (G, P) 

◮ G geheim, P öffentlich 

◮ G und P einfach gemeinsam berechenbar 

◮ M = G(P(M)) 

◮ Ableiten von G aus P schwierig (Primzahlrechnung) 



Kryptologie 

Verschlüsselung und Primzahlen 


Kryptologie 


Public Key – RSA – Schlüssel-Konstruktion 

Berechne: 

Teiler von: 

1983731287 × 943765649 

1781137561759059887 

1. wähle Primzahlen p, q ≫ 1 (real über 100 Stellen) 

2. N = p · q, z.B. p = 47, q = 79 ⇒ N = 3713 

3. N öffentlich 

4. berechne Z = (p − 1)(q − 1), hier Z = 3588 

5. wähle Primzahl d > p, q, z.B. d = 97 

6. bestimme e mit (e · d) mod Z = 1 (z.B. e = 37, meist relativ klein) 

7. e öffentlich, d geheim 

8. p, q, Z verwerfen 



Kryptologie 


Kryptologie 

Kryptologie – Arithmetik großer Zahlen 

Public Key – RSA 

Public Key – RSA – Umsetzung 

◮ Verschlüsseln 

◮ öffentliche Schlüssel N und e des Adressaten beschaffen 

◮ C = M e mod N 

◮ Beispielnachricht: ATTACK..., M = 01 20 20 01 03 11 . . . 

◮ blockweise: 0120 37 mod 3713 = 1404, . . . 

◮ Entschlüsseln 

◮ M = C d mod N 

◮ im Beispiel: 1404 97 mod 3713 = 0120 

◮ Schwierigkeiten: 

◮ Primzahlen p, q finden 

◮ Arithmetik großer Zahlen (Karatsuba, FFT) 

◮ öffentlichen Schlüssel e aus Geheimschlüssel d finden (erweiterter 

Euklidischer Algorithmus) 

◮ deutlich rechenaufwändiger/langsamer als symmetrische Verfahren 

◮ Kombination mit symmetrischen Verfahren 



Kryptologie 


Diskurs: Multiplikation großer Zahlen 

Karatsuba: teile und herrsche rekursiv A = O(n log 2 3 ) ≈ O(n 1,585 ) 

x = x 2n−1 b 2n−1 + . . . + x n b n + x n−1 b n−1 + . . . + x 0 

= x h B + x l , B = b n 

y = y h B + y l 

Beispiel: 4853762169725189 

} {{ } 

2 n=16 

= } 48537621 {{ } · 

x h 

x · y = (x h B + x l ) · (y h B + y l ) 

B=10 n 

{}}{ 

10 8 + 69725189 } {{ } 

x l 

= x h y 

}{{} h B 2 + (x h y l + x l y h ) B + x 

} {{ } l y 

}{{} l 

H 

M+H+L 

L 

M = (x h − x l ) · (y l − y h ) = x h y l + x l y h − x h y h − x l y l 


Kryptologie 

Arithmetik mit großen Zahlen – Typen 

◮ Datentyp (Ziffer, Zahl, Vorzeichen) 

◮ Deklaration 


#define BASE 10 /* minimize conversion effort at I/O */ 

typedef int digit; 

struct bignum { 

int n; /* number of digits */ 

int neg; /* sign: 1 - negative, 0 - otherwise */ 

digit *d; /* digits stored in big endian */ 

}; 

typedef struct bignum bignum; 

◮ Konstruktor 

bignum *newnum(int n, int neg, digit *d) { 

bignum *b = (bignum *) resize(NULL, sizeof(bignum)); 

b->n = n; b->neg = neg; 

b->d = (digit *) resize(b->d, n * sizeof(digit)); 

return b; 

} 


Kryptologie Kryptologie – Arithmetik großer Zahlen 

Arithmetik mit großen Zahlen – Operationen 

◮ Beispiel Addition(Annahme: Vorzeichen, Ziffernanzahl gleich) 

Kryptologie 


Arithmetik mit großen Zahlen – Übungen 

◮ 

bignum *add(bignum *x, bignum *y) { 

int i, n = x->n; digit *u = x->d, *v = y->d, *w; 

bignum *z = newnum(n+1, x->neg, NULL); w = z->d; 

for ( i = 0; i < n; i ++ ) *(w++) = *(u++) + *(v++); 

carry(z); return z; 

} 

Übertrag 

void carry(bignum *a) { 

digit c = 0, *d = a->d; int n = a->n; 

for (d += n; n; n--) { 

c += *(--d); *d = c % BASE; c /= BASE; 

if ( *d < 0 ) { *d += BASE; c--; } 

} 

} 

◮ Bibliothek implementieren mit 

◮ Ein-, Ausgabe, 

◮ Addition, Negation, Subtraktion, 

◮ Multiplikation (klassisch und Karatsuba), 

◮ Hilfsfunktionen (Speicherverwaltung, Normalisierung, Vergleich); 

◮ Mit Standardbibliotheken vergleichen. 



Diskurs: Modulorechnung 


◮ Beispiel: Modul M = 13 

◮ implizite Modulorechnung 

◮ 7 + 11 =?, 15 + 21 =? 

◮ 7 · 5 =?, 8 · 9 =? 

◮ 8 − 3 =?, 3 − 7 =?, 7 − 12 = x ⇔ x + 12 = 7 

◮ 6 · 11 =?, 6 · 6 −1 = 1 ⇒ 6 −1 = 11 (Inverse) 

Kryptologie 

Modulorechnung für Potenzen 


◮ Beispiel: 87 173 mod 97 =? 

◮ implizite Modulorechnung: a ⊙ b ≡ (a · b) mod M 

◮ 87 173 mod 97 = 87 

} 

⊙ 87 ⊙ 87 

{{ 

. . . 87 ⊙ 87 

} 

mod97 

172 Multiplikation 

◮ 

◮ 

173 D = 10101101 B 

⇒ 87 173 mod 97 = 87 128+32+8+4+1 mod 97 

= 87 128 ⊙ 87 32 ⊙ 87 8 ⊙ 87 4 ⊙ 87 1 mod 97 

a 0 = 87 

a k+1 = a k ⊙ a k 

⇒ 87 173 mod 97 = a 0 ⊙ a 2 ⊙ a 3 ⊙ a 5 ⊙ a 

} {{ } 7 

10 Multiplikationen 



Kryptologie 


Modulorechnung für Potenzen – Programm 

typedef unsigned long long int unum; 

extern unum M; 

unum mprod(unum a, unum b) /* a * b */ 

{ 

return( ((a % M) * (b % M)) % M ); 

} 

unum mpow(unum a, unum b) /* a ** b */ 

{ 

unum c = 1; 

a = a % M; 

while ( b ) { 

if ( b & 1 ) c = mprod(c, a); 

a = mprod(a, a); b >>= 1; 

} 

return c; 

} 


RSA – Schlüsselzusammenhang 


◮ Modul Z = (p − 1)(q − 1) 

◮ Schlüssel d geheim 

◮ öffentlicher Schlüssel e =? 

◮ e invers zu d bezüglich Modul Z 

◮ Erweiterter Euklidischer Algorithmus: xgcd() 

e d ≡ 1 (mod Z) 

1 ≡ gcd(Z, d) 

= x · Z + y · d 

(x, y) = xgcd(Z, d) 

⇒ e = y mod Z 


Kryptologie 

Erweiterter Euklidischer Algorithmus 

g = gcd(a, b) 


g = x · a + y · b, (x, y) =? 

(x, y) = xgcd(a, b) 

r 0 = a = (s 0 = 1) · a + (t 0 = 0) · b 

r 1 = b = (s 1 = 0) · a + (t 1 = 1) · b q = ⌊r 0 /r 1 ⌋ 

r 2 = r 0 − q r 1 =(s 2 = s 0 − q s 1 ) · a+(t 2 = t 0 − q t 1 ) · b q = ⌊r 1 /r 2 ⌋ 

. . . . . . 

r n = 0=r n−2 − q r n−1 =(s n−2 − q s n−1 ) · a+(t n−2 − q t n−1 ) · b 

r n−1 = gcd(a, b) ⇒ x = s n−1 , y = t n−1 

Kryptologie 


Erweiterter Euklidischer Algorithmus – Beispiel 

◮ Modul M = 31 

◮ bestimme das Inverse e zu d = 13! 

◮ (x, y) = xgcd(M, d) 

◮ e = y 

mod M 

i r i = M · s i + d · t i q = ⌊r i−1 /r i ⌋ 

0 31= 31 · 1 + 13 · 0 

1 13= 31 · 0 + 13 · 1 2 

2 5 = 31 · 1 + 13 · −2 2 

3 3 =31 · −2+ 13 · 5 1 

4 2 = 31 · 3 + 13 · −7 1 

5 1 =31 · −5+ 13 · 12 2 

n = 6 0 = 31 · 13 +13 · −31 

⇒ e = t n−1 = 12 wegen 12 · 13 ≡ 1 (mod 31) 



Kryptologie 


Erweiterter Euklidischer Algorithmus – Implementation 

Public Key – Anwendung 

Kryptologie 

Kryptologie – Anwendung 

int xgcd(int a, int b, int *x, int *y) { 

int r[2] = {a, b}, s[2] = {1, 0}, t[2] = {0, 1}, i, n; 

A 

M 

} 

for ( i = 0; r[n = !i]; i = n ) { 

int q = r[i] / r[n]; 

r[i] -= q * r[n]; 

s[i] -= q * s[n]; 

t[i] -= q * t[n]; 

} 

*x = s[i]; *y = t[i]; /* (x, y) = xgcd(a, b) */ 

return r[i]; /* = gcd(a, b) */ 

M 

S 

GS 

PS 

C 

GA 

PA 

E 

GE 

PE 

M 



Kryptologie 

Kryptologie – Anwendung 

Geometrie 

Geometrische Objekte 

Public Key – RSA – Übung 

Koordinaten 

◮ Beispielzahlen p, q, d, e bestimmen/ermitteln, 

◮ Nachricht M erstellen und in Chiffre C verschlüsseln, 

◮ Chiffre C entschlüsseln. 

y 

r 

(x,y) 

◮ kartesisch: (x, y) 

◮ polar: (r, ϕ) 

◮ komplex: 

◮ z = x + i y = r e 

i ϕ 

◮ x = r cos ϕ, y = r sin ϕ 

ϕ 

x 



Geometrie 

Punkte, Strecken, Polygone 


Geometrie 

Geometrische Objekte kodieren 


A 

Punkt 

(x,y) 

Strecke 

P 

(x 1 

,y 1 

) 

A 

Q 

(x 2 

,y 2 

) 

F 

(x 1 

,y 1 

) 

B 

Rechteck 

(x 1 

,y 1 

) 

E 

D 

C 

Polygon 

A B 

(x 2 

,y 2 

) 

(x 2 

,y 2 

) 

◮ Koordinaten 

◮ Kennzeichen 

struct point { int x, int y; char c; }; 

struct line { struct point p1, p2; }; 

struct rect { struct point ul, or; }; 

struct point polygon[N]; 

typedef struct point point; 

typedef struct line line; 



Geometrie 

Schnitt von Strecken 

Geometrie 



Orientierung von Strecken 

Funktion ccw(P0, P1, P2) (counter clockwise) 

D 

B 

P2 

◮ P 0 P 2 steiler als P 0 P 1 

⇒ ccw() = 1 

A 

C 

P0 

dx2 

ccw 

dy2 

dx1 

P1 

dy1 

◮ P 0 P 2 flacher als P 0 P 1 

⇒ ccw() = −1 

◮ P 0 , P 1 , P 2 kollinear: 

◮ P 0 → P 1 → P 2 

⇒ ccw() = 1 

◮ P 0 → P 2 → P 1 

⇒ ccw() = 0 

◮ P2 → P 0 → P 1 

⇒ ccw() = −1 



Geometrie 


Orientierung von Strecken – CCW(Implementierung) 

int ccw(point p0, point p1, point p2) 

{ /* P2 left to P0->P1 ? */ 

int dx1, dx2, dy1, dy2; 

dx1 = p1.x - p0.x; dy1 = p1.y - p0.y; 

dx2 = p2.x - p0.x; dy2 = p2.y - p0.y; 

if ( dx1*dy2 > dy1*dx2 ) /* slope P0-P1, P0-P2 */ 

return 1; /* left - ccw */ 

if ( dx1*dy2 < dy1*dx2 ) 

return -1; /* right */ 

/* else collinear cases */ 

if ((dx1*dx2 < 0) || (dy1*dy2 < 0)) 

return -1; /* different directions from P0 */ 

if ((dx1*dx1 + dy1*dy1) < (dx2*dx2 + dy2*dy2)) 

return 1; /* P0 -> P1 -> P2 */ 

return 0; /* P0 -> P2 -> P1 (P2 in between) */ 

} 



Strecken schneiden sich, wenn 

Geometrie 


◮ Enden der Strecke AB auf verschiedenen Seiten von CD und 

◮ Enden der Strecke CD auf verschiedenen Seiten von AB 

int intersect(line l1, line l2) 

{ 

return ( ((ccw(l1.p1, l1.p2, l2.p1) 

* ccw(l1.p1, l1.p2, l2.p2))

Geometrie 

Einfacher geschlossener Pfad 

Polygon 

Geometrie 

Polygon 

Einfacher geschlossener Pfad – Algorithmus 

◮ gegeben: Punktemenge P i 

◮ gesucht: Linienzug, der 

◮ alle Punkte erreicht 

◮ sich selbst nicht schneidet 

1. wähle einen (innenliegenden) Punkt als Anker A (Ursprung) 

2. berechne Winkel α i zwischen Abszisse und A P i 

3. sortiere Punkte nach aufsteigendem Winkel 

4. verbinde die sortierten Punkte 

Aufwand: A =? 



Geometrie 

Polygon 

Einfacher geschlossener Pfad – Ablauf 

Geometrie 

Polygon 

Einfacher geschlossener Pfad – Winkel 

M 

4 

J 

α i = atan2(∆y, ∆x) 

C 

I 

H 

N 

E 

B 

K 

A 

F 

G 

3 

L 

2 

D 

1 

0 

double a(point p1, point p2) 

{ 

/* use if math is fast */ 

int dx, dy; 

dx = p2.x - p1.x; 

dy = p2.y - p1.y; 

return atan2(dy, dx); 

/* radians */ 

} 



Enthaltensein in Polygon 

Geometrie 

Polygon 

Geometrie 

Polygon 

Enthaltensein in Polygon – Umlauf 

◮ Polygon P i , i = 1 . . . n 

◮ Punkt A in Polygon? 

◮ Testlinie von außen bis A 

◮ Anzahl Schnitte ⇒ innen/außen? 

A 

A 

1. Testlinie −∞ → A 

2. laufe um Polygon 

3. ignoriere P i auf Testlinie 

4. zähle Schnitte m 

5. m ungerade ⇒ A innen 

P1 

Pn 

P2 

P3 

P4 

A 

A 

A 



Geometrie 

Polygon 

Geometrie 

Polygon 

Enthaltensein in Polygon – Implementation 

Enthaltensein in Polygon (einfach, konvex) 

int inside(point A, point p[], int N) 

{ 

int i, j = 0, cnt = 0; /* j: last point not on test line*/ 

line lt, lp; /* lt: test line, lp: intersection line */ 

p[0] = p[N]; p[N + 1] = p[1]; /* close polygon */ 

lt.p1 = lt.p2 = A; 

lt.p1.x = -INT_MAX; /* test line starts far away */ 

for ( i = 1; i

Geometrie 

Polygon 

Geometrie 

Polygon 

Konvexe Hülle 

Konvexe Hülle – Einwickeln 

1. Punkte P i , i = 1 . . . n 

2. (außenliegender) Ankerpunkt A 

3. A P i : Winkel α i 

4. α min : Linie 

A = O(n 2 ) 

I 

H 

J 

K 

L 

O 

G 

F 

M 

N 

E 

C 

A 

D 

B 

I 

H 

J 

K 

L 

O 

G 

F 

M 

N 

E 

C 

A 

D 

B 



Geometrie 

Polygon 

Konvexe Hülle – Einwickeln: Implementation 

int wrap(struct point p[], int N) 

{ 

int i = 1, min, M; double th, th0, al; point t; 

for (min = 0; i < N; i++) 

if (p[i].y < p[min].y) min = i; 

p[N] = p[min]; th = 0.0; 

for (M = 0; M < N; M++) { 

swap(p[M], p[min]); min = N; th0 = th; th = 360.0; 

for (i = M + 1; i

Geometrie 

Polygon 

Geometrie 

Polygon 

Konvexe Hülle – Graham(Ablauf) 

Konvexe Hülle – Graham: Implementation 

A 

E 

C 

D 

B 

int grahamscan(point p[], int N) 

{ 

int i, min, M; 

point t; 

for (min = 1, i = 2; i

Geometrie 

Polygonfläche – Berechnung 

Polygon 

Geometrie 

Polygonfläche – Implementation 

Polygon 

∑n−1 

2A = 2 a i = 

i=0 

= 

= 

= 

= 

∑n−1 

x i y i+1 − x i+1 y i 

i=0 

n−1 

∑ 

x i y i+1 − 

i=0 

n∑ 

x i y i+1 − 

i=1 

n∑ 

x i y i−1 

i=1 

n∑ 

x i y i−1 , P n+1 = P 1 

i=1 

n∑ 

x i y i+1 − x i y i−1 

i=1 

n∑ 

x i (y i+1 − y i−1 ) 

i=1 

double pgarea(point p[], int n) 

{ 

double a; /* area */ 

int i; 

} 

/* initialize area - avoid modulo operation */ 

a = p[0].x * (p[1].y - p[n-1].y) + 

p[n-1].x * (p[0].y - p[n-2].y); 

for ( i = 1; i < n-1; i ++ ) { 

a += p[i].x * (p[i+1].y - p[i-1].y); 

} 

a = ( a < 0 ) ? (-a) : a; /* area positive */ 

return(a/2); 



Geometrie 

Schnelles Zeichnen – Kreis 

Geometrie 


Kreis im Raster 

Kreis im Raster – Trigonometrie 

y 

45° 

ϕ 

r 

(x,y) 

x 

y = √ r 2 − x 2 

x = r cos ϕ 

y = r sin ϕ 

◮ Raster-Einheit: 1 Pixel 

◮ Symmetrie im Kreis 

void trigo(int r) 

{ 

double pi4, phi, rad, x, y; 

int i, n; 

pi4 = atan(1.0); /* pi/4 */ 

rad = (double) abs(r); 

n = rnd(rad * pi4); /* pixels */ 

for ( i = 0; i < n; i ++ ) { 

phi = (pi4 * i) / n; 

x = rad * sin(phi); 

y = rad * cos(phi); 

plot(r, rnd(x), rnd(y)); 

} 

} 

int rnd(double x) { 

/* round to */ 

/* nearest int */ 

int s = 1, r; 

if ( x < 0 ) { 

x = -x; 

s = -1; 

} 

r = (int) (x+0.5); 

return (s * r); 

} 



Geometrie 


Geometrie 


Kreis im Raster – Wurzel 

Kreis im Raster – Bresenham 

y 

void wurzel(int r) 

{ 

double x, y, yh, r2; 

yh = abs(r) / sqrt(2.0); 

r2 = (double) (r * r); 

for ( y = 0.0; y 0 ⇒ y → y − 1 

Geometrie 


Kreis im Raster – Bresenham(Implementation) 

void bresenham(int r) 

{ 

int x = 0, y, f = 0; 

y = abs(r); /* start at top */ 

while (x < y) { 

plot(r, x, y); /* show pixel */ 

++ x; /* next pixel right */ 

if (f < 0) { /* edge inside circle? */ 

f += 2*x - 1; /* yes, move right */ 

} else { 

f += 2*(x - y); /* no */ 

--y; /* move down */ 

} 

} 

} 



Graphen 

Graphen 


Graphen 

Graphen – Datenstrukturen 

F 

M 

D 

E 

N 

1 2 

1 

2 

L 

O 

A 

G 

ungerichtet 

K 

J 

C 

B 

H 

I 

◮ (un-)gerichtet 

◮ (un-)gewichtet 

◮ licht/dicht 

◮ (a-)zyklisch 

◮ V Knoten 

◮ E Kanten 

◮ Pfad 

◮ Graph/Baum 

◮ Zusammenhang 

◮ Spannbaum 

Adjazenzmatrix 

ungerichtet 

A B C D E F G 

A 1 1 1 0 0 1 1 

B 1 1 0 0 0 0 0 

C 1 0 1 0 0 0 0 

D 0 0 0 1 1 1 0 

E 0 0 0 1 1 1 1 

F 1 0 0 1 1 1 0 

G 1 0 0 0 1 0 1 

gerichtet 

H I J K 

H 0 1 1 1 

I 0 0 0 0 

J 0 0 0 1 

K 0 0 0 0 

gewichtet 

L M N O 

L 1 1 0 2 

M 1 1 1 0 

N 0 1 1 2 

O 2 0 2 1 

gewichtet 

gerichtet 



Graphen 


Graphen 


Graphen – Datenstrukturen 

Adjazenzstruktur zu 1) 

Liste der Nachbarn 

#define Vmax 256 

struct nb { 

int c, w; 

struct nb *next; 

}; 

typedef struct nb nb; 

nb *alist[Vmax]; 

A 

B 

C 

F 

G 

B 

A 

C 

A 

D 

E 

F 

E 

D 

F 

G 

F 

A 

D 

E 

G 

A 

E 

Graphen – Visualisierung 

Beispiel zu 1) mit Graphviz (http://www.graphviz.org) 

digraph undir { 

fontname=Helvetica; 

label = "ungerichtet"; 

splines = false; 

color = none; 

edge [arrowhead=none, fontname=Helvetica]; 

node [shape=circle, width=0.3, fontname=Helvetica]; 

A -> { B C G }; 

A -> F [minlen=3]; 

D -> { E F}; 

E -> { F G}; 

} 



Graphen 

Graphen – Traversierung/Suche 

Graphen – Suche 

Graphen 

Graphen – Tiefensuche(rekursiv) 


int id; 

void dfs() 

{ 

node *v; 

id = 0; 

for (v = fstnode(); v != NULL; v = nxtnode(v)) { 

if ( unseen(v) ) { 

visit(v); 

} 

} 

} 

void visit(node *v) 

{ 

edge *e; 

node *t; 

} 

mark(v, ++id); 

for (e = fstout(v); e != NULL; e = nxtout(e)) { 

t = e->head; 

if ( unseen(t) ) { 

visit(t); 

} 

} 



Graphen Graphen – Suche 

Graphen – Verlauf Tiefensuche (rekursiv) 

l 

k 

q 

i 

r 

n 

t 

h 

j 

u 

s 

e 

g 

f 

v 

d 

w 

z 

a 

x 

b 

c 

y 


Graphen 


Graphen – Tiefen-/Breitensuche(iterativ) 

traverse() 

{ 

node *v; 



visit(v); 

} 

} 

} 

int dfs() 

{ 

stack_init(); 

empty = stackempty; 

insert = push; 

extract = pop; 

traverse(); 

} 

int bfs() 

{ 

strcpy(method, "bfs"); 

queue_init(); 

empty = queueempty; 

insert = put; 

extract = get; 

traverse(); 

} 


Graphen 


Graphen 


Graphen – Traversierung Tiefen-/Breitensuche 

void visit(node *v) 

{ 

edge *e; 

node *t; 

id = 0; 

insert(v); 

while ( !empty() ) { 

v = extract(); 

mark(v, ++id); 

for (e = fstout(v); e != NULL; e = nxtout(e)) { 

t = e->head; 

if ( unseen(t) ) { 

insert(t); 

mark(t, -1); 

} 

} 

} 

} 


Graphen – Tiefensuche Verlauf (iterativ per Stack) 

l 

k 

q 

i 

r 

n 

t 

h 

j 

u 

s 

e 

g 

f 

v 

d 

w 

z 

a 

x 

b 

c 

y 


Graphen 


Graphen 


Graphen – Breitensuche Verlauf (per Queue) 

Graphen – Tiefen-/Breitensuche Vergleich 

k 

l 

h 

i 

j 

q 

r 

n 

t 

◮ Tiefensuche: Bestimmung der Pfadlängen 

◮ Breitensuche: Bestimmung kürzester Pfade 

e 

f 

g 

d 

s 

u 

v 

a 

b 

c 

z 

w 

x 

y 



Graphen 


Graphen 


Graphentraversierung – Aufwand 

Graphen – Zusammenhang 

◮ Adjazenzmatrix: A = O(n 2 ) 

◮ Adjazenzstruktur: A = O(n) 

int traverse() 

{ 

node *v; 

int n = 0; 



visit(v); 

n ++; 

} 

} 

return n; 

} 



Graphen 


Graphen 


Graphen – Zyklen 

Graphen – Topologisches Sortieren 

◮ zusammenhängender Graph 

◮ zyklenfrei: jeder Knoten ist Kantenende (Ausnahme: Wurzel) 

◮ V − E = 1 ⇒ zyklenfrei 

◮ V = E ⇒ ein Zyklus 

◮ E − V = n ⇒ n + 1 Zyklen 

◮ DAG (directed, acyclic 

graph) 

◮ Topologische Sortierung: 

A B F E D J K L M G C H I 

◮ Tiefensuche mit 

umgekehrter Richtung 

→ umgekehrte 

topologische Sortierung 

E 

D 

F 

A 

C 

B 

H 

G 

L 

J 

M 

K 

I 



Graphen – Kürzeste Pfade 

Graphen Graphen – kürzeste Pfade 

◮ gegeben: Netz aus Knoten mit gewichteten Kanten 

◮ gesucht: die kürzesten Wege im Netz 


◮ Transport 

◮ Netzwerktechnik (Routing: OSPF) 


Graphen 

Graphen – kürzeste Pfade 

1: procedure ShortestPath(Graph, start): 

2: for all v ∈ Graph do 

3: dist(v) ← ∞, pre(v) ← 0 

4: end for 

5: dist(start) ← 0, Q ← v ∈ Graph 

6: while |Q| > 0 do 

7: u ← v ∈ Q, dist(v) = min 

8: if dist(u) < ∞ then 

9: remove(u) from Q 

10: for all v ∈ Neighbour(u) do 

11: d ← dist(u) + dist(u, v) 

12: if d < dist(v) then 

13: dist(v) ← d, pre(v) ← u 

14: end if 

15: end for 

16: end if 

17: end while 



Graphen 


Graphen – Kürzeste Pfade/Prioritätssuche 

#define unseen -(INT_MAX - 1) 

int dist[Vmax], pre[Vmax], id = 0; 

listpfs() 

{ 

int k; 

pqinitialize(); 

for ( k = 0; k < N; k++ ) 

dist[k] = -unseen; 

for ( k = 0; k < N; k++ ) 

if ( dist[k] == -unseen ) 

visit(idx[k]); 

} 


Graphen 


Graphen – Kürzeste Pfade/Traversierung 

void visit(int k) 

{ 

struct node *t; int prio; 

if (pqupdate(k, unseen) != 0) pre[k] = 0; 

while (!pqempty()) { 

id++; k = pqremove(); dist[k] = -dist[k]; 

if (dist[k] == unseen) dist[k] = 0; 

for (t = alist[k]; t != t->next; t = t->next) { 

if (dist[t->c] < 0) { 

if (pqupdate(t->c, prio = dist[k]+t->w)) { 

dist[t->c] = -prio; pre[t->c] = k; 

} 

} 

} 

} 

} 


Graphen 


Graphen – Kürzeste Pfade/Implementation 

Schwierige Probleme 

Weiterführende Themen 

Schwierige Probleme 

◮ Prioritätswarteschlange: Heap 

◮ A = O((E + V ) log V ) 

◮ Analogie zu Tiefen-/Breitensuche 

◮ 

Ähnliche Probleme: z.B. minimaler Spannbaum 

◮ Aufwand steigt stärker als polynomial 

◮ Beispiele: 

◮ Handelsreisendenproblem 

◮ Rucksackproblem 

◮ Aussagenlogik (Cook) 

◮ diophantische Gleichungen 



NP-Vollständigkeit 

Weiterführende Themen 

NP-Vollständigkeit 

◮ Klasseneinteilung Probleme: 

P: können mit deterministischen Automaten in 

polynomialer Zeit gelöst werden 

NP: können mit nondeterministischen Automaten in 

polynomialer Zeit gelöst werden 

NP-vollständig: eines lösbar ⇒ alle lösbar 

◮ Nondeterministischer Automat 

◮ Ungelöst: P = NP? 

◮ Approximation

Präsentation - Torsten Finke

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?