Übung Algorithmen I

Transkript

1 Übung Algorithmen I Lukas Barth [email protected] (Mit Folien von Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks)

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

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

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, Wie inplace?

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 inplace?

6 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 else for j := i downto 2 do a[j]:= a[j 1] a[1]:= e while a[j-1]>e do a[j]:= a[j 1] a[j]:= e j:= j 1 // new minimum // use a[1] as a sentinel

7 Anschaulich... Jemand Insertion Sort vortanzen?

8 Anschaulich... Jemand Insertion Sort vortanzen? Rumänischer Volkstanz!

9 Adaptives Sortieren Warm-Up Folge Folge

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

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

12 Adaptives Sortieren Warm-Up II Folge

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

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

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

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

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

18 Insertion Sort Adaptiv? Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do // move a[i] to the right place e:= a[i] if e < a[1] then else for j := i downto 2 do a[j]:= a[j 1] a[1]:= e while a[j-1]>e do a[j]:= a[j 1] a[j]:= e j:= j 1 // new minimum // use a[1] as a sentinel

19 Insertion Sort Adaptiv? Procedure insertionsort(a : Array [1..n] of Element) for i := 2 to n do // move a[i] to the right place e:= a[i] if e < a[1] then else for j := i downto 2 do a[j]:= a[j 1] a[1]:= e while a[j-1]>e do a[j]:= a[j 1] a[j]:= e j:= j 1 (n 1) + I (a) Schleifendurchläufe // new minimum // use a[1] as a sentinel

20 Insertion Sort Erwartete Laufzeit Wie viele Inversionen erwarten wir?

21 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

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

23 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

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

25 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 (σ)).

26 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

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 (σ)). E(X i,j (σ)) = 1 2 E(X (σ)) = E(X i,j (σ)) = 1 i<j n n(n 1) 2 1 2

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

29 Natural Merge Sort Idee Liste nicht bis auf ein-elementige Listen aufspalten Nutze Runs aus Wie war nochmal Merge Sort? Hat das denn niemand getanzt?!?

30 Natural Merge Sort Idee Liste nicht bis auf ein-elementige Listen aufspalten Nutze Runs aus Wie war nochmal Merge Sort? Hat das denn niemand getanzt?!? Auf rumänischen Volkstanz ist Verlass!

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 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 E(R(σ)) = p(σ) R(σ) = n #k k

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

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

41 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

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

43 Runs Erwartete Anzahl von Runs # k = # n k+1 2 E(R(σ)) = = = n 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 # k = n + 1 n! n!

44 Runs Erwartete Anzahl von Runs # k = # n k+1 2 E(R(σ)) = = = n 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 # k = n + 1 n! n! Daraus folgt: E(R(σ)) = n + 1 2

45 Removals Folge

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

47 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). Splitsort an adaptive sorting algorithm. Information Processing Letters, 39(4),

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 )

49 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

50 Split Sort

51 Split Sort

52 Split Sort

53 Split Sort

54 Split Sort

55 Split Sort

56 Split Sort

57 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!

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

59 Vorgefertigte Sortieralgorithmen in aktuellen Programmiersprachen Hinweis: Verwendet diese Sortieralgorithmen anstatt eigene zu implementieren! Außer, wenn ihr einen Sortieralgorithmus implementieren sollt.

60 C++ Mischung aus Quick-Sort, Heapsort und Insertion Sort #include <algorithm> int numbers[] = {42, 7, 9, 18, 1, 123}; std::vector<int> vec(numbers, numbers + 6); std::sort(vec.begin(), vec.end()) Alternative, für (per se) ungeordnete Dinge: #include <algorithm> bool less_than(elements& a, Elements& b) { /*...*/ }... Elements* elements = createelements(n); std::sort(elements, elements + n, less_than)...oder... std::stable_sort(elements, elements + n, less_than)

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