Algorithmen und Datenstrukturen Kapitel 7 Dynamische Mengen, das Suchproblem &
|
|
|
- Hannelore Kerner
- vor 5 Jahren
- Abrufe
Transkript
1 Grundlagen Algorithmen und Datenstrukturen Kapitel 7 Dynamische Mengen, das Suchproblem & Frank Heitmann heitmann@informatik.uni-hamburg.de 25. November 2015 Frank Heitmann heitmann@informatik.uni-hamburg.de 1/122
2 Dynamische Mengen Grundlagen Grundlegende Algorithmen Definition Bisher hatten wir oft statische Mengen, bei denen sich die Anzahl der Elemente nicht ändert (z.b. beim Sortieren). Oft soll eine Menge aber zeitabhängig wachsen und schrumpfen können. Man spricht dann von dynamischen Mengen. Kennengelernt haben wir bereits den Stack, die Queue und die verkettete Liste. Anmerkung Wir beschränken uns oft auf die Darstellung der für unsere wichtigen Daten. Meist enthalten die Objekte aber zusätzliche Satellitendaten z.b. einen Wächter am Ende einer verketteten Liste. Frank Heitmann 2/122
3 Dynamische Mengen Grundlagen Grundlegende Algorithmen Definition Bisher hatten wir oft statische Mengen, bei denen sich die Anzahl der Elemente nicht ändert (z.b. beim Sortieren). Oft soll eine Menge aber zeitabhängig wachsen und schrumpfen können. Man spricht dann von dynamischen Mengen. Kennengelernt haben wir bereits den Stack, die Queue und die verkettete Liste. Anmerkung Wir beschränken uns oft auf die Darstellung der für unsere wichtigen Daten. Meist enthalten die Objekte aber zusätzliche Satellitendaten z.b. einen Wächter am Ende einer verketteten Liste. Frank Heitmann 2/122
4 Dynamische Mengen Grundlagen Grundlegende Algorithmen Definition Bisher hatten wir oft statische Mengen, bei denen sich die Anzahl der Elemente nicht ändert (z.b. beim Sortieren). Oft soll eine Menge aber zeitabhängig wachsen und schrumpfen können. Man spricht dann von dynamischen Mengen. Kennengelernt haben wir bereits den Stack, die Queue und die verkettete Liste. Anmerkung Wir beschränken uns oft auf die Darstellung der für unsere wichtigen Daten. Meist enthalten die Objekte aber zusätzliche Satellitendaten z.b. einen Wächter am Ende einer verketteten Liste. Frank Heitmann 2/122
5 Dynamische Mengen Grundlagen Grundlegende Algorithmen Wichtige (dynamischer Mengen): Search(S, k). Gibt es einen Zeiger x auf ein Element in S mit schlüssel[x] = k? Insert(S, x). Delete(S, x). Minimum(S), Maximum(S), Successor(S, x), Predecessor(S, x). Viele hiervon haben wir schon bei z.b. der verketteten Liste gesehen, aber wie schnell waren die? Frank Heitmann heitmann@informatik.uni-hamburg.de 3/122
6 Das Suchproblem Grundlagen Grundlegende Algorithmen Definition (Das Suchproblem) Eingabe: Eine Sequenz < a 1, a 2,..., a n > von n Zahlen und ein Wert k. Gesucht: Ein Index i mit k = A[i], falls k in A vorkommt oder der Wert nil. Definition (Das Suchproblem (allgemein)) Eingabe: Eine Menge M und ein Wert k. Gesucht: Ein Zeiger x auf ein Element in M mit schlüssel[x] = k oder nil, falls kein solches Element existiert. Frank Heitmann heitmann@informatik.uni-hamburg.de 4/122
7 Das Suchproblem Grundlagen Grundlegende Algorithmen Definition (Das Suchproblem) Eingabe: Eine Sequenz < a 1, a 2,..., a n > von n Zahlen und ein Wert k. Gesucht: Ein Index i mit k = A[i], falls k in A vorkommt oder der Wert nil. Definition (Das Suchproblem (allgemein)) Eingabe: Eine Menge M und ein Wert k. Gesucht: Ein Zeiger x auf ein Element in M mit schlüssel[x] = k oder nil, falls kein solches Element existiert. Frank Heitmann heitmann@informatik.uni-hamburg.de 4/122
8 Grundlagen Brute-Force-Suche (Array) Grundlegende Algorithmen Algorithmus 1 Search(A[1..n], k) 1: for i = 1 to n do 2: if a[i] == k then 3: return i 4: end if 5: end for 6: return nil Analyse Laufzeit ist in Θ(n). Korrektheit folgt mit Schleifeninvariante (oder hier auch direkt). Frank Heitmann heitmann@informatik.uni-hamburg.de 5/122
9 Grundlagen Brute-Force-Suche (Liste) Grundlegende Algorithmen Algorithmus 2 Search(L, k) 1: x = kopf[l] 2: while x nil && schlüssel[x] k do 3: x = nachfolger[x] 4: end while 5: return x Analyse Laufzeit ist wieder in Θ(n). Korrektheit zeigt man wie oben. Frank Heitmann heitmann@informatik.uni-hamburg.de 6/122
10 Binäre Suche Grundlagen Grundlegende Algorithmen Algorithmus 3 Binäre Suche (Array) 1: while first last idx < 0 do 2: m = first + ((last first)/2) 3: if a[m] < p then 4: first = m + 1 5: else if a[m] > p then 6: last = m 1 7: else 8: idx = m 9: end if 10: end while 11: return idx Analyse Laufzeit ist in Θ(log n) (T (n) = T (n/2) + c). Frank Heitmann heitmann@informatik.uni-hamburg.de 7/122
11 Grundlagen Grundlegende Algorithmen Grundlegende Algorithmen - Zusammenfassung Zusammenfassung Die Laufzeit der Brute-Force-Suchalgorithmen war in Θ(n), insb. da jedes Element betrachtet werden musste. Die binäre Suche erlaubt eine Laufzeit in Θ(log n), ist aber nicht bei jeder Datenstruktur anwendbar! Wir suchen nun Datenstrukturen, die die Suche und auch die anderen für dynamische Mengen in wenig Zeit (z.b. in O(log n)) erlauben. Pause to Ponder Unsere bisherigen Datenstrukturen erlauben dies nicht. Man überlege sich dies an Array, Stack, Queue, Liste und Heap... Frank Heitmann heitmann@informatik.uni-hamburg.de 8/122
12 Grundlagen Grundlegende Algorithmen Grundlegende Algorithmen - Zusammenfassung Zusammenfassung Die Laufzeit der Brute-Force-Suchalgorithmen war in Θ(n), insb. da jedes Element betrachtet werden musste. Die binäre Suche erlaubt eine Laufzeit in Θ(log n), ist aber nicht bei jeder Datenstruktur anwendbar! Wir suchen nun Datenstrukturen, die die Suche und auch die anderen für dynamische Mengen in wenig Zeit (z.b. in O(log n)) erlauben. Pause to Ponder Unsere bisherigen Datenstrukturen erlauben dies nicht. Man überlege sich dies an Array, Stack, Queue, Liste und Heap... Frank Heitmann heitmann@informatik.uni-hamburg.de 8/122
13 Grundlagen - Die Idee Ein binärer Suchbaum ist eine Datenstruktur, die viele auf dynamischen Mengen ermöglicht, insb. die Search, Minimum, Maximum, Predecessor, Successor, Insert und Delete. Ein binärer Suchbaum ist ein binärer Baum (jeder Knoten hat bis zu zwei Kindern), wobei der Baum noch die spezielle Suchbaum-Eigenschaft erfüllt. Der Baum wird (anders als der Heap!) meist durch eine verkettete Datenstruktur (ähnlich der doppelt-verketteten Liste) repräsentiert. Jeder Knoten ist ein Objekt mit den Attributen schlüssel (und den Satellitendaten), links, rechts, p, die auf den jeweiligen linken bzw. rechten Nachfolger, bzw. den Vaterknoten zeigen (fehlen diese, sind die entsprechenden Attribute auf nil gesetzt). Frank Heitmann heitmann@informatik.uni-hamburg.de 9/122
14 Grundlagen - Die Idee Binäre Suchbaum-Eigenschaft: Sei p ein Knoten im binären Suchbaum. Sei l ein Knoten im linken Teilbaum von n, r im rechten, dann gilt stets: schlüssel[l] schlüssel[p] und schlüssel[p] schlüssel[r] nil 13 nil 16 nil nil nil nil (Im Bild sind nicht alle nil-knoten eingezeichnet, nachfolgend verzichten wir meist ganz auf sie.) Frank Heitmann heitmann@informatik.uni-hamburg.de 10/122
15 Grundlagen - Beispiel (gut) Frank Heitmann heitmann@informatik.uni-hamburg.de 11/122
16 Grundlagen - Beispiel (schlecht) Frank Heitmann heitmann@informatik.uni-hamburg.de 12/122
17 Die Grundlagen Wir werden nachfolgenden folgende betrachten: InorderTreeWalk(x). TreeSearch(x, k), IterativeTreeSearch(x, k). TreeMinimum(x), TreeMaximum(x). TreeSuccessor(x), TreePredecessor(x). TreeInsert(T, x), TreeDelete(T, z). Frank Heitmann 13/122
18 Grundlagen InorderTreeWalk - Die Idee Gibt die Schlüssel aus, wobei zuerst die Schlüssel des linken, dann der Schlüssel der Wurzel und dann die Schlüssel des rechten Teilbaumes ausgegeben werden. Frank Heitmann heitmann@informatik.uni-hamburg.de 14/122
19 InorderTreeWalk Grundlagen Algorithmus 4 InorderTreeWalk(x) 1: if x nil then 2: InorderTreeWalk(links[x]) 3: print schlüssel[x] 4: InorderTreeWalk(rechts[x]) 5: end if Anmerkung Ähnlich kann man auch PreorderTreeWalk (Wurzel zuerst) und PostorderTreeWalk (Wurzel zuletzt) schreiben. Frank Heitmann heitmann@informatik.uni-hamburg.de 15/122
20 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 16/122
21 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 17/122
22 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 18/122
23 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 19/122
24 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 20/122
25 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 21/122
26 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 22/122
27 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 23/122
28 Grundlagen InorderTreeWalk - Beispiel Frank Heitmann heitmann@informatik.uni-hamburg.de 24/122
29 InorderTreeWalk Grundlagen Anmerkung Bei einem binären Suchbaum werden die Schlüssel bei InorderTreeWalk in sortierter Reihenfolge ausgegeben! (Der Satz, dass dies korrekt ist, folgt gleich. Der Beweis mündlich.) Pause to Ponder Laufzeit? Frank Heitmann 25/122
30 InorderTreeWalk Grundlagen Anmerkung Bei einem binären Suchbaum werden die Schlüssel bei InorderTreeWalk in sortierter Reihenfolge ausgegeben! (Der Satz, dass dies korrekt ist, folgt gleich. Der Beweis mündlich.) Pause to Ponder Laufzeit? Frank Heitmann 25/122
31 InorderTreeWalk Grundlagen Algorithmus 5 InorderTreeWalk(x) 1: if x nil then 2: InorderTreeWalk(links[x]) 3: print schlüssel[x] 4: InorderTreeWalk(rechts[x]) 5: end if Satz Wenn x die Wurzel eines Teilbaums mit n Knoten ist, dann ist InorderTreeWalk(x) korrekt (folgt per Induktion aus den Eigenschaften binärer Suchbäume). Frank Heitmann heitmann@informatik.uni-hamburg.de 26/122
32 Grundlagen InorderTreeWalk - Laufzeitanalyse (1/4) Satz Wenn x die Wurzel eines Teilbaums mit n Knoten ist, dann ist InorderTreeWalk(x) in Zeit Θ(n). Beweis. Aufstellen der Rekurrenzgleichung: Beim einem leeren (Teil-)Baum gilt T (0) = c. Ferner gilt bei Aufruf auf einen Knoten dessen linker Teilbaum k und dessen rechter Teilbaum n k 1 Knoten hat T (n) = T (k) + T (n k 1) + d. Wir vermuten nun T (n) Θ(n), d.h. wir vermuten T (n) = e n für eine Konstante e. Frank Heitmann heitmann@informatik.uni-hamburg.de 27/122
33 Grundlagen InorderTreeWalk - Laufzeitanalyse (1/4) Satz Wenn x die Wurzel eines Teilbaums mit n Knoten ist, dann ist InorderTreeWalk(x) in Zeit Θ(n). Beweis. Aufstellen der Rekurrenzgleichung: Beim einem leeren (Teil-)Baum gilt T (0) = c. Ferner gilt bei Aufruf auf einen Knoten dessen linker Teilbaum k und dessen rechter Teilbaum n k 1 Knoten hat T (n) = T (k) + T (n k 1) + d. Wir vermuten nun T (n) Θ(n), d.h. wir vermuten T (n) = e n für eine Konstante e. Frank Heitmann heitmann@informatik.uni-hamburg.de 27/122
34 Grundlagen InorderTreeWalk - Laufzeitanalyse (1/4) Satz Wenn x die Wurzel eines Teilbaums mit n Knoten ist, dann ist InorderTreeWalk(x) in Zeit Θ(n). Beweis. Aufstellen der Rekurrenzgleichung: Beim einem leeren (Teil-)Baum gilt T (0) = c. Ferner gilt bei Aufruf auf einen Knoten dessen linker Teilbaum k und dessen rechter Teilbaum n k 1 Knoten hat T (n) = T (k) + T (n k 1) + d. Wir vermuten nun T (n) Θ(n), d.h. wir vermuten T (n) = e n für eine Konstante e. Frank Heitmann heitmann@informatik.uni-hamburg.de 27/122
35 Grundlagen InorderTreeWalk - Laufzeitanalyse (1/4) Satz Wenn x die Wurzel eines Teilbaums mit n Knoten ist, dann ist InorderTreeWalk(x) in Zeit Θ(n). Beweis. Aufstellen der Rekurrenzgleichung: Beim einem leeren (Teil-)Baum gilt T (0) = c. Ferner gilt bei Aufruf auf einen Knoten dessen linker Teilbaum k und dessen rechter Teilbaum n k 1 Knoten hat T (n) = T (k) + T (n k 1) + d. Wir vermuten nun T (n) Θ(n), d.h. wir vermuten T (n) = e n für eine Konstante e. Frank Heitmann heitmann@informatik.uni-hamburg.de 27/122
36 Grundlagen InorderTreeWalk - Laufzeitanalyse (2/4) Beweis. Behauptung: T (n) = e n. Wollen wir dies mit Induktion beweisen, so merken wir gleich beim Induktionsanfang T (0) = e 0 = 0 c. Wir müssen unsere Vermutung also verbessern! Neue Vermutung: T (n) = e n + c. Damit ist immer noch T (n) Θ(n), aber der Induktionsanfang klappt jetzt! Frank Heitmann heitmann@informatik.uni-hamburg.de 28/122
37 Grundlagen InorderTreeWalk - Laufzeitanalyse (2/4) Beweis. Behauptung: T (n) = e n. Wollen wir dies mit Induktion beweisen, so merken wir gleich beim Induktionsanfang T (0) = e 0 = 0 c. Wir müssen unsere Vermutung also verbessern! Neue Vermutung: T (n) = e n + c. Damit ist immer noch T (n) Θ(n), aber der Induktionsanfang klappt jetzt! Frank Heitmann heitmann@informatik.uni-hamburg.de 28/122
38 Grundlagen InorderTreeWalk - Laufzeitanalyse (2/4) Beweis. Behauptung: T (n) = e n. Wollen wir dies mit Induktion beweisen, so merken wir gleich beim Induktionsanfang T (0) = e 0 = 0 c. Wir müssen unsere Vermutung also verbessern! Neue Vermutung: T (n) = e n + c. Damit ist immer noch T (n) Θ(n), aber der Induktionsanfang klappt jetzt! Frank Heitmann heitmann@informatik.uni-hamburg.de 28/122
39 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
40 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
41 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
42 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
43 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
44 Grundlagen InorderTreeWalk - Laufzeitanalyse (3/4) Beweis. Behauptung: T (n) = e n + c. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = (e k + c) + (e (n k 1) + c) + d = e n e + 2c + d Setzen wir e = c + d (denn wir wollen ja T (n) = e n + c erreichen (nicht T (n + 1) =..., da wir den Induktionsschritt ja auf n machen)) und verfeinern auf diese Weise also unsere Behauptung erneut (!), so wird gleich alles klappen! Frank Heitmann heitmann@informatik.uni-hamburg.de 29/122
45 Grundlagen InorderTreeWalk - Laufzeitanalyse Anmerkung Nimmt man als Behauptung gleich T (n) = (c+d)n+c, so klappt alles sofort, aber die Gleichung fällt dann vom Himmel. Oben kommt man auf e = c + d, weil man ja möchte, dass sich T (n) = e n + c ergibt. Frank Heitmann heitmann@informatik.uni-hamburg.de 30/122
46 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
47 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
48 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
49 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
50 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
51 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
52 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
53 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
54 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
55 Grundlagen InorderTreeWalk - Laufzeitanalyse (4/4) Beweis. Gegeben (aus dem Code): T (n) mit T (0) = c und T (n) = T (k) + T (n k 1) + d. Behauptung: T (n) = (c + d) n + c. Induktionsanfang: T (0) = c. Induktionsannahme: Behauptung gelte schon für Werte kleiner n. Induktionsschritt (n 1 n): T (n) = T (k) + T (n k 1) + d = ((c + d) k + c) + ((c + d) (n k 1) + c) + d = (c + d) n (c + d) + 2c + d = (c + d) n + c Also gilt T (n) Θ(n). Frank Heitmann heitmann@informatik.uni-hamburg.de 31/122
56 Grundlagen TreeSearch - Die Idee am Beispiel TreeSearch 7? 15? 11? Frank Heitmann heitmann@informatik.uni-hamburg.de 32/122
57 TreeSearch - Die Idee Grundlagen Beginne mit der Wurzel. Ist diese kleiner als der Schlüssel, so suche im rechten Teilbaum, ist sie grösser, suche im linken. Fahre wie oben mit der Wurzel diese Teilbaumes fort. Breche ab, wenn Schlüssel gefunden oder, wenn nil- Knoten erreicht wird. Frank Heitmann heitmann@informatik.uni-hamburg.de 33/122
58 Grundlagen TreeSearch - Pseudocode Algorithmus 6 TreeSearch(x, k) 1: if x == nil or k == schlüssel[x] then 2: return x 3: else if k < schlüssel[x] then 4: return TreeSearch(links[x], k) 5: else 6: return TreeSearch(rechts[x], k) 7: end if Analyse Die Knoten, die während der Rekursion besucht werden, bilden einen Pfad von der Wurzel bis maximal zu einem Blatt. Die Korrektheit folgt aus den Eigenschaften binärer Suchbäume. Die Laufzeit ist in O(h), wobei h die Höhe des Baumes ist. Frank Heitmann heitmann@informatik.uni-hamburg.de 34/122
59 Grundlagen TreeSearch - Pseudocode Algorithmus 7 TreeSearch(x, k) 1: if x == nil or k == schlüssel[x] then 2: return x 3: else if k < schlüssel[x] then 4: return TreeSearch(links[x], k) 5: else 6: return TreeSearch(rechts[x], k) 7: end if Analyse Die Knoten, die während der Rekursion besucht werden, bilden einen Pfad von der Wurzel bis maximal zu einem Blatt. Die Korrektheit folgt aus den Eigenschaften binärer Suchbäume. Die Laufzeit ist in O(h), wobei h die Höhe des Baumes ist. Frank Heitmann heitmann@informatik.uni-hamburg.de 34/122
60 Grundlagen TreeSearch - Pseudocode (iterativ) Algorithmus 8 IterativeTreeSearch(x, k) 1: while x nil and k schlüssel[x] do 2: if k < schlüssel[x] then 3: x = links[x] 4: else 5: x = rechts[x] 6: end if 7: end while 8: return x Frank Heitmann heitmann@informatik.uni-hamburg.de 35/122
61 Grundlagen TreeSearch, Minimum und Maximum am Beispiel TreeSearch 5? Minimum? Maximum? Frank Heitmann heitmann@informatik.uni-hamburg.de 36/122
62 Grundlagen Minimum und Maximum Algorithmus 9 TreeMinimum(x) 1: while links[x] nil do 2: x = links[x] 3: end while 4: return x Algorithmus 10 TreeMaximum(x) 1: while rechts[x] nil do 2: x = rechts[x] 3: end while 4: return x Analyse (Korrektheit und Laufzeit) wie bei TreeSearch. Frank Heitmann heitmann@informatik.uni-hamburg.de 37/122
63 Grundlagen Minimum und Maximum Algorithmus 11 TreeMinimum(x) 1: while links[x] nil do 2: x = links[x] 3: end while 4: return x Algorithmus 12 TreeMaximum(x) 1: while rechts[x] nil do 2: x = rechts[x] 3: end while 4: return x Analyse (Korrektheit und Laufzeit) wie bei TreeSearch. Frank Heitmann heitmann@informatik.uni-hamburg.de 37/122
64 Grundlagen Vorgänger und Nachfolger Wir wollen den Nachfolger eines Knotens in der sortierten Reihenfolge ausgeben. (Den Vorgänger ermittelt man analog.) Wir können dies machen ohne jemals Schlüssel zu vergleichen! Frank Heitmann heitmann@informatik.uni-hamburg.de 38/122
65 Nachfolger - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 39/122
66 Nachfolger - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 40/122
67 Nachfolger - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 41/122
68 Nachfolger - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 42/122
69 Nachfolger - Die Idee Grundlagen Der Nachfolger eines Knotens x ist der Knoten mit dem kleinsten Schlüssel, der größer ist als schlüssel[x]. Größer als schlüssel[x] heisst im rechten Teilbaum von x und dort am kleinsten heisst das Minimum ( ganz links ). Problem: x muss gar keinen rechten Teilbaum haben! Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. (Geht das auch nicht, dann ist x das größte Element und hat keinen Nachfolger.) Frank Heitmann heitmann@informatik.uni-hamburg.de 43/122
70 Nachfolger - Die Idee Grundlagen Der Nachfolger eines Knotens x ist der Knoten mit dem kleinsten Schlüssel, der größer ist als schlüssel[x]. Größer als schlüssel[x] heisst im rechten Teilbaum von x und dort am kleinsten heisst das Minimum ( ganz links ). Problem: x muss gar keinen rechten Teilbaum haben! Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. (Geht das auch nicht, dann ist x das größte Element und hat keinen Nachfolger.) Frank Heitmann heitmann@informatik.uni-hamburg.de 43/122
71 Nachfolger - Die Idee Grundlagen Der Nachfolger eines Knotens x ist der Knoten mit dem kleinsten Schlüssel, der größer ist als schlüssel[x]. Größer als schlüssel[x] heisst im rechten Teilbaum von x und dort am kleinsten heisst das Minimum ( ganz links ). Problem: x muss gar keinen rechten Teilbaum haben! Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. (Geht das auch nicht, dann ist x das größte Element und hat keinen Nachfolger.) Frank Heitmann heitmann@informatik.uni-hamburg.de 43/122
72 Nachfolger - Die Idee Grundlagen Der Nachfolger eines Knotens x ist der Knoten mit dem kleinsten Schlüssel, der größer ist als schlüssel[x]. Größer als schlüssel[x] heisst im rechten Teilbaum von x und dort am kleinsten heisst das Minimum ( ganz links ). Problem: x muss gar keinen rechten Teilbaum haben! Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. (Geht das auch nicht, dann ist x das größte Element und hat keinen Nachfolger.) Frank Heitmann heitmann@informatik.uni-hamburg.de 43/122
73 Nachfolger - Die Idee Grundlagen Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. Das heißt wir gehen von x aus nach oben und der erste Knoten y auf den wir treffen von dem aus gesehen x in seinem linken Teilbaum ist, ist der gesuchte. Dann gilt nämlich gerade schlüssel[x] < schlüssel[y] (wegen linken oben) und es gibt auch keinen Schlüssel dazwischen (wegen erste oben). (Obiges kann in einen Beweis um-/ausformuliert werden.) Bemerkung Umgangssprachlich: Wir gehen im Baum immer weiter nach oben, wenn wir das erste Mal nach rechts gehen, haben wir den gesuchten Knoten. Frank Heitmann heitmann@informatik.uni-hamburg.de 44/122
74 Nachfolger - Die Idee Grundlagen Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist Frank Heitmann heitmann@informatik.uni-hamburg.de 45/122
75 Nachfolger - Die Idee Grundlagen Dann ist der Nachfolger y der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist Frank Heitmann heitmann@informatik.uni-hamburg.de 46/122
76 Grundlagen Nachfolger - Pseudocode Algorithmus 13 TreeSucessor(x) 1: if rechts[x] nil then 2: return TreeMinimum(rechts[x]) 3: end if 4: y = p[x] 5: while y nil and x == rechts[y] do 6: x = y 7: y = p[y] 8: end while 9: return y Analyse Korrektheit folgt aus obigen Überlegungen. Laufzeit ist wieder in O(h). Die Routine TreePredecessor implementiert man analog. Frank Heitmann heitmann@informatik.uni-hamburg.de 47/122
77 Einfügen - Die Idee Grundlagen Wir manipulieren nun die (dynamische!) Datenstruktur, indem wir ein Element hinzufügen. Dabei soll die Suchbaum-Eigenschaft erhalten bleiben. Im Prinzip suchen wir (ähnlich der Suche) den richtigen Platz und fügen das neue Element einfach als Blatt an... Frank Heitmann heitmann@informatik.uni-hamburg.de 48/122
78 Einfügen - Die Idee Grundlagen Wir manipulieren nun die (dynamische!) Datenstruktur, indem wir ein Element hinzufügen. Dabei soll die Suchbaum-Eigenschaft erhalten bleiben. Im Prinzip suchen wir (ähnlich der Suche) den richtigen Platz und fügen das neue Element einfach als Blatt an... Frank Heitmann heitmann@informatik.uni-hamburg.de 48/122
79 Einfügen - Beispiel Grundlagen Insert 11? Insert 4? Frank Heitmann heitmann@informatik.uni-hamburg.de 49/122
80 Einfügen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 50/122
81 Einfügen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 51/122
82 Einfügen - Die Idee Grundlagen Im Code halten wir nun einen Zeiger auf x (hier soll das neue Element hin) und einen Zeiger y auf p[x]. An y wird dann das neue Element angehängt... Frank Heitmann heitmann@informatik.uni-hamburg.de 52/122
83 Grundlagen Einfügen - Pseudocode Teil 1 Algorithmus 14 TreeInsert(T, z) - Teil 1 1: y = nil 2: x = wurzel[t ] 3: while x nil do 4: y = x 5: if schlüssel[z] < schlüssel[x] then 6: x = links[x] 7: else 8: x = rechts[x] 9: end if 10: end while Erklärung x zeigt jetzt auf nil. y auf den zuletzt besuchten Knoten an den jetzt der neue Knoten z angefügt werden soll. Oft ist y ein Blatt. Frank Heitmann heitmann@informatik.uni-hamburg.de 53/122
84 Grundlagen Einfügen - Pseudocode Teil 2 Algorithmus 15 TreeInsert(T, z) - Teil 2 1: p[z] = y 2: if y == nil then 3: wurzel[t ] = z 4: else 5: if schlüssel[z] < schlüssel[y] then 6: links[y] = z 7: else 8: rechts[y] = z 9: end if 10: end if Erklärung Der Vater von z ist y und z ist linkes oder rechtes Kind von y (je nach Schlüssel). links[z] und rechts[z] sind ferner nil. Frank Heitmann heitmann@informatik.uni-hamburg.de 54/122
85 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
86 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
87 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
88 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
89 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
90 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
91 Löschen - Die Idee Grundlagen Das Löschen eines Knotens z ist komplizierter. Es gibt drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. (Man vergleiche dies mit der Lösch-Operation bei verketteten Listen!) 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 55/122
92 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 56/122
93 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 57/122
94 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 58/122
95 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 59/122
96 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 60/122
97 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 61/122
98 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 62/122
99 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 63/122
100 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 64/122
101 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 65/122
102 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 66/122
103 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 67/122
104 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 68/122
105 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 69/122
106 Löschen - Beispiel Grundlagen Frank Heitmann heitmann@informatik.uni-hamburg.de 70/122
107 Löschen - Pseudocode Grundlagen Auf den Sourcecode verzichten wir hier. Ähnlich wie beim Einfügen müssen die Zeigern umgebogen werden. Weitere Details findet man im [Cormen] in Kapitel Frank Heitmann heitmann@informatik.uni-hamburg.de 71/122
108 Grundlagen - Zusammenfassung (1/4) Zusammenfassung der InorderTreeWalk Rekursiv erst die Elemente des linken Teilbaumes ausgeben, dann das Element selbst, dann die Elemente des rechten Teilbaumes. Gibt bei einem binären Suchbaum die Elemente in sortierter Reihenfolge aus. TreeSearch Suche im linken Teilbaum weiter, wenn zu suchendes Element kleiner ist als das Wurzelelement, sonst im rechten Teilbaum. Frank Heitmann heitmann@informatik.uni-hamburg.de 72/122
109 Grundlagen - Zusammenfassung (2/4) Zusammenfassung der Minimum Element ganz links. Maximum Element ganz rechts. Nachfolger (von x) der Knoten mit dem kleinsten Schlüssel, der größer ist als schlüssel[x]. Minimum im rechten Teilbaum oder der jüngste Vorfahre von x, dessen linkes Kind ebenfalls ein Vorfahre von x ist. Vorgänger (von x) analog... Frank Heitmann heitmann@informatik.uni-hamburg.de 73/122
110 Grundlagen - Zusammenfassung (3/4) Zusammenfassung der Einfügen Ähnnlich wie beim Suchen die geeignete Position suchen und das neue Element als neues Blatt anfügen. Löschen Drei Fälle: 1 z hat keine Kinder. Dann kann er einfach gelöscht werden. (p[z] zeigt auf nil statt auf z). 2 z hat genau ein Kind. Dann werden p[z] und left[z] bzw. right[z] verbunden und damit z ausgeschnitten. 3 z hat zwei Kinder. Dann wird z s Nachfolger y genommen (hat kein linkes Kind!), ausgeschnitten (siehe 2. oben) und mit seinen Daten die Daten von z ersetzt. Frank Heitmann heitmann@informatik.uni-hamburg.de 74/122
111 Grundlagen - Zusammenfassung (4/4) Zusammenfassung der Die InorderTreeWalk, TreeSearch, Minimum, Maximum, Successor, Insert und Delete sind alle korrekt, was man stets recht einfach über die Eigenschaften binärer Suchbäume zeigen kann (ggf. mit Induktion über die Anzahl der Knoten oder die Tiefe des Baumes). Bei einem binären Suchbaum mit n Knoten der Höhe h, ist die Laufzeit von InorderTreeWalk in O(n), die aller anderen in O(h). Anmerkung Diese Laufzeiten sind zwar gut, da bei einem (ungefähr) ausgeglichenen Baum h log n ist. Das Problem ist aber, dass binäre Suchbäume nicht ausgeglichen sein müssen! Im worst-case sind obige alle in Θ(n)! Frank Heitmann heitmann@informatik.uni-hamburg.de 75/122
112 Grundlagen - Zusammenfassung (4/4) Zusammenfassung der Die InorderTreeWalk, TreeSearch, Minimum, Maximum, Successor, Insert und Delete sind alle korrekt, was man stets recht einfach über die Eigenschaften binärer Suchbäume zeigen kann (ggf. mit Induktion über die Anzahl der Knoten oder die Tiefe des Baumes). Bei einem binären Suchbaum mit n Knoten der Höhe h, ist die Laufzeit von InorderTreeWalk in O(n), die aller anderen in O(h). Anmerkung Diese Laufzeiten sind zwar gut, da bei einem (ungefähr) ausgeglichenen Baum h log n ist. Das Problem ist aber, dass binäre Suchbäume nicht ausgeglichen sein müssen! Im worst-case sind obige alle in Θ(n)! Frank Heitmann heitmann@informatik.uni-hamburg.de 75/122
113 Grundlagen - Zusammenfassung (4/4) Zusammenfassung der Die InorderTreeWalk, TreeSearch, Minimum, Maximum, Successor, Insert und Delete sind alle korrekt, was man stets recht einfach über die Eigenschaften binärer Suchbäume zeigen kann (ggf. mit Induktion über die Anzahl der Knoten oder die Tiefe des Baumes). Bei einem binären Suchbaum mit n Knoten der Höhe h, ist die Laufzeit von InorderTreeWalk in O(n), die aller anderen in O(h). Anmerkung Diese Laufzeiten sind zwar gut, da bei einem (ungefähr) ausgeglichenen Baum h log n ist. Das Problem ist aber, dass binäre Suchbäume nicht ausgeglichen sein müssen! Im worst-case sind obige alle in Θ(n)! Frank Heitmann heitmann@informatik.uni-hamburg.de 75/122
114 Grundlagen - Die Idee sind binäre Suchbäume, bei denen jeder Knoten eine Farbe hat (rot oder schwarz). Durch Einschränkungen (Rot-Schwarz-Eigenschaften) wird sichergestellt, dass der Baum annähernd balanciert ist, so dass die dann auch im worst-case in O(log n) laufen. Das Problem ist es dann die wie insb. Einfügen und Löschen so zu implementieren, dass die Rot-Schwarz-Eigenschaften erhalten bleiben (und sie dann trotzdem in O(log n) sind)! Frank Heitmann heitmann@informatik.uni-hamburg.de 76/122
115 Grundlagen - Die Idee sind binäre Suchbäume, bei denen jeder Knoten eine Farbe hat (rot oder schwarz). Durch Einschränkungen (Rot-Schwarz-Eigenschaften) wird sichergestellt, dass der Baum annähernd balanciert ist, so dass die dann auch im worst-case in O(log n) laufen. Das Problem ist es dann die wie insb. Einfügen und Löschen so zu implementieren, dass die Rot-Schwarz-Eigenschaften erhalten bleiben (und sie dann trotzdem in O(log n) sind)! Frank Heitmann heitmann@informatik.uni-hamburg.de 76/122
116 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
117 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
118 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
119 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
120 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
121 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Frank Heitmann heitmann@informatik.uni-hamburg.de 77/122
122 AVL-Bäume - Die Idee Grundlagen Ein AVL-Baum ist ein binärer Suchbaum, der höhenbalanciert ist, d.h. für jeden Knoten x unterscheiden sich die Höhen des linken und rechten Teilbaumes maximal um 1. Ist also h[links[x]] die Höhe des linken und h[rechts[x]] die Höhe des rechten Teilbaumes, dann gilt bei einem AVL-Baum für jeden Knoten x h[links[x]] h[rechts[x]] { 1, 0, 1} Bei AVL-Bäumen spielt wie auch bei n die Rotation eine wichtige Rolle. Mit ihr wird der Baum nach einer Einfügeoperation stets wieder ausbalanciert. Frank Heitmann heitmann@informatik.uni-hamburg.de 78/122
123 Zusammenfassung Grundlagen Grundlagen des Suchens: Brute-Force-Algorithmus Binäres Suchen (Array muss sortiert sein!) Suchbäume Definition TreeWalk, Suchen, Minimum, Maximum Vorgänger, Nachfolger Einfügen, Entfernen AVL-Bäume Frank Heitmann 79/122
124 Grundlagen Frank Heitmann 80/122
125 Grundlagen Rot-Schwarz-Eigenschaften 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Frank Heitmann heitmann@informatik.uni-hamburg.de 81/122
126 Grundlagen Ein Rot-Schwarz-Baum (noch ohne Färbung) nil 13 nil 16 nil nil nil nil Frank Heitmann heitmann@informatik.uni-hamburg.de 82/122
127 Grundlagen Ein Rot-Schwarz-Baum (noch ohne Färbung) nil [T] Frank Heitmann heitmann@informatik.uni-hamburg.de 83/122
128 Grundlagen Ein Rot-Schwarz-Baum (Wurzel und Blätter gefärbt) nil [T] Frank Heitmann heitmann@informatik.uni-hamburg.de 84/122
129 Grundlagen Ein Rot-Schwarz-Baum (gefärbt) nil [T] Frank Heitmann heitmann@informatik.uni-hamburg.de 85/122
130 Grundlagen Ein Rot-Schwarz-Baum (in schön) Frank Heitmann heitmann@informatik.uni-hamburg.de 86/122
131 Grundlagen Rot-Schwarz-Eigenschaften (Wiederholung) 1 Jeder Knoten ist entweder rot oder schwarz. 2 Die Wurzel ist schwarz. 3 Jedes Blatt ist schwarz. 4 Wenn ein Knoten rot ist, dann sind seine beiden Kinder schwarz. 5 Für jeden Knoten enthalten alle Pfade, die an diesem Knoten starten und in einem Blatt des Teilbaumes dieses Knotens enden, die gleiche Anzahl schwarzer Knoten Anmerkung Die Blätter sind alle nil-knoten (der Wächter nil[t ]) und schwarz. Die Wurzel hat als Vorgänger auch nil[t ] (Siehe die beiden vorherigen Bilder.) Frank Heitmann heitmann@informatik.uni-hamburg.de 87/122
132 Balanciertheit Grundlagen Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Satz Die Search, Minimum, Maximum, Successor, Predecessor für dynamische Mengen lassen sich auf n in Zeit O(log n) implementieren, wobei n die Anzahl der Knoten ist. Frank Heitmann heitmann@informatik.uni-hamburg.de 88/122
133 Balanciertheit Grundlagen Satz Ein Rot-Schwarz-Baum mit n inneren Knoten hat höchstens die Höhe 2 log(n + 1). Satz Die Search, Minimum, Maximum, Successor, Predecessor für dynamische Mengen lassen sich auf n in Zeit O(log n) implementieren, wobei n die Anzahl der Knoten ist. Frank Heitmann heitmann@informatik.uni-hamburg.de 88/122
134 Rotationen Grundlagen Auch die TreeInsert und TreeDelete sind in Zeit O(log n), aber da sie den Baum modifizieren, kann es passieren, dass die Rot-Schwarz-Eigenschaften danach nicht mehr erfüllt sind. Um die Eigenschaften wiederherzustellen, müssen ggf. Farben und die Zeigerstruktur geändert werden. Ein wichtiges Hilfsmittel hierbei (zur Änderung der Zeigerstruktur) ist die Rotation... Frank Heitmann 89/122
135 Rotationen Grundlagen Auch die TreeInsert und TreeDelete sind in Zeit O(log n), aber da sie den Baum modifizieren, kann es passieren, dass die Rot-Schwarz-Eigenschaften danach nicht mehr erfüllt sind. Um die Eigenschaften wiederherzustellen, müssen ggf. Farben und die Zeigerstruktur geändert werden. Ein wichtiges Hilfsmittel hierbei (zur Änderung der Zeigerstruktur) ist die Rotation... Frank Heitmann 89/122
136 Rotationen Grundlagen Auch die TreeInsert und TreeDelete sind in Zeit O(log n), aber da sie den Baum modifizieren, kann es passieren, dass die Rot-Schwarz-Eigenschaften danach nicht mehr erfüllt sind. Um die Eigenschaften wiederherzustellen, müssen ggf. Farben und die Zeigerstruktur geändert werden. Ein wichtiges Hilfsmittel hierbei (zur Änderung der Zeigerstruktur) ist die Rotation... Frank Heitmann 89/122
137 Rotation - Bildlich Grundlagen x LeftRotate(x) y A y RightRotate(x) x C B C A B Frank Heitmann heitmann@informatik.uni-hamburg.de 90/122
138 Linksrotation Grundlagen x LeftRotate(x) y A y x C B C A B Das rechte Kind (y) von x ist nicht nil. y wird neue Wurzel des Teilbaumes. x wird das linke Kind von y. Das linke Kind von y wird rechtes Kinds von x. Frank Heitmann heitmann@informatik.uni-hamburg.de 91/122
139 Grundlagen Linksrotation - zum Merken x LeftRotate(x) y A y x C B C A B Ziehe an A-x-y-C wie an einer Schnur. A und x rutschen nach unten, y und C nach oben B bleibt übrig. Einziger sinnvoller Platz: rechts von x. Erhälte die binäre Suchbaum-Eigenschaft! Frank Heitmann heitmann@informatik.uni-hamburg.de 92/122
Algorithmen und Datenstrukturen Kapitel 7 Dynamische Mengen, das Suchproblem &
Algorithmen und Datenstrukturen Kapitel 7 Dynamische Mengen, das Suchproblem & Frank Heitmann heitmann@informatik.uni-hamburg.de 25. November 2015 Frank Heitmann heitmann@informatik.uni-hamburg.de 1/122
Dynamische Mengen. Algorithmen und Datenstrukturen Kapitel 7 Dynamische Mengen, das Suchproblem & Das Suchproblem.
lgorithmen und atenstrukturen Kapitel 7 namische Mengen, das Suchproblem & namische Mengen rundlegende lgorithmen efinition isher hatten wir oft statische Mengen, bei denen sich die nahl der Elemente nicht
Datenstruktur, die viele Operationen dynamischer Mengen unterstützt
Algorithmen und Datenstrukturen 265 10 Binäre Suchbäume Suchbäume Datenstruktur, die viele Operationen dynamischer Mengen unterstützt Kann als Wörterbuch, aber auch zu mehr eingesetzt werden (Prioritätsschlange)
13. Binäre Suchbäume
1. Binäre Suchbäume Binäre Suchbäume realiesieren Wörterbücher. Sie unterstützen die Operationen 1. Einfügen (Insert) 2. Entfernen (Delete). Suchen (Search) 4. Maximum/Minimum-Suche 5. Vorgänger (Predecessor),
Kapitel 9 Suchalgorithmen
Kapitel 9 Suchalgorithmen Suchverfahren: Verfahren, das in einem Suchraum nach Mustern oder Objekten mit bestimmten Eigenschaften sucht. Vielfältige Anwendungsbereiche für Suchverfahren: u.a. Suchen in
Kapitel 9 Suchalgorithmen
Kapitel 9 Suchalgorithmen Technische Universität München Suchverfahren: Verfahren, das in einem Suchraum nach Mustern oder Objekten mit bestimmten Eigenschaften sucht. Vielfältige Anwendungsbereiche für
Algorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 2016/17 13. Vorlesung Binäre Suchbäume Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Dynamische Menge verwaltet Elemente einer sich ändernden Menge
14. Rot-Schwarz-Bäume
Bislang: Wörterbuchoperationen bei binären Suchbäume effizient durchführbar, falls Höhe des Baums klein. Rot-Schwarz-Bäume spezielle Suchbäume. Rot-Schwarz-Baum mit n Knoten hat Höhe höchstens 2 log(n+1).
Christian Rieck, Arne Schmidt
Institute of Operating Systems and Computer Networks Algorithms Group Algorithmen und Datenstrukturen Wintersemester 207/208 Übung#5, 2.2.207 Christian Rieck, Arne Schmidt Bäume Satz Jeder gerichtete Baum
Dynamische Mengen. Realisierungen durch Bäume
Dynamische Mengen Eine dynamische Menge ist eine Datenstruktur, die eine Menge von Objekten verwaltet. Jedes Objekt x trägt einen eindeutigen Schlüssel key[x]. Die Datenstruktur soll mindestens die folgenden
Das Suchproblem 4. Suchen Das Auswahlproblem Suche in Array
Das Suchproblem Gegeben. Suchen Lineare Suche, Binäre Suche, Interpolationssuche, Untere Schranken [Ottman/Widmayer, Kap. 3.2, Cormen et al, Kap. 2: Problems 2.-3,2.2-3,2.3-] Menge von Datensätzen. Beispiele
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
Das Suchproblem 4. Suchen Das Auswahlproblem Suche in Array
Das Suchproblem Gegeben. Suchen Lineare Suche, Binäre Suche, Interpolationssuche, Exponentielle Suche, Untere Schranken [Ottman/Widmayer, Kap. 3.2, Cormen et al, Kap. 2: Problems 2.-3,2.2-3,2.3-] Menge
Programm heute. Algorithmen und Datenstrukturen (für ET/IT) Suchen. Lineare Suche. Such-Algorithmen. Sommersemester Dr.
Programm heute Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 0 Dr. Tobias Lasser Computer Aided Medical Procedures Technische Universität München Fortgeschrittene Datenstrukturen Such-Algorithmen
Das Suchproblem. Gegeben Menge von Datensätzen. Beispiele Telefonverzeichnis, Wörterbuch, Symboltabelle
122 4. Suchen Lineare Suche, Binäre Suche, Interpolationssuche, Untere Schranken [Ottman/Widmayer, Kap. 3.2, Cormen et al, Kap. 2: Problems 2.1-3,2.2-3,2.3-5] 123 Das Suchproblem Gegeben Menge von Datensätzen.
9. Natürliche Suchbäume
Bäume Bäume sind. Natürliche Suchbäume [Ottman/Widmayer, Kap..1, Cormen et al, Kap. 12.1-12.] Verallgemeinerte Listen: Knoten können mehrere Nachfolger haben Spezielle Graphen: Graphen bestehen aus Knoten
1 Raumwechsel: Gr. 15 (Do 10-12, F-235) ab sofort in G Studie zum Arbeitsverhalten von Studierenden unter Leitung
Organisatorisches Algorithmen und Datenstrukturen Kapitel 3: Divide & Conquer Frank Heitmann heitmann@informatik.uni-hamburg.de 1 Raumwechsel: Gr. 15 (Do 10-12, F-235) ab sofort in G-021. 2 Studie zum
ContainerDatenstrukturen. Große Übung 4
ContainerDatenstrukturen Große Übung 4 Aufgabenstellung Verwalte Kollektion S von n Objekten Grundaufgaben: Iterieren/Auflistung Suche nach Objekt x mit Wert/Schlüssel k Füge ein Objekt x hinzu Entferne
Definition 14 Rot-Schwarz-Bäume sind externe Binärbäume (jeder Knoten hat 0 oder 2 Kinder) mit roten und schwarzen Kanten, so dass gilt:
2.1.2 Rot-Schwarz-Bäume Definition 14 Rot-Schwarz-Bäume sind externe Binärbäume (jeder Knoten hat 0 oder 2 Kinder) mit roten und schwarzen Kanten, so dass gilt: 1 alle Blätter hängen an schwarzen Kanten
Datenstrukturen & Algorithmen Lösungen zu Blatt 6 FS 14
Eidgenössische Technische Hochschule Zürich Ecole polytechnique fédérale de Zurich Politecnico federale di Zurigo Federal Institute of Technology at Zurich Institut für Theoretische Informatik 2. April
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
Algorithmen und Datenstrukturen Suchbaum
Algorithmen und Datenstrukturen Suchbaum Matthias Teschner Graphische Datenverarbeitung Institut für Informatik Universität Freiburg SS 12 Motivation Datenstruktur zur Repräsentation dynamischer Mengen
Übersicht. Rot-schwarz Bäume. Rot-schwarz Bäume. Beispiel. Eigenschaften. Datenstrukturen & Algorithmen. Rot-schwarz Bäume Eigenschaften Einfügen
Datenstrukturen & Algorithmen Übersicht Rot-schwarz Bäume Eigenschaften Einfügen Matthias Zwicker Universität Bern Frühling 2009 2 Rot-schwarz Bäume Binäre Suchbäume sind nur effizient wenn Höhe des Baumes
3. Binäre Suchbäume. 3.1 Natürliche binäre Suchbäume. EADS 3.1 Natürliche binäre Suchbäume 78/598 ľernst W. Mayr
3. Binäre Suchbäume 3.1 Natürliche binäre Suchbäume Definition 18 Ein natürlicher binärer Suchbaum über einem durch total geordneten Universum U ist ein als interner Suchbaum organisierter Binärbaum (also:
Informatik II Bäume zum effizienten Information Retrieval
lausthal Informatik II Bäume zum effizienten Information Retrieval. Zachmann lausthal University, ermany zach@in.tu-clausthal.de Binäre Suchbäume (binary search tree, BST) Speichere wieder Daten als "Schlüssel
Anwendungsbeispiel MinHeap
Anwendungsbeispiel MinHeap Uns seien n ganze Zahlen gegeben und wir möchten darin die k größten Zahlen bestimmen; zudem gelten, dass n deutlich größer als k ist Wir können das Problem mit Laufzeit in O(n
Kapitel 4: Dynamische Datenstrukturen. Algorithmen und Datenstrukturen WS 2012/13. Prof. Dr. Sándor Fekete
Kapitel 4: Dynamische Datenstrukturen Algorithmen und Datenstrukturen WS 2012/13 Prof. Dr. Sándor Fekete 4.4 Binäre Suche Aufgabenstellung: Rate eine Zahl zwischen 100 und 114! Algorithmus 4.1 INPUT: OUTPUT:
Beispiellösungen zu den Übungen Datenstrukturen und Algorithmen SS 2008 Blatt 6
Robert Elsässer u.v.a. Paderborn, 29. Mai 2008 Beispiellösungen zu den Übungen Datenstrukturen und Algorithmen SS 2008 Blatt 6 Aufgabe 1 (6 Punkte): Zunächst sollte klar sein, daß ein vollständiger Binärer
Datenstrukturen & Algorithmen
Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010 Übersicht Binäre Suchbäume Einführung und Begriffe Binäre Suchbäume 2 Binäre Suchbäume Datenstruktur für dynamische Mengen
Informatik II, SS 2016
Informatik II - SS 2016 (Algorithmen & Datenstrukturen) Vorlesung 11 (1.6.2016) Binäre Suchbäume III Algorithmen und Komplexität Tiefe eines binären Suchbaums Worst-Case Laufzeit der Operationen in binären
Vorlesung Informatik 2 Algorithmen und Datenstrukturen
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (21 - Balancierte Bäume, AVL-Bäume) Prof. Dr. Susanne Albers Balancierte Bäume Eine Klasse von binären Suchbäumen ist balanciert, wenn jede der drei
11.1 Grundlagen - Denitionen
11 Binärbäume 11.1 Grundlagen - Denitionen Denition: Ein Baum ist eine Menge, die durch eine sog. Nachfolgerrelation strukturiert ist. In einem Baum gilt: (I) (II) 1 Knoten w ohne VATER(w), das ist die
18. Natürliche Suchbäume
Wörterbuchimplementationen 1. Natürliche Suchbäume [Ottman/Widmayer, Kap..1, Cormen et al, Kap. 12.1-12.] Hashing: Implementierung von Wörterbüchern mit erwartet sehr schnellen Zugriffszeiten. Nachteile
Abgabe: (vor der Vorlesung) Aufgabe 7.1 (P) Binomial Heap
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 7 Prof. Dr. Helmut Seidl, S. Pott,
Informatik II, SS 2016
Informatik II - SS 2016 (Algorithmen & Datenstrukturen) Vorlesung 10 (27.5.2016) Binäre Suchbäume II Algorithmen und Komplexität Zusätzliche Dictionary Operationen Dictionary: Zusätzliche mögliche Operationen:
Einfache binäre Suchbäume können entarten, so dass sich die Tiefen ihrer Blattknoten stark unterscheiden
5.6.2 AVL-Bäume Einfache binäre Suchbäume können entarten, so dass sich die Tiefen ihrer Blattknoten stark unterscheiden AVL-Bäume, benannt nach ihren Erfindern G. M. Adelson- Velskii und E. M. Landis,
Datenstrukturen & Algorithmen Lösungen zu Blatt 4 FS 15
Eidgenössische Technische Hochschule Zürich Ecole polytechnique fédérale de Zurich Politecnico federale di Zurigo Federal Institute of Technology at Zurich Institut für Theoretische Informatik 18. März
14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften
![14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften](/thumbs/86/93979187.jpg "14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften")
Heapsort, Quicksort, Mergesort 14. Sortieren II 14.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 397 398 Heapsort [Max-]Heap 7 Inspiration von Selectsort: Schnelles Einfügen Binärer Baum
Kapitel 4: Dynamische Datenstrukturen. Algorithmen und Datenstrukturen WS 2017/18. Pro f. Dr. Sán do r Fe k e te
Kapitel 4: Dynamische Datenstrukturen Algorithmen und Datenstrukturen WS 2017/18 Pro f. Dr. Sán do r Fe k e te 1 4.1 Grundoperationen Aufgabenstellung: 3 4.1 Grundoperationen Aufgabenstellung: Verwalten
Algorithmen I. Tutorium 1-6. Sitzung. Dennis Felsing
Algorithmen I Tutorium 1-6. Sitzung Dennis Felsing dennis.felsing@student.kit.edu www.stud.uni-karlsruhe.de/~ubcqr/algo 2011-05-23 Überblick 1 Binäre Suchbäume 2 Dennis Felsing Algorithmen I 2/20 Binäre
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
Wiederholung. Datenstrukturen und. Bäume. Wiederholung. Suchen in linearen Feldern VO
Wiederholung Datenstrukturen und Algorithmen VO 708.031 Suchen in linearen Feldern Ohne Vorsortierung: Sequentielle Suche Speicherung nach Zugriffswahrscheinlichkeit Selbstanordnende Felder Mit Vorsortierung:
Kapitel 4: Dynamische Datenstrukturen. Algorithmen und Datenstrukturen WS 2017/18. Pro f. Dr. Sán do r Fe k e te
Kapitel 4: Dynamische Datenstrukturen Algorithmen und Datenstrukturen WS 2017/18 Pro f. Dr. Sán do r Fe k e te 1 Binärer Suchbaum Außerdem wichtig: Struktur der Schlüsselwerte! 2 Ordnungsstruktur Linker
Algorithmen und Datenstrukturen Kapitel 2: Korrektheit von Algorithmen und Laufzeitanalyse rekursiver Algorithmen (mittels Rekurrenzgleichungen)
Algorithmen und Datenstrukturen Kapitel 2: und Laufzeitanalyse rekursiver Algorithmen (mittels ) Frank Heitmann heitmann@informatik.uni-hamburg.de 21. Oktober 2015 Frank Heitmann heitmann@informatik.uni-hamburg.de
Vorlesung Algorithmische Geometrie. Streckenschnitte. Martin Nöllenburg INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK
Vorlesung Algorithmische Geometrie INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK Martin Nöllenburg 22.04.2014 Überlagern von Kartenebenen Beispiel: Gegeben zwei verschiedene Kartenebenen,
Datenstrukturen und Algorithmen SS17 Lösung - Übung 5
Prof. aa Dr. Ir. G. Woeginger T. Hartmann, D. Korzeniewski, B. Tauer Hausaufgabe (Inorder-Traversierung binärer Suchbäume): (3 + 3 Punkte) Es soll bewiesen werden, dass die Inorder-Traversierung alle Schlüssel
Informatik II, SS 2014
Informatik II SS 2014 (Algorithmen & Datenstrukturen) Vorlesung 10 (3.6.2014) Binäre Suchbäume I Algorithmen und Komplexität Zusätzliche Dictionary Operationen Dictionary: Zusätzliche mögliche Operationen:
Informatik II, SS 2018
Informatik II - SS 2018 (Algorithmen & Datenstrukturen) Vorlesung 10 (28.5.2018) 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
Suchbäume. Suchbäume. Einfügen in Binären Suchbäumen. Suchen in Binären Suchbäumen. Prinzip Suchbaum. Algorithmen und Datenstrukturen
Suchbäume Suchbäume Prinzip Suchbaum Der Wert eines Knotens wird als Schlüssel verstanden Knoten kann auch weitere Daten enthalten, die aber hier nicht weiter betrachtet werden Werte der Schlüssel müssen
1. Motivation / Grundlagen 2. Sortierverfahren 3. Elementare Datenstrukturen / Anwendungen 4. Bäume / Graphen 5. Hashing 6. Algorithmische Geometrie
Gliederung 1. Motivation / Grundlagen 2. Sortierverfahren 3. Elementare Datenstrukturen / Anwendungen 4. Bäume / Graphen 5. Hashing 6. Algorithmische Geometrie 4/3, Folie 1 2010 Prof. Steffen Lange - HDa/FbI
Algorithmen und Datenstrukturen Kapitel 2: Korrektheit von Algorithmen und Laufzeitanalyse rekursiver Algorithmen (mittels Rekurrenzgleichungen)
Algorithmen und Datenstrukturen Kapitel 2: und Laufzeitanalyse rekursiver Algorithmen (mittels Rekurrenzgleichungen) Frank Heitmann heitmann@informatik.uni-hamburg.de 21. Oktober 2015 Frank Heitmann heitmann@informatik.uni-hamburg.de
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] Heapsort 211 Inspiration von Selectsort: Schnelles Einfügen Inspiration von Insertionsort:
Datenstrukturen und Algorithmen
Datenstrukturen und Algorithmen VO 708.031 Bäume robert.legenstein@igi.tugraz.at 1 Inhalt der Vorlesung 1. Motivation, Einführung, Grundlagen 2. Algorithmische Grundprinzipien 3. Sortierverfahren 4. Halden
Algorithmen und Datenstrukturen
Universität Innsbruck Institut für Informatik Zweite Prüfung 16. Oktober 2008 Algorithmen und Datenstrukturen Name: Matrikelnr: Die Prüfung besteht aus 8 Aufgaben. Die verfügbaren Punkte für jede Aufgabe
11. Elementare Datenstrukturen
11. Elementare Datenstrukturen Definition 11.1: Eine dynamische Menge ist gegeben durch eine oder mehrer Mengen von Objekten sowie Operationen auf diesen Mengen und den Objekten der Mengen. Dynamische
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
Kapitel Andere dynamische Datenstrukturen
Institute of Operating Systems and Computer Networks Algorithms Group Kapitel 4.8-4.11 Andere dynamische Datenstrukturen Algorithmen und Datenstrukturen Wintersemester 2017/2018 Vorlesung#13, 12.12.2017
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 216 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda Vorstellung des 6. Übungsblatts. Hashing Binäre Suchbäume AVL-Bäume 2 Aufgabe: Hashing mit
Kap. 4.2 Binäre Suchbäume ff Kap. 4.3: AVL-Bäume
Kap. 4.2 Binäre Suchbäume ff Kap. 4.3: AVL-Bäume Professor Dr. Lehrstuhl für Algorithm Engineering, LS11 Fakultät für Informatik, TU Dortmund 12./13. VO DAP2 SS 2009 28.5./2.6.2009 1 Motivation Warum soll
Übung zur Vorlesung Algorithmische Geometrie
Übung zur Vorlesung Algorithmische Geometrie Dipl.-Math. Bastian Rieck Arbeitsgruppe Computergraphik und Visualisierung Interdisziplinäres Zentrum für Wissenschaftliches Rechnen 8. Mai 2012 B. Rieck (CoVis)
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:
AVL-Bäume. (Algorithmen und Datenstrukturen I) Prof. Dr. Oliver Braun. Letzte Änderung: :16. AVL-Bäume 1/38
AVL-Bäume (Algorithmen und Datenstrukturen I) Prof. Dr. Oliver Braun Letzte Änderung: 18.03.2018 18:16 AVL-Bäume 1/38 Balancierte Bäume in einem zufällig erzeugten Binärbaum haben die Algorithmen Suchen,
Kapitel Andere dynamische Datenstrukturen
Institute of Operating Systems and Computer Networks Algorithms Group Kapitel 4.8-4.11 Andere dynamische Datenstrukturen Algorithmen und Datenstrukturen Wintersemester 2018/2019 Vorlesung#15, 18.12.2018
Binäre Suchbäume. Mengen, Funktionalität, Binäre Suchbäume, Heaps, Treaps
Binäre Suchbäume Mengen, Funktionalität, Binäre Suchbäume, Heaps, Treaps Mengen n Ziel: Aufrechterhalten einer Menge (hier: ganzer Zahlen) unter folgenden Operationen: Mengen n Ziel: Aufrechterhalten einer
VL-11: Rot-Schwarz Bäume. (Datenstrukturen und Algorithmen, SS 2017) Janosch Fuchs
VL-11: Rot-Schwarz Bäume (Datenstrukturen und Algorithmen, SS 2017) Janosch Fuchs SS 2017, RWTH DSAL/SS 2017 VL-11: Rot-Schwarz Bäume 1/41 Organisatorisches Vorlesung: Gerhard Woeginger (Zimmer 4024 im
Algorithmen und Datenstrukturen I AVL-Bäume
Algorithmen und Datenstrukturen I AVL-Bäume Prof. Dr. Oliver Braun Letzte Änderung: 01.12.2017 14:42 Algorithmen und Datenstrukturen I, AVL-Bäume 1/38 Balancierte Bäume in einem zufällig erzeugten Binärbaum
5. Vorrangwarteschlangen - Priority Queues
5. Vorrangwarteschlangen - Priority Queues Priority Queues unterstützen die Operationen Insert(), Delete(), ExtractMin(), FindMin(), DecreaseKey(), Merge(). Priority Queues per se sind nicht für IsElement()-Anfragen,
1 AVL-Bäume. 1.1 Aufgabentyp. 1.2 Überblick. 1.3 Grundidee
AVL-Bäume. Aufgabentyp Fügen Sie in einen anfangs leeren AVL Baum die folgenden Schlüssel ein:... Wenden Sie hierbei konsequent den Einfüge /Balancierungsalgorithmus an und dokumentieren Sie die ausgeführten
Übungen zur Vorlesung Datenstrukturen und Algorithmen SS 07 Beispiellösung Blatt 5
Kamil Swierkot Paderborn, den 01.06.2007 Aufgabe 17 Übungen zur Vorlesung Datenstrukturen und Algorithmen SS 07 Beispiellösung Blatt 5 Bei der Optimierungsvariante des SubSetSum Problems wird bei der Eingabe
Ü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
Algorithmen und Datenstrukturen 2. Dynamische Datenstrukturen
Algorithmen und Datenstrukturen 2 Dynamische Datenstrukturen Algorithmen für dynamische Datenstrukturen Zugriff auf Variable und Felder durch einen Ausdruck: Namen durch feste Adressen referenziert Anzahl
Algorithmen und Datenstrukturen Balancierte Suchbäume
Algorithmen und Datenstrukturen Balancierte Suchbäume Matthias Teschner Graphische Datenverarbeitung Institut für Informatik Universität Freiburg SS 12 Überblick Einführung Einfügen und Löschen Einfügen
Algorithmen 1 Tutorium
Algorithmen 1 Tutorium Tutorium 13 Misch Sadler 18. Juli 2011 INHALT: VIELES Übersicht 1 Dynamische Programmierung 2 Wiederholung 3 Klausuraufgaben 4 Ende Misch Sadler Algo 1 Tut 18. Juli 2011 2/21 Übersicht
Rotation. y T 3. Abbildung 3.10: Rotation nach rechts (analog links) Doppelrotation y
Die AVL-Eigenschaft soll bei Einfügungen und Streichungen erhalten bleiben. Dafür gibt es zwei mögliche Operationen: -1-2 Rotation Abbildung 3.1: Rotation nach rechts (analog links) -2 +1 z ±1 T 4 Doppelrotation
Vorlesung Algorithmische Geometrie. Streckenschnitte. Martin Nöllenburg INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK
Vorlesung Algorithmische Geometrie INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK Martin Nöllenburg 24.04.2011 Überlagern von Kartenebenen Beispiel: Gegeben zwei verschiedene Kartenebenen,
Satz 172 Jedes vergleichsbasierte Sortierverfahren benötigt im worst-case mindestens n ld n + O(n) Vergleiche und hat damit Laufzeit Ω(n log n).
2.6 Vergleichsbasierte Sortierverfahren Alle bisher betrachteten Sortierverfahren sind vergleichsbasiert, d.h. sie greifen auf Schlüssel k, k (außer in Zuweisungen) nur in Vergleichsoperationen der Form
Informatik II, SS 2014
Informatik II SS 2014 (Algorithmen & Datenstrukturen) Vorlesung 13 (18.6.2014) Binäre Suchbäume IV (Rot Schwarz Bäume) Algorithmen und Komplexität Rot Schwarz Bäume Ziel: Binäre Suchbäume, welche immer
Algorithmen und Datenstrukturen. Bäume. M. Herpers, Y. Jung, P. Klingebiel
Algorithmen und Datenstrukturen Bäume M. Herpers, Y. Jung, P. Klingebiel 1 Lernziele Baumstrukturen und Ihre Verwendung kennen Grundbegriffe zu Bäumen anwenden können Baumstruktur in C anlegen können Suchbäume
2 i. i=0. und beweisen Sie mittels eines geeigneten Verfahrens die Korrektheit der geschlossenen Form.
für Informatik Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Vollständige Induktion): Finden Sie eine geschlossene Form für die
Algorithmen und Komplexität Lösungsvorschlag zu Übungsblatt 8
ETH Zürich Institut für Theoretische Informatik Prof. Dr. Angelika Steger Florian Meier, Ralph Keusch HS 2017 Algorithmen und Komplexität Lösungsvorschlag zu Übungsblatt 8 Lösungsvorschlag zu Aufgabe 1
Datenstrukturen und Algorithmen D-INFK. Musterlösung 1
Eidgenössische Technische Hochschule Zürich Ecole polytechnique fédérale de Zurich Politecnico federale di Zurigo Federal Institute of Technology at Zurich Institut für Theoretische Informatik Peter Widmayer
Algorithmen und Datenstrukturen II
Algorithmen und Datenstrukturen II und Red-Black-Trees Dr. Georg Sauthoff 1 AG Praktische Informatik July 1, SoSe 2011 1 gsauthof@techfak.uni-bielefeld.de Suchbäume (Indexdatenstrukturen) Zugriff in O(logn)
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
Algorithmen & Komplexität
Algorithmen & Komplexität Angelika Steger Institut für Theoretische Informatik steger@inf.ethz.ch Breitensuche, Tiefensuche Wir besprechen nun zwei grundlegende Verfahren, alle Knoten eines Graphen zu
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.
Frank Heitmann 2/28. 1: return A[1]
![Frank Heitmann 2/28. 1: return A[1]](/thumbs/96/130033624.jpg "Frank Heitmann 2/28. 1: return A[1]")
Algorithmen und Datenstrukturen Kapitel 4 Neue Datenstrukturen, besseres (?) Sortieren (Teil 3) Frank Heitmann heitmann@informatik.uni-hamburg.de Heaps als Warteschlangen Heaps können genutzt werden, um
2.7 Bucket-Sort Bucket-Sort ist ein nicht-vergleichsbasiertes Sortierverfahren. Hier können z.b. n Schlüssel aus
2.7 Bucket-Sort Bucket-Sort ist ein nicht-vergleichsbasiertes Sortierverfahren. Hier können z.b. n Schlüssel aus {0, 1,..., B 1} d in Zeit O(d(n + B)) sortiert werden, indem sie zuerst gemäß dem letzten
ADS 1: Algorithmen und Datenstrukturen
ADS 1: Algorithmen und Datenstrukturen Teil IX Uwe Quasthoff Institut für Informatik Abteilung Automatische Sprachverarbeitung Universität Leipzig 1 Dezember 017 [Letzte Aktualisierung: 04/1/017, 10:56]
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
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Prof. Martin Lercher Institut für Informatik Heinrich-Heine-Universität Düsseldorf Teil 6 Suchbäume Version vom 25. November 2016 1 / 75 Vorlesung 10 22. November 2016 2
Kapitel : Andere dynamische Datenstrukturen. Algorithmen und Datenstrukturen WS 2012/13. Prof. Dr. Sándor Fekete
Kapitel 4.8-4.11: Andere dynamische Datenstrukturen Algorithmen und Datenstrukturen WS 2012/13 Prof. Dr. Sándor Fekete 4.6 AVL-Bäume 4.8 Rot-Schwarz-Bäume Idee: Verwende Farben, um den Baum vertikal zu
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
Kurs 1663 Datenstrukturen" Musterlösungen zur Klausur vom Seite 1. Musterlösungen zur Hauptklausur Kurs 1663 Datenstrukturen 15.
Kurs 1663 Datenstrukturen" Musterlösungen zur Klausur vom 15.08.98 Seite 1 Musterlösungen zur Hauptklausur Kurs 1663 Datenstrukturen 15. August 1998 Kurs 1663 Datenstrukturen" Musterlösungen zur Klausur
Teil 1: Suchen. Ausgeglichene Bäume B-Bäume Digitale Suchbäume. M.O.Franz, Oktober 2007 Algorithmen und Datenstrukturen - Binärbäume 1-1
Teil : Suchen Problemstellung Elementare Suchverfahren Hashverfahren Binäre Suchbäume (Wiederholung aus Prog 2) Bäume: Begriffe, Eigenschaften und Traversierung Binäre Suchbäume Gefädelte Suchbäume Ausgeglichene
Vorlesung Algorithmische Geometrie. Streckenschnitte. Martin Nöllenburg INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK
Vorlesung Algorithmische Geometrie INSTITUT FÜR THEORETISCHE INFORMATIK FAKULTÄT FÜR INFORMATIK Martin Nöllenburg 24.04.2011 Überlagern von Kartenebenen Beispiel: Gegeben zwei verschiedene Kartenebenen,
Vorlesung Datenstrukturen
Vorlesung Datenstrukturen Sortierte Folgen Maike Buchin 30.5., 1.6., 13.6.2017 Sortierte Folgen Häufiges Szenario: in einer Menge von Objekten mit Schlüsseln (aus geordnetem Universum) sollen Elemente
Programm heute. Algorithmen und Datenstrukturen (für ET/IT) Übersicht: Graphen. Definition: Ungerichteter Graph. Definition: Ungerichteter Graph
Programm heute Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 07 Dr. Stefanie Demirci Computer Aided Medical Procedures Technische Universität München 7 Fortgeschrittene Datenstrukturen Graphen
1. Motivation / Grundlagen 2. Sortierverfahren 3. Elementare Datenstrukturen / Anwendungen 4. Bäume / Graphen 5. Hashing 6. Algorithmische Geometrie
Gliederung 1. Motivation / Grundlagen 2. Sortierverfahren 3. Elementare Datenstrukturen / Anwendungen 4. Bäume / Graphen 5. Hashing 6. Algorithmische Geometrie 4/2, Folie 1 2014 Prof. Steffen Lange - HDa/FbI