7. Übung zu Algorithmen I 1. Juni 2016
|
|
|
- Karsten Ursler
- vor 6 Jahren
- Abrufe
Transkript
1 7. Übung zu Algorithmen I 1. Juni 2016 Lukas Barth lukas.barth@kit.edu (mit Folien von Lisa Kohl)
2 Roadmap Ganzzahliges Sortieren mit reellen Zahlen Schnellere Priority Queues Bucket Queue Radix Heap
3 Organisatorisches Nächste Woche: Übungsklausur! Deshalb: Heute kein Übungsblatt!
4 Organisatorisches Nächste Woche: Übungsklausur! Deshalb: Heute kein Übungsblatt! ÜB 6, Aufgabe 1b): dpartition ist kaputt Volle Punktzahl auf die 1b Wir reparieren den Pseudocode
5 Erinnerung: Bucketsort Procedure KSort(s : Sequence of Element) b=,..., : Array [0..K 1] of Sequence of Element foreach e s do b[key(e)].pushback(e) s := concatenation of b[0],..., b[k 1] Zeit: O(n + K) s e b[0] b[1] b[2] b[3] b[4]
6 Bucket Sort für [0, 1) Annahme: Zahlen uniform gleichverteilt im Intervall [0, 1)
7 Bucket Sort für [0, 1) Annahme: Zahlen uniform gleichverteilt im Intervall [0, 1) Vorgehen:
8 Bucket Sort für [0, 1) Annahme: Zahlen uniform gleichverteilt im Intervall [0, 1) Vorgehen: 1. teile Interval [0, 1) in n Buckets der gleichen Größe
9 Bucket Sort für [0, 1) Annahme: Zahlen uniform gleichverteilt im Intervall [0, 1) Vorgehen: 1. teile Interval [0, 1) in n Buckets der gleichen Größe 2. sortiere Eingabe in die Buckets
10 Bucket Sort für [0, 1) Annahme: Zahlen uniform gleichverteilt im Intervall [0, 1) Vorgehen: 1. teile Interval [0, 1) in n Buckets der gleichen Größe 2. sortiere Eingabe in die Buckets 3. sortiere die Zahlen in jedem Bucket (mit Insertionsort)
11 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01}
12 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
13 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
14 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
15 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
16 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
17 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
18 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
19 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
20 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
21 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
22 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
23 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
24 Bucket Sort für [0, 1) Beispiel a = {0.234, 0.9, 0.11, 0.89, 0.19, 0.8, 0.56, 0.87, 0.661, 0.01} <0.1 <0.2 <0.3 <0.4 <0.5 <0.6 <0.7 <0.8 <
25 Bucket Sort für [0, 1) Pseudocode Function ibsort(a : Array of [0, 1)) : Array of [0, 1) n:= a. length for i:= 1 to n do insert a[i] into list b[ n a[i] ] for i:= 0 to n 1 do sort list b[i] with insertion sort concatenate lists b[0], b[1],... and write result in array b return b
26 Bucket Sort für [0, 1) Pseudocode Function ibsort(a : Array of [0, 1)) : Array of [0, 1) n:= a. length for i:= 1 to n do insert a[i] into list b[ n a[i] ] for i:= 0 to n 1 do sort list b[i] with insertion sort concatenate lists b[0], b[1],... and write result in array b return b
27 Bucket Sort für [0, 1) Pseudocode Function ibsort(a : Array of [0, 1)) : Array of [0, 1) n:= a. length for i:= 1 to n do insert a[i] into list b[ n a[i] ] for i:= 0 to n 1 do sort list b[i] with insertion sort concatenate lists b[0], b[1],... and write result in array b return b
28 Bucket Sort für [0, 1) Pseudocode Function ibsort(a : Array of [0, 1)) : Array of [0, 1) n:= a. length for i:= 1 to n do insert a[i] into list b[ n a[i] ] for i:= 0 to n 1 do sort list b[i] with insertion sort concatenate lists b[0], b[1],... and write result in array b return b
29 Bucket Sort für [0, 1) Laufzeit interessanter Teil: sort list b[i] with insertion sort ( )
30 Bucket Sort für [0, 1) Laufzeit interessanter Teil: sort list b[i] with insertion sort ( ) jedes Element landet mit Wkt. p := 1/n in b[i]
31 Bucket Sort für [0, 1) Laufzeit interessanter Teil: sort list b[i] with insertion sort ( ) jedes Element landet mit Wkt. p := 1/n in b[i] definiere Zufallsvariable X ij : { 1 falls Element j in Bucket i landet X ij = 0 sonst
32 Bucket Sort für [0, 1) Laufzeit interessanter Teil: sort list b[i] with insertion sort ( ) jedes Element landet mit Wkt. p := 1/n in b[i] definiere Zufallsvariable X ij : { 1 falls Element j in Bucket i landet X ij = 0 sonst definiere Zufallsvariable X i für die Größe der Buckets i: X i = n j=1 X ij
33 Bucket Sort für [0, 1) Laufzeit [ ] n E[X i ] = E X ij j=1
34 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] j=1
35 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] j=1 jedes Element landet mit Wkt. p := 1/n in b[i] E[X ij ] = (1 ) 1 n n
36 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] = n j=1 j=1 1 = 1 n jedes Element landet mit Wkt. p := 1/n in b[i] E[X ij ] = (1 ) 1 n n
37 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] = n j=1 j=1 1 = 1 n jedes Element landet mit Wkt. p := 1/n in b[i] E[X ij ] = (1 ) 1 n n Erwartet konstante Länge!
38 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] = n j=1 j=1 1 = 1 n jedes Element landet mit Wkt. p := 1/n in b[i] E[X ij ] = (1 ) 1 n n Erwartet konstante Länge! Erwartet konstanter Aufwand pro Insertionsort
39 Bucket Sort für [0, 1) Laufzeit E[X i ] = E [ ] n X ij j=1 = n E[X ij ] = n j=1 j=1 1 = 1 n jedes Element landet mit Wkt. p := 1/n in b[i] E[X ij ] = (1 ) 1 n n Erwartet konstante Länge! Erwartet konstanter Aufwand pro Insertionsort Erwartet O(n) insgesamt
40 Bucket Sort für [0, 1) Was ist mit der Schranke? Haben wir jetzt die Ω (n log n)-schranke ausgetrickst?
41 Bucket Sort für [0, 1) Was ist mit der Schranke? Haben wir jetzt die Ω (n log n)-schranke ausgetrickst? Nein! Wir haben Gleichverteilung angenommen!
42 Sortieren - Auf einen Blick Haben wir da keinen Experten?
43 Sortieren - Auf einen Blick Worst Case Erwartet Bemerkung Insertionsort O(n 2 ) O(n 2 ) stabil Quicksort O(n 2 ) O(n log n) in-place Mergesort O(n log n) O(n log n) stabil Bucketsort O(n + k) O(n + k) k: Anzahl möglicher Schlüssel Radixsort O(d(n + K)) O(d(n + K)) d = log K (max)
44 Sortieren - Auf einen Blick Worst Case Erwartet Bemerkung Insertionsort O(n 2 ) O(n 2 ) stabil Quicksort O(n 2 ) O(n log n) in-place Mergesort O(n log n) O(n log n) stabil Bucketsort O(n + k) O(n + k) k: Anzahl möglicher Schlüssel Radixsort O(d(n + K)) O(d(n + K)) d = log K (max) Bubblesort O(n 2 ) O(n 2 ) stabil
45 Sortieren - Auf einen Blick Worst Case Erwartet Bemerkung Insertionsort O(n 2 ) O(n 2 ) stabil Quicksort O(n 2 ) O(n log n) in-place Mergesort O(n log n) O(n log n) stabil Bucketsort O(n + k) O(n + k) k: Anzahl möglicher Schlüssel Radixsort O(d(n + K)) O(d(n + K)) d = log K (max) Bubblesort O(n 2 ) O(n 2 ) stabil Thanks Obama!
46 Priority Queues Erinnerung Operation Binary Heap Fibonacci Heap (Buch) build O(n) O(n) size O(1) O(1) min O(1) O(1) insert O(log n) O(1) deletemin O(log n) O(log n) remove O(log n) O(log n) decreasekey O(log n) O(1) am. merge O(n) O(1)
47 Priority Queues Zwei Annahmen Monotonizität Für ein einzufügendes v und das aktuelle Minimum min gelte: v min
48 Priority Queues Zwei Annahmen Monotonizität Für ein einzufügendes v und das aktuelle Minimum min gelte: v min Beschränkte Spanne Für ein einzufügendes v und ein (a priori bekanntes) C gelte: v < min +C Alle Werte sind ganzzahlig
49 Bucket Queue Ein erster Ansatz mod Zyklisches Array der Größe C
50 Bucket Queue Ein erster Ansatz Zyklisches Array der Größe C Feld i: Alle Elemente x, für die x i mod C
51 Bucket Queue Ein erster Ansatz mod Zyklisches Array der Größe C Feld i: Alle Elemente x, für die x i mod C 18 17
52 Bucket Queue Ein erster Ansatz mod Zyklisches Array der Größe C Feld i: Alle Elemente x, für die x i mod C 18 17
53 Bucket Queue Ein erster Ansatz mod Zyklisches Array der Größe C 15 Feld i: Alle Elemente x, für die x i mod C 18 17
54 Bucket Queue Ein erster Ansatz min mod Zyklisches Array der Größe C 15 Feld i: Alle Elemente x, für die x i mod C min-pointer 18 17
55 Bucket Queue insert min mod Eine Modulo-Rechnung, eine Listenoperation O(1) 18 17
56 Bucket Queue deletemin min mod Wenn min-feld nicht leer: Eine Listenoperation 18 17
57 Bucket Queue deletemin min mod Wenn min-feld nicht leer: Eine Listenoperation Wenn min-feld leer: min maximal C mal inkrementieren O(C)
58 Binary Radix Heap Idee Wir wollen O(log C) Laufzeiten C unterschiedliche Werte können mit log 2 C Bits unterschieden werden Felder Bits?
59 Binary Radix Heap Idee Wir wollen O(log C) Laufzeiten C unterschiedliche Werte können mit log 2 C Bits unterschieden werden Felder Bits? Most Significant Difference msd(x, y) := höchstwertiges Bit, in dem die Binärdarstellungen von x und y sich unterscheiden
60 Binary Radix Heap Idee Wir wollen O(log C) Laufzeiten C unterschiedliche Werte können mit log 2 C Bits unterschieden werden Felder Bits? Most Significant Difference msd(x, y) := höchstwertiges Bit, in dem die Binärdarstellungen von x und y sich unterscheiden 60 = =
61 Binary Radix Heap Idee Wir wollen O(log C) Laufzeiten C unterschiedliche Werte können mit log 2 C Bits unterschieden werden Felder Bits? Most Significant Difference msd(x, y) := höchstwertiges Bit, in dem die Binärdarstellungen von x und y sich unterscheiden 60 = = msd(60, 42) = 4
62 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x)
63 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
64 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
65 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
66 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
67 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
68 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
69 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
70 Binary Radix Heap Datenstruktur K = log C + 1 Buckets, nummeriert 1, 0, 1,... log C Minimale Elemente in Bucket 1 Element x > min gehört in Bucket msd(min, x) * 011** 00*** 1****
71 Binary Radix Heap Schummelei Sei C = 16. Was ist mit diesen Zahlen: 511 = =
72 Binary Radix Heap Schummelei Sei C = 16. Was ist mit diesen Zahlen: 511 = = Offenbar ist msd(511, 512) = 9 Aber wir haben nur log = 5 Buckets?
73 Binary Radix Heap Schummelei Sei C = 16. Was ist mit diesen Zahlen: 511 = = Offenbar ist msd(511, 512) = 9 Aber wir haben nur log = 5 Buckets? 511 = = = =
74 Binary Radix Heap insert Bestimmen von msd(min, x) Kombination aus XOR, Logarithmus und Abrunden Können Prozessoren in konstanter Zeit...
75 Binary Radix Heap insert Bestimmen von msd(min, x) Kombination aus XOR, Logarithmus und Abrunden Können Prozessoren in konstanter Zeit... Eigentlich ist das geschummelt...
76 Binary Radix Heap insert Bestimmen von msd(min, x) Kombination aus XOR, Logarithmus und Abrunden Können Prozessoren in konstanter Zeit... Eigentlich ist das geschummelt... Ins richtige Bucket einfügen Nur noch Listenoperation
77 Binary Radix Heap deletemin Fall 1: Bucket -1 nicht leer Ein Element daraus zurückgeben
78 Binary Radix Heap deletemin Fall 1: Bucket -1 nicht leer Ein Element daraus zurückgeben Fall 2: Bucket -1 leer Nächstes nicht-leeres Bucket suchen Kleinste(s) Element(e) daraus zum Minimum erklären und nach -1 verschieben
79 Binary Radix Heap deletemin Fall 1: Bucket -1 nicht leer Ein Element daraus zurückgeben Fall 2: Bucket -1 leer Nächstes nicht-leeres Bucket suchen Kleinste(s) Element(e) daraus zum Minimum erklären und nach -1 verschieben Was ist mit der Invariante...?
80 Binary Radix Heap deletemin * 011** 00*** 1****
81 Binary Radix Heap deletemin * 011** 00*** 1****
82 Binary Radix Heap deletemin * 011** 00*** 1****
83 Binary Radix Heap deletemin * 011** 00*** 1****
84 Binary Radix Heap deletemin * 0100* 011** 00*** 1****
85 Binary Radix Heap deletemin * 0100* 011** 00*** 1****
86 Binary Radix Heap deletemin * 0100* 011** 00*** 1****
87 Binary Radix Heap deletemin * 0100* 011** 00*** 1****
88 Binary Radix Heap deletemin * 0100* 011** 00*** 1**** Nur Elemente eines Buckets müssen betrachtet werden Diese werden alle mindestens um einen Bucket verschoben
89 Binary Radix Heap deletemin * 0100* 011** 00*** 1**** Nur Elemente eines Buckets müssen betrachtet werden Diese werden alle mindestens um einen Bucket verschoben Wie oft kann ein Element verschoben werden?
90 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben!
91 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element
92 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element Zahle log C beim Entfernen des entsprechenden Elements ein
93 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element Zahle log C beim Entfernen des entsprechenden Elements ein Kosten für deletemin O(log C) zum finden eines gefüllten Buckets
94 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element Zahle log C beim Entfernen des entsprechenden Elements ein Kosten für deletemin O(log C) zum finden eines gefüllten Buckets O(log C) Einzahlung in die Amortisation
95 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element Zahle log C beim Entfernen des entsprechenden Elements ein Kosten für deletemin O(log C) zum finden eines gefüllten Buckets O(log C) Einzahlung in die Amortisation Kosten fürs Verteilen des Buckets: Wird noch bezahlt!
96 Binary Radix Heap deletemin - Amortisierung Jedes betrachtete Element wird verschoben! Pro Element: maximal log C Mal verschieben Gesamtkosten log C pro Element Zahle log C beim Entfernen des entsprechenden Elements ein Kosten für deletemin O(log C) zum finden eines gefüllten Buckets O(log C) Einzahlung in die Amortisation Kosten fürs Verteilen des Buckets: Wird noch bezahlt! O(log C) amortisiert
97 Binary Radix Heap Und was ist mit C? * 011** 00*** 1**** Warum kann man keine Elemente x > min +C ins letzte Bucket einfügen?
98 Binary Radix Heap Und was ist mit C? * 011** 00*** 1**** Warum kann man keine Elemente x > min +C ins letzte Bucket einfügen? Angenommen, im letzten Bucket sind sehr große Elemente... und wir müssen das letzte Bucket leeren und umverteilen...
99 Binary Radix Heap Und was ist mit C? * 011** 00*** 1**** Warum kann man keine Elemente x > min +C ins letzte Bucket einfügen? Angenommen, im letzten Bucket sind sehr große Elemente... und wir müssen das letzte Bucket leeren und umverteilen... Dann können welche übrig bleiben!
100 Binary Radix Heap Und was ist mit C? * 011** 00*** 1**** Warum kann man keine Elemente x > min +C ins letzte Bucket einfügen? Angenommen, im letzten Bucket sind sehr große Elemente... und wir müssen das letzte Bucket leeren und umverteilen... Dann können welche übrig bleiben! Das durfte aber in der Amortisierung nicht passieren!
101 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt!
102 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
103 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
104 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
105 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
106 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
107 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
108 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 01[1,2]* 0[0,2]** [1,2]**
109 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 011[0,2] 01[1,2]* 01[0,2]* 0[0,2]** [1,2]**
110 Binary Radix Heap Warum nicht ternäre Radix Heaps...? Behauptung: Das ganze wird kompakter, wenn man Basis 3 wählt! [1,2] 011[0,2] 01[1,2]* 01[0,2]* 0[0,2]** [1,2]** hat sich nicht bewegt!
111 Schnelle Heaps Zusammenfassung Voraussetzungen Monotonizität Beschränkte Spanne Bucket Queue insert O(1) deletemin O(C) Radix Heap insert O(1) deletemin O(log C) amortisiert
112 Zusammenfassung Priority Queues Bucket Queue Radix Heap Ganzzahliges Sortieren Für rationale Zahlen!
Denition: Rang eines Elements e einer Folge s = Position von e in sort(s) (angefangen bei 1). Frage: warum ist r nicht notwendig eindeutig?
207 Auswahl (Selection) Denition: Rang eines Elements e einer Folge s = Position von e in sort(s) (angefangen bei 1). Frage: warum ist r nicht notwendig eindeutig? // return an element of s with rank k
Algorithmen I. Prof. Jörn Müller-Quade Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?
Algorithmen I Prof. Jörn Müller-Quade 29.05.2017 Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?id=799 (Folien von Peter Sanders) KIT Institut für Theoretische Informatik
Wie beim letzten Mal - bitte besucht: http://pingo.upb.de/549170 Ihr seid gleich wieder gefragt... Übung Algorithmen I 4.5.16 Lukas Barth lukas.barth@kit.edu (Mit Folien von Julian Arz, Timo Bingmann,
Erinnerung VL
Erinnerung VL 30.05.2016 Radix-Sort, Abschluss Sortieren Prioritätslisten: Warteschlange mit Prioritäten deletemin: kleinstes Element rausnehmen insert: Element einfügen Binäre Heaps als Implementierung
Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]
![Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]](/thumbs/69/61689021.jpg "Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]")
Heapsort / 1 Heap: Ein Array heißt Heap, falls A [i] A [2i] und A[i] A [2i + 1] (für 2i n bzw. 2i + 1 n) gilt. Beispiel: A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] Heapsort / 2 Darstellung eines Heaps als
Übung Algorithmen I
Übung Algorithmen I 10.5.17 Sascha Witt sascha.witt@kit.edu (Mit Folien von Lukas Barth, Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks) Roadmap Listen Skip List Hotlist Amortisierte
Algorithmen I. Prof. Jörn Müller-Quade Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?
Algorithmen I Prof. Jörn Müller-Quade 07.06.2017 Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?id=799 (Folien von Peter Sanders) KIT Institut für Theoretische Informatik
1. Übungsblatt zu Algorithmen II im WS 2011/2012
Karlsruher Institut für Technologie Institut für Theoretische Informatik Prof. Dr. Peter Sanders Moritz Kobitzsch, Dennis Schieferdecker. Übungsblatt zu Algorithmen II im WS 0/0 http://algo.iti.kit.edu/algorithmenii.php
Übungsklausur Algorithmen I
Jun.-Prof. Hofheinz, Jun.-Prof. Meyerhenke (ITI, KIT) 08.06.2015 Übungsklausur Algorithmen I Aufgabe 1. (Algorithm Engineering) Nennen Sie zwei Konzepte, die Algorithm Engineering im Gegensatz zu theoretischer
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen 11. Übung Verkettete Listen, Sortieren Insertionsort, Mergesort, Radixsort, Quicksort Clemens Lang Übungen zu AuD 19. Januar 2010 Clemens Lang (Übungen zu AuD) Algorithmen
Bucketsort. Korrektheit. Beispiel. Eingabe: Array A mit n Elementen im Bereich [0,1) Annahme: die Elemente sind in [0,1) gleichverteilt.
Bucketsort Beispiel Eingabe: Array A mit n Elementen im Bereich [0,1) Annahme: die Elemente sind in [0,1) gleichverteilt 1 2 A.78.17 0 1 B.12.17 Sonst: Skalieren ( Aufwand O(n) ) 3.39 2.21.23.26 Idee:
Motivation Überblick
Kap. ff: Untere Laufzeitschranke und Lineare Verfahren Professor Dr. Lehrstuhl für Algorithm Engineering, LS Fakultät für Informatik, TU Dortmund 8. VO DAP SS 009. Mai 009. Übungstest Termin: Di 9. Mai
Algorithmen I. Tutorium 1-3. Sitzung. Dennis Felsing
Algorithmen I Tutorium 1-3. Sitzung Dennis Felsing dennis.felsing@student.kit.edu www.stud.uni-karlsruhe.de/~ubcqr/algo 2011-05-02 Überblick 1 Sortieren und Suchen 2 Mastertheorem 3 Datenstrukturen 4 Kreativaufgabe
Übungsklausur Algorithmen I
Universität Karlsruhe, Institut für Theoretische Informatik Prof. Dr. P. Sanders 26.5.2010 svorschlag Übungsklausur Algorithmen I Hiermit bestätige ich, dass ich die Klausur selbständig bearbeitet habe:
Übung Algorithmen I
Übung Algorithmen I 24.5.17 Sascha Witt sascha.witt@kit.edu (Mit Folien von Lukas Barth, Julian Arz, Timo Bingmann, Sebastian Schlag und Christoph Striecks) Organisatorisches Übungsklausur Am 21.06.2017
Ü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
Dies ist gerade der konstruktive Schritt beim Aufbau von Binomialbäumen.
Linken von Bäumen: Zwei Bäume desselben Wurzel-Rangs werden unter Einhaltung der Heap-Bedingung verbunden. Sind k 1 und k 2 die Wurzeln der zwei zu linkenden Bäume, so wird ein neuer Baum aufgebaut, dessen
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2017 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda: Sortierverfahren 1. Schreibtischtest 2. Stabilität 3. Sortierung spezieller Arrays 4. Untere
Sortieralgorithmen. Jan Pöschko. 18. Januar Problemstellung Definition Warum Sortieren?... 2
Jan Pöschko 18. Januar 2007 Inhaltsverzeichnis 1 Problemstellung 2 1.1 Definition................................... 2 1.2 Warum Sortieren?.............................. 2 2 Einfache Sortieralgorithmen
Sortierte Folgen 250
Sortierte Folgen 250 Sortierte Folgen: he 1,...,e n i mit e 1 apple applee n kennzeichnende Funktion: M.locate(k):= addressof min{e 2 M : e k} Navigations Datenstruktur 2 3 5 7 11 13 17 19 00 Annahme:
Prof. Dr. Margarita Esponda
Algorithmen und Programmieren II Sortieralgorithmen imperativ Teil I Prof. Dr. Margarita Esponda Freie Universität Berlin Sortieralgorithmen Bubble-Sort Insert-Sort Selection-Sort Vergleichsalgorithmen
Grundlagen: Algorithmen und Datenstrukturen
Grundlagen: Algorithmen und Datenstrukturen Prof. Dr. Hanjo Täubig Lehrstuhl für Effiziente Algorithmen (Prof. Dr. Ernst W. Mayr) Institut für Informatik Technische Universität München Sommersemester 2010
A7.1 Untere Schranke. Algorithmen und Datenstrukturen. A7.1 Untere Schranke. Algorithmen und Datenstrukturen. A7.2 Quicksort. A7.
Algorithmen und Datenstrukturen 14. März 2018 A7. III Algorithmen und Datenstrukturen A7. III Marcel Lüthi and Gabriele Röger Universität Basel 14. März 2018 A7.1 Untere Schranke A7.2 Quicksort A7.3 Heapsort
4. Übung zu Algorithmen I 17. Mai 2017
4. Übung zu Algorithmen I 17. Mai 2017 Björn Kaidel bjoern.kaidel@kit.edu (mit Folien von Julian Arz, Timo Bingmann, Lisa Kohl, Christian Schulz, Sebastian Schlag und Christoph Striecks) Organisatorisches
Algorithmen und Datenstrukturen Heapsort
Algorithmen und Datenstrukturen 2 5 Heapsort In diesem Kapitel wird Heapsort, ein weiterer Sortieralgorithmus, vorgestellt. Dieser besitzt wie MERGE-SORT eine Laufzeit von O(n log n), sortiert jedoch das
8.1.3 Operation Build-Max-Heap Operation zur Konstruktion eines Heaps Eingabe: Feld A[1..n], n = länge(a) BUILD-MAX-HEAP (A)
![8.1.3 Operation Build-Max-Heap Operation zur Konstruktion eines Heaps Eingabe: Feld A[1..n], n = länge(a) BUILD-MAX-HEAP (A)](/thumbs/61/46182525.jpg "8.1.3 Operation Build-Max-Heap Operation zur Konstruktion eines Heaps Eingabe: Feld A[1..n], n = länge(a) BUILD-MAX-HEAP (A)")
Stand der Vorlesung: Datenstruktur Heap: fast vollständiger Binärbaum MaxHeap: sortierter Heap, größtes Element an Wurzel Sortierverfahren: HeapSort: Sortieren eines Feldes A[1.. n] Idee: in place: Feld
Sortieren II / HeapSort Heaps
Organisatorisches VL-07: Sortieren II: HeapSort (Datenstrukturen und Algorithmen, SS 2017) Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Email: dsal-i1@algo.rwth-aachen.de Webseite: http://algo.rwth-aachen.de/lehre/ss17/dsa.php
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2016 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda 1. Vorstellen des vierten Übungsblatts 2. Vorbereitende Aufgaben für das vierte Übungsblatt
Übung Algorithmen I
Übung Algorithmen I 20.5.15 Christoph Striecks Christoph.Striecks@kit.edu (Mit Folien von Julian Arz, Timo Bingmann und Sebastian Schlag.) Roadmap Organisation Mergesort, Quicksort Dual Pivot Quicksort
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen A7. Sortieren III Marcel Lüthi and Gabriele Röger Universität Basel 14. März 2018 Untere Schranke Sortierverfahren Sortieren Vergleichsbasierte Verfahren Nicht vergleichsbasierte
INSTITUT FÜR THEORETISCHE INFORMATIK, PROF. SANDERS
Julian Arz, Timo Bingmann, Sebastian Schlag INSTITUT FÜR THEORETISCHE INFORMATIK, PROF. SANDERS 1 KIT Julian Universität Arz, des Timo LandesBingmann, Baden-Württemberg Sebastian und Schlag nationales
Tutoraufgabe 1 (Sortieralgorithmus):
Prof. aa Dr. Ir. Joost-Pieter Katoen Datenstrukturen und Algorithmen SS Tutoriumslösung - Übung 4 (Abgabe 2..2) Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Sortieralgorithmus):
Technische Universität München
Stand der Vorlesung: Datenstruktur Heap: fast vollständiger Binärbaum MaxHeap: sortierter Heap, größtes Element an Wurzel Sortierverfahren: HeapSort: Sortieren eines Feldes A[1.. n] Idee: in place: Feld
Erinnerung VL vom
Erinnerung VL vom 09.05.2016 Analyse von Hashtabellen mit verketteten Listen Erwartete Laufzeit O(1) bei zuf. Hashfkt. und falls M O(m) Guter Ersatz (hier) für zuf. Hashfkt.: universelle Hashfunktionen
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2016 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda Amortisierte Analyse Suche in sortierten Arrays Heaps Vorstellen des fünften Übungsblatts
Übung: Algorithmen und Datenstrukturen SS 2007
Übung: Algorithmen und Datenstrukturen SS 2007 Prof. Lengauer Sven Apel, Michael Claÿen, Christoph Zengler, Christof König Blatt 5 Votierung in der Woche vom 04.06.0708.06.07 Aufgabe 12 Manuelle Sortierung
Suchen und Sortieren Sortieren. Heaps
Suchen und Heaps (Folie 245, Seite 63 im Skript) 3 7 21 10 17 31 49 28 14 35 24 42 38 Definition Ein Heap ist ein Binärbaum, der die Heapeigenschaft hat (Kinder sind größer als der Vater), bis auf die
Algorithms & Data Structures 2
Algorithms & Data Structures Digital Sorting WS B. Anzengruber-Tanase (Institute for Pervasive Computing, JKU Linz) (Institute for Pervasive Computing, JKU Linz) WIEDERHOLUNG :: UNTERE SCHRANKE FÜR SORTIEREN
Algorithmen I. Prof. Jörn Müller-Quade Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?
Algorithmen I Prof. Jörn Müller-Quade 19.6.1 Institut für Theoretische Informatik Web: https://crypto.iti.kit.edu/index.php?id=99 (Folien von Peter Sanders) KIT Institut für Theoretische Informatik 1 Organisatorisches
Grundlagen der Algorithmen und Datenstrukturen Kapitel 10
Grundlagen der Algorithmen und Datenstrukturen Kapitel 0 Christian Scheideler + Helmut Seidl SS 009 5.06.09 Kapitel 0 Kürzeste Wege Zentrale Frage: Wie komme ich am schnellsten von A nach B? B A 5.06.09
(Digital) Sorting. October 25, Algorithms & Datastructures 2 Exercises WS 2016
(Digital) Sorting October 2, 2016 Algorithms & Datastructures 2 Exercises WS 2016 Dipl.-Ing. University Linz, Institute for Pervasive Computing Altenberger Straße 69, A-4040 Linz kurz@pervasive.jku.at
Sortieren und Suchen. Jens Wächtler Hallo Welt! -Seminar LS 2
Sortieren und Suchen Jens Wächtler 17.05.2017 Hallo Welt! -Seminar LS 2 Überblick Sortieren kurze Wiederholung Binäre & Ternäre Suche Binäre Suche in einer Liste Bisektionsverfahren (Nullstellensuche)
Vorlesung Datenstrukturen
Vorlesung Datenstrukturen Prioritätswarteschlangen Maike Buchin 18. und 23.5.2017 Prioritätswarteschlange Häufiges Szenario: dynamische Menge von Objekten mit Prioritäten, z.b. Aufgaben, Prozesse, in der
Untere Schranke für allgemeine Sortierverfahren
Untere Schranke für allgemeine Sortierverfahren Prinzipielle Frage: wie schnell kann ein Algorithmus (im worst case) überhaupt sein? omputational Model hier: RAM und nur Vergleiche auf Elemente Sog. "comparison-based
Datenstrukturen & Algorithmen
Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010 Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 2 Motivation Sortieren ist Voraussetzung für viele Anwendungen Nach
Fibonacci-Heaps und deren Anwendung
Fibonacci-Heaps und deren Anwendung Alexander Schiffel und Stefan Hurtz 24. Juli 2005 Inhaltsverzeichnis 1 Einleitung und Motivation 2 2 Die Datenstruktur 2 3 Amortisierte Laufzeitanalyse 3 4 Grundoperationen
Termine für Übungstests. Kap. 3 Sortieren HeapSort ff Priority Queues. Motivation. Überblick. Analyse SiftDown
Kap. Sortieren..5 HeapSort ff..6 Priority Queues Professor Dr. Vorlesung am Do 7.5. entfällt wegen FVV um Uhr Lehrstuhl für Algorithm Engineering, LS Fakultät für nformatik, TU Dortmund 7. VO DAP SS 009
Kapitel 2. Weitere Beispiele Effizienter Algorithmen
Kapitel 2 Weitere Beispiele Effizienter Algorithmen Sequentielle Suche Gegeben: Array a[1..n] Suche in a nach Element x Ohne weitere Zusatzinformationen: Sequentielle Suche a[1] a[2] a[3] Laufzeit: n Schritte
Eingabe: Array A mit n Elementen im Bereich [0,1) Annahme: die Elemente sind in [0,1) gleichverteilt
Bucketsort Eingabe: Array A mit n Elementen im Bereich [0,1) Annahme: die Elemente sind in [0,1) gleichverteilt Sonst: Skalieren ( Aufwand O(n) ), oder Algo etwas umschreiben Idee: Teile [0, 1) in k gleich
Kapitel 8 Fortgeschrittene Sortieralgorithmen
Kapitel 8 Fortgeschrittene Sortieralgorithmen Zur Erinnerung: in Kapitel 6 Elementare Sortierverfahren Sortierverfahren, die auf Vergleichen von Werten basieren. Aufwand zum Sortieren von Feldern von n
Effiziente Algorithmen und Datenstrukturen I. Kapitel 9: Minimale Spannbäume
Effiziente Algorithmen und Datenstrukturen I Kapitel 9: Minimale Spannbäume Christian Scheideler WS 008 19.0.009 Kapitel 9 1 Minimaler Spannbaum Zentrale Frage: Welche Kanten muss ich nehmen, um mit minimalen
1. Übung zur Vorlesung Algorithmentechnik am
1. Übung zur Vorlesung Algorithmentechnik am 23.10.2008 1/ 52 Übersicht Organisatorisches Landau-Symbole & Laufzeiten Amortisierte Analyse Rekursionsauflösung Heaps und Fibonacci Heaps 2/ 52 Organisatorisches
markiert, 0: unmarkiert.)
4.2 Fibonacci-Heaps Fibonacci-Heaps (F-Heaps) implementieren adressierbare Priority Queues (siehe Anfang von Kap. 4). Wie bei Binomialheaps besteht der Heap aus heapgeordneten Bäumen, jedoch mit gelockerten
Grundlagen Algorithmen und Datenstrukturen TUM Sommersemester 2011 (2) Dozent: Hanjo Täubig
Grundlagen Algorithmen und Datenstrukturen TUM Sommersemester 2011 (2) Dozent: Hanjo Täubig Janosch Maier 3. August 2011 Inhaltsverzeichnis 1 Sortieren 3 1.1 Externes Sortieren..........................
8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften
![8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften](/thumbs/72/66389118.jpg "8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften")
Heapsort, Quicksort, Mergesort 8. Sortieren II 8.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 9 210 Heapsort [Max-]Heap 6 Inspiration von Selectsort: Schnelles Einfügen Binärer Baum mit
Heapsort, Quicksort, Mergesort. 8. Sortieren II
209 Heapsort, Quicksort, Mergesort 8. Sortieren II 210 8.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 211 Heapsort Inspiration von Selectsort: Schnelles Einfügen Inspiration von Insertionsort:
Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Spezielle Sortierverfahren Autor: Sven Schuierer
Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Spezielle Sortierverfahren Autor: Sven Schuierer Institut für Informatik Georges-Köhler-Allee Albert-Ludwigs-Universität Freiburg 1
7. Sortieren Lernziele. 7. Sortieren
7. Sortieren Lernziele 7. Sortieren Lernziele: Die wichtigsten Sortierverfahren kennen und einsetzen können, Aufwand und weitere Eigenschaften der Sortierverfahren kennen, das Problemlösungsparadigma Teile-und-herrsche
4.2 Fibonacci-Heaps Aufbau Potenzialfunktion. Knoten v hat folgende Felder:
4.2 Fibonacci-Heaps 4.2.1 Aufbau Knoten v hat folgende Felder: Vaterzeiger p(v) Zeiger auf linkes Geschwister: prev(v) Zeiger auf rechtes Geschwister: next(v) Kindzeiger: child(v) Schlüssel: key: aus U
Grundlagen: Algorithmen und Datenstrukturen
Grundlagen: Algorithmen und Datenstrukturen Prof. Dr. Hanjo Täubig Lehrstuhl für Effiziente Algorithmen (Prof. Dr. Ernst W. Mayr) Institut für Informatik Technische Universität München Sommersemester 00
Übersicht. Einfache Verfahren MergeSort Untere Schranke QuickSort Selektieren Schnelleres Sortieren Externes Sortieren. 6 Sortieren.
Übersicht 6 Sortieren Einfache Verfahren MergeSort Untere Schranke QuickSort Selektieren Schnelleres Sortieren Externes Sortieren H. Täubig (TUM) GAD SS 14 221 Statisches Wörterbuch Sortieren Lösungsmöglichkeiten:
Übersicht. Datenstrukturen und Algorithmen. Übersicht. Heaps. Vorlesung 8: Heapsort (K6) Joost-Pieter Katoen. 7. Mai 2015
Datenstrukturen und Algorithmen Vorlesung 8: (K6) 1 Joost-Pieter Katoen Lehrstuhl für Informatik Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-15/dsal/ 7. Mai 015 3 Joost-Pieter
Programmieren I. Kapitel 7. Sortieren und Suchen
Programmieren I Kapitel 7. Sortieren und Suchen Kapitel 7: Sortieren und Suchen Ziel: Varianten der häufigsten Anwendung kennenlernen Ordnung Suchen lineares Suchen Binärsuche oder Bisektionssuche Sortieren
Praktikum Algorithmische Anwendungen WS 2006/07 Sortieren in linearer Laufzeit
Praktikum Algorithmische Anwendungen WS 2006/07 Sortieren in linearer Laufzeit Team A blau Martin Herfurth 11043831 Markus Wagner 11043447 5. Februar 2007 1 1 Untere Schranke für Vergleichsbasierte Algorithmen
Erinnerung VL
Erinnerung VL.6.16 Graphtraversierung (DFS, topologische Sortierung und mehr) Kürzeste Wege: Problemstellung, Algorithmen Analoger Algorithmus Dijkstras Algorithmus: Idee, Korrektheit Heute: mehr zu Dijkstra,
Informatik II, SS 2014
Informatik II SS 2014 (Algorithmen & Datenstrukturen) Vorlesung 11 (4.6.2014) Binäre Suchbäume II Algorithmen und Komplexität Binäre Suchbäume Binäre Suchbäume müssen nicht immer so schön symmetrisch sein
Counting - Sort [ [ ] [ [ ] 1. SS 2008 Datenstrukturen und Algorithmen Sortieren in linearer Zeit
![Counting - Sort [ [ ] [ [ ] 1. SS 2008 Datenstrukturen und Algorithmen Sortieren in linearer Zeit](/thumbs/60/44575606.jpg "Counting - Sort [ [ ] [ [ ] 1. SS 2008 Datenstrukturen und Algorithmen Sortieren in linearer Zeit")
Counting-Sort Counting - Sort ( A,B,k ). for i to k. do C[ i]. for j to length[ A]. do C[ A[ j ] C[ A[ j ] +. > C[ i] enthält Anzahl der Elemente in 6. for i to k. do C[ i] C[ i] + C[ i ]. > C[ i] enthält
8. A & D - Heapsort. Werden sehen, wie wir durch geschicktes Organsieren von Daten effiziente Algorithmen entwerfen können.
8. A & D - Heapsort Werden sehen, wie wir durch geschicktes Organsieren von Daten effiziente Algorithmen entwerfen können. Genauer werden wir immer wieder benötigte Operationen durch Datenstrukturen unterstützen.
4. Sortieren 4.1 Vorbemerkungen
. Seite 1/21 4. Sortieren 4.1 Vorbemerkungen allgemeines Sortierproblem spezielle Sortierprobleme Ordne a 1,..., a n so um, dass Elemente in aufsteigender Reihenfolge stehen. Die a i stammen aus vollständig
Algorithmen und Datenstrukturen 12
12. Juli 2012 1 Besprechung Blatt 11 Fragen 2 Binary Search Binäre Suche in Arrays Binäre Suchbäume (Binary Search Tree) 3 Sortierverfahren Allgemein Heapsort Bubblesort Insertionsort Mergesort Quicksort
Datenstrukturen & Algorithmen
Datenstrukturen & Algorithmen VO 708.031 Um was geht es? Datenstrukturen Algorithmen Algorithmus Versuch einer Erklärung: Ein Algorithmus nimmt bestimmte Daten als Input und transformiert diese nach festen
Klausur Algorithmen und Datenstrukturen SS August Arbeitszeit 90 min
TU Ilmenau, Fakultät für Informatik und Automatisierung FG Komplexitätstheorie und Effiziente Algorithmen Univ.-Prof. Dr. M. Dietzfelbinger, Dipl.-Ing. C. Mattern Klausur Algorithmen und Datenstrukturen
Programmiertechnik II
Sortieren: Einfache Algorithmen Sortieren Abstrakte Operation geg: Menge von items (Elemente) jedes Element besitzt Sortierschlüssel Schlüssel unterliegen einer Ordnung eventuell sind doppelte Schlüssel
Algorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 01/13 6. Vorlesung Prioritäten setzen Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I Guten Morgen! Tipps für unseren ersten Test am 0. November: Lesen
Konvexe Hülle. Abbildung: [Wikipedia]: Nicht-konvexe Menge (links), konvexe Menge (rechts) KIT Institut für Theoretische Informatik 510
![Konvexe Hülle. Abbildung: [Wikipedia]: Nicht-konvexe Menge (links), konvexe Menge (rechts) KIT Institut für Theoretische Informatik 510](/thumbs/72/66802198.jpg "Konvexe Hülle. Abbildung: [Wikipedia]: Nicht-konvexe Menge (links), konvexe Menge (rechts) KIT Institut für Theoretische Informatik 510")
Konvexe Hülle Definition konvexe Menge: Für je zwei beliebige Punkte, die zur Menge gehören, liegt auch stets deren Verbindungsstrecke ganz in der Menge. Abbildung: [Wikipedia]: Nicht-konvexe Menge (links),
Mergeable Heaps. C. Komusiewicz 7.1 Fibonacci-Heaps: Überblick 117
C. Komusiewicz 7.1 Fibonacci-Heaps: Überblick 117 Mergeable Heaps Erweiterung von Standardheaps, die die folgenden fünf Operationen unterstützen. Make-Heappq liefert neuen, leeren Heap. InsertpH, xq fügt
Abschnitt: Algorithmendesign und Laufzeitanalyse
Abschnitt: Algorithmendesign und Laufzeitanalyse Definition Divide-and-Conquer Paradigma Divide-and-Conquer Algorithmen verwenden die Strategien 1 Divide: Teile das Problem rekursiv in Subproblem gleicher
2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,..., a n 2, 1, 3 Sortieralg. Für festes n ist ein vergleichsbasierter Sortieralg. charakterisiert
1 Algorithmen und Datenstrukturen Wintersemester 2014/15 9. Vorlesung Sortieren in Linearzeit Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,...,
f 1 (n) = log(n) + n 2 n 5 f 2 (n) = n 3 + n 2 f 3 (n) = log(n 2 ) f 4 (n) = n n f 5 (n) = (log(n)) 2
Prof. aa Dr. E. Ábrahám Datenstrukturen und Algorithmen SS Lösung - Präsenzübung.05.0 F. Corzilius, S. Schupp, T. Ströder Aufgabe (Asymptotische Komplexität): (6 + 0 + 6 = Punkte) a) Geben Sie eine formale
Beispiellösung zu den Übungen Datenstrukturen und Algorithmen SS 2008 Blatt 5
Robert Elsässer Paderborn, den 15. Mai 2008 u.v.a. Beispiellösung zu den Übungen Datenstrukturen und Algorithmen SS 2008 Blatt 5 AUFGABE 1 (6 Punkte): Nehmen wir an, Anfang bezeichne in einer normalen
13. Hashing. AVL-Bäume: Frage: Suche, Minimum, Maximum, Nachfolger in O(log n) Einfügen, Löschen in O(log n)
AVL-Bäume: Ausgabe aller Elemente in O(n) Suche, Minimum, Maximum, Nachfolger in O(log n) Einfügen, Löschen in O(log n) Frage: Kann man Einfügen, Löschen und Suchen in O(1) Zeit? 1 Hashing einfache Methode
2.2 Allgemeine (vergleichsbasierte) Sortierverfahren
. Allgemeine (vergleichsbasierte) Sortierverfahren Vergleichsbaum: Der Aufbau des Verbleichsbaum ist für jeden Algorithmus und jede Eingabelänge n gleich. Jede Permutation der Eingabe, muss zu einem anderen
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 217 Marc Bux, Humboldt-Universität zu Berlin Agenda 1. Graphen und Bäume 2. Binäre Suchbäume 3. AVL-Bäume 4. Algorithmen und Datenstrukturen 2 Agenda
Grundlegende Algorithmen Kapitel 4: Kürzeste Wege
Grundlegende Algorithmen Kapitel 4: Kürzeste Wege Christian Scheideler WS 009 08.0.00 Kapitel 4 Kürzeste Wege Zentrale Frage: Wie komme ich am schnellsten von A nach B? B A 08.0.00 Kapitel 4 Kürzeste Wege
Vorrangswarteschlangen:Operationen
Fibonacci Heaps Vorrangswarteschlangen:Operationen (Vorrangs)warteschlange Q Operationen: Q.initialize(): erstellt die leere Schlange Q Q.isEmpty(): liefert true gdw. Q ist leer Q.insert(e): fügt Eintrag
Das Suchproblem. Gegeben Menge von Datensätzen. Beispiele Telefonverzeichnis, Wörterbuch, Symboltabelle
119 4. Suchen Lineare Suche, Binäre Suche, Interpolationssuche, Exponentielle Suche, Untere Schranken [Ottman/Widmayer, Kap. 3.2, Cormen et al, Kap. 2: Problems 2.1-3,2.2-3,2.3-5] 120 Das Suchproblem Gegeben
Lernmodul 7 Algorithmus von Dijkstra
Folie 1 von 30 Lernmodul 7 Algorithmus von Dijkstra Quelle: http://www.map24.de Folie 2 von 30 Algorithmus von Dijkstra Übersicht Kürzester Weg von A nach B in einem Graphen Problemstellung: Suche einer
in eine Folge ai, so daß bezgl. einer Ordnung gilt: a a, j < n
6. Sortieren Umordnen von Objekten a in eine Folge ai,..., ai n, so daß bezgl. einer Ordnung gilt: a a, j < n Begriffe: ij i j + ) Stabilität : Ein Sortierverfahren heißt stabil, falls die relative Reihenfolge
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2017 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda: Kürzeste Wege, Heaps, Hashing Heute: Kürzeste Wege: Dijkstra Heaps: Binäre Min-Heaps Hashing:
Pro Informatik 2009: Objektorientierte Programmierung Tag 17. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik
Tag 17 Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik 08.09.2009 Agenda Tag 16 Datenstrukturen Abstrakte Datentypen, ADT Folge: Stack, Queue, Liste, ADT Menge: Bäume:
Vorlesung Informatik 2 Algorithmen und Datenstrukturen
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (17 Fibonacci-Heaps) Prof. Dr. Susanne Albers Vorrangswarteschlangen Bekannte Datenstrukturen zum Einfügen und Entfernen von Elementen Stapel (Stack):
3. Übungsblatt zu Algorithmen I im SoSe 2017
Karlsruher Institut für Technologie Prof. Dr. Jörn Müller-Quade Institut für Theoretische Informatik Björn Kaidel, Sebastian Schlag, Sascha Witt 3. Übungsblatt zu Algorithmen I im SoSe 2017 http://crypto.iti.kit.edu/index.php?id=799
Suchen und Sortieren (Die klassischen Algorithmen)
Suchen und Sortieren (Die klassischen Algorithmen) Lineare Suche und Binäre Suche (Vorbedingung und Komplexität) Sortieralgorithmen (allgemein) Direkte Sortierverfahren (einfach aber langsam) Schnelle
2. Übungsblatt zu Algorithmen II im WS 2016/2017
Karlsruher Institut für Technologie Institut für Theoretische Informatik Prof. Dr. Peter Sanders Dr. Christian Schulz, Dr. Simon Gog Michael Axtmann. Übungsblatt zu Algorithmen II im WS 016/017 Aufgabe
10. Übung Algorithmen I
INSTITUT FÜR THEORETISCHE INFORMATIK 1 KIT Universität des Landes Baden-Württemberg und nationales Forschungszentrum in der Helmholtz-Gemeinschaft Institut für Theoretische www.kit.edu Informatik Bäume
Datenstrukturen und Algorithmen 2. Klausur SS 2001
UNIVERSITÄT PADERBORN FACHBEREICH 7 (MATHEMATIK INFORMATIK) Datenstrukturen und Algorithmen 2. Klausur SS 200 Lösungsansätze Dienstag, 8. September 200 Name, Vorname:...................................................
Abstrakter Datentyp (ADT): Besteht aus einer Menge von Objekten, sowie Operationen, die auf diesen Objekten wirken.
Abstrakte Datentypen und Datenstrukturen/ Einfache Beispiele Abstrakter Datentyp (ADT): Besteht aus einer Menge von Objekten, sowie Operationen, die auf diesen Objekten wirken. Datenstruktur (DS): Realisierung
Kapitel 6 Elementare Sortieralgorithmen
Kapitel 6 Elementare Sortieralgorithmen Ziel: Kennenlernen elementarer Sortierverfahren und deren Effizienz Zur Erinnerung: Das Sortier-Problem Gegeben: Folge A von n Elementen a 1, a 2,..., a n ; Eine
Pro Informatik 2009: Objektorientierte Programmierung Tag 18. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik
Tag 18 Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik 09.09.2009 Agenda Tag 16 Datenstrukturen Abstrakte Datentypen, ADT Folge: Stack, Queue, Liste, ADT Menge: Bäume:
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Große Übung #6 Phillip Keldenich, Arne Schmidt 26.02.2017 Heute: Master-Theorem Phillip Keldenich, Arne Schmidt Große Übung 2 Vorbetrachtungen Wir betrachten rekursive Gleichungen