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

−→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

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

(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 , Arithmetik mod 2 (XOR and AND)Anzahl Slots m in Hashtabelle m = 2w

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

(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

∀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

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

j=1 Mijxj =⊕k

j=1 Mijyj

2wk = 2−w = 12w = 1

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

j=1 Mijxj =⊕k

j=1 Mijyj

2wk = 2−w = 12w = 1

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

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)

Selection Sort

endfor

Wieviele Vergleiche?

immern(n − 1)

Selection Sort

endfor

Wieviele Vergleiche? immern(n − 1)

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)

, 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)

, 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(

)Inversionen.

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

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(

)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).

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(∑

Xi,j (σ))

=∑i<j

E(Xi,j (σ)) .

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

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

⇒Worst casen (n − 1)

)und average case

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...

Übung Informatik1 für ET und MT1 4.Übung: Inhalte: Binäre Algorithmen für arithmetische Grundrechenarten Beispiel zur Addition positiver und negativer.

Algorithmen und Datenstrukturen Große Übung vom 04.11.10 ChristianeSchmidt.

Übung Algorithmen und Datenstrukturen · • Überschuss wird als Kredit/Potential gespeichert. • Kredit/Potential wird verwendet, um für teurere Operation zu zahlen. • Verfahren

Rainer Marrone, TUHH, Arbeitsbereich STS Übung: · PDF file1 Vorlesung "Software-Engineering" § Voraussetzungen: - Algorithmen und Datenstrukturen - Objektorientierte Programmierung

Optimierungs- Algorithmen Petra Mutzel Technische Universität Wien Institut für Computergraphik und Algorithmen Algorithmen und Datenstrukturen 2.

Algorithmen und Datenstrukturen - Übung 1 · PDF file S. Friedrichs (TU Braunschweig, ... Ein Algorithmus ist eine Berechnungsvorschrift, die zu jeder Instanz eines

Modulhandbuch für den Studiengang …...3 Algorithmen Modulbezeichnung: Algorithmen Unitbezeichnung: Algorithmen: Grundlagen; Parallele Algorithmen Studiensemester: 3 Modulverantwortliche(r):

Informatik 1 Übung 7. NACHBESPRECHUNG Übung 6 SCOPE.

Unbounded Linear Operators on Interpolation Spaces€¦ · we examine ordinary diﬀerential operators as an example for unbounded linear operators on interpolation spaces. The spaces

Algorithmen und Komplexität Teil 1: Grundlegende Algorithmen

Algorithmen und Datenstrukturen Große Übung vom 29.10.09 NilsSchweer.

Grundlagen: Algorithmen und Datenstrukturen · Grundlagen: Algorithmen und Datenstrukturen Hanjo Taubig¨ Lehrstuhl fur Efﬁziente Algorithmen¨ (Prof.Dr. Ernst W. Mayr) Institut

INTELLIGENTE DATENANALYSE IN MATLAB€¦ · Vorlesung: Grundlagen Maschinelles Lernen und MATLAB. Konzepte/Algorithmen der intelligenten Datenanalyse. Übung: Implementierung der

12 Greedy-Algorithmen - TU Bergakademie Freibergernst/Lehre/AD/Folien/adKapitel12.pdf · Algorithmen und Datenstrukturen 310 12 Greedy-Algorithmen • weitere Optimierungsstrategie,

Eigenschaften von Algorithmen Klaus Becker 2008. 2 Algorithmen Zielsetzung: klassische Algorithmen erkunden und dabei zentrale Eigenschaften von Algorithmen.

Optimierungs- Algorithmen Petra Mutzel Technische Universität Wien Institut für Computergraphik und Algorithmen AK5: Ausgewählte Algorithmen Ak der Algorithmik.

Übung Algorithmen und Datenstrukturen - hu-berlin.de · 2016. 6. 29. · Übung Algorithmen und Datenstrukturen Sommersemester 2016 Patrick Schäfer, Humboldt -Universität zu Berlin

Algorithmen & Datenstrukturen

Algorithmen für Ad-hoc- und Sensornetze - Übung 2 Greedy Routing · Besprechung: Leader Election in allgemeinen Graphen Greedy Routing Fabian Fuchs – Algorithmen fur Ad-hoc- und

Externspeicher- Algorithmen Petra Mutzel Technische Universität Wien Institut für Computergraphik und Algorithmen AK5: Ausgewählte Algorithmen Ak der Algorithmik.