Pro Informatik 2009: Objektorientierte Programmierung Tag 17. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik

Save this PDF as:
 WORD  PNG  TXT  JPG

Größe: px
Ab Seite anzeigen:

Download "Pro Informatik 2009: Objektorientierte Programmierung Tag 17. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik"

Transkript

1 Tag 17 Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik

2 Agenda Tag 16 Datenstrukturen Abstrakte Datentypen, ADT Folge: Stack, Queue, Liste, ADT Menge: Bäume: Binärbäume, Suchbäume, AVL-Bäume, Prioritätswarteschlangen, Heap, Graphen ADTs in Java Tag 17 Sortieralgorithmen InsertionSort, BubbleSort, SelectionSort, ShellSort, MergeSort, QuickSort, Binary Tree Sort, HeapSort Untere Schranke für vergleichsbasierte Sortierverfahren, BucketSort, CountingSort, RadixSort Tag 18 Suchalgorithmen Binärsuche, Breitensuche, Tiefensuche, Backtracking Klausurvorbereitung Tag 19 Klausur Tag 20 Letzter Tag Weitere Projekte am Fachbereich, Klausurnachbesprechung, Grillen? 3

3 Sortieralgorithmen Suchen und Sortieren sind zwei Grunddisziplinen der Informatik. Ein Sortierverfahren ist ein Algorithmus, der dazu dient, eine Folge von Elementen in eine sortierte Folge zu bringen. Voraussetzung ist, dass auf der Menge der Elemente eine strenge schwache Ordnung definiert ist, z.b. die lexikographische Ordnung von Zeichenketten oder die numerische Ordnung von Zahlen. Es gibt eine Reihe von Sortierverfahren, die jedoch unterschiedlich effizient sind. Man unterscheidet zwischen stabilen und instabilen Sortierverfahren. Stabile Sortierverfahren sind solche, die die relative Reihenfolge von Elementen, die bezüglich der Ordnung äquivalent sind, nicht verändern. Instabile Verfahren garantieren dies nicht. Zudem unterscheidet man zwischen Sortierverfahren, die in-place (bzw. in-situ) arbeiten, d.h. die ohne oder nur mit einer konstanten kleinen Menge an zusätzlichen Speicherplatz arbeiten, und solchen, die dies nicht tun. Unter bestimmten Rahmenbedingungen arbeiten manche Verfahren äußerst effizient, z.b. bei kleineren Datenmengen oder bei größtenteils bereits vorsortierten Daten. 4

4 InsertionSort InsertionSort (Sortieren durch Einfügen) ist ein sehr einfaches Sortierverfahren. Es hat eine langsamere Laufzeit als die anderen bekannteren Sortierverfahren, dennoch bietet es einige Vorteile: sehr einfach zu verstehen und zu implementieren sehr schnell bei kleinen Datenmengen sehr schnell bei genügend vorsortierten Daten stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online (kann Folge sortieren, während es sie erhält) 5

5 InsertionSort Idee Die zu sortierende Folge a 0,...,a n-1 wird am Anfang und nach jedem Iterationsschritt in zwei Folgen aufgeteilt: Der erste Teil a 0,...,a i-1 ist bereits (aufsteigend) sortiert, der zweite Teil a i,...,a n-1 bleibt noch unsortiert. Am Anfang bildet die leere Menge vorne den ersten Teil und die gesamte unsortierte Folge den zweiten Teil. Das Element a i wird nun als nächstes an die richtige Stelle in den bereits sortierten Teil eingefügt. Damit ist der sortierte Teil um ein Element größer geworden, sodass im nächsten Iterationsschritt dieses Verfahren wiederholt wird, bis zum Schluss alle Elemente im sortierten Teil sich befinden und die Folge sortiert ist. Applet: 6

6 InsertionSort Implementierung in Java: public class InsertionSort { public static void insertionsort (int[] a) { //Durchlaufe die Liste linear, vorderer Teil ist sortiert //Füge Element an richtige Stelle im sortierten Teil ein for (int i=0; i < a.length; i++) { insert (a, i); private static void insert (int[] a, int i) { int k = a[i]; //k ist das einzufügende Element int j = i; //Verschiebe alle Elemente > k eins nach rechts while (j!= 0 && a[j-1] > k) { a[j] = a[j-1]; j--; //Füge k an richtige Stelle ein a[j] = k; 7

7 InsertionSort Analyse Bei der Analyse von Sortieralgorithmen wird in der Regel die Anzahl der Vergleiche gezählt in Bezug auf die Eingabegröße n (= Anzahl der Elemente, die sortiert werden müssen). Die Anzahl der Vergleiche des Verfahren ist abhängig von der Anordnung der Elemente in der unsortierten Folge. Zusätzlich sind Verschiebungen nötig, falls auf einem Array gearbeitet wird, wo die Elemente nach dem neu eingefügten Element verschoben werden. Die Verschiebungen sind vergleichsweise teuer. Alle größeren Elemente müssen eins nach rechts rücken, um die Einfügeposition frei zu machen. Daher ist für das Einfügen lineare Zeit erforderlich. Im Best Case ist die Folge bereits sortiert, die Laufzeit beträgt dann O(n), da jedes einzufügende Element nur ein Vergleich mit dem Element links davon benötigt. Im Average und Worst Case beträgt die Komplexität O(n 2 ). Der Worst Case trifft ein, wenn das einzufügende Element stets an allererster Stelle eingefügt werden muss (z.b. bei einer invers sortierten Folge) und berechnet sich mit 8

8 BubbleSort BubbleSort (to bubble aufsteigende Blasen) ist ein ebenfallse ein einfacher Sortieralgorithmus. Den Namen verdankt er der Weise wie die Elemente nach und nach wie Blasen im Wasser nach hinten (bzw. vorne) wandern. BubbleSort ist sehr simpel zu verstehen, ist aber auch meist sehr ineffizient (besonders bei großen Datenmengen). sehr einfach zu verstehen und zu implementieren stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 9

9 BubbleSort Idee Der Algorithmus durchläuft die zu sortierende Folge und vertauscht benachbarte Paare, die in der falschen Reihenfolge vorliegen. Dies garantiert das die großen Elemente nach und nach ans Ende der Folge wandern. Dieser Durchlauf wird solange wiederholt bis keine Vertauschungen mehr nötig sind und die Folge damit sortiert ist. Um die Geschwindigkeit zu verbessern bedarf es nur den Durchlauf bis zu den schon nach hinten gewanderten Elementen, da diese bereits an die richtige sortierte Position gewandert sind. Dadurch wird stets ein Element weniger geprüft, ändert aber insgesamt nichts an der Komplexität des Algorithmus. Applet: 10

10 BubbleSort Implementierung in Java: public class BubbleSort { public static void bubblesort (int[] a){ //äußere For-Schleife (so viele Durchläufe wie Elemente) for(int i=1; i<a.length; i++) { //innere For-Schleife (läuft bis schon platzierten Elementen) for(int j=0; j<a.length-i; j++) { //falls in falscher Reihenfolge, dann vertauschen if (a[j]>a[j+1]) swap(a, j, j+1); //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 11

11 BubbleSort Analyse Die Komplexität von BubbleSort ist stark abhängig inwieweit die Elemente von ihrer richtigen sortierten Position entfernt sind. Im Best Case ist die Folge bereits sortiert und der Algorithmus benötigt einen Durchlauf und bricht danach ab, was eine Laufzeit von O(n) verursacht. Im Worst Case beträgt die Laufzeit jedoch O(n 2 ), wie man schön an der verschachtelten For-Schleife sehen kann. Es kann auch berechnet werden, indem man sich überlegt, dass ein Element nie mehr als n Positionen von der sortierten Position entfernt sein kann und sich nur um eine Position pro Iteration bewegt. Obwohl BubbleSort im Worst Case asymptotisch gleich schnell wie InsertionSort ist, unterscheiden sich die Anzahl der Vertauschungen in beiden Verfahren enorm. In der Praxis zeigt sich das BubbleSort viel langsamer läuft und sich als extrem ineffizient präsentiert. 12

12 SelectionSort SelectionSort (Sortieren durch Auswählen) ist vergleichbar mit InsertionSort und sehr intuitiv zu verstehen. Leider ist es asymptotisch nicht schneller als InsertionSort. sehr einfach zu verstehen und zu implementieren sehr schnell bei kleinen Datenmengen sehr schnell bei genügend vorsortierten Daten stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 13

13 SelectionSort Idee Das Verfahren ist relativ einfach: Die zu sortierende Folge wird in zwei Teile aufgeteilt: eine bereits sortierte Folge und die restlich noch unsortierte Folge. In jedem Iterationsschritt wird das Minimum aus der unsortierten Folge bestimmt und mit dem ersten Element dieser unsortierten Folge vertauscht. Man beginnt mit der gesamten Folge als zu sortierende Folge und ist fertig, wenn alle Elemente sich in der sortierten Folge befinden und die Folge somit komplett sortiert ist. Damit das Verfahren stabil sortiert ist es nötig das Minimum nicht zu vertauschen sondern an die sortierte Folge anzuhängen, sodass es sich zwischen sortierter und unsortierter Folge befindet. Dies macht das Verfahren stabil, jedoch wird mehr Rechenzeit verbraucht, da Elemente im Array verschoben werden müssen. Applet: 14

14 SelectionSort Implementierung in Java: public class SelectionSort { public static void selectionsort (int[] a) { //durchlaufe die Folge... //und vertausche mit Minimum der unsortierten Folge for (int i=0; i<a.length; i++) { swap(a, i, minindex(a, i)); //finde den Index des Minimum nach Position i private static int minindex (int[] a, int i) { int m = i; //setze i as vorläufiges Minimum for (int j=i+1; j<a.length; j++) { //falls kleiner als das Minimum, dann neues Minimum if (a[j] < a[m]) m = j; return m; //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 15

15 SelectionSort Analyse SelectionSort benötigt n-1 Durchläufe um jeweils das Minimum zu bestimmen. Beim ersten Mal benötigt das Bestimmen des Minimums n-1 Vergleiche, beim zweiten Mal n-2 usw. So kann man sich die Laufzeit des Algorithmus bestimmen als 16

16 ShellSort ShellSort ist ein von Donald L. Shell entwickelter und nach ihm benannter Sortieralgorithmus aus dem Jahre Er basiert auf dem Prinzip von InsertionSort und ist asymptotisch etwas schneller. basiert auf InsertionSort mit den Vor- und Nachteilen in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 17

17 ShellSort Idee InsertionSort ist sehr effizient bei genügend vorsortierten Daten, aber langsam, weil Elemente pro Iterationsschritt nur maximal um eine Position bewegt werden. ShellSort verbessert nun InsertionSort indem Elemente, die eine bestimmte Entfernung voneinander entfernt sind (gap size), vergleicht und sie notfalls vertauscht. Die gap size wird nach jeder Iteration verringert, sodass der nächste Iterationsschritt auf leicht vorsortierten Daten basiert. Um dies bildlich zu veranschaulichen, behilft man sich einer Matrixdarstellung mit k Spalten, wobei k die gap size repräsentiert. Jede Spalte wird dann separat mit dem InsertionSort sortiert. Dies geschieht vergleichsweise schnell auf diesen kleinen Datensätzen. Im nächsten Schritt wird die gap size verringert und der Algortihmus wiederholt. Im letzten Schritt liegt eine einspaltrige Matrix vor, worauf ein InsertionSort eine sortierte Folge garantiert und zudem schnell ablaufen sollte, da sie nun genügend vorsortiert sein müsste. Applet: 18

18 ShellSort Implementierung in Java: public class ShellSort { public static void shellsort (int[] a) { int i, j, k, h, t; //vordefinierte gute gap sizes (können verändert werden) int cols[] = {4711, 1968, 815, 271, 111, 41, 13, 4, 1; for (k=0; k<cols.length; k++) { //gap size auslesen h = cols[k]; //vertauschen, falls in falsche Reihenfolge for (i=h; i<a.length; i++) { j = i; t = a[j]; while (j>=h && a[j-h]>t) { a[j] = a[j-h]; j = j-h; a[j] = t; 19

19 ShellSort Analyse Die Laufzeit von ShellSort ist relativ schwer zu analysieren, wir ersparen uns hier die detaillierte Analyse. Die Laufzeiten von ShellSort gehen von O(n (log n) 2 ) bis O(n 1.5 ) je nach Implementation. Sie hängt vor allem von der Wahl der gap sizes ab. Die Folge 1, 3, 7, 15, 31, 63,..., 2k-1 führt zu einer Laufzeit von O(n 1.5 ), die Folge 1, 2, 3, 4, 6, 8, 9, 12, 16,..., 2p3q jedoch zu einer Laufzeit von O(n (log n) 2 ). Es kann gezeigt werden, dass die durchschnittliche Laufzeit bei etwa O(n 1.25 ) liegt, aber ein Beweis für ein O(n log n) im worst case wurde noch nicht gefunden. 20

20 MergeSort Den MergeSort Algorithmus haben wir bereits im Rahmen der Divide-and-Conquer Algorithmen kennen gelernt. MergeSort ist ein wohlbekanntes Sortierverfahren nach John von Neumann aus dem Jahre gute Komplexität stabil (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place möglich (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online möglich (kann Folge sortieren, während es sie erhält) 21

21 MergeSort Idee Der Algorithmus besteht aus zwei Teilen, dem Aufteilen der zu sortierenden Folge in zwei kleinere Teilfolgen und das Zusammenfügen der entstandenen Teilfolgen bis wieder eine gesamte sortierte Folge entstanden ist. Das Aufteilen geschieht relativ einfach indem die Folge stets in zwei gleich große Hälften aufgeteilt werden bis die Teilfolgen klein genug sind um sie effizient zu sortieren (meist bei ein- oder zweielementrigen Folgen). Beim Zusammenfügen wird nach dem Reißverschlussprinzip gearbeitet, wobei jeweils das kleinste Element beider Folgen als nächstes in die zusammengefügte Folge eingefügt wird, sodass die Folge sortiert bleibt. MergeSort ist üblicherweise nicht in-place, aber es gibt zahlreiche trickreiche Implementierungen, die dieses verwirklichen. Applet: 22

22 MergeSort Implementierung in Java: public class MergeSort { public static void mergesort (int[] a) { mergesort(a, 0, a.length-1); private static void mergesort (int[] a, int l, int r) { //Rekursionsanker: a[l..r] ist leer oder hat nur ein Element if ( l>=r ) return; //Rekursionsschritt: a[l..r] ist nicht leer //teile in Teilfolgen und füge wieder zusammen int m = (l+r)/2; mergesort (a, l, m); mergesort (a, m+1, r); merge (a, l, m, r);... 23

23 MergeSort Implementierung in Java: Fortsetzung:... //fügt zwei Teilfolgen wieder zusammen private static void merge (int[] a, int l, int m, int r) { //Rekursionsanker: zweite Teilfolge ist leer if (m+1>r) return; int[] b = new int[a.length]; //erstelle Hilfsarray //kopiere a[l..m] nach b[l..m] for (int i=l; i!=m+1; i++) { b[i] = a[i]; //kopiere a[m+1..r] nach b[m+1..r] in umgekehrter Reihenfolge for (int i=m+1; i!=r+1; i++) { b[i] = a[r+m+1-i]; //füge b[l..m] und b[m+1..r] zu a[l..r] zusammen int k=l; int j=r; //Zeiger die von außen nach innen wandern for (int i=l; i!=r+1; i++) { if (b[k] <= b[j]) a[i] = b[k++]; else a[i] = b[j--]; 24

24 MergeSort Analyse Best, Average und Worst Case haben die gleiche Komplexität von O(n log n). MergeSort benötigt O(n) zusätzlichen Speicherplatz, falls es nicht in-place implementiert ist. Der Divide-Schritt geht in konstanter Zeit, der größere Aufwand ist in beim Zusammenfügen zu ermitteln. Beim Zusammenfügen müssen in jeder Ebene im worst case n Vergleiche durchgeführt werden. Es gibt log n Ebenen, daher ergibt sich eine Gesamtlaufzeit von O(n log n). Für Fortgeschrittene: Falls für einen Durchlauf einer Folge von n Elementen T(n) Zeit benötigt wird, dann benötigen wir zweimal die Zeit für eine Folge halber Länge (2T(n/2)) und die Zeit die Elemente von a nach b und zurück zu kopieren (n). Es ergibt sich eine Rekursionsformel T(n) = 2T(n/2) + n und T(1) = 0, welches sich mittels Master Theorem zu T(n) O(n log n) auflöst. 25

25 QuickSort Auch den QuickSort-Algorithmus kennen wir aus dem Divide-and-Conquer Prinzip. QuickSort wurde entwickelt von C. Antony R. Hoare. Genauso wie MergeSort ist Quicksort ein gutes Beispiel für das Teile-und-Herrsche Prinzip. QuickSort ist im worst case langsamer als MergeSort, im average case aber asymptotisch gleich schnell. Trotzdem ist QuickSort in der Praxis bedeutend schneller, weil die innere Schleife des Algorithmus auf den meisten Architekturen besonders effizient implementiert werden kann. Das Verfahren wird als in-place angesehen, obwohl die Rekursion zusätzlichen Stackspeicher benötigt. schnell, da innere Schleife effizient zu implementieren ist oft in der Prexis eingesetzt in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 26

26 QuickSort Idee Der QuickSort-Algorithmus ist ein typisches Beispiel für die Entwurfstechnik Divide-and-Conquer. Um eine Liste zu sortieren wird ein Pivotelement p ausgewählt und die Elemente der Liste in zwei neue Listen gespeichert, mit der Eigenschaft, dass in der ersten Liste die Elemente kleiner oder gleich p und in der zweiten Liste die Elemente größer p liegen. Mit den beiden Listen wird wieder genauso verfahren. Es gibt mehrere vielversprechende Strategien das Pivot-Element geschickt zu wählen, so dass der Algorithmus effizient abläuft. Im einfachsten Fall nimmt man das erste oder das letzte Element. Etwas besser ist es, das mittlere Element oder den Median zu wählen. Applet: 27

27 QuickSort Implementierung in Java: public class QuickSort { public static void quicksort (int[] a) { quicksort(a, 0, a.length-1); private static void quicksort (int[] a, int l, int r) { //Rekursionsanker: Liste ist leer if (l>=r) return; //Rekursionsschritt: Aufteilen und rekursives Sortieren int m = partition(a, l, r); quicksort(a,l,m-1); quicksort(a,m+1,r);... 28

28 QuickSort... Implementierung in Java: //Aufteilen des Arrays von l+1 bis r mit Pivot a[l] private static int partition (int[] a, int l, int r) { int i=l+1; //Zeiger am linken Rand int j=r; //Zeiger am rechten Rand int p = a[l]; //Pivot-Element //Zeiger bewegen sich nach innen oder Elemente werden vertauscht while (i<=j) { if (a[i]<=p) i++; else if (a[j]>p) j--; else swap(a,i,j); //vertausche Pivot-Element zwischen die Teilfolgen swap(a,l,j); //gebe die Position des Pivot-Elements zurück return j; //vertauscht zwei Elemente im Array private static void swap (int[] a, int i, int j) { int h = a[i]; a[i] = a[j]; a[j] = h; 29

29 QuickSort Analyse Wählen wir stets das erste Objekt als Pivot-Element, ist die Auswahl des Pivot-Elements in O(1) möglich. Im Best Case wird jedes Mal die Folge in zwei nahezu gleich große Teilfolgen aufgeteilt. Es finden, ähnlich wie bei MergeSort, n Vergleiche auf jeder Ebene statt bei log n Ebenen. Dies ergibt eine Laufzeit von O(n log n). Im Worst Case jedoch (falls die Liste invers sortiert ist) werden Teilfolgen der Länge 1 und n-1 erzeugt. In diesem Fall entartet der Rekursionsbaum zu einer linearen Kette von n verschachtelten Aufrufen. Jeder i-te Iterationsschritt muss O(n-i) Elemente durchlaufen, was folgende Laufzeit ergibt: 30

30 Binary Tree Sort Binary Tree Sort ist die Bezeichnung eine Menge an Daten mit Hilfe des binären Suchbaums zu sortieren. gute Komplexität stabil möglich (die Reihenfolge von schon sortierten Elementen ändert sich nach Sortierung nicht) in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) online (kann Folge sortieren, während es sie erhält) Idee Die zu sortierende Elemente werden einfach in einem binären Suchbaum gespeichert. Um die Elemente in einer sortierten Reihenfolge zu erhalten, muss der Baum nur inorder traversiert werden. Analyse Das Einfügen eines Elements in einen binären Suchbaum benötigt O(log n) Zeit. Für n Elemente wären das insgesamt O(n log n) Zeit. Die Inorder-Traversierung benötigt nur O(n). Die Gesamtlaufzeit beträgt somit O(n log n). Applet: 31

31 HeapSort HeapSort ist ein sehr effizientes Sortierverfahren, 1964 entwickelt von Robert W. Floyd und J. W. J. Williams. Es ist eine Weiterentwicklung vom SelectionSort und ist mit einer Worst Case Laufzeit von O(n log n) einer der besten vergleichsbasierten Sortieralgorithmen. Es arbeitet in-place, sortiert aber nicht stabil. sehr effizient mit fast allen Datensätzen oft in der Praxis eingesetzt in-place (bzw. in-situ, d.h. es wird kein zusätzlicher Speicher benötigt) 32

32 HeapSort Idee HeapSort benutzt, wie der Name schon erahnen lässt, eine Heap Datenstruktur. In der einfachsten Ausführung werden die Elemente der zu sortierenden Folge nacheinander in einen Min-Heap eingefügt. Die Datenstruktur kümmert sich um die Anordnung der Elementen in einem partiell geordneten Baum, sodass man schnell das Minimum entfernen kann. Tut man dies bis der Heap leer ist, so erhält man die Elemente in der richtigen Reihenfolge als sortierte Folge. Leider ist dies kein in-place Verfahren. Für eine in-place Methode siehe die Beschreibung auf der Applet-Webseite (unten). Analyse Ein HeapSort, der nicht in-place arbeitet, benötigt n mal O(log n) zum Erstellen des Heaps und erneut n mal O(log n) um die Minima zu entnehmen. Das Resultat ist eine Laufzeit von O(n log n). Applet: 33

33 PAUSE 34

34 Geht es schneller als O(n log n)? Überblick der bisherigen Sortierverfahren und die Laufzeit im worst case InsertionSort O(n 2 ) BubbleSort O(n 2 ) SelectionSort O(n 2 ) ShellSort O(n 1,5 ) MergeSort O(n log n) QuickSort O(n 2 ), aber O(n log n) im average case Binary Tree Sort O(n log n) HeapSort O(n log n) Frage: Gibt es Verfahren, die noch schneller sind als O(n log n)? 35

35 Vergleichsbasierte Sortierverfahren Die bisherigen Sortierverfahren, die wir kennen gelernt haben, fallen unter die Kategorie universelle, vergleichsbasierte Sortierverfahren. Sie sind universell, weil sie auf jede beliebige Folge von Werten anwendbar sind, und die Laufzeit nur abhängig von der Anzahl der Werte ist und nicht von der Größe der Werte. Sie sind vergleichsbasiert, weil sie auf paarweisen Vergleichen der zu sortierenden Elemente basieren. Bei der Komplexitätsanalyse wird davon ausgegangen, dass der Aufwand zum Vergleich zweier Elemente konstant ist, sodass man beweisen kann, dass es eine untere Schranke Ω(n log n) f ür solche Verfahren gibt. 36

36 Untere Schranke für vergleichsbasierte Sortierverfahren Behauptung: Es gibt kein vergleichsbasiertes Sortierverfahren, das schneller arbeitet als O(n log n). Beweis: Ein Sortierverfahren soll die Folge X = (x 1, x 2,..., x n ) sortieren. Alle möglichen Permutationen von X könnten das Ergebnis darstellen, daher gibt es n! Möglichkeiten. Ein vergleichsbasiertes Verfahren kann pro Schritt nur entscheiden ob ein Wert x i größer oder kleiner als x j ist. Die Möglichkeiten lassen sich also in einem binären Entscheidungsbaum darstellen. Die Mindestanzahl von Schritten zu einem Blattknoten ist log(n!). Man kann log(n!) nach unten abschätzen durch Damit gilt 37

37 Untere Schranke für vergleichsbasierte Sortierverfahren Beispiel eines Entscheidungsbaums für die Folge (a, b, c): a<b? b<c? a<c? a,b,c a<c? b,a,c b<c? a,c,b c,a,b b,c,a c,b,a 3 Elemente 3! = 6 Blattknoten 38

38 Sortieren in linearer Zeit Es gibt einige Sortierverfahren, die nicht vergleichsbasiert arbeiten, und sind damit schneller als O(n log n). Jedoch haben sie andere Einschränkungen auf die Eigenschaften der Elemente, die sie sortieren. BucketSort CountingSort RadixSort 39

39 BucketSort Bucketsort ist ein nicht-vergleichsbasiertes Sortierverfahren, das eine Liste in linearer Laufzeit sortieren kann. Idee BucketSort verwaltet zum Sortieren der Folge a[1...n] eine weitere Folge b[0...m-1], welches m lineare verkettete Listen verwaltet, die Buckets. Die zu sortierenden Elemente werden in m Intervalle zerlegt und jedes Element landet in ihrem zugehörigen Bucket. Dort werden mehrere Buckets mit einem Standard-Verfahren (z.b. InsertionSort) sortiert. Zum Schluss werden die einzelnen Buckets hintereinander gehängt. Analyse Die Wahrscheinlichkeit, dass ein a[j] in die Liste b[i] kommt ist 1/n. BucketSort sortiert im average case in O(n). Im worst case jedoch O(n 2 ), wenn alle Elemente in einem bucket landen und zum Beispiel InsertionSort als Standard-Verfahren gewählt wird. 40

40 BucketSort Beispiel Sortiere Dezimalzahlen, wähle Buckets gemäß erster Ziffer nach dem Komma: a b 1 0,60 0 0,01 0,07 0,08 2 0,08 1 0,18 3 0,23 2 0,23 4 0, , ,18 5 0,58 7 0,01 6 0,60 0,68 8 0,84 7 0,71 9 0,68 8 0, ,

41 BucketSort Implementierung in Java: Nimmt die Wertigkeit des Elements als Index public class BucketSort { public static void bucketsort(int a[], int numbuckets) { // histogramm erstellen int buckets[] = new int[numbuckets]; //verteilen auf Buckets, Elemente werden einfachshalber nur hochgezählt for (int i = 0; i < a.length; i++) { buckets[a[i]]++; //zusammenhängen int x = 0; for (int i = 0; i < numbuckets; i++) { while (buckets[i] > 0) { a[x++] = i; buckets[i]--; 42

42 CountingSort CountingSort ist ein nicht-vergleichsbasiertes Sortierverfahren, das genauso wie BucketSort das Intervall der Werte der zu sortierenden Elemente ausnutzt. Idee Sei a[1...n] die Folge, die zu sortieren ist. Bestimme für jedes Element x in a die Anzahl der Elemente, die in der sortierten Reihenfolge vor x liegen und platziere damit x an die korrekte Stelle. Um CountingSort zu einem stabilen Sortierverfahren zu machen, wird das zu sortierende Feld von hinten aufgerollt und die jeweiligen Elemente an die richtige Position gesetzt. 43

43 CountingSort Beispiel A C C B

44 CountingSort Implementierung in Java: Sortiert Array a in b, mit Hilfsarray c public class CountingSort { public static void countingsort(int[] a, int numcells) { //temporäres Array erzeugen zum Zählen int[] c = new int[numcells]; // Indizes des Zahlen-Arrays durchgehen for(int i=0; i < c.length; i++) { // für jedes Vorkommen von a[i] wird c[a[i]] um eins erhöht c[a[i]] = c[a[i]] + 1; for(int i=1; i < c.length; i++) { c[i] = c[i] + c[i-1]; //c[i] gibt nun die Anzahl der Elemente <= i in a an int[] b = new int[a.length]; //füge Elemente an richtiger Stelle ein for(int i=a.length-1; i >= 0; i--) { b[c[a[i]]-1] = a[i]; c[a[i]] = c[a[i]] - 1; 45

45 CountingSort Analyse Sei n die Anzahl der zu sortierenden Elemente und m das Intervall der Zahlen. Dann ist leicht aus der Implementierung herzuleiten, dass die Laufzeit O(n+m) beträgt und damit linear ist. 46

46 RadixSort RadixSort ist ebenfalls ein nicht-vergleichbasiertes Sortierverfahren, welches auf CountingSort aufbaut. Voraussetzung für RadixSort ist, dass die Zeichen der zu sortierenden Daten aus einem endlichen Alphabet stammen, z.b. Buchstaben aus dem lat. Alphabet, Ziffern aus dem Dezimalsystem. Idee Für jedes Element x wird eine bestimmte Stelle x[i] untersucht. Zuerst werden die Elemente gemäß x[i] in Fächer verteilt (Partitionierung). Nach der Verteilung werden alle Daten nach aufsteigender Wertigkeit von x[i] aufgesammelt. Danach wird dies mit der nächsthöheren Stelle x[j] wiederholt, bis alle Stellen abgearbeitet sind. 47

47 RadixSort Beispiel Partitionieren nach Ziffer 3: Zusammensammeln: Partitionieren nach Ziffer 2: Zusammensammeln:

48 RadixSort Beispiel Zusammensammeln: Partitionieren nach Ziffer 1: Zusammensammeln:

49 RadixSort Analyse Sei n die Anzahl der zu sortierenden Elemente und m die maximale Anzahl an Stellen eines Elements. Für jede Stelle müssen alle n Elemente partitioniert und zusammengesammelt werden. Es ergibt sich also eine Gesamtlaufzeit von O(m*n). Nehmen wir an, dass m konstant ist, dann folgt daraus, dass RadixSort in linearer Zeit sortiert. 50

Pro Informatik 2009: Objektorientierte Programmierung Tag 18. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik

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:

Mehr

Sortieralgorithmen. Jan Pöschko. 18. Januar Problemstellung Definition Warum Sortieren?... 2

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

Mehr

Übung: Algorithmen und Datenstrukturen SS 2007

Ü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

Mehr

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

Mehr

Sortieralgorithmen. Selection Sort

Sortieralgorithmen. Selection Sort intuitivster Suchalgorithmus Sortieralgorithmen Selection Sort In jedem Schritt wird das kleinste Element im noch unsortierten Array gesucht und ans Ende des bisher sortierten Teilarrays gehangen 3 1 4

Mehr

Prof. Dr. Margarita Esponda

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

Mehr

Übung Algorithmen und Datenstrukturen

Ü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

Mehr

Programmieren I. Kapitel 7. Sortieren und Suchen

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

Mehr

Kapitel 6 Elementare Sortieralgorithmen

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

Mehr

7. Sortieren Lernziele. 7. Sortieren

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

Mehr

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

Mehr

Algorithmen I. Tutorium 1-3. Sitzung. Dennis Felsing

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

Mehr

Technische Universität München

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

Mehr

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

Mehr

2 Sortieren. Beispiel: Es seien n = 8 und a = i : a i : ϕ(i) : a ϕ(i) :

2 Sortieren. Beispiel: Es seien n = 8 und a = i : a i : ϕ(i) : a ϕ(i) : 2 Sortieren Das Sortieren einer Datenfolge ist eines der am leichtesten zu verstehenden und am häufigsten auftretenden algorithmischen Probleme. In seiner einfachsten Form besteht das Problem darin, eine

Mehr

2.3.1 Einleitung Einfache Sortierverfahren Höhere Sortierverfahren Komplexität von Sortierverfahren Spezielle Sortierverfahren

2.3.1 Einleitung Einfache Sortierverfahren Höhere Sortierverfahren Komplexität von Sortierverfahren Spezielle Sortierverfahren 2.3 Sortieren 2.3.1 Einleitung 2.3.2 Einfache Sortierverfahren 2.3.3 Höhere Sortierverfahren 2.3.4 Komplexität von Sortierverfahren 2.3.5 Spezielle Sortierverfahren 1 Selection-Sort Idee: Suche kleinstes

Mehr

Tutoraufgabe 1 (Sortieralgorithmus):

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

Mehr

JAVA - Suchen - Sortieren

JAVA - Suchen - Sortieren Übungen Informatik I JAVA - Suchen - Sortieren http://www.fbi-lkt.fh-karlsruhe.de/lab/info01/tutorial Übungen Informatik 1 Folie 1 Inhalt Suchen/Sortieren binary search mergesort bubblesort Übungen Informatik

Mehr

Grundlegende Sortieralgorithmen

Grundlegende Sortieralgorithmen Grundlegende Sortieralgorithmen Martin Wirsing in Zusammenarbeit mit Matthias Hölzl und Nora Koch Sortieren in Java Man kann Sortierverfahren in einem imperativem oder einem objektorientierten Stil programmieren.

Mehr

Algorithmen und Datenstrukturen

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

Mehr

Kapitel 8 Fortgeschrittene Sortieralgorithmen

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

Mehr

Übersicht. Datenstrukturen und Algorithmen. Übersicht. Divide-and-Conquer. Vorlesung 9: Quicksort (K7)

Übersicht. Datenstrukturen und Algorithmen. Übersicht. Divide-and-Conquer. Vorlesung 9: Quicksort (K7) Datenstrukturen und Algorithmen Vorlesung 9: (K7) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://www-i2.rwth-aachen.de/i2/dsal0/ Algorithmus 8. Mai 200 Joost-Pieter

Mehr

Abschnitt: Algorithmendesign und Laufzeitanalyse

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

Mehr

Datenstrukturen und Algorithmen

Datenstrukturen und Algorithmen Joost-Pieter Katoen Datenstrukturen und Algorithmen 1/32 Datenstrukturen und Algorithmen Vorlesung 7: Sortieren (K2) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group

Mehr

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen Kapitel 9 Komplexität von Algorithmen und Sortieralgorithmen Arrays 1 Ziele Komplexität von Algorithmen bestimmen können (in Bezug auf Laufzeit und auf Speicherplatzbedarf) Sortieralgorithmen kennenlernen:

Mehr

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen 1 Kapitel 9 Komplexität von Algorithmen und Sortieralgorithmen Ziele 2 Komplexität von Algorithmen bestimmen können (in Bezug auf Laufzeit und auf Speicherplatzbedarf) Sortieralgorithmen kennenlernen:

Mehr

2.2 Allgemeine (vergleichsbasierte) Sortierverfahren

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

Mehr

Sortieralgorithmen. Inhalt: InsertionSort BubbleSort QuickSort. Marco Block

Sortieralgorithmen. Inhalt: InsertionSort BubbleSort QuickSort. Marco Block Inhalt: InsertionSort BubbleSort QuickSort Block M.: "Java-Intensivkurs - In 14 Tagen lernen Projekte erfolgreich zu realisieren", Springer-Verlag 2007 InsertionSort I Das Problem unsortierte Daten in

Mehr

Sortieralgorithmen. Direkte Sortierverfahren & Shellsort, Quicksort, Heapsort. Vorlesung Algorithmen und Datenstrukturen 2 im SS 2004

Sortieralgorithmen. Direkte Sortierverfahren & Shellsort, Quicksort, Heapsort. Vorlesung Algorithmen und Datenstrukturen 2 im SS 2004 Sortieralgorithmen Direkte Sortierverfahren & Shellsort, Quicksort, Heapsort Vorlesung Algorithmen und Datenstrukturen 2 im SS 2004 Prof. Dr. W. P. Kowalk Universität Oldenburg Algorithmen und Datenstrukturen

Mehr

Programmiertechnik II

Programmiertechnik II 2007 Martin v. Löwis Sortieren: Quicksort und Mergesort Charles Antony Richard Hoare 2007 Martin v. Löwis Geboren 11. 1. 1934 in Colombo (Sri Lanka) Studium in Oxford (Philosophie, Latein, Griechisch)

Mehr

Interne Sortierverfahren

Interne Sortierverfahren Angewandte Datentechnik Interne Sortierverfahren Interne Sortierverfahren Ausarbeitung einer Maturafrage aus dem Fach A n g e w a n d t e D a t e n t e c h n i k Andreas Hechenblaickner 5CDH HTBLA Kaindorf/Sulm

Mehr

Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Einfache Sortierverfahren Autor: Stefan Edelkamp

Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Einfache Sortierverfahren Autor: Stefan Edelkamp Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Einfache Sortierverfahren Autor: Stefan Edelkamp Institut für Informatik Georges-Köhler-Allee Albert-Ludwigs-Universität Freiburg 1

Mehr

Kap. 3: Sortieren. Überblick. Unser Sortierproblem. Motivation. Laufzeitmessung. Warum soll ich hier bleiben? Sortierverfahren sind WICHTIG!!!

Kap. 3: Sortieren. Überblick. Unser Sortierproblem. Motivation. Laufzeitmessung. Warum soll ich hier bleiben? Sortierverfahren sind WICHTIG!!! Kap. 3: Sortieren Professor Dr. Lehrstuhl für Algorithm Engineering, LS11 Fakultät für Informatik, TU Dortmund Überblick Einführung in das Sortierproblem Insertion-Sort Selection-Sort Merge-Sort 4. VO

Mehr

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

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

Mehr

Untere Schranke für allgemeine Sortierverfahren

Untere Schranke für allgemeine Sortierverfahren Untere Schranke für allgemeine Sortierverfahren Prinzipielle Frage: wie schnell kann ein Algorithmus (im worst case) überhaupt sein? Satz: Zum einer Folge von n Keys mit einem allgemeinen Sortierverfahren

Mehr

Aufgabe (Schreibtischtest, Algorithmenanalyse)

Aufgabe (Schreibtischtest, Algorithmenanalyse) Aufgabe (Schreibtischtest, Algorithmenanalyse) Führen Sie einen Schreibtischtest für den Algorithmus Positionsort für das folgende Eingabe-Array durch. Geben Sie nach jedem Durchlauf der for-schleife mit

Mehr

Bucketsort. Korrektheit. Beispiel. Eingabe: Array A mit n Elementen im Bereich [0,1) Annahme: die Elemente sind in [0,1) gleichverteilt.

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:

Mehr

Übung Algorithmen I

Ü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

Mehr

Suchen und Sortieren

Suchen und Sortieren Suchen und Sortieren Suchen Sortieren Mischen Zeitmessungen Bewertung von Sortier-Verfahren Seite 1 Suchverfahren Begriffe Suchen = Bestimmen der Position (Adresse) eines Wertes in einer Datenfolge Sequentielles

Mehr

7. Übung zu Algorithmen I 1. Juni 2016

7. Übung zu Algorithmen I 1. Juni 2016 7. Übung zu Algorithmen I 1. Juni 2016 Lukas Barth lukas.barth@kit.edu (mit Folien von Lisa Kohl) Roadmap Ganzzahliges Sortieren mit reellen Zahlen Schnellere Priority Queues Bucket Queue Radix Heap Organisatorisches

Mehr

4. Sortieren 4.1 Vorbemerkungen

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

Mehr

Suchen und Sortieren (Die klassischen Algorithmen)

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

Mehr

Informatik II, SS 2014

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

Mehr

Stud.-Nummer: Datenstrukturen & Algorithmen Seite 1

Stud.-Nummer: Datenstrukturen & Algorithmen Seite 1 Stud.-Nummer: Datenstrukturen & Algorithmen Seite 1 Aufgabe 1. / 16 P Instruktionen: 1) In dieser Aufgabe sollen Sie nur die Ergebnisse angeben. Diese können Sie direkt bei den Aufgaben notieren. 2) Sofern

Mehr

Sortieren durch Mischen (Mergesort; John von Neumann 1945)

Sortieren durch Mischen (Mergesort; John von Neumann 1945) Sortieren durch Mischen (Mergesort; John von Neumann 1945) Gegeben folgendes Feld der Größe 10. 3 8 9 11 18 1 7 10 22 32 Die beiden "Hälften" sind hier bereits vorsortiert! Wir können das Feld sortieren,

Mehr

Algorithmen und Datenstrukturen 1

Algorithmen und Datenstrukturen 1 Algorithmen und Datenstrukturen 1 4. Vorlesung Peter F. Stadler Universität Leipzig Institut für Informatik studla@bioinf.uni-leipzig.de 4. Sortierverfahren Elementare Sortierverfahren - Sortieren durch

Mehr

Vorlesung Datenstrukturen

Vorlesung Datenstrukturen Vorlesung Datenstrukturen Heaps Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 469 Prioritätswarteschlange Problem Häufig ist das Prinzip einer einfachen Warteschlangen-Datenstruktur

Mehr

1. Aufgabe (6 Punkte): Java-Programmierung (Arrays)

1. Aufgabe (6 Punkte): Java-Programmierung (Arrays) Der folgende Mitschrieb wurde von Prof. Alexa am 16.07.2008 als Probeklausur in der MPGI2 Vorlesung gezeigt und wurde auf http://www.basicinside.de/2008/node/94 veröffentlicht. Die Abschrift ist unter

Mehr

2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,..., a n 2, 1, 3 Sortieralg. Für festes n ist ein vergleichsbasierter Sortieralg. charakterisiert

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

Mehr

Grundlagen der Informatik

Grundlagen der Informatik Jörn Fischer j.fischer@hs-mannheim.de Willkommen zur Vorlesung Grundlagen der Informatik ADS-Teil Page 2 Überblick Inhalt 1 Eigenschaften von Algorithmen Algorithmenbegriff O-Notation Entwurfstechniken

Mehr

Algorithmen und Datenstrukturen SS09. Foliensatz 15. Michael Brinkmeier. Technische Universität Ilmenau Institut für Theoretische Informatik

Algorithmen und Datenstrukturen SS09. Foliensatz 15. Michael Brinkmeier. Technische Universität Ilmenau Institut für Theoretische Informatik Foliensatz 15 Michael Brinkmeier Technische Universität Ilmenau Institut für Theoretische Informatik Sommersemester 2009 TU Ilmenau Seite 1 / 16 Untere Schranken für das Vergleichsbasierte Sortieren TU

Mehr

Komplexität von Algorithmen OOPM, Ralf Lämmel

Komplexität von Algorithmen OOPM, Ralf Lämmel Ganz schön komplex! Komplexität von Algorithmen OOPM, Ralf Lämmel 885 Motivierendes Beispiel Algorithmus Eingabe: ein Zahlen-Feld a der Länge n Ausgabe: Durchschnitt Fragen: sum = 0; i = 0; while (i

Mehr

Algorithmen und Datenstrukturen. Kapitel 3: Sortierverfahren. Skript zur Vorlesung. Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen. Kapitel 3: Sortierverfahren. Skript zur Vorlesung. Algorithmen und Datenstrukturen LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS DATABASE Algorithmen und Datenstrukturen Kapitel 3: Sortierverfahren Skript zur Vorlesung Algorithmen und Datenstrukturen Sommersemester

Mehr

damit hätten wir nach Ende der Schleife: "a[0 n-1] enthält nur Elemente aus a[0 n-1], aber in sortierter Reihenfolge".

damit hätten wir nach Ende der Schleife: a[0 n-1] enthält nur Elemente aus a[0 n-1], aber in sortierter Reihenfolge. Korrektheit Invariante: a[0 k-1] enthält nur Elemente aus a[0 k-1], aber in sortierter Reihenfolge Terminierung: Die Schleife endet mit k=n def insertionsort(a): for k in range( 1, len(a) ): while i >

Mehr

2. Felder (Arrays) 2.1 Suchen in Feldern. lineares Suchen: siehe Kapitel 1. Binäres Suchen. Vor.: Elemente (z.b. aufsteigend) sortiert

2. Felder (Arrays) 2.1 Suchen in Feldern. lineares Suchen: siehe Kapitel 1. Binäres Suchen. Vor.: Elemente (z.b. aufsteigend) sortiert 10 2.1 Suchen in Feldern 2. Felder (Arrays) lineares Suchen: siehe Kapitel 1 Binäres Suchen Vor.: Elemente (z.b. aufsteigend) sortiert ( später) Idee: Divide & Conquer (teile und herrsche) public

Mehr

Übung Algorithmen und Datenstrukturen

Übung Algorithmen und Datenstrukturen Übung Algorithmen und Datenstrukturen Sommersemester 2017 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda 1. Sortierte Listen 2. Stacks & Queues 3. Teile und Herrsche Nächste Woche: Vorrechnen (first-come-first-served)

Mehr

In C und Java müssen Variablen und Methodenergebnisse durch Typangaben erläutert werden. Welche der folgenden Aussagen sind korrekt und welche nicht:

In C und Java müssen Variablen und Methodenergebnisse durch Typangaben erläutert werden. Welche der folgenden Aussagen sind korrekt und welche nicht: Typprüfung (Compiler / Laufzeit) In C und Java müssen Variablen und Methodenergebnisse durch Typangaben erläutert werden. Welche der folgenden Aussagen sind korrekt und welche nicht: 1) Der Compiler prüft

Mehr

Tutoraufgabe 1 (Sortieren): Lösung: Datenstrukturen und Algorithmen SS14 Lösung - Übung 4

Tutoraufgabe 1 (Sortieren): Lösung: Datenstrukturen und Algorithmen SS14 Lösung - Übung 4 Prof. aa Dr. E. Ábrahám Datenstrukturen und Algorithmen SS Lösung - Übung F. Corzilius, S. Schupp, T. Ströder Tutoraufgabe (Sortieren): a) Sortieren Sie das folgende Array durch Anwendung des Selectionsort-Algorithmus.

Mehr

Grundlagen der Programmierung 2. Sortierverfahren

Grundlagen der Programmierung 2. Sortierverfahren Grundlagen der Programmierung 2 Sortierverfahren Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 30. Mai 2006 Sortieren Ziel: Bringe Folge von Objekten in eine Reihenfolge

Mehr

NAME, VORNAME: Studiennummer: Matrikel:

NAME, VORNAME: Studiennummer: Matrikel: TU Ilmenau, Fakultat IA Institut für Theoretische Informatik FG Komplexitätstheorie und Effiziente Algorithmen Prof. Dr. (USA) M. Dietzfelbinger Klausur Algorithmen und Datenstrukturen SS08, Ing.-Inf.

Mehr

Die Schnittstelle Comparable

Die Schnittstelle Comparable Die Schnittstelle Comparable Wir wollen Such- und Sortieroperationen für beliebige Objekte definieren. Dazu verwenden wir die vordefinierte Schnittstelle Comparable: public interface Comparable { int compareto(object

Mehr

Algorithmen und Datenstrukturen 1

Algorithmen und Datenstrukturen 1 Algorithmen und Datenstrukturen 1 6. Vorlesung Martin Middendorf / Universität Leipzig Institut für Informatik middendorf@informatik.uni-leipzig.de studla@bioinf.uni-leipzig.de Merge-Sort Anwendbar für

Mehr

Übungsblatt 1. f(n) = f(n) = O(g(n)) g(n) = O(f(n)) Zeigen oder widerlegen Sie: 3 n = Θ(2 n ) Aufgabe 1.2 Gegeben sei die folgende Funktion:

Übungsblatt 1. f(n) = f(n) = O(g(n)) g(n) = O(f(n)) Zeigen oder widerlegen Sie: 3 n = Θ(2 n ) Aufgabe 1.2 Gegeben sei die folgende Funktion: Übungsblatt 1 Aufgabe 1.1 Beweisen oder widerlegen Sie, dass für die im Folgenden definierte Funktion f(n) die Beziehung f(n) = Θ(n 4 ) gilt. Beachten Sie, dass zu einem vollständigen Beweis gegebenenfalls

Mehr

Name: Seite 2. Beantworten Sie die Fragen in den Aufgaben 1 und 2 mit einer kurzen, prägnanten Antwort.

Name: Seite 2. Beantworten Sie die Fragen in den Aufgaben 1 und 2 mit einer kurzen, prägnanten Antwort. Name: Seite 2 Beantworten Sie die Fragen in den Aufgaben 1 und 2 mit einer kurzen, prägnanten Antwort. Aufgabe 1 (8 Punkte) 1. Wie sieht -5 in der 4Bit 2-er Komplementdarstellung aus? 2. Berechnen Sie

Mehr

Kapitel 2. Sortieren. Adressenverwaltung (lexikographisch) Treerlisten bei Suchanfragen (Relevanz) Verdeckung (z-koordinate) ...

Kapitel 2. Sortieren. Adressenverwaltung (lexikographisch) Treerlisten bei Suchanfragen (Relevanz) Verdeckung (z-koordinate) ... Kapitel 2 Sortieren Das Sortieren ist eines der grundlegenden Probleme in der Informatik. Es wird geschätzt, dass mehr als ein Viertel aller kommerzieller Rechenzeit auf Sortiervorgänge entfällt. Einige

Mehr

lim log 2n n = > 0 Da es einen Limes gibt, gibt es auch einen Limes inferior, der gleich diesem Limes ist.

lim log 2n n = > 0 Da es einen Limes gibt, gibt es auch einen Limes inferior, der gleich diesem Limes ist. Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Jonathan Heinen, Thomas Ströder, Sabrina von Styp Aufgabe 1 (O-Notation): Beweisen oder widerlegen Sie die folgenden Aussagen: (3 + 3 + 4 = 10 Punkte)

Mehr

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

Mehr

Algo-Animation. Konstruktion der Partition: eigentliche Kunst / Arbeit bei Quicksort. Resultat: Partition A=A 1 WA 2 A 1 W A 2.

Algo-Animation. Konstruktion der Partition: eigentliche Kunst / Arbeit bei Quicksort. Resultat: Partition A=A 1 WA 2 A 1 W A 2. Algo-Animation Konstruktion der Partition: eigentliche Kunst / Arbeit bei Quicksort 1. Wahl eines Elementes W im Array (heißt Pivot-Element) 2. Suchen eines i von links mit A[i]>W 3. Suchen eines j von

Mehr

Informatik B Sommersemester Musterlösung zur Klausur vom

Informatik B Sommersemester Musterlösung zur Klausur vom Informatik B Sommersemester 007 Musterlösung zur Klausur vom 0.07.007 Aufgabe : Graphen und Graphalgorithmen + + + () Punkte Für eine beliebige positive, ganze Zahl n definieren wir einen Graphen G n =

Mehr

Programmierung mit C Algorithmen

Programmierung mit C Algorithmen Programmierung mit C Algorithmen Informationen /7/ Robert Sedgewick Algorithmen in C. 742 Seiten, ISBN 3-827-37182-1. /8/ Kyle Loudon Algorithmen mit C, ISBN 3-4897-211653-0. Online-Buch "C von A bis Z",

Mehr

Übersicht. Datenstrukturen und Algorithmen. Übersicht. Heaps. Vorlesung 8: Heapsort (K6) Joost-Pieter Katoen. 7. Mai 2015

Ü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

Mehr

3. Übungsblatt zu Algorithmen I im SoSe 2017

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

Mehr

Algorithmen und Datenstrukturen 1-3. Seminar -

Algorithmen und Datenstrukturen 1-3. Seminar - Algorithmen und Datenstrukturen 1-3. Seminar - Dominic Rose Bioinformatics Group, University of Leipzig Wintersemester 2009/10 Outline Spezielle Listen: Stacks, Queues Sortierverfahren 3. Übungsserie Wiederholung:

Mehr

Algorithmen und Datenstrukturen

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

Mehr

Quicksort ist ein Divide-and-Conquer-Verfahren.

Quicksort ist ein Divide-and-Conquer-Verfahren. . Quicksort Wie bei vielen anderen Sortierverfahren (Bubblesort, Mergesort, usw.) ist auch bei Quicksort die Aufgabe, die Elemente eines Array a[..n] zu sortieren. Quicksort ist ein Divide-and-Conquer-Verfahren.

Mehr

Inhaltsverzeichnis. Teil 1 Grundlagen 23

Inhaltsverzeichnis. Teil 1 Grundlagen 23 Inhaltsverzeichnis Vorwort 11 Umfang 12 Einsatz als Unterrichtsmittel 12 Algorithmen mit Praxisbezug 13 Programmiersprache 14 Danksagung 15 Vorwort des C++-Beraters 16 Hinweise zu den Übungen 21 Teil 1

Mehr

Algorithmen und Datenstrukturen Heapsort

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

Mehr

Übung Datenstrukturen. Sortieren

Übung Datenstrukturen. Sortieren Übung Datenstrukturen Sortieren Aufgabe 1 Gegeben sei nebenstehender Sortieralgorithmus für ein Feld a[] ganzer Zahlen mit N Elementen: a) Um welches Sortierverfahren handelt es sich? b) Geben Sie möglichst

Mehr

Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen Algorithmen und Datenstrukturen Prof. Martin Lercher Institut für Informatik Heinrich-Heine-Universität Düsseldorf Algorithmen und Datenstrukturen Teil 2 Sortieren Version vom: 7. Dezember 2016 1 / 94

Mehr

Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Suchverfahren Autor: Stefan Edelkamp / Sven Schuierer

Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Suchverfahren Autor: Stefan Edelkamp / Sven Schuierer Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Suchverfahren Autor: Stefan Edelkamp / Sven Schuierer Institut für Informatik Georges-Köhler-Allee Albert-Ludwigs-Universität Freiburg

Mehr

Sortierverfahren. Sortierverfahren für eindimensionale Arrays

Sortierverfahren. Sortierverfahren für eindimensionale Arrays Sortierverfahren Sortierverfahren Sortieren durch Einfügen Sortieren durch Auswählen Sortieren durch Vertauschen (Bubblesort) Quicksort Sortierverfahren für eindimensionale Arrays 1 Gegeben ist eine beliebige

Mehr

Inhaltsverzeichnis. Teil 1 Grundlagen 21. Teil 2 Datenstrukturen 85

Inhaltsverzeichnis. Teil 1 Grundlagen 21. Teil 2 Datenstrukturen 85 Inhaltsverzeichnis Vorwort 13 Umfang 14 Einsatz als Unterrichtsmittel 14 Algorithmen mit Praxisbezug 15 Programmiersprache 16 Danksagung 17 Vorwort des Java-Beraters 18 Hinweise zu den Übungen 19 Teil

Mehr

Algorithmen und Datenstrukturen

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

Mehr

Grundlagen der Programmierung

Grundlagen der Programmierung Grundlagen der Programmierung Algorithmen und Datenstrukturen Die Inhalte der Vorlesung wurden primär auf Basis der angegebenen Literatur erstellt. Darüber hinaus sind viele Teile direkt aus der Vorlesung

Mehr

Algorithmen und Datenstrukturen Wintersemester 2004/ November T(n) = T(n a) + T(a) + n

Algorithmen und Datenstrukturen Wintersemester 2004/ November T(n) = T(n a) + T(a) + n Lehrstuhl für Praktische Informatik III Norman May B6, 29, Raum C0.05 68131 Mannheim Telefon: (0621) 181 2517 Email: norman@pi3.informatik.uni-mannheim.de Matthias Brantner B6, 29, Raum C0.05 68131 Mannheim

Mehr

Algorithmen und Datenstrukturen

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

Mehr

Alle bislang betrachteten Sortieralgorithmen hatten (worst-case) Laufzeit Ω(nlog(n)).

Alle bislang betrachteten Sortieralgorithmen hatten (worst-case) Laufzeit Ω(nlog(n)). 8. Untere Schranken für Sortieren Alle bislang betrachteten Sortieralgorithmen hatten (worst-case) Laufzeit Ω(nlog(n)). Werden nun gemeinsame Eigenschaften dieser Algorithmen untersuchen. Fassen gemeinsame

Mehr

Sortieren durch Einfügen

Sortieren durch Einfügen Sortieren durch Einfügen Ein Algorithmus zum Informatikjahr 2006 Prof. Dr. W. Kowalk, Universität Oldenburg, kowalk@kowalk.de Schon wieder Aufräumen, dabei habe ich doch erst neulich Nun ja, wenn alles

Mehr

Termine für Übungstests. Kap. 3 Sortieren HeapSort ff Priority Queues. Motivation. Überblick. Analyse SiftDown

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

Mehr

Vorlesung Datenstrukturen

Vorlesung Datenstrukturen Vorlesung Datenstrukturen Binärbaum Suchbaum Dr. Frank Seifert Vorlesung Datenstrukturen - Sommersemester 2016 Folie 356 Datenstruktur Binärbaum Strukturrepräsentation des mathematischen Konzepts Binärbaum

Mehr

13. Bäume: effektives Suchen und Sortieren

13. Bäume: effektives Suchen und Sortieren Schwerpunkte Aufgabe und Vorteile von Bäumen 13. Bäume: effektives Suchen und Sortieren Java-Beispiele: Baum.java Traverse.java TraverseTest.java Sortieren mit Bäumen Ausgabealgorithmen: - Preorder - Postorder

Mehr

Datenstrukturen und Algorithmen D-INFK

Datenstrukturen und Algorithmen D-INFK 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

Mehr

Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen Algorithmen und Datenstrukturen Dr. Michael Brinkmeier Technische Universität Ilmenau Fakultät Informatik und Automatisierung Fachgebiet Automaten und Formale Sprachen 4.7.2007 Dr. Michael Brinkmeier (TU

Mehr

Robert Sedgewick. Algorithmen in Java. Teil 1-4 Grundlagen Datenstrukturen Sortieren Suchen. Java-Beratung durch Michael Schidlowsky

Robert Sedgewick. Algorithmen in Java. Teil 1-4 Grundlagen Datenstrukturen Sortieren Suchen. Java-Beratung durch Michael Schidlowsky Robert Sedgewick Algorithmen in Java Teil 1-4 Grundlagen Datenstrukturen Sortieren Suchen Java-Beratung durch Michael Schidlowsky 3., überarbeitete Auflage \ PEARSON ein Imprint von Pearson Education München

Mehr

Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen 1 Algorithmen und Datenstrukturen Wintersemester 2014/15 3. Vorlesung Laufzeitanalyse Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Recap: Diskutieren Sie mit Ihrer NachbarIn! 1. 2. 3. Was sind

Mehr

Programmiertechnik II

Programmiertechnik II 2007 Martin v. Löwis Priority Queues and Heapsort 2007 Martin v. Löwis 2 Priority Queue Abstrakter Datentyp Inhalt: Elemente mit Priorität Operationen: Einfügen: Angabe des Elements und seiner Priorität

Mehr

Priority Queues and Heapsort

Priority Queues and Heapsort 19. ovember 2012 Prioritätswarteschlangen und Priority Queues and Ferd van denhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software ngineering 19. ovember 2012 D/FHTBM Priority Queues and 19.

Mehr

Erster Sortier-Algorithmus: Bubblesort

Erster Sortier-Algorithmus: Bubblesort Erster Sortier-Algorithmus: Bubblesort Die Idee des Algo: Vergleiche von links nach rechts jeweils zwei Nachbarelemente und vertausche deren Inhalt, falls sie in der falschen Reihenfolge stehen; Wiederhole

Mehr

Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen Algorithmen und Datenstrukturen Prof. Martin Lercher Institut für Informatik Heinrich-Heine-Universität Düsseldorf Algorithmen und Datenstrukturen Teil 3 Suchen in Listen Version vom: 15. November 2016

Mehr

Suchen und Sortieren Sortieren. Heaps

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

Mehr