in eine Folge ai, so daß bezgl. einer Ordnung gilt: a a, j < n

Transkript

1 6. Sortieren Umordnen von Objekten a in eine Folge ai,..., ai n, so daß bezgl. einer Ordnung gilt: a a, j < n Begriffe: ij i j + ) Stabilität : Ein Sortierverfahren heißt stabil, falls die relative Reihenfolge gleichrangiger Objekte nicht verändert wird, d. h. i j < ik, falls ai = a j i und j < k. k Wichtig für vorsortierte Datenmengen! Z. B. erst Sortierung nach Vornamen, dann Sortierung nach Namen Sortierung nach Vornamen soll erhalten bleiben. 2) Internes Sortieren : Datenmenge befindet sich währ des Sortierens vollständig im Hauptspeicher. Externes Sortieren : Der größte Teil der Datenmenge befindet sich auf externen Speichern. 3) Zeitbedarf : Gem. Kap. 4 werden im worst-case mindestens O(n log n) Vergleiche benötigt. Forderung: Nur Sortierverfahren betrachten, die diese Schranke erreichen. Platzbedarf: Wenig zusätzlicher Speicher (Sortieren in-situ) Beispiele : Bubblesort intern ineffizient, Sortieren durch Mischen O(n log n) extern Klassifikation : Sortieren durch Abzählen Einfügen Austauschen Auswählen Mischen Bucketsort Shell-Sort Bubblesort Quicksort Heapsort sic Worstcase Laufzeit O(n 2 ) Average case O(n log n) Worstcase Laufzeit O(n log n) 6. Quicksort Gebräuchlichstes internes Sortierverfahren. (Hoare 962) Idee : Gegeben lineares Array A mit n Elementen a) Transportiere die n 2 kleinsten Elemente in die Feldelemente A[],..., A n 2 und die n 2 größten in die Feldelemente A n A n 2 +,..., [ ] b) We das Verfahren rekursiv auf die erste Hälfte an. c) We das Verfahren rekursiv auf die zweite Hälfte an. Def. Sei M = {m,..., m n } eine Menge mit einer Ordnung. Das Objekt x M mit der Eigenschaft {m i m i < x} {m i x < m i } heißt Median.

2 Beispiel : Algorithmus : procedure quick (l, r:...n); vor i, j:...n; x, w: Objekt; i:=l; j:=r; "Bestimme Median x in A[l]... A[r]"; repeat while A[i] < x do i:= i+; while A[j] > x do j:= j-; if i j then "tausche A[i] und A[j]"; i:= i+; j:= j- until i > j; if l < j then quick (l,j); if i < r then quick (i,r); Laufzeit: Durch den Median wird A jeweils in zwei gleichgroße Hälften geteilt. Nach O(log 2 n) Teilungsvorgängen sind die entstehen Arrays nur noch einelementig, und das Verfahren bricht ab. Der übrige Rumpf von quick benötigt O ((r-l) + M (r-l)) = O (n+m(n)), wobei M(n) die Zeit für das Bestimmen des Medians in einem Feld der Länge n ist. Folglich T quick (n) = O (n+m(n)) + 2 T n quick 2 Problem : M(n)? Der Median ist zwar in linearer Zeit zu bestimmen (s. Buch von Ottmann/Widmayer), das Verfahren ist jedoch aufwig. T quick (n) = O(n) + 2 T n quick = O(n log n) 2 Abschwächung : Wähle nicht in jedem Rekursionsschritt den Median, sondern irgein Element x. Wird x zufällig gewählt, so ist anzunehmen, daß es das Feld in zwei etwa gleichgroße Teile teilt. (Eine analoge Idee haben wir schon beim AVL-Baum benutzt: Ein weniger ausgeglichener Baum ist genauso gut wie ein exakt ausgeglichener. Hier bezieht sich jetzt die Ausgeglichenheit auf den Rekursionsbaum). Laufzeit dann : T(n) = O(n) + T(m) + T(n-m) m und n-m sind hier die Längen der beiden Teile des Arrays. m n 2

3 Sonderfälle : Es wird jeweils der Median gewählt: T(n) = O(n) + 2 T n = O(n log n) 2 Es wird jeweils das kleinste (oder größte) Element für x gewählt: T(n) = O(n) + T() + T(n-) = O(n 2 ) In diesem Falle wird also Quicksort zum Slowsort mit unbrauchbarer Laufzeit. ( Worst Case ). Dieser Fall tritt oft bei schon sortiertem Feld ein. Frage : Wie oft tritt der Worst case auf, wenn x in jedem rekursiven Aufruf zufällig gewählt wird? Annahmen : ) Zu sortieren sind die Zahlen,..., n. 2) Alle n! Anordnungen der Zahlen im Ausgangsfeld sind gleich wahrscheinlich 3) Als Median wählen wir immer a n. Folgerung : Wird quick für a aufgerufen, so folgt aus den Annahmen, daß jedes k mit k n mit gleicher Wahrscheinlichkeit /n an Position a n auftritt und daher als Median gewählt wird. Ist k Median, so werden durch die Aufteilung zwei Folgen der Längen k- und n-k erzeugt. Man kann nun zeigen, daß die Teilfolgen wieder zufällig sind. Rekursionsformel: T(0) = 0, T() = c T(n) n n (T(k-)+T(n-k)) + b n k= Mittelwert des Aufwands für alle Teilungen n 2: T(n) 2 n- n T(k) + b n k= Aufwand für Teilung Zeige nun: T(n) c n log n für hinreich großes c. Beweis durch Induktion: Induktionsanfang: n=,2 ist klar. 3

4 Induktionsvoraussetzung : Sei die Aussage wahr für alle i<n, also T(i) = c i log i für i<n Dann gilt: n 2 2c T( n) T( k) + b n = k log k + b n n k= n n / 2 n / 2 2c = [ n ]+ + n + k logk k log k n b n k= log n- k= 2 2 2c n n n n 3n 3n log n log n bn n c n n n n = log n + bn n = c nlogn c logn cn c + bn cn c c n log n + bn 4 2 Für c 4b: T(n) c n log n. Ergebnis : Im Mittel benötigt Quicksort O(n log n) Vergleiche zum Sortieren von n Zahlen. Praxis : Wähle Median aufgrund einer Stichprobe zufällig als Median von (a l, a (l+r)/2, a r ) Speicher : wird vor allem durch die Rekursionstiefe bestimmt: im schlimmsten Fall: O(n) im mittleren Fall: O(log n) Durch geschickte Implementierung läßt sich der Stach auch im worst-case auf O(log n) begrenzen. logn- 6.2 Bucketsort Sortierverfahren, das ohne Vergleiche auskommt und besondere Voraussetzungen an die zu sortieren Objekte stellt. Idee : Lege für jedes zu sortiere Objekt ein Bucket (Behälter, Eimer, Fach) an Lege jedes Objekt in das zugehörige Bucket (gleiche Objekte kommen in denselben Bucket) Gib die Buckets der Ordnung nach aus. 4

5 Voraussetzung : Der Grundtyp der zu sortieren Elemente muß lich (nicht zu groß) sein. Beispiel : Grundtyp... 0 Eingabe : Ausgabe : Algorithmus: Skalarer Grundtyp T=(t,..., t m ) var buckets: array [T] of integer for i:= t to t m do buckets [t i ] : = 0; while not eof do read (x); buckets [x] : = buckets [x] + ; for i : =t to t m do while buckets [t i ] > 0 do write (t i ); buckets [t i ] : = buckets [t i ] - Laufzeit: O(m+n+m) = O(m+n) Da m konstant, folgt Laufzeit O(n) Speicher: O(m) (bzw. O()) Anwung: sortieren von Zeichenfolgen (Radixsort), in lexikographischer Reihenfolge z.b. acd bad dca dba bcd Vorgehensweise: - Anlegen von 26 Buckets für die Buchstaben (+ Bucket für Leerzeichen) - Bucketsort n mit dem letzten Zeichen so oft aufrufen, wie das längste Wort lang ist. dba dca dca, dba, acd, bad, bcd bcd bad acd bad dba bad, dba, dca, acd, bcd bcd acd dca fi bcd dca acd bad dba acd, bad, bcd, dba, dca STOP 5

6 Bemerkung: In Kap. 4 wurde gezeigt, daß zum Sortieren mind. O(n log n) Vergleiche erforderlich sind. Bucketsort kommt ganz ohne Vergleiche aus. Wie geht das zusammen? Klar, Bucketsort ist kein allgemeines Sortierverfahren. Es nutzt zusätzliche Eigenschaften des zu sortieren Raumes aus; nicht jede zu sortiere Menge besitzt diese Eigenschaften. kein Widerspruch zwischen beiden Aussagen. Wichtig : Komplexitätsaussagen sind immer relativ zu den zur Verfügung stehen elementaren Operationen zu interpretieren. 6.3 Heapsort Merkmale: Sortieren durch Auswählen garantiertes O(n log n)-verfahren im Mittel schlechter als Quicksort (es gibt allerdings auch bessere Implementierungen) Idee: Man wählt in jedem Auswahlschritt das Maximum des verbleiben Feldes und gibt es aus. Die Auswahl ist so geschickt zu organisieren, daß ein O(n log n)-verfahren entsteht. Man bedient sich dazu - wie oft - eines binären Baums, den man als sog. Heap organisiert. Def.: Eine Folge von Objekten a heiß Heap, falls gilt: a j a 2j, a j a 2j+, für 2j, 2j+ n Folgerung: a = max a j j n, Beispiel: a 80 a a 3 a 4 a a 6 a 7 a 8 6 eindeutige Beziehung zwischen Array und Baum a a 2 a 3 a 4 a 5 a 6 a 7 a 8 Im folgen häufig Wechsel zwischen Argumentation auf Bäumen und Arrays. 6

7 Grundgerüst Algorithmus Heapsort: Annahme: Heap aus a gegeben. Methode: Solange Heap nicht leer tue Gib a aus; danach steht also das max (a 2 ) an Position. Entferne a aus dem Heap; Stelle Heap-Eigenschaft für die Schlüssel a 2 im Indexbereich...n- wieder her e. Problem Wiederherstellen der Heap-Bedingung: Offenbar liegen nach Entfernen von a zwei Heaps mit Wurzel a 2 und a 3 vor. Vorgehen : Man setzt das Element mit dem höchsten Index an die Positon. Dies verletzt im allgemeinen die Heap-Eigenschaft. Dann läßt man das Element im Heap absinken, indem man es solange immer wieder mit dem größeren der beiden Söhne vertauscht, bis beide Söhne kleiner sind oder das Element unten angekommen ist. Beispiel : Aus dem Heap oben wird 80 entfernt und 6 an seine Stelle gesetzt sink sink STOP Algorithmus : Wiederherstellen der Heap-Eigenschaft: für a,... a m+ Setze a m+ an die Stelle von a ; Solange a i hat linken Sohn tue wenn a i hat rechten Sohn dann a j :=Sohn von a i mit größerem Wert; wenn a i < a j dann vertausche a i und a j ; i:=j sonst STOP e e. Für die gültige Implementierung fehlt noch der Aufbau des ersten Heaps. Die Vorgehensweise ist klar: Man versenkt die zu sortieren Elemente nacheinander im Heap. Das Programm: [Floyd 964] procedure sink (i, t: integer) j Absinken des Elements i im Bereich..t var j, k: integer; j:=2 i; k:=j+; if j t then if A[i] A[j] then j:= i; if k t then if A[k] > A[j] then j:=k; if i j then vertausche A[i] und A[j] ; sink (j, t). 7

8 Hauptprogramm Sortieren: {Aufbau eines Heap} for i:=(n div 2) downto do sink (i, n); {Sortieren} for m:=n downto 2 do vertausche A[] und A[m] ; sink (, m-) Hier wird ausgenutzt, daß die Elemente a,..., n / 2 + an bereits jeweils die Heap-Eigenschaft besitzen. Daher nt die Schleife bei i=n div 2. Analyse : Die Laufzeit von Heapsort wird wesentlich durch die Laufzeit von sink bestimmt. Beim Versickern werden Elemente bis max. zu den Blättern durch fortlfd. Vertauschen transportiert. Bei n Objekten beträgt die Höhe des Baumes O(log n). Jeder Versickerungsprozeß benötigt also O(log n) Schritte im worst-case. Der Aufbau eines Heaps benötigt also O(n log n) [tatsächlich: O(n), wenn man genauer nachrechnet] Das Sortieren ebenfalls O(n log n), da genau n Versickerungsschritte auszuführen sind. Bemerkungen : Heapsort ist ein echtes in-situ-verfahren, da es nur konstant viel Speicher zusätzlich benötigt (, anders als die gängigen Varianten von Quicksort). Für Heapsort spielt die Vorsortierung (anders als bei gängigen Versionen von Quicksort) der Daten keine Rolle. Heapsort ist nicht stabil. 8