4. Übung – Algorithmen Ialgo2.iti.kit.edu/documents/algo1-2014/uebung_04.pdf · Unbounded...

1 Julian Arz, Timo Bingmann, Sebastian Schlag4. Übung – Algorithmen I

Fakultät für InformatikInstitut für Theoretische Informatik

INSTITUT FÜR THEORETISCHE INFORMATIK, PROF. SANDERS

4. Übung – Algorithmen IJulian Arz, Timo Bingmann, Sebastian Schlag

KIT – Universität des Landes Baden-Württemberg undnationales Forschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu



Unbounded Hashtables

Unbounded HashtablesAmortisierung



ProblemAnzahl der einzufügenden Elemente nicht bekannt

Was passiert wenn eine Hashtabelle zu voll wird?Hashing mit linearer Suche: ÜberlaufHashing mit verk. Liste: Verlangsamerung der Operationen

Lösung: Hashtabelle dynamisch vergrößern und verkleinern

Unbounded Hashtablesmit verketteten Listen



Modifizierte Operationenfind : keine Veränderunginsert : Größe verdoppeln, bei #Slots Elementeremove: Größe halbieren, bei 1

4#Slots Elemente

Erinnert an unbeschränkte Arrays

Unbounded Hashtablesmit verketteten Listen



Problem:Hashfunktion muss zur Tabellengröße passenGrund: Soll möglichst gleichverteilt streuenNach Größenänderung nicht mehr der Fall

Lösung: Bei Größenänderung neue Hashfunktion wählen

Dann: vollständiger „rehash“D.h.: Elemente nicht nur kopieren, sondern alle neu einfügen

Unbounded HashtableLaufzeit



Laufzeit von insert, find, remove (exkl. rehash):Unverändert erwartet O(1)

Laufzeit von rehash:Amortisiert O(1)

Argumentation wie bei unbeschränkten ArraysBankkontomethode

Neue Hashfunktion wählenBeispiel



Hashen von Zahlen

h(x) = x mod TabellengrößeProblem: Tabellengröße = 2k

Entspricht Extrahieren der k niedrigsten BitsNur k niedrigsten Bits nehmen Einfluss

Besser:Tabellengröße immer PrimzahlMöglichst weit entfernt von Zweierpotenzen

Implementierung:PrimzahlentabelleWähle bei Größenänderungen die nächstgrößere Primzahl aus Tabelle

RehashBeispiel



insert: 22, 42, 9, 25, 18 und 96h1(x) = x mod 5, h2(x) = x mod 11

43210

−→42−→22

−→25

−→ 9

−→18

109876543210 −→22

−→42−→ 9

−→25

−→18−→96



Universalität von Hashfunktionen

Analyse für zufällige Hash-FunktionenWiederholung



Satz∀k : die erwartete Anzahl kollidierender Elemente ist O(1),falls |M| = O(m).

für festes k definiere Kollisionslänge X := |t [h(k)]|die Anzahl der Element die auf den gleichen Slot gehasht werden

Wahrscheinlichkeit für KollisionWiederholung



M ′ := {e ∈ M : key(e) 6= k}0-1 ZV Xe: 1 für h(e) = h(k),e ∈ M ′,0 sonst

E [X ] = E [∑e∈M′

Xe] =∑e∈M′

E [Xe] =∑e∈M′

P [Xe = 1] = |M ′| · P [Xe = 1] =

= |M ′| ·

Anzahl aller Hashfunktionen mit h(e)=h(k)︷︸︸︷m|Key |−1

m|Key |︸︷︷︸Anzahl aller Hashfunktionen

=

= |M ′| · 1m

=|M ′|m

= O(1)

Wichtig:Wahrscheinlichkeit über Wahl der HashfunktionHashfunktion zufällig aus Menge aller möglichen ausgewählt

Universelles Hashing



Idee: nutze nur bestimmte “einfache” Hash-Funktionen

H ⊆ {0..m − 1}Key ist universell falls für alle x , y in Key mit x 6= yund zufälligem h ∈ H,

P [h(x) = h(y)] =1m.

Theorem gilt auch für universelle Familien von Hashfunktionen



Universalität von HashfunktionenBeispiele

Bit-Matrix-MultiplikationUniversalität



hM(x) = Mx

M ∈ {0,1}w×k , Arithmetik mod 2 (XOR and AND)Anzahl Slots m in Hashtabelle m = 2w

Beachte: x ∈ {0,1}k und Mx ∈ {0,1}w

M =

(1 0 1 10 1 1 1

)und x = (1,0,0,1)T

⇒ Mx mod 2 = (0,1)T




hM(x) = Mx ,M ∈ {0,1}w×k ,m = 2w

Zu zeigen, für alle x 6= y und hM gilt

P[hM(x) = hM(y)] = 1m

für ein M gewählt aus allen möglichen.

h(x) = h(y)

⇔Mx = My

⇔∀i ∈ {1, . . . ,w} :

k⊕j=1

Mijxj =

k⊕j=1

Mijyj




∀i ∈ {1, . . . ,w} :⊕k

j=1 Mijxj =⊕k

j=1 Mijyj

Anzahl Matrizen, die obiges Gleichungssystem lösen?

w Gleichungen und wk Variablen Mij

⇒ unterbestimmt, x 6= ywk −w Vektoren spannen Lösungsraum auf⇒ 2wk−w Lösungen

Anzahl möglicher Matrizen M: 2wk

P[hM(x) = hM(y)] = 2wk−w

2wk = 2−w = 12w = 1

m

Anwendung von Hashing in derComputersicherheit



Passwort-HashesZertifikate (z.B. zur Verwendung von https)SSH-Fingerprint

etwas andere Anforderungen:typischerweise längere AusgabeGeschwindigkeit der Berechnung weniger entscheidendwenig Hinweise vom Bild auf das UrbildKollisionen schwer zu erzeugen

Beispiele: MD5, SHA-1



Hashing von Zeichenketten

Nicht: kryptographische Message Digests (MD5, SHA, etc)!




Gegeben Zeichenkette s = 〈x0, x1, . . . , xn−1〉.Ganz schlechte Hashfunktion:

h(s) =

n−1∑i=0

xi mod 2k

Etwas weniger schlechte Hashfunktion:

h(s) = 1 · x0 + 3 · x1 + 5 · x2 + 7 · x3 + · · · mod 2k




Hashfunktion aus frühen BerkeleyDB/SDBM:

uint32 hash(String str){

uint32 h = 0;for (int i = 0; i < str.size(); ++i)

h = h * 65599 + str[i];return h;

}

Als Bitoperationen:

h = (h << 6) + (h << 16) - h + str[i];

Moderne Hashfunktionen



Fowler–Noll–Vo Hashfunktion (DNS-Server, Databases)

unsigned int hash(String str){

unsigned int h = offset;for (int i = 0; i < str.size(); ++i){

h = h * prime;h = h XOR str[i];

}return h;

}

Für 32-bit: offset = 2166136261, prime = 16777619.Für 64-bit: offset = 14695981039346656037, prime = 1099511628211.

Noch aktueller: MurmerHash (Perl, Hadoop, etc)

Sortieren – Rebooted



(1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5), (1, 2, 4, 5, 3), (1, 2, 5, 3, 4), (1, 2, 5, 4, 3),(1, 3, 2, 4, 5), (1, 3, 2, 5, 4), (1, 3, 4, 2, 5), (1, 3, 4, 5, 2), (1, 3, 5, 2, 4), (1, 3, 5, 4, 2),(1, 4, 2, 3, 5), (1, 4, 2, 5, 3), (1, 4, 3, 2, 5), (1, 4, 3, 5, 2), (1, 4, 5, 2, 3), (1, 4, 5, 3, 2),(1, 5, 2, 3, 4), (1, 5, 2, 4, 3), (1, 5, 3, 2, 4), (1, 5, 3, 4, 2), (1, 5, 4, 2, 3), (1, 5, 4, 3, 2),(2, 1, 3, 4, 5), (2, 1, 3, 5, 4), (2, 1, 4, 3, 5), (2, 1, 4, 5, 3), (2, 1, 5, 3, 4), (2, 1, 5, 4, 3),(2, 3, 1, 4, 5), (2, 3, 1, 5, 4), (2, 3, 4, 1, 5), (2, 3, 4, 5, 1), (2, 3, 5, 1, 4), (2, 3, 5, 4, 1),(2, 4, 1, 3, 5), (2, 4, 1, 5, 3), (2, 4, 3, 1, 5), (2, 4, 3, 5, 1), (2, 4, 5, 1, 3), (2, 4, 5, 3, 1),(2, 5, 1, 3, 4), (2, 5, 1, 4, 3), (2, 5, 3, 1, 4), (2, 5, 3, 4, 1), (2, 5, 4, 1, 3), (2, 5, 4, 3, 1),(3, 1, 2, 4, 5), (3, 1, 2, 5, 4), (3, 1, 4, 2, 5), (3, 1, 4, 5, 2), (3, 1, 5, 2, 4), (3, 1, 5, 4, 2),(3, 2, 1, 4, 5), (3, 2, 1, 5, 4), (3, 2, 4, 1, 5), (3, 2, 4, 5, 1), (3, 2, 5, 1, 4), (3, 2, 5, 4, 1),(3, 4, 1, 2, 5), (3, 4, 1, 5, 2), (3, 4, 2, 1, 5), (3, 4, 2, 5, 1), (3, 4, 5, 1, 2), (3, 4, 5, 2, 1),(3, 5, 1, 2, 4), (3, 5, 1, 4, 2), (3, 5, 2, 1, 4), (3, 5, 2, 4, 1), (3, 5, 4, 1, 2), (3, 5, 4, 2, 1),(4, 1, 2, 3, 5), (4, 1, 2, 5, 3), (4, 1, 3, 2, 5), (4, 1, 3, 5, 2), (4, 1, 5, 2, 3), (4, 1, 5, 3, 2),(4, 2, 1, 3, 5), (4, 2, 1, 5, 3), (4, 2, 3, 1, 5), (4, 2, 3, 5, 1), (4, 2, 5, 1, 3), (4, 2, 5, 3, 1),(4, 3, 1, 2, 5), (4, 3, 1, 5, 2), (4, 3, 2, 1, 5), (4, 3, 2, 5, 1), (4, 3, 5, 1, 2), (4, 3, 5, 2, 1),(4, 5, 1, 2, 3), (4, 5, 1, 3, 2), (4, 5, 2, 1, 3), (4, 5, 2, 3, 1), (4, 5, 3, 1, 2), (4, 5, 3, 2, 1),(5, 1, 2, 3, 4), (5, 1, 2, 4, 3), (5, 1, 3, 2, 4), (5, 1, 3, 4, 2), (5, 1, 4, 2, 3), (5, 1, 4, 3, 2),(5, 2, 1, 3, 4), (5, 2, 1, 4, 3), (5, 2, 3, 1, 4), (5, 2, 3, 4, 1), (5, 2, 4, 1, 3), (5, 2, 4, 3, 1),(5, 3, 1, 2, 4), (5, 3, 1, 4, 2), (5, 3, 2, 1, 4), (5, 3, 2, 4, 1), (5, 3, 4, 1, 2), (5, 3, 4, 2, 1),(5, 4, 1, 2, 3), (5, 4, 1, 3, 2), (5, 4, 2, 1, 3), (5, 4, 2, 3, 1), (5, 4, 3, 1, 2), (5, 4, 3, 2, 1).

Sortieren – Rebooted



Die meisten intuitiven Sortieralgorithmen basieren auf:

1 Selection: finde das kleinste (oder größte) Element, und trenne esvon den übrigen. Wiederhole bis alle ausgewählt wurden.

2 Insertion: betrachte Elemente einzeln und füge in sortierteTeilfolgen ein.

3 Exchange: vertauscht ungeordnete Paare von Elemente, bis keineweitere Vertauschungen notwendig sind.

4 Enumeration: vergleiche ein Element mit allen anderen. Dannplatziere es endgültig an Hand der Anzahl kleiner Elemente.

In der Regel erreichen diese nicht die untere Schranke Θ(n log n).

Selection Sort



Function selectionSort(A : Array of Element; n : N)for i := 0 to n − 1 do

min := ifor j := i + 1 to n − 1 do // Suche kleinstes Element

if A[j ] < A[min] thenmin := j

endforswap(A[i ],A[min]) // Tausche Element an Anfanginvariant A[0] ≤ · · · ≤ A[i ]

endfor

Wieviele Vergleiche? immern(n − 1)

2= Θ

(n2)

!

Selection Sort







endfor

Wieviele Vergleiche?

immern(n − 1)

2= Θ

(n2)

!

Selection Sort







endfor

Wieviele Vergleiche? immern(n − 1)

2= Θ

(n2)

!

Insertion Sort



Function insertionSort(A : Array of Element; n : N)for i := 1 to n − 1 do // {A[0]} ist sortiert

j := ix := A[j ]while (j > 0) & (A[j − 1] > x) // Finde richtige Stelle j

A[j ] := A[j − 1] // Schiebe größere Elementej := j − 1 // nach hinten.

endwhileA[j ] := x // Setze Elementinvariant A[0] ≤ · · · ≤ A[i ]

endfor

Insertion Sort







endfor

Vermeide j > 0 mit einem Sentinel A[−1] := −∞.

Insertion Sort







endfor

Wieviele Vergleiche? worst-case?

Insertion Sort







endfor

Wieviele Vergleiche? worst-case:n (n − 1)

2= Θ

(n2)

, average?

Insertion Sort




j := i

x := A[j ]

while (j > 0) & (A[j − 1] > A[j ]) // Finde richtige Stelle jswap(A[j − 1],A[j ]) // Schiebe größere Elementej := j − 1 // nach hinten.

endwhile

A[j ] := x // Setze Element

invariant A[0] ≤ · · · ≤ A[i ]endfor

Wieviele Swaps? worst-case:n (n − 1)

2= Θ

(n2)

, average?

Insertion Sort – Average Case



Annahme: Alle Elemente verschieden und die Eingabe ist einezufällige Permutation davon.

⇒ Jede der n! Permutationen σ ∈ Sn ist gleich wahrscheinlich.

Eine Paar (i , j) ∈ N1 mit i < j ist eine Inversion, wenn σ(i) > σ(j).

( 3 4 1 5 2 )σ =

Ein σ ∈ Sn hat zwischen 0 und(

n2

)Inversionen.

Beispiele: (1,2,3,4,5) und (5,4,3,2,1).




( 3 4 1 5 2 )σ =

Jeder Austausch falsch sortierter, benachbarter Positionen (swap)reduziert die Anzahl der Inversionen um genau 1.

⇒ Die Anzahl von swaps in Insertion-Sort ist genau die AnzahlInversionen in der Eingabe-Permutation.

Nenne diese Anzahl X (σ). Wir suchen den Erwartungswert: E(X (σ)).

Permutationen von 1, . . . ,5



(1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5), (1, 2, 4, 5, 3), (1, 2, 5, 3, 4), (1, 2, 5, 4, 3),(1, 3, 2, 4, 5), (1, 3, 2, 5, 4), (1, 3, 4, 2, 5), (1, 3, 4, 5, 2), (1, 3, 5, 2, 4), (1, 3, 5, 4, 2),(1, 4, 2, 3, 5), (1, 4, 2, 5, 3), (1, 4, 3, 2, 5), (1, 4, 3, 5, 2), (1, 4, 5, 2, 3), (1, 4, 5, 3, 2),(1, 5, 2, 3, 4), (1, 5, 2, 4, 3), (1, 5, 3, 2, 4), (1, 5, 3, 4, 2), (1, 5, 4, 2, 3), (1, 5, 4, 3, 2),(2, 1, 3, 4, 5), (2, 1, 3, 5, 4), (2, 1, 4, 3, 5), (2, 1, 4, 5, 3), (2, 1, 5, 3, 4), (2, 1, 5, 4, 3),(2, 3, 1, 4, 5), (2, 3, 1, 5, 4), (2, 3, 4, 1, 5), (2, 3, 4, 5, 1), (2, 3, 5, 1, 4), (2, 3, 5, 4, 1),(2, 4, 1, 3, 5), (2, 4, 1, 5, 3), (2, 4, 3, 1, 5), (2, 4, 3, 5, 1), (2, 4, 5, 1, 3), (2, 4, 5, 3, 1),(2, 5, 1, 3, 4), (2, 5, 1, 4, 3), (2, 5, 3, 1, 4), (2, 5, 3, 4, 1), (2, 5, 4, 1, 3), (2, 5, 4, 3, 1),(3, 1, 2, 4, 5), (3, 1, 2, 5, 4), (3, 1, 4, 2, 5), (3, 1, 4, 5, 2), (3, 1, 5, 2, 4), (3, 1, 5, 4, 2),(3, 2, 1, 4, 5), (3, 2, 1, 5, 4), (3, 2, 4, 1, 5), (3, 2, 4, 5, 1), (3, 2, 5, 1, 4), (3, 2, 5, 4, 1),(3, 4, 1, 2, 5), (3, 4, 1, 5, 2), (3, 4, 2, 1, 5), (3, 4, 2, 5, 1), (3, 4, 5, 1, 2), (3, 4, 5, 2, 1),(3, 5, 1, 2, 4), (3, 5, 1, 4, 2), (3, 5, 2, 1, 4), (3, 5, 2, 4, 1), (3, 5, 4, 1, 2), (3, 5, 4, 2, 1),(4, 1, 2, 3, 5), (4, 1, 2, 5, 3), (4, 1, 3, 2, 5), (4, 1, 3, 5, 2), (4, 1, 5, 2, 3), (4, 1, 5, 3, 2),(4, 2, 1, 3, 5), (4, 2, 1, 5, 3), (4, 2, 3, 1, 5), (4, 2, 3, 5, 1), (4, 2, 5, 1, 3), (4, 2, 5, 3, 1),(4, 3, 1, 2, 5), (4, 3, 1, 5, 2), (4, 3, 2, 1, 5), (4, 3, 2, 5, 1), (4, 3, 5, 1, 2), (4, 3, 5, 2, 1),(4, 5, 1, 2, 3), (4, 5, 1, 3, 2), (4, 5, 2, 1, 3), (4, 5, 2, 3, 1), (4, 5, 3, 1, 2), (4, 5, 3, 2, 1),(5, 1, 2, 3, 4), (5, 1, 2, 4, 3), (5, 1, 3, 2, 4), (5, 1, 3, 4, 2), (5, 1, 4, 2, 3), (5, 1, 4, 3, 2),(5, 2, 1, 3, 4), (5, 2, 1, 4, 3), (5, 2, 3, 1, 4), (5, 2, 3, 4, 1), (5, 2, 4, 1, 3), (5, 2, 4, 3, 1),(5, 3, 1, 2, 4), (5, 3, 1, 4, 2), (5, 3, 2, 1, 4), (5, 3, 2, 4, 1), (5, 3, 4, 1, 2), (5, 3, 4, 2, 1),(5, 4, 1, 2, 3), (5, 4, 1, 3, 2), (5, 4, 2, 1, 3), (5, 4, 2, 3, 1), (5, 4, 3, 1, 2), (5, 4, 3, 2, 1).




Wir zählen die erwartete Anzahl von Inversionen:

Für eine Permutation σ ∈ Sn sei

Xi,j (σ) :=

{1 falls (i , j) eine Inversion in σ,0 sonst.

Also ist X :=∑i<j

Xi,j (σ) die Anzahl von Inversionen und

E(X (σ)) = E(∑

i<j

Xi,j (σ))

=∑i<j

E(Xi,j (σ)) .

Da E(Xi,j (σ)) =12

, ist so mit E(X (σ)) =

(n2

)· 1

2.

⇒Worst casen (n − 1)

2=

(n2

)und average case

(n2

)· 1

2.

4. Übung – Algorithmen Ialgo2.iti.kit.edu/documents/algo1-2014/uebung_04.pdf · Unbounded...

Documents

Transcript of 4. Übung – Algorithmen Ialgo2.iti.kit.edu/documents/algo1-2014/uebung_04.pdf · Unbounded...