Sortieren

Ziel: Bringe Folge von Objekten in eine bestimmte Reihenfolge

Beispiel

(Muller, Darmstadt, 456)(Meier, Wiesbaden,123 )(Schmitt, Frankfurt, 789)(Adam, Hamburg, 999)

Aufsteigend nach Namen sortiert:

(Adam, Hamburg, 999)(Meier, Wiesbaden, 456)(Muller, Darmstadt, 123)(Schmitt, Frankfurt, 789)

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 1

Sortieren, Beispiel (2)

Aufsteigend nach Kundennummer sortiert:

(Muller, Darmstadt, 123)(Meier, Wiesbaden, 456)(Schmitt, Frankfurt, 789)(Adam, Hamburg, 999)

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 2

Sortieren

Eingabe: Liste von ObjektenVergleichsoperator auf den Objekten

Ausgabe: Liste der Objekte mit i.a. anderer Reihenfolge [a1, . . . an]so dass i j ai aj

Annahme: Ordnung ist transitiv, reflexiv, total,aber nicht notwendig antisymmetrisch

total : es gilt a b oder b a.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 3

Sortiermethoden

Annahme im Folgenden: Liste von Zahlen.

Wir betrachten:

Insert-Sort Sortieren durch EinfugenBubble-Sort Sortieren durch binares VertauschenMerge-Sort Sortieren durch rekursives MischenQuick-Sort Sortieren durch rekursive Zerlegung und Vergleichen

Es gibt noch weitere Sortierverfahren

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 4

Sortieren

Sortierprogramme in Haskell fur ListenDemonstration der PrinzipienAbschatzung der Komplexitat

Sortierprogramme in Python fur ArrayPrinzipien der destruktiven AbanderungIn-place-Algorithmen

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 5

Sortieren durch Einfugen (Insert-Sort)

Idee: geordnetes Einfugen der Elemente in die bereits sortierte Liste

Sortiere: 5,3,99,1,2,7

sortierte Liste restliche Elemente5 3,99,1,2,73,5 99,1,2,73,5, 99 1,2,71,3,5, 99 2,71,2,3,5, 99 71,2,3,5, 7, 99

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 6

Insert-Sort: Haskell-Programm

Sortieren durch Einfugen:

sorteinfuegen xs = sorteinfuegenr xs []

sorteinfuegenr: unsortierter Rest, sortierter Anteil

sorteinfuegenr [] ys = ys

sorteinfuegenr (x:xs) [] = sorteinfuegenr xs [x]

sorteinfuegenr (x:xs) ys = sorteinfuegenr xs (sorteinfuegenr1 x ys)

sorteinfuegenr1 x [] = [x]

sorteinfuegenr1 x (y:ys) =

if x

Sortieren mit Blasensort

(Bubble-Sort)

Vertauschung von benachbarten Elementen;

falls notwendig: Mehrfaches Durcharbeiten der Liste

5 3 99 1 2 75 3 99 1 2 75 3 99 1 2 75 3 1 99 2 75 1 3 99 2 71 5 3 99 2 71 5 3 99 2 71 5 3 99 2 71 5 3 2 99 71 5 2 3 99 71 2 5 3 99 7. . .

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 8

Bubble-Sort: Haskell-Programm

Sortieren durch Vertauschen von benachbarten Feldern

bubblesort [] = []

bubblesort [x] = [x]

bubblesort xs =

let y:resty = bubblesort1 xs

in y: (bubblesort resty)

bubblesort1 [x] = [x]

bubblesort1 (x:rest) =

let (y:resty) = bubblesort1 rest

in if x > y then y:x: resty

else (x: y:resty)

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 9

Bubble-Sort mit Optimierung:

Haskell-Programm

bubblesorto [] = []

bubblesorto [x] = [x]

bubblesorto xs =

let (aenderung,y:resty) = bubblesorto1 xs

in if aenderung then y: (bubblesorto resty)

else xs

bubblesorto1 [x] = (False,[x])

bubblesorto1 (x:rest) =

let (aenderung, y:resty) = bubblesorto1 rest

in if x > y then (True,y:x: resty)

else (aenderung,x: y:resty)

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 10

Quicksort: Rekursives Zerlegen

Idee

Pivot = erstes Element der Liste:

Zerlege Liste in Teillisten von Elemente, die bzgl Pivot:kleinere, grossere und gleiche Elemente enthalten

Sortiere diese rekursiv (Quicksort)

Fuge sie zusammen.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 11

Quicksort: Beispiel

Sortiere: 5,3,99,1,2,7

Pivot 5kleinere/groere Elte 3,1,2 99,7Pivots 1 | 99kleinere/groere Elte 2,3 | 7 -Pivots 2 |kleinere/groere Elte 3 |Zusammensetzen: 1,2,3,5,7,99

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 12

Sortieren mit Quicksort: Haskell-Programm

quicks [] = []

quicks [x] = [x]

quicks [x,y] = if x

Mergesort: Sortieren durch Mischen

Rekursives Verfahren: Zerlege Liste in erste und zweite Halftesortiere beide rekursivzusammenmischen

Sortiere: 5,3,99,1,2,7

Zerlegen 5,3,99 | 1,2,7Zerlegen 5 3,99 | 1 2,7

. . . | . . .. . . 5 3,99 | 1 2,7Merge 3,5,99 | 1,2,7Merge 1,2,3,5,7,99

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 14

Sortieren mittels Mischen: Haskell-Programm

mischsort xs = mergesort (length xs) xs

mergesort _ [] = []

mergesort _ [x] = [x]

mergesort _ [x,y] = if x

Sortieren: Mindestanzahl der Vergleiche

Satz Sortieren einer Liste von n Zahlen durch Vergleichsoperationen

benotigt im schlechtesten Fall mindestens n log2(n) Vergleiche.

Argumentation:

Ein Entscheidungsbaum-Programm zur Lange n sortiert eine Eingabe-

liste [a1, . . . , an] der Lange n folgendermaen:

An den Verzweigungen wird die Frage gestellt: ist ai > aj? fur be-

stimmte (feste) Indizes i, j,

die Ausgabe am Ende ist die sortierte Permutation der Eingabeliste.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 16

Sortieren: Mindestanzahl der Vergleiche

Es gibt immer eine Eingabeliste, so dass n log2(n) Vergleiche zumSortieren notig sind

Begrundung:

Der Entscheidungsbaum hat n! Blatter, da jede Eingabereihenfolge

moglich ist.

Die Tiefe d des Baumes > log2(n!).

Offenbar: n! 1 . . . 1 n/2

n/2 . . . n/2 n/2

= (n/2)(n/2).

log2(n!) > log((n/2)(n/2)) = 0.5 n llog(n/2) = 0.5 n (log2(n) 1).

D.h. (n llog2(n)).

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 17

Sortieren: Mindestanzahl der Vergleiche(3)

Abschatzung kann leicht verbessert werden

mittels der Stirlingformel fur n!.

Aber: Man konnte noch nicht allgemein nachweisen,

dass dies auch eine untere Schranke ist,

wenn man alle Algorithmen zulasst.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 18

Eigenschaften der Sortierverfahren

Zeitbedarf im schlechtesten Fall / besten Fall / im Mittel Stabilitat

Ein Sortierverfahren ist stabil,

wenn die Reihenfolge von Elementen mit gleichem Sortierschlussel

erhalten bleibt.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 19

Eigenschaften des Insert-Sort

Gut fur kleinere Listen, oder fast sortierte Listen

im schlechtesten Fall: O(n2):

Fur Listen der Lange n hochstens: 1 + 2 + . . . + (n 1) Vergleiche

im besten Fall: O(n) fur vorsortierte Listen.

Die Haskell-Implementierung ist stabil.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 20

Insert-Sort: Variante

Folgende Variante des Insert-sort ist stabil und hat Komplexitat O(n)

fur vorsortierte Listen:

sorteinfuegeno xs = reverse (sorteinfuegenor xs [])

sorteinfuegenor [] ys = ys

sorteinfuegenor (x:xs) [] = sorteinfuegenor xs [x]

sorteinfuegenor (x:xs) ys = sorteinfuegenor xs (sorteinfuegenor1 x ys)

sorteinfuegenor1 x [] = [x]

sorteinfuegenor1 x (y:ys) =

if x >= y then x:y:ys

else y : (sorteinfuegenor1 x ys)

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 21

Eigenschaften des Bubble-Sort

Gut: wenn Elemente schon in der Nahe ihres endgultigen Platzes sind.

im schlechtesten Fall: (n 1) + (n 2) + . . . + 1 = O(n2)

im besten Fall: O(n), wenn Liste schon sortiert

Stabil, wenn gleiche Elemente nicht vertauscht werden.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 22

Eigenschaften des Quicksort

im schlechtesten Fall: O(n2), wenn Liste bereits sortiert

im besten Fall: O(n log(n))

Im Mittel: O(n log(n))

Gut: wenn Listen gro und Werte zufallig verteilt.

Beim Experimentieren in Haskell mit zufallig erzeugten Listen ist es

das beste Verfahren

Haskell-Implementierung ist stabil,

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 23

Eigenschaften des Mischsort

im schlechtesten Fall: O(n log(n)).

Im besten Fall: auch O(n log(n)).

Gut: Wenn keine Komplexitats-Ausrutscher vorkommen sollen

Experiment: in Haskell ist es nur dann besser als Quicksort,

wenn Teile der Listen bereits sortiert sind.

Stabil, wenn der Merge Stabilitat beachtet:

D.h. wenn gleiche Elemente aus der linken Liste vor denen aus der

rechten Liste einsortiert werden.

Praktische Informatik 1, WS 2004/05, Folien Sortieren1, (14. Januar2005) Seite 24

Komplexitat des Mischsort

Genauere Begrundung

Behauptung: Mischsort hat einen Zeitbedarf von O(n log(n))

Abschatzung von redms:

redms(n) = c + redmische(n) + 2 redms(n/2)= c + n + 2 r