Sortierverfahren

1. Sortierverfahren Klaus Becker 2012

2. Sortierverfahren

3. Teil 1 Einen Datenbestand durchsuchen

4. Einen Datenbestand durchsuchen Krause,Stefanie,Brandenburgische Str. 20,74343,Sachsenheim Brandt,Mandy,Scharnweberstrasse 84,68199,Mannheim Almenhof Möller,Jens,Schoenebergerstrasse 47,08313,Bernsbach Herzog,Marco,Scharnweberstrasse 90,61130,Nidderau Schmitz,Andreas,Meininger Strasse 84,66539,Neunkirchen Ludwigsthal Ebersbacher,Michelle,Alt-Moabit 10,06691,Zeitz Koertig,Christine,Hardenbergstraße 82,66887,Niederalben Schmidt,Vanessa,Paderborner Strasse 44,86359,Gersthofen Meister,Stephan,Fasanenstrasse 17,22605,Hamburg Othmarschen ... Aachen,Anke,Reeperbahn 11,18201,Bad Doberan Aachen,Dirk,Schmarjestrasse 80,33619,Bielefeld Innenstadt Aachen,Anne,Gotzkowskystraße 77,75179,Pforzheim Nordweststadt Abend,Kerstin,Lietzensee-Ufer 71,91217,Hersbruck Abend,Kristin,Marseiller Strasse 44,21775,Steinau Abend,Niklas,Knesebeckstraße 24,45770,Marl Abend,Stephanie,Albrechtstrasse 42,55469,Oppertshausen Abend,Annett,Ufnau Strasse 29,87640,Biessenhofen Abend,Alexander,Budapester Straße 12,18273,Gleviner Burg ... gesucht: Katja Herrmann aus Queidersbach gesucht: Katja Herrmann aus Queidersbach

5. Algorithmische Suche - unsortierte Liste Krause,Stefanie,Brandenburgische Str. 20,74343,Sachsenheim Brandt,Mandy,Scharnweberstrasse 84,68199,Mannheim Almenhof Möller,Jens,Schoenebergerstrasse 47,08313,Bernsbach Herzog,Marco,Scharnweberstrasse 90,61130,Nidderau Schmitz,Andreas,Meininger Strasse 84,66539,Neunkirchen Ludwigsthal Ebersbacher,Michelle,Alt-Moabit 10,06691,Zeitz Koertig,Christine,Hardenbergstraße 82,66887,Niederalben Schmidt,Vanessa,Paderborner Strasse 44,86359,Gersthofen Meister,Stephan,Fasanenstrasse 17,22605,Hamburg Othmarschen ... Aufgabe: (a) Entwickle einen Algorithmus, mit dem man in der gezeigten Datenliste nach einer Person mit einem vorgegebenen Nachnamen suchen kann. Wenn der übergebene Name in der Datenliste vorkommt, dann soll der Index des zugehörigen Datensatzes zurückgegeben werden. Kommt der Name mehrfach vor, dann soll der Index des ersten passenden Datensatzes zurückgegeben werden. Kommt der Name in der Datenliste nicht vor, dann soll der Index -1 zurückgegeben werden. (b) Implementiere den Algorithmus und teste ihn. (siehe auch I:1.19.1.1.1) unsortierte Daten

6. Algorithmische Suche - sortierte Liste Aachen,Anke,Reeperbahn 11,18201,Bad Doberan Aachen,Dirk,Schmarjestrasse 80,33619,Bielefeld Innenstadt Aachen,Anne,Gotzkowskystraße 77,75179,Pforzheim Nordweststadt Abend,Kerstin,Lietzensee-Ufer 71,91217,Hersbruck Abend,Kristin,Marseiller Strasse 44,21775,Steinau Abend,Niklas,Knesebeckstraße 24,45770,Marl Abend,Stephanie,Albrechtstrasse 42,55469,Oppertshausen Abend,Annett,Ufnau Strasse 29,87640,Biessenhofen Abend,Alexander,Budapester Straße 12,18273,Gleviner Burg ... Aufgabe: (a) Betrachte verschiedene Szenarien. Wann kann man jeweils die Suche abbrechen, wenn man die Daten des Datenbestandes der Reihe nach durchläuft? (b) Passe den Suchalgorithmus entsprechend an. Implementiere und teste ihn anschließend. (siehe auch I:1.19.1.1.1) sortierte Daten

7. Algorithmische Suche - sortierte Liste def suchen(name, liste): indexErgebnis = -1 gefunden = False links = 0 rechts = len(liste)-1 while not gefunden and links <= rechts: mitte = (links + rechts) // 2 if name == liste[mitte][0]: gefunden = True indexErgebnis = mitte elif name < liste[mitte][0]: rechts = mitte-1 else: links = mitte+1 return indexErgebnis Aufgabe: Die folgende (in Python implementierte) Funktion benutzt ein Suchverfahren, das den Namen "binäre Suche" hat. (a) Beschreibe den hier zu Grunde liegenden Algorithmus in eigenen Worten. Verdeutliche ihn auch anhand von Beispielen. (b) Teste die Funktion mit dem gegebenen Datenbestand. (siehe auch I:1.19.1.1.1) binäre Suche

8. Algorithmische Suche - sortierte Liste Aufgabe: Das Suchverfahren "binäre Suche" kann man auch mit einem rekursiven Algorithmus beschreiben. Entwickle diesen Algorithmus (oder recherchiere ihn im Internet). Implementiere den Algorithmus anschließend und teste ihn.

9. Lineare Suche - unsortierte Liste Suche: Ko Ergebnis: 5 Gr, Lo, Br, Mi, Sc, Ko, Fr, Be, Ke, Na, Eb, Kr, Wi, Sc, He, Suche: Ga Ergebnis: -1 Gr, Lo, Br, Mi, Sc, Ko, Fr, Be, Ke, Na, Eb, Kr, Wi, Sc, He, def suchen(name, liste): gefunden = False indexErgebnis = -1 i = 0 while i < len(liste) and not gefunden: if name == liste[i][0]: gefunden = True indexErgebnis = i else: i = i+1 return indexErgebnis

10. Lineare Suche - sortierte Liste Suche: Ko Ergebnis: 7 Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Suche: Ga Ergebnis: -1 Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Suche: Ta Ergebnis: -1 Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, def suchen(name, liste): indexErgebnis = -1 i = 0 while i < len(liste) and name > liste[i][0]: i = i+1 if name == liste[i][0]: indexErgebnis = i return indexErgebnis

11. Binäre Suche - sortierte Liste Suche: Ga Ga, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Ga, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, def suchen(name, liste): indexErgebnis = -1 gefunden = False links = 0 rechts = len(liste)-1 while not gefunden and links <= rechts: mitte = (links + rechts) // 2 if name == liste[mitte][0]: gefunden = True indexErgebnis = mitte elif name < liste[mitte][0]: rechts = mitte-1 else: links = mitte+1 return indexErgebnis Ga, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Ga, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi,

12. Binäre Suche - sortierte Liste Suche: Ta Ta, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Ta, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, def suchen(name, liste): indexErgebnis = -1 gefunden = False links = 0 rechts = len(liste)-1 while not gefunden and links <= rechts: mitte = (links + rechts) // 2 if name == liste[mitte][0]: gefunden = True indexErgebnis = mitte elif name < liste[mitte][0]: rechts = mitte-1 else: links = mitte+1 return indexErgebnis Ta, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Ta, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi, Be, Br, Eb, Fr, Gr, He, Ke, Ko, Kr, Lo, Mi, Na, Sc, Sc, Wi,

13. Teil 2 Einen Datenbestand sortieren

14. Das Sortierproblem Krause,Stefanie,Brandenburgische Str. 20,74343,Sachsenheim Brandt,Mandy,Scharnweberstrasse 84,68199,Mannheim Almenhof Möller,Jens,Schoenebergerstrasse 47,08313,Bernsbach Herzog,Marco,Scharnweberstrasse 90,61130,Nidderau Schmitz,Andreas,Meininger Strasse 84,66539,Neunkirchen Ludwigsthal ... Aachen,Anke,Reeperbahn 11,18201,Bad Doberan Aachen,Dirk,Schmarjestrasse 80,33619,Bielefeld Innenstadt Aachen,Anne,Gotzkowskystraße 77,75179,Pforzheim Nordweststadt Abend,Kerstin,Lietzensee-Ufer 71,91217,Hersbruck Abend,Kristin,Marseiller Strasse 44,21775,Steinau ... Das Sortierproblem besteht darin, Verfahren zu entwickeln, die eine sortierte Anordnung von Datensätzen automatisiert erzeugen. Die einzige Voraussetzung, die die Daten erfüllen müssen, besteht darin, dass man sie nach einem Kriterium vergleichen kann. Es soll also möglich sein, bei zwei Daten D1 und D2 (der Ausgangsdatenliste) zu entscheiden, ob (nach dem vorgegebenen Vergleichskriterium) D1 kleiner als D2 oder D2 kleiner als D1 ist oder ob D1 und D2 bzgl. des Vergleichskriterium gleichwertig sind.

15. Das Sortierproblem - formal betrachtet Gegeben ist eine Liste von Datensätzen [D0, D1, ..., Dn-2, Dn-1]. Die Datensätze sollen über eine Ordnungsrelation < verglichen werden können. Es soll also möglich sein, Vergleiche wie D0 < D1 eindeutig zu entscheiden. Mit der Ordnungsrelation ≤ erfassen wir die Möglichkeit, dass zwei Datensätze in dem zu vergleichenden Merkmal übereinstimmen können. Es soll D1 ≤ D0 gelten, wenn D0 < D1 nicht gilt. Gesucht ist eine neue Anordnung der Datensätze [Dp(0), Dp(1), ..., Dp(n-2), Dp(n-1)] mit der Eigenschaft, dass Dp(0) ≤ Dp(1) ≤ ... ≤ Dp(n-2) ≤ Dp(n-1) gilt. Die neue Anordnung der Datensätze wird hier durch eine bestimmte Anordnung (man sagt auch Permutation) p(0), p(1), ..., p(n-2), p(n-1) der Indexwerte 0, 1, ..., n-2, n-1 beschrieben.

16. Entwicklung von Sortierverfahren Aufgabe ist es im Folgenden, ein (oder mehrere) Sortierverfahren zu entwickeln. Für die Entwicklung von Sortierverfahren spielt die Komplexität der Daten keine zentrale Rolle. Wir gehen daher im Folgenden von einfachen Daten (hier Zahlen) aus. 25 17 32 56 25 19 8 66 29 6 20 29 6 8 17 19 20 25 25 29 29 32 56 66

17. Vorgehen wie ein Computer Ein Computer hat (in der Regel) keinen Überblick über alle Daten. Er kann zudem (in der Regel) nicht so intelligent wie ein Mensch agieren. Um die Arbeitsweise eines Computers zu simulieren, legen wir Regeln fest, die beim Sortieren beachtet werden müssen. Zunächst einmal werden alle Karten umgedreht. Der "Sortierer" hat keine Gesamtsicht auf alle Daten. 25 17 32 56 25 19 8 66 29 6 20 29

18. Spielregeln Regel 1: Karten umdrehen: 25 17 32 56 25 19 8 66 29 6 20 29 Regel 2: 2 Karten vergleichen und in Abhängigkeit des Ergebnisses weiteragieren: ? < 25 17 32 56 25 19 8 66 29 6 20 29 Regel 3: Karten markieren (es dürfen auch mehrere unterscheidbare Marken benutzt werden): 25 17 32 56 25 19 8 66 29 6 20 29

19. Spielregeln Regel 4: Eine Karte an eine andere Stelle verschieben: 25 17 32 56 19 8 66 29 6 20 29 25 Regel 5: Karten austauschen (d.h. zwei Karten geeignet verschieben): 25 17 32 56 19 8 66 29 6 20 29 Weitere (sinnvolle) Regeln können nach Bedarf eingeführt werden.

20. Teil 3 Sortieralgorithmen

21. Sortierverfahren Es gibt zahlreiche Verfahren, um Datensätze zu sortieren. Wir werden uns im Folgenden auf 4 Standardverfahren konzentrieren.

22. Selectionsort (Sortieren d. Auswählen) Wie sortieren Kartenspieler ihre Spielkarten? Auf YouTube wird ein Verfahren gezeigt, das Selectionsort genannt wird. Schaue dir das Video genau an. Kannst du die Grundidee des benutzten Sortierverfahrens beschreiben?

23. 25 17 32 56 25 19 8 66 29 6 20 29 25 17 32 56 25 19 8 66 29 20 29 6 25 17 32 56 25 19 66 29 20 29 6 8 25 32 56 25 19 66 29 20 29 6 8 17 Selectionsort (Sortieren d. Auswählen) Idee: Suche jeweils das kleinste Element im unsortierten Bereich und lege es am Ende des sortierten Bereichs ab.

24. 25 17 32 56 25 19 8 66 29 6 20 29 25 17 32 56 25 19 8 66 29 20 29 6 25 17 32 56 25 19 66 29 20 29 6 8 6 8 17 25 32 56 25 19 66 29 20 29 Selectionsort (Sortieren d. Auswählen) Realisierung mit 2 Listen ALGORITHMUS selectionsort Übergabe: Liste L unsortierter Bereich ist die gesamte Liste L der sortierte Bereich ist zunächst leer SOLANGE der unsortierte Bereich noch Elemente hat: suche das kleinste Element im unsortierten Bereich entferne es im unsortierten Bereich füge es im sortierten Bereich an letzter Stelle an Rückgabe: sortierter Bereich

25. 25 17 32 56 25 19 8 66 29 6 20 29 25 17 32 56 25 19 8 66 29 20 29 6 25 17 32 56 25 19 66 29 20 29 6 8 6 8 17 25 32 56 25 19 66 29 20 29 Selectionsort (Sortieren d. Auswählen) Realisierung mit 2 Listen ALGORITHMUS selectionsort Übergabe: Liste L unsortierter Bereich ist die gesamte Liste L der sortierte Bereich ist zunächst leer SOLANGE der unsortierte Bereich noch Elemente hat: suche das kleinste Element im unsortierten Bereich entferne es im unsortierten Bereich füge es im sortierten Bereich an letzter Stelle an Rückgabe: sortierter Bereich

26. Insertionsort (Sortieren d. Einfügen) Auf YouTube gibt es eines interessantes Video zum Sortieren durch Einfügen. Schaue dir das Video genau an. Wie gehen die Tänzer beim Sortieren vor? Kannst du die Grundidee des benutzten Sortierverfahrens beschreiben?

27. Insertionsort (Sortieren d. Einfügen) Idee: Füge jeweils das erste Element des unsortierten Bereichts an der richtigen Stelle im sortierten Bereich ein. 25 17 32 56 25 19 8 66 29 6 20 29 32 56 25 19 8 66 29 6 20 29 17 25 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 25 56 19 8 66 29 6 20 29 17 25 32

28. 25 17 32 56 25 19 8 66 29 6 20 29 32 56 25 19 8 66 29 6 20 29 17 25 17 25 32 56 25 19 8 66 29 6 20 29 56 25 19 8 66 29 6 20 29 17 25 32 25 56 19 8 66 29 6 20 29 17 25 32 Insertionsort (Sortieren d. Einfügen) Realisierung mit 2 Listen ALGORITHMUS insertionsort Übergabe: Liste sortierter Bereich besteht aus dem ersten Element der Liste unsortierter Bereich ist die Restliste (ohne das erste Element) SOLANGE der unsortierte Bereich Elemente hat: entferne das erste Element aus dem unsortierten Bereich füge es an der richtigen Stelle im sortierten Bereich ein Rückgabe: sortierter Bereich

29. 25 17 32 56 25 19 8 66 29 6 20 29 32 56 25 19 8 66 29 6 20 29 17 25 17 25 32 56 25 19 8 66 29 6 20 29 56 25 19 8 66 29 6 20 29 17 25 32 32 56 19 8 66 29 6 20 29 17 25 25 Insertionsort (Sortieren d. Einfügen) Realisierung mit 1 Liste ALGORITHMUS insertionsort Übergabe: Liste sortierter Bereich besteht aus dem ersten Element der Liste unsortierter Bereich ist die Restliste (ohne das erste Element) SOLANGE der unsortierte Bereich Elemente hat: füge das erste Element des unsortierten Bereichs an der richtigen Stelle im sortierten Bereich ein verkleinere den unsortierten Bereich Rückgabe: sortierter Bereich

30. Bubblesort (Sortieren d. Aufsteigen) Auf YouTube gibt es eines interessantes Video zum Sortieren. Schaue dir das Video genau an. Wie gehen die Lego-Arbeiter beim Sortieren vor? Kannst du die Grundidee des benutzten Sortierverfahrens beschreiben?

31. Bubblesort (Sortieren d. Aufsteigen) Idee: Durchlaufe (mehrfach) den gesamten Bereich. Vergleiche jeweils zwei benachbarte Element und vertausche sie, wenn die Reihenfolge nicht stimmt. 32 25 17 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 25 56 19 8 66 29 6 20 29 ... 17 25 32 25 19 8 56 29 6 20 29 66

32. 25 17 32 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 56 25 19 8 66 29 6 20 29 17 25 32 25 56 19 8 66 29 6 20 29 ... 17 25 32 25 19 8 56 29 6 20 29 66 Bubblesort (Sortieren d. Aufsteigen) ALGORITHMUS bubblesort Übergabe: Liste unsortierter Bereich ist zunächst die gesamte Liste SOLANGE der unsortierte Bereich mehr als ein Element hat: duchlaufe den unsortierten Bereich von links nach rechts wenn dabei zwei benachbarte Elemente in der falschen Reihenfolge vorliegen: vertausche die beiden Elemente verkürze den unsortierten Bereich durch Weglassen des letzten Elements Rückgabe: überarbeitete Liste Realisierung mit 1 Liste

33. Quicksort (Sortieren d. Zerlegen) Eine Person (z.B. die erste in der Reihe) wird als Vergleichsperson ausgewählt. Im vorliegenden Beispiel ist das Anton. Anton 1.74 Britta 1.64 Carlo 1.85 Durs 1.89 Georg 1.78 Fiona 1.67 Greta 1.61 Fabian 1.92 Hannah 1.58 Igor 1.70 Jana 1.78 Eli 1.74 Alle anderen ordnen sich links bzw. rechts von der Vergleichsperson ein, je nachdem, ob sie kleiner oder größergleich als die Vergleichsperson sind. Anton 1.74 Britta 1.64 Fiona 1.67 Greta 1.61 Hannah 1.58 Igor 1.70 Carlo 1.85 Durs 1.89 Fabian 1.92 Jana 1.78 Georg 1.78 Eli 1.74

34. Quicksort (Sortieren d. Zerlegen) Anton bleibt jetzt auf seiner Position. Er nimmt nicht mehr an weiteren Spielrunden teil. Dasselbe Spiel wird jetzt im linken und im rechten Bereich durchgeführt: Eine Person (z.B. die erste in der Reihe) wird wiederum als Vergleichsperson ausgewählt. Britta 1.64 Anton 1.74 Carlo 1.85 Fiona 1.67 Greta 1.61 Hannah 1.58 Igor 1.70 Durs 1.89 Fabian 1.92 Jana 1.78 Georg 1.78 Eli 1.74 Wie geht das Spiel weiter? Wann ist das Spiel beendet? Welche Extremfälle können während des Spiels auftreten? Funktioniert das Sortierspiel dann auch noch?

35. Quicksort (Sortieren d. Zerlegen) Idee: Ein Element der Liste (z.B. das erste Element) wird ausgewählt. Die Restliste wird dann gemäß dieses Elements in zwei Teillisten aufgeteilt: die Liste der Elemente der Restliste, die kleiner als das ausgewählte Element sind sowie die Liste der Elemente der Restliste, die nicht kleiner (d.h. größer oder gleich) als das ausgewählte Element sind. Dieser Vorgang wird mit den Teillisten völlig analog fortgesetzt. 25 17 32 56 25 19 8 66 29 6 20 29 Zerlegen 17 19 8 6 20 25 32 56 25 66 29 29 Zerlegen Zerlegen ... ... Zusammens. Zusammens. 6 8 17 19 20 25 25 29 29 32 56 66 Zusammensetzen 6 8 17 19 20 25 25 29 29 32 56 66

36. Quicksort (Sortieren d. Zerlegen) ALGORITHMUS quicksort Übergabe: Liste L wenn die Liste L mehr als ein Element hat: # zerlegen wähle als Pivotelement p das erste Element der Liste aus erzeuge Teillisten K und G aus der Restliste (L ohne p) mit: - alle Elemente aus K sind kleiner als das Pivotelement p - alle Elemente aus G sind größergleich als das Pivotelement p # Quicksort auf die verkleinerten Listen anwenden KSortiert = quicksort(K) GSortiert = quicksort(G) # zusammensetzen LSortiert = KSortiert + [p] + GSortiert Rückgabe: LSortiert Realisierung mit mehreren Listen

37. Quicksort (Sortieren d. Zerlegen) - alt. Eine Person (z.B. die erste in der Reihe) wird als Vergleichsperson ausgewählt.Suche von links eine Person, die größergleich als die ausgewählte Person ist. Suche von rechts eine Person, die kleinergleich als die ausgewählte Person ist. Britta 1.64 Durs 1.89 Georg 1.78 Fiona 1.67 Greta 1.61 Fabian 1.92 Hannah 1.58 Anton 1.74 Carlo 1.85 Jana 1.78 Igor 1.70 Eli 1.75 Wenn "links < rechts": Personen tauschen ihre Position in der Reihe. Anton 1.74 Eli 1.75 Britta 1.64 Carlo 1.85 Georg 1.78 Fiona 1.67 Greta 1.61 Fabian 1.92 Hannah 1.58 Durs 1.89 Jana 1.78 Igor 1.70 usw.

38. Quicksort (Sortieren d. Zerlegen) - alt. ALGORITHMUS quicksort Übergabe: Liste L wenn die Liste L nicht leer ist: # zerlegen wähle als Pivotelement p (z.B.) das erste Element der Liste aus tausche Elemente innerhalb L so, dass eine Zerlegung entsteht mit: - L = K + G alle Elemente aus K sind kleinergleich als das Pivotelement p alle Elemente aus G sind größergleich als das Pivotelement p K und G enthalten mindestens ein Element # Quicksort auf die verkleinerten Listen anwenden quicksort(K) quicksort(G) Rückgabe: L Realisierung mit 1 Liste

39. Quicksort (Sortieren d. Zerlegen) - alt. def quicksort(L, anfang, ende): if L != []: pivot = L[anfang] links = anfang rechts = ende while links <= rechts: while L[links] < pivot: links = links+1 while L[rechts] > pivot: rechts = rechts-1 if links <= rechts: if links < rechts: h = L[links] L[links] = L[rechts] L[rechts] = h links = links+1 rechts = rechts-1 if anfang < rechts: L = quicksort(L, anfang, rechts) if links < ende: L = quicksort(L, links, ende) return L >>> Quicksort: [21, 9, 20, 45, 5, 58, 40, 17] Quicksort: [17, 9, 20, 5] Quicksort: [5, 9] Quicksort: [20, 17] Quicksort: [45, 58, 40, 21] Quicksort: [21, 40] Quicksort: [58, 45] Implementierung mit 1 Liste

40. Quicksort (Sortieren d. Zerlegen) - alt. Quicksort [29, 17, 56, 6, 60, 41, 8, 25, 30, 20, 32, 19] Pivot: 29 [19, 17, 20, 6, 25, 8] [41, 60, 30, 56, 32, 29] Quicksort [19, 17, 20, 6, 25, 8] Pivot: 19 [8, 17, 6] [20, 25, 19] Quicksort [8, 17, 6] Pivot: 8 [6] [17, 8] Quicksort [17, 8] Pivot: 17 [8] [17] Quicksort [20, 25, 19] Pivot: 20 [19] [25, 20] Quicksort [25, 20] Pivot: 25 [20] [25] Quicksort [41, 60, 30, 56, 32, 29] Pivot: 41 [29, 32, 30] [56, 60, 41] Quicksort [29, 32, 30] Pivot: 29 [29] [29, 32, 30] Quicksort [32, 30] Pivot: 32 [30] [32] Quicksort [56, 60, 41] Pivot: 56 [41] [60, 56] Quicksort [60, 56] Pivot: 60 [56] [60]

41. Teil 4 Laufzeitverhalten

42. Zielsetzung Algorithmen stellen oft nur einen Zwischenschritt beim Problemlösen dar. In der Praxis ist man meist an Programmen - also Implementierungen von Algorithmen in einer Programmiersprache - interessiert, die von Rechnern real ausgeführt werden können. Dabei spielt der Ressourcenverbrauch (Laufzeitverhalten und Speicherplatzbelegung) der Programme eine zentrale Rolle. Erwünscht sind solche Programme, die mit möglichst wenig Ressourcen auskommen. Wir werden uns im Folgenden auf die Ressource "Rechenzeit" konzentrieren, da Speicherplatz heute für viele Problemlösungen genügend zur Verfügung steht. Laufzeitmessungen liefern wichtige Informationen über die Einsetzbarkeit von Programmen. Programme, bei denen man sehr lange auf Ergebnisse warten muss, sind - je nach Anwendungsgebiet - oft nicht praxistauglich. Ziel der folgenden Untersuchungen ist es, das Laufzeitverhalten von Sortieralgorithmen zu ermitteln und die Ergebnisse genauer zu analysieren.

43. Laufzeitmessungen from time import * print("Start") t1 = clock() # Ausführung des Programms ... t2 = clock() t = t2 - t1 print("Stopp") print("Rechenzeit: ", t) from time import * from random import randint # Sortieralgorithmus def selectionsort(L): ... # Initialisierung der Liste print("Aufbau der Testliste") anzahl = 100 L = [] for i in range(anzahl): L = L + [randint(1, 10*anzahl)] print(L) print("Start des Sortiervorgangs") # Sortierung der Liste t1 = clock() L_sortiert = selectionsort(L) t2 = clock() t = t2 - t1 print("Ende des Sortiervorgangs") # Ausgabe print(L_sortiert) print("Rechenzeit: ", t) Muster Beispiel

44. Systematische Laufzeitmessungen from time import * from random import randint # Sortieralgorithmus ... # Initialisierung der Anzahl der Listenelemente anzahl = 1000 while anzahl < 10000: # Erzeugung der Liste L = [] for i in range(anzahl): L = L + [randint(1, 10*anzahl)] # Bestimmung der Rechenzeit t1 = clock() L_sortiert = selectionsort(L) t2 = clock() t = t2 - t1 # Ausgabe des Messergebnisses print("Anz...: ", anzahl, "Rechenzeit: ", t) # Erhoehung der Anzahl anzahl = anzahl + 1000 >>> Anzahl der Listenelemente: 1000 Rechenzeit: 0.208472864568 Anzahl der Listenelemente: 2000 Rechenzeit: 0.82472800314 Anzahl der Listenelemente: 3000 Rechenzeit: 1.83589394742 Anzahl der Listenelemente: 4000 Rechenzeit: 3.3119754047 Anzahl der Listenelemente: 5000 Rechenzeit: 5.27956234661 Anzahl der Listenelemente: 6000 Rechenzeit: 7.45063213341 Anzahl der Listenelemente: 7000 Rechenzeit: 9.99217191012 Anzahl der Listenelemente: 8000 Rechenzeit: 13.1027999369 Anzahl der Listenelemente: 9000 Rechenzeit: 16.5563961341 Wir bestimmen die Laufzeit t(n) systematisch in Abhängigkeit der Listenlänge n für wachs-ende Listenlängen (z.B. n = 1000, 2000, ...). Beispiel

45. Laufzeitmessungen - Selectionsort Aufgabe: Führe selbst systematische Laufzeitmessungen durch (u.a. für Selectionsort und Quicksort). Versuche, anhand der Messwerte Gesetzmäßigkeiten aufzudecken (z.B.: Wie ändert sich t(n), wenn man n verdoppelt?) Benutze die Gesetzmäßigkeiten, um Vorhersagen zu treffen (z.B.: Wie lange dauert es, um ... Listenelemente zu sortieren?). Überprüfe deine Vorhersagen.

46. Laufzeitmessungen - Selectionsort Anzahl der Listenelemente: 1000 Rechenzeit: 0.204296356101 Anzahl der Listenelemente: 2000 Rechenzeit: 0.809496178984 Anzahl der Listenelemente: 3000 Rechenzeit: 1.83842583345 Anzahl der Listenelemente: 4000 Rechenzeit: 3.23999810032 Anzahl der Listenelemente: 5000 Rechenzeit: 5.16765678319 Anzahl der Listenelemente: 6000 Rechenzeit: 7.2468548377 Anzahl der Listenelemente: 7000 Rechenzeit: 9.91592506869 Anzahl der Listenelemente: 8000 Rechenzeit: 12.9162480148 Anzahl der Listenelemente: 9000 Rechenzeit: 16.3896752241 ... *2 *2 *2

47. Laufzeitmessungen - Quicksort Anzahl der Listenelemente: 1000 Rechenzeit: 0.0178980848125 Anzahl der Listenelemente: 2000 Rechenzeit: 0.0625291761942 Anzahl der Listenelemente: 3000 Rechenzeit: 0.133521718542 Anzahl der Listenelemente: 4000 Rechenzeit: 0.176368784301 Anzahl der Listenelemente: 5000 Rechenzeit: 0.351487409713 Anzahl der Listenelemente: 6000 Rechenzeit: 0.330103965727 Anzahl der Listenelemente: 7000 Rechenzeit: 0.58496680444 Anzahl der Listenelemente: 8000 Rechenzeit: 0.854964248249 Anzahl der Listenelemente: 9000 Rechenzeit: 0.942683218119 ... # ALGORITHMUS quicksort(L) wenn die Liste L mehr als ein Element hat: # zerlegen wähle als Pivotelement p das erste Element d. Liste aus erzeuge Teillisten K und G aus "L ohne p" mit - alle Elemente aus K sind kleiner als das Pivotelement p - alle Elemente aus G sind nicht kleiner als p # Quicksort auf die verkleinerten Listen anwenden KSortiert = quicksort(K) GSortiert = quicksort(G) # zusammensetzen LSortiert = KSortiert + [p] + GSortiert # Rückgabe: LSortiert *2 *2 *2

48. Laufzeitmessungen - Quicksort Anzahl der Listenelemente: 1000 Rechenzeit: 0.00662849607981 Anzahl der Listenelemente: 2000 Rechenzeit: 0.0137794049244 Anzahl der Listenelemente: 3000 Rechenzeit: 0.0227299838387 Anzahl der Listenelemente: 4000 Rechenzeit: 0.031230226188 Anzahl der Listenelemente: 5000 Rechenzeit: 0.0419377323096 Anzahl der Listenelemente: 6000 Rechenzeit: 0.0518194351517 Anzahl der Listenelemente: 7000 Rechenzeit: 0.0589655947893 Anzahl der Listenelemente: 8000 Rechenzeit: 0.069147894495 Anzahl der Listenelemente: 9000 Rechenzeit: 0.0784993623491 ... # ALGORITHMUS quicksort(L) wenn die Liste L mehr als ein Element hat: # zerlegen wähle als Pivotelement p das erste Element d. Liste aus tausche Elemente innerhalb L so, dass eine Zerlegung L = K + [p] + G entsteht mit - alle Elemente aus K sind kleiner als Pivotelement p - alle Elemente aus G sind nicht kleiner als p # Quicksort auf die verkleinerten Listen anwenden quicksort(K) quicksort(G) # Rückgabe: L *2 *2 *2

49. Schwierigkeiten bei Laufzeitmessungen Start Stopp Rechenzeit: 3.27038296767 Start Stopp Rechenzeit: 3.23336066455 Start Stopp Rechenzeit: 3.25390210208 Start Stopp Rechenzeit: 3.2653359575 Start Stopp Rechenzeit: 3.24174441165 Start Stopp Rechenzeit: 3.25976206473 Start Stopp Rechenzeit: 3.2584529598 Start Stopp Rechenzeit: 3.26073537279 Start Stopp Rechenzeit: 3.23565201723 Start Stopp Rechenzeit: 3.23315561056 Selectionsort - wiederholte Durchführung einer Laufzeitmessung Start Stopp Rechenzeit: 3.2807468547 Start Stopp Rechenzeit: 3.41092736647 Start Stopp Rechenzeit: 3.4124093984 Start Stopp Rechenzeit: 5.37245627587 Start Stopp Rechenzeit: 6.69305316737 Start Stopp Rechenzeit: 6.70120168904 Start Stopp Rechenzeit: 6.67988976253 Start Stopp Rechenzeit: 6.67656727321 Start Stopp Rechenzeit: 6.70371150523 Start Stopp Rechenzeit: 4.73779544607 Selectionsort - wiederholte Durchführung einer Laufzeitmessung

50. Problematik von Laufzeitmessungen Laufzeitmessungen werden in der Praxis durchgeführt, um das Laufzeitverhalten eines Programms unter Realbedingungen zu ermitteln. Aus systematisch durchgeführten Laufzeitmessungen kann man oft Gesetzmäßigkeiten erschließen, wie die Laufzeit von den zu verarbeitenden Daten abhängt. Bei Laufzeitmessungen muss man aber sehr genau darauf achten, dass sie unter gleichen Bedingungen erfolgen. Ein Wechsel des Rechners führt in der Regel zu anderen Ergebnissen. Auch Änderungen in der Implementierung wirken sich in der Regel auf die Messergebnisse aus. Selbst bei ein und demselben Rechner und derselben Implementierung können sich die Bedingungen ändern, da oft mehrere Prozesse gleichzeitig ablaufen. Ergebnisse von Laufzeitmessungen sind also kaum auf andere Systeme (andere Rechner, andere Programmiersprachen) übertragbar. Um diese Schwierigkeit zu überwinden, soll im Folgenden ein anderer Weg zur Beschreibung der Berechnungskomplexität beschritten werden.