Übung Algorithmen I

Größe: px

Ab Seite anzeigen:

Download "Übung Algorithmen I"

Sylvia Schneider
vor 6 Jahren
Abrufe

1 Übung Algorithmen I Sascha Witt sascha.witt@kit.edu (Mit Folien von Lukas Barth, Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks)

2 Organisatorisches Übungsklausur Am (anstatt Vorlesung/Übung) Nur zur persönlichen Lernkontrolle. Flieÿt nicht in die Note mit ein.

3 Roadmap Sortieren Kleine Wiederholung Visualisierungen Adaptives Sortieren Kennzahlen für Chaos Split Sort Reales Sortieren

4 Rückblick: Insertion Sort Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] move a[i] to the right place Beispiel:, 4, 7, 1, 1 4, 7, 1, 1 4, 7, 1, 1 1, 4, 7, 1 1, 1, 4, 7,

5 Rückblick: Insertion Sort Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] move a[i] to the right place Beispiel:, 4, 7, 1, 1 4, 7, 1, 1 4, 7, 1, 1 1, 4, 7, 1 1, 1, 4, 7, Wie in-place?

6 Rückblick: Insertion Sort Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] move a[i] to the right place Beispiel:, 4, 7, 1, 1 4, 7, 1, 1 4, 7, 1, 1 1, 4, 7, 1 1, 1, 4, 7, Wie in-place?

7 Sortieren durch Einfügen: Variante 1 Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] // move a[i] to the right place e := a[i] j := i while j > 1 and a[j 1] > e do a[j] := a[j 1] j := j 1 a[j] := e

8 Sentinels am Beispiel Sortieren durch Einfügen Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] // move a[i] to the right place e := a[i] if e < a[1] then // new minimum else for j := i downto 2 do a[j] := a[j 1] a[1] := e j := i while a[j 1] > e do a[j] := a[j 1] j := j 1 a[j] := e // use a[1] as a sentinel

9 Anschaulich... Sound of Sorting

10 Anschaulich... Sound of Sorting Volkstänze

11 Adaptives Sortieren Warm-Up Folge Folge

12 Adaptives Sortieren Warm-Up Folge Nur zwei Paare vertauscht Folge Ziemliches Chaos

13 Adaptives Sortieren Warm-Up Folge Nur zwei Paare vertauscht Folge Ziemliches Chaos Inversion Paar (i, j) N 2 mit i < j und a[i] > a[j] (wenn aufsteigend sortiert werden soll... )

14 Adaptives Sortieren Warm-Up II Folge

15 Adaptives Sortieren Warm-Up II Folge Wirkt irgendwie sortiert, aber viele Inversionen

16 Adaptives Sortieren Warm-Up II Folge Wirkt irgendwie sortiert, aber viele Inversionen Run Sortierte (zusammenhängende) Teilfolge

17 Adaptives Sortieren Warm-Up II Folge Wirkt irgendwie sortiert, aber viele Inversionen Run Sortierte (zusammenhängende) Teilfolge Folge 3 hat zwei Runs

18 Adaptives Sortieren Sortieren Untere Schranke Ω (n log n) Keine Annahme über Eingabedaten

19 Adaptives Sortieren Sortieren Untere Schranke Ω (n log n) Keine Annahme über Eingabedaten Adaptives Sortieren Eingabedaten schon Ein bisschen sortiert Laufzeit steigt mit Länge n und Chaos m Kennzahlen für Chaos? (Oder Vorsortiertheit...)

20 Insertion Sort Adaptiv? Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] // move a[i] to the right place e := a[i] j := i 1 while j > 1 and a[j] > e do a[j + 1] := a[j] j := j 1 a[j] := e

21 Insertion Sort Adaptiv? Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do invariant a[1] a[i 1] // move a[i] to the right place e := a[i] j := i 1 while j > 1 and a[j] > e do a[j + 1] := a[j] j := j 1 a[j] := e (n 1) + I (a) Schleifendurchläufe

22 Insertion Sort Erwartete Laufzeit Wie viele Inversionen erwarten wir?

23 Insertion Sort Erwartete Laufzeit Wie viele Inversionen erwarten wir? Annahme: Alle Elemente verschieden und die Eingabe ist eine zufällige Permutation von n Elementen. Jede der n! Permutationen σ ist gleich wahrscheinlich. Best Case: Alles sortiert keine Inversionen Worst Case: Alles umgekehrt sortiert: ( n 2) Inversionen

24 Insertion Sort Average Case Wir zählen die erwartete Anzahl von Inversionen: Für eine Permutation σ S n sei { 1 falls (i, j) eine Inversion in σ, X i,j (σ) := 0 sonst.

25 Insertion Sort Average Case Wir zählen die erwartete Anzahl von Inversionen: Für eine Permutation σ S n sei { 1 falls (i, j) eine Inversion in σ, X i,j (σ) := 0 sonst. Also ist X (σ) := i<j X i,j (σ) die Anzahl von Inversionen und ( ) E(X (σ)) = E X i,j (σ) = E(X i,j (σ)). i<j i<j

26 Insertion Sort Average Case ( ) E(X (σ)) = E X i,j (σ) = i<j 1 i<j n E(X i,j (σ)).

27 Insertion Sort Average Case Erinnerung ( ) E(X (σ)) = E X i,j (σ) = i<j 1 i<j n Alle Permutationen gleich wahrscheinlich! E(X i,j (σ)).

28 Insertion Sort Average Case Erinnerung ( ) E(X (σ)) = E X i,j (σ) = i<j 1 i<j n Alle Permutationen gleich wahrscheinlich! E(X i,j (σ)). E(X i,j (σ)) = 1 2

29 Insertion Sort Average Case Erinnerung ( ) E(X (σ)) = E X i,j (σ) = i<j 1 i<j n Alle Permutationen gleich wahrscheinlich! E(X i,j (σ)). E(X (σ)) = 1 i<j n E(X i,j (σ)) = 1 2 ( ) n E(X i,j (σ)) = 1 n(n 1) =

30 Natural Merge Sort Idee Liste nicht bis auf ein-elementige Listen aufspalten Nutze Runs aus ( )

31 Runs Wie groÿ werden die Runs?

32 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs.

33 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs. Beobachtung: Permutation mit k Runs hat k 1 Abstiege

34 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs. Beobachtung: Permutation mit k Runs hat k 1 Abstiege

35 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs. Beobachtung: Permutation mit k Runs hat k 1 Abstiege Rückwärts gelesen hat sie n (k 1) = n k + 1 Runs.

36 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs. Beobachtung: Permutation mit k Runs hat k 1 Abstiege Rückwärts gelesen hat sie n (k 1) = n k + 1 Runs. Bijektion von Permutationen mit k Runs auf Permutationen mit n k + 1 Runs

37 Runs Erwartete Anzahl von Runs Für festes n sei # k die Anzahl der Permutationen von n Elementen mit k Runs. Beobachtung: Permutation mit k Runs hat k 1 Abstiege Rückwärts gelesen hat sie n (k 1) = n k + 1 Runs. Bijektion von Permutationen mit k Runs auf Permutationen mit n k + 1 Runs # k = # n k+1

38 Runs Erwartete Anzahl von Runs E(R(σ)) = σ S n p(σ) R(σ) = n k=1 # k n! k

39 Runs Erwartete Anzahl von Runs 2 E(R(σ)) = 2 σ S n p(σ) R(σ) = 2 n k=1 # k n! k

40 Runs Erwartete Anzahl von Runs 2 E(R(σ)) = 2 n # k p(σ) R(σ) = 2 n! k σ S n k=1 n # k n = n! k + # n k+1 (n k + 1) } n! {{} k=1 k=1 Indexvertauschung

41 Runs Erwartete Anzahl von Runs 2 E(R(σ)) = n k=1 # k n! k + n k=1 # n k+1 (n k + 1) n!

42 Runs Erwartete Anzahl von Runs # k = # n k+1 n 2 E(R(σ)) = (1) = = k=1 n k=1 n k=1 # k n! k + n k=1 # k n! k + n k=1 # n k+1 (n k + 1) n! # k (n k + 1) n! # k n + 1 (k + (n k + 1)) = n! n! n k=1 (1) # k = n + 1 n! n!

43 Runs Erwartete Anzahl von Runs # k = # n k+1 n 2 E(R(σ)) = (1) = = k=1 n k=1 n k=1 # k n! k + n k=1 # k n! k + n k=1 # n k+1 (n k + 1) n! # k (n k + 1) n! # k n + 1 (k + (n k + 1)) = n! n! n k=1 (1) # k = n + 1 n! n! Daraus folgt: E(R(σ)) = n + 1 2

44 Removals Folge

45 Removals Folge Einzelne Entfernungen führen zu sortierter (Teil-)Liste

46 Removals Folge Einzelne Entfernungen führen zu sortierter (Teil-)Liste Split Sort Nutze Removals aus Asymptotisch optimal bezüglich Removals (und Inversionen!) Levcopoulos, C., & Petersson, O. (1991). Splitsortan adaptive sorting algorithm. Information Processing Letters, 39(4),

47 Split Sort Procedure splitsort(a : Array [1..n] of Element) split(a, a G, a S ) if a S > 1 then splitsort(a S ) splitsort(a G ) merge(a, a G, a S )

48 Split Sort Procedure splitsort(a : Array [1..n] of Element) split(a, a G, a S ) if a S > 1 then splitsort(a S ) splitsort(a G ) merge(a, a G, a S ) Splitting Finde Paare, an denen Abstiege sind Verschiebe diese in a G bzw. a S

49 Split Sort

50 Split Sort

51 Split Sort

52 Split Sort

53 Split Sort

54 Split Sort

55 Split Sort

56 Adaptives Sortieren Zusammenfassung Idee: Vorsortierung ausnutzen! Maÿzahlen für Chaos / Vorsortiertheit Inversionen Insertion Sort Runs Natural Merge Sort Removals Split Sort... und viele mehr!

57 Vorgefertigte Sortieralgorithmen in aktuellen Programmiersprachen Hinweis: Verwendet diese Sortieralgorithmen anstatt eigene zu implementieren!

58 Vorgefertigte Sortieralgorithmen in aktuellen Programmiersprachen Hinweis: Verwendet diese Sortieralgorithmen anstatt eigene zu implementieren! Auÿer, wenn ihr einen Sortieralgorithmus implementieren sollt (oder wollt).

59 C++ Mischung aus Quick-Sort, Heapsort und Insertion Sort #include <algorithm> //... std::vector<int> vec = {42, 7, 9, 18, 1, 123}; std::sort(vec.begin(), vec.end()); std::sort(vec.begin(), vec.end(), std::greater<>()); Alternative, für (per se) ungeordnete Dinge: auto vec = getelements(); auto comp = [](auto&& lhs, auto&& rhs) {... }; std::sort(vec.begin(), vec.end(), comp); //...oder... std::stable_sort(vec.begin(), vec.end(), comp);

60 Java Zahlen: Variante von Quick-Sort int[] numbers = {42, 7, 9, 18, 1, 123}; java.util.arrays.sort(numbers); Allgemeine Elemente: Variante von Merge-Sort Comparator<Elem> comparator = new Comparator<Elem> { int compare(elem a, Elem b) {... } } Elem[] elements = {... }; java.util.arrays.sort(elements, 3, 15, comparator);

Ähnliche Dokumente

Übung Algorithmen I

Übung Algorithmen I 18.5.16 Lukas Barth lukas.barth@kit.edu (Mit Folien von Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks) Roadmap Sortieren Kleine Wiederholung Visualisierungen Adaptives