6. SORTIEREN

AlgorithmenundDatenstrukturen
6.SORTIEREN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
1
Problemstellungen
Sor-eren
§  GrundlegendesProbleminderInformaCk
§  Aufgabe:
w  OrdnenvonDateienmitDatensätzen,dieSchlüssel
enthalten
w  UmordnenderDatensätzeso,dassklardefinierteOrdnung
derSchlüssel(numerisch/alphabeCsch)besteht
§  Vereinfachung:nurBetrachtungderSchlüssel,z.B.
Feldvonint-Werten
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
2
Problemstellungen
Sor-eren-Grundbegriffe
§  Verfahren
w  Intern:inHauptspeicherstrukturen(Felder,Listen)
w  Extern:DatensätzeaufexternenMedien(Festpla5eetc.)
§  Annahmen
w  TotaleOrdnung(Zahlen,alphabeCsch,etc.)
w  Aufsteigend
w  PlatzbedarfkonstantfürjedesElement
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
3
Problemstellungen
Sor-eren-Problembeschreibung
Problem–Sor-erproblem
Eingabe:FolgevonZahlen⟨a1,…,an⟩
Ausgabe:PermutaCon⟨a1',…,an'⟩ derZahlenmitder
Eigenscha^:a1'≤a2'≤ …≤an'
§  SorCerungnacheinemSchlüssel(key),z.B.Zahlen
§  Übertragbar(inProgrammen)aufbeliebigeDatenstrukturen
(mitSchlüssel)
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
4
Problemstellungen
Stabilität
EinSorCerverfahrenheißtstabil,
wennesdierelaCveReihenfolgegleicherSchlüssel
inderDateibeibehält.
Beispiel:alphabeCschgeordneteListevonPersonensollnachAlter
sorCertwerden!PersonenmitgleichemAlterweiterhinalphabeCsch
geordnet:
Name
Alter
Name
Alter
Aristoteles
24
Platon
28
Sokrates
30
Theophrastos 28
Theophrastos
28
Sokrates
SorCeren
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
Aristoteles
24
Platon
28
5
30
AlgorithmenundDatenstrukturen
6.1ALGORITHMENFÜR
VERGLEICHSBASIERTESSORTIEREN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
6
Problemstellungen
VergleichsbasiertesSor-eren
•  WichCgsterSpezialfalldesSorCerproblems
•  ZurSorCerungkönnennurdirekte
VergleichezweierWertebenutztwerden
•  DerWertebereichderSchlüsselkannbeliebigsein
Problem:VergleichsbasiertesSorCeren
Eingabe:ArrayganzerZahlen
Ausgabe:SorCertesArrayderselbenZahlen
(Mehrfachvorkommenbleibenerhalten)
Anmerkung:einigeSorCerverfahrensindeffizienterwenn
Listenansta5Arraysbenutztwerden
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
7
Problemstellungen
Sor-erinterfaceinJava
public interface Sort {
/**
* sorts the given array.
* @param f- array to sort.
*/
public void execute(int[] f);
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
8
Allgemeines
ÜberblickSor-erverfahren
• 
• 
• 
• 
InserConSort
SelecConSort
MergeSort
QuickSort
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
9
AlgorithmenundDatenstrukturen
6.1.1INSERTIONSORT
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
10
Algorithmen
Sor-erendurchEinfügen:DasPrinzip
§  Idee
w Umsetzungdertypischenmenschlichen
Vorgehensweise,etwabeimSorCereneines
StapelsvonKarten:
1. StartemitdererstenKarteeinenneuenStapel
2. NimmjeweilsnächsteKartedesOriginalstapels:füge
dieseanderrichCgenStapelindenneuenStapelein
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
11
Algorithmen
Sor-erendurchEinfügen:Beispiel
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
12
Algorithmen
Sor-erendurchEinfügen:Algorithmus
class InsertionSort implements Sort{
}
f.lengthvieleElemente
imArrayvonPos.0
bisf.length-1
public void execute(int[] f) {
int m,j;
for (int i = 1; i < f.length; i++){
j = i;
m = f[i];
while (j > 0 && f[j-1] > m) {
/*verschiebe f[j-1] nach rechts */ Wennf[j-1]>m],
f[j] = f[j-1];
schiebef[j-1]nach
j--;
rechts
}
f[j] = m;
}
Setzef[i]an
}
PosiConf[j]
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
13
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusInserConSortterminiertfürjede
Eingabeint[]fnachendlicherZeit.
Beweis
DieLaufvariableiinderäußerenfor-Schleifewirdin
jedemDurchgangumeinserhöhtundwirddamit
irgendwanndieAbbruchbedingung(eineKonstante)
erreichen.DieLaufvariablejderinnerenwhile-Schleife
wirdinjedemDurchgangumeinsverringertundsomit
dieSchleifenbedingungj>0irgendwannnichtmehr
erfüllen.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
14
Analysen
Analyse
Theorem(Korrektheit)
DerAlgorithmusInserConSortlöstdasProblemdes
vergleichsbasiertenSorCerens.
Beweis:
Wirzeigen,dassdiefolgendeAussageeineInvariante
deräußerenfor-Schleifeist(d.h.sieistamEndeeines
jedenSchleifendurchgangsgülCg):
DasTeilarrayf[0..i]istsorCert
Damitgiltauch,dassnachAbbruchderfor-Schleifedas
Arrayf[0..n]=f(mitn=f.length-1)sorCertist.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
15
Analysen
Analyse
Zuzeigen:AmEndeeinesjedenDurchgangsder
äußerenfor-Schleifeistf[0..i]sorCert.
ZeigediesdurchIndukConnachi:
•  i=1:ImerstenDurchgangwirddasersteElementf[0]
mitdemzweitenElementf[1]verglichenundggfs.
getauschtumSorCerungzuerreichen(whileBedingung)
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
16
Analysen
Analyse
•  i→i+1:Angenommenf[0...i]istamAnfangder
äußerenfor-SchleifeimDurchgangi+1sorCert.
Inderwhile-SchleifewerdenElementesolangeeinen
Platzweiternachhintenverschoben,biseinIndexk
erreichtwird,sodassalleElementemitIndex0..k-1
kleiner/gleichdemursprünglichenElementanIndex
i+1sind(IndukConsbedingung)undalleElemente
mitIndexk+1...i+1größersind(while-Bedingung).
DasursprünglicheElementanIndexi+1wirddannan
PosiConkgeschrieben.Damitgilt,dassf[0...i+1]
sorCertist.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
17
Analysen
Aufwandsanalyse
§  AnzahlderVertauschungen
§  AnzahlderVergleiche
§  Vergleichedominieren
Vertauschungen,d.h.es
werden(wesentlich)mehr
Vergleicheals
VertauschungenbenöCgt
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
18
Analysen
Aufwandsanalyse(2)
§  BesterFall
w  ListeistschonsorCert
§  Mi5lerer(zuerwartender)
Fall
w  ListeunsorCert
§  SchlechtesterFall
w  z.B.:Listeistabsteigend
sorCert
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
19
Analysen
Aufwandsanalyse(3)
§  WirmüsseninjedemFallalleElementei:=1bisn-1durchgehen,
d.h.immerFaktorn-1fürdieAnzahlderVergleiche
n=f.length
§  DannmüssenwirzurkorrektenEinfügeposiConzurückgehen
BesterFall:Listesor-ert
§  EinfügeposiConistgleichnacheinemSchri5
anPosiConi-1,d.h.AnzahlderVergleiche=Anzahlder
Schleifendurchläufe=n-1
§  BeijedemRückwegzurEinfügeposiCon:Faktor1
GesamtzahlderVergleiche:(n-1)‧1=n-1
FürgroßeListenabgeschätztalsn-1 ≈ n
§  „linearerAufwand“
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
20
Analysen
Aufwandsanalyse(4)
Mi]lerer(zuerwartender)Fall:Listeunsor-ert
§  EinfügeposiConwahrscheinlichaufHäl^edesRückweges
§  Aufwandsabschätzung
w  Beijedemdern-1Rückwege,addiere(i-1)/2Vergleiche
w  GesamtanzahlderVergleiche:
Gaußsche
Summenformel
fürk=1…n-1
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
21
Analysen
Aufwandsanalyse(5)
SchlechtesterFall:z.B.Listeumgekehrtsor-ert
§  EinfügeposiConamEndesdesRückwegsbeiPosiCon1
§  Beijedemdern-1Rückwegemüsseni-1Elementeverglichen
werden(d.h.allevorherigenElementef[1...i-1])
§  AnalogzuvorhergehendenÜberlegungen,bloßdoppelte
Rückweglänge
DarausergibtsichdieGesamtanzahlderVergleiche:
Gaußsche
Summenformel
fürk=1…n-1
LetztenbeidenFälle:„quadraCscherAufwand“,wennkonstante
FaktorennichtberücksichCgtwerden
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
22
Analysen
Aufwandsanalyse(6)
Theorem(Laufzeit)
DieAnzahlderVergleichsoperaConenvonInserConSort
istimbestenFallΘ(n)undimdurchschni5lichenund
schlechtestenFallO(n2).
Beweis
SieheVorüberlegungen.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
23
Algorithmen
Op-mierung
•  IndervorgestelltenVersion
desAlgorithmuswirddie
EinfügeposiConeines
Elementsdurch
(umgekehrte)sequenzielle
Suchegefunden
•  Verwendetmanhierbinäre
Suche(dasTeilarrayvor
demaktuellenElementist
sorCert!)kanndieAnzahl
derVergleichsoperaConen
gesenktwerdenzu
O(nlogn)
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
24
AlgorithmenundDatenstrukturen
6.1.2SELECTIONSORT
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
25
Algorithmen
Sor-erendurchSelek-on
§  Idee
w  SuchejeweilsgrößtenWertimArrayundtauschediesen
andieletzteStelle
w  Fahredannmitderum1kleinerenListefort
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
26
Algorithmen
Sor-erendurchSelek-on:Beispiel
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
27
Algorithmen
Sor-erendurchSelek-on
§  Idee:SuchejeweilsgrößtenWertundtauschediesenandie
letzteStelle,fahredannmitderum1kleinerenListefort
class SelectionSort implements Sort{
void execute (int[] f) {
int marker = f.length -1;
while (marker >= 0) {
/*bestimme größtes Element links v. Marker*/
int max = 0; /* Indexposition*/
for (int i = 1; i <= marker; i++){
if (f[i] > f[max])
max = i;
swap(f, marker, max);
marker--;
/*verkleinere Array */
}
}
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
28
Algorithmen
Sor-erendurchSelek-on(2)
§  Hilfsmethodeswap
w  vertauschezweiElementeimArray
void
swap(int[] f, int idx1, int idx2) {
int tmp = f[idx1];
f[idx1] = f[idx2];
f[idx2] = tmp;
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
29
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusSelecConSortterminiertfürjedeEingabe
int[]fnachendlicherZeit.
Beweis
DieVariablemarkerwirdzuAnfangdesAlgorithmusauf
einenposiCvenendlichenWertgesetztundinjedem
Durchgangderäußerenwhile-Schleifeum1verkleinert.
Abbruchderwhile-Schleifeerfolgt,wennmarkerkleiner0
ist,alsowirddiewhile-Schleifeendlicho^durchlaufen.Die
innerefor-SchleifehatinjedemDurchgangmarker-viele
(alsoendlichviele)Durchläufe.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
30
Analysen
Analyse
Theorem(Korrektheit)
DerAlgorithmusSelecConSortlöstdasProblemdes
vergleichsbasiertenSorCerens.
Beweis:
Übung
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
31
Analysen
Analyse
Theorem(Laufzeit)
DerAlgorithmusSelecConSorthateineLaufzeitvonΘ(n2).Diese
Laufzeitistdieselbefürdenbesten,mi5lerenundschlechtesten
Fall.
Beweis:
Dieäußerewhile-Schleifewirdgenaun-mal(n=f.length)
durchlaufen.DortwerdensomitnVertauschungen
vorgenommen(=jeweilskonstanterAufwand).DieinnereforSchleifehatimi-tenDurchlaufderwhile-Schleifen-iDurchläufe
mitjeweilseinemVergleich,deswegeninsgesamt
vieleVergleiche,alsoΘ(n2).
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
32
AlgorithmenundDatenstrukturen
6.1.3MERGESORT
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
33
Algorithmen
MergeSort:Prinzip
§  MergeSortisteinDivide-and-ConquerAlgorithmus
zumvergleichsbasiertenSorCeren
§  Idee:
1. TeilediezusorCerendeFolgeinzweiTeile
2. Sor-erebeideTeilegetrenntvoneinander
3. MischedieTeilergebnisseinderrichCgenReihenfolge
zusammen
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
34
Algorithmen
Beispiel
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
35
Algorithmen
Algorithmus
class MergeSort implements Sort{
void execute(int[] f) {
int[] tmpF = new int[f.length];
mergeSort(f, tmpF, 0, F.length -1);
}
private void mergeSort(int[] f, int[] tmpF, int left,int right){
if (left < right) {
int m = (left + right)/2;
mergeSort(f, tmpF, left, m);
mergeSort(f, tmpF, m+1, right);
merge(f, tmpF, left, m+1, right);
}
}
...
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
36
Algorithmen
Algorithmus(2)-merge
...
private void merge(int[] f, int[] tmpF, int startLeft,
int startRight, int endRight) {
int endLeft = startRight-1;
int tmpPos = startLeft;
int numElements = endRight – startLeft +1;
while (startLeft <= endLeft && startRight <= endRight)
if (f[startLeft] < f[startRight])
tmpF[tmpPos++] = f[startLeft++];
else
tmpF[tmpPos++] = f[startRight++];
while (startLeft <= endLeft)
tmpF[tmpPos++] = f[startLeft++];
while (startRight <= endRight)
tmpF[tmpPos++] = f[startRight++];
for (int i = 0; i < numElements; i++, endRight--)
f[endRight] = tmpF[endRight];
}
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
37
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusMergeSortterminiertfürjedeEingabeint[]f
nachendlicherZeit.
Beweis
Zeigezunächst,dassjederAufrufmergeSort(int[] f,
int[] tmpF, int left,int right)terminiert:
•  Fallsle^<rightnichtgilt,terminiertderAufrufsofort
•  AndernfallsrufenwirmergeSortrekursivauf,wobeientweder
le^einenechtgrößerenoderrighteinenechtkleinerenWert
erhält.InjedemFallwirdnacheinemgewissenrekursiven
AbsCegirgendwannle^<rightnichtmehrgelten.
TerminierungderMethodemergeistÜbung.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
38
Analysen
Analyse
Theorem(Korrektheit)
DerAlgorithmusMergeSortlöstdasProblemdes
vergleichsbasiertenSorCerens.
Beweis:
DurchIndukConnachn=f.length.Annahmen=2kfür
eineganzeZahlk.
•  n=1:Fürn=1istderersteAufrufdermergeSort
HilfsmethodemergeSort(f, tmpF, 0, 0)
undsomitgiltnichtle^<right.DieMethode
terminiertohneÄnderunganf.Diesistkorrekt,da
jedeseinelemenCgeArraysorCertist.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
39
Analysen
Analyse
•  n/2→n:Seif[0...n-1]einbeliebigesArray.Dererste
AufrufmergeSort(f, tmpF, 0, n-1) erfüllt
le^<rightundeswerdenfolgendeRekursiveAufrufe
getäCgt:
mergeSort(f, tmpF, 0, n/2-1) mergeSort(f, tmpF, n/2, n-1) BeideAufrufeerhalteneinArrayderLängen/2.Nach
IndukConsannahmegilt,dassanschliessendsowohl
f[0...n/2-1]alsauchf[n/2...n-1]separatsorCertsind.
Nochzuzeigenist,dassmergekorrektzwei
sorCerteArraysineinsorCertesArraymischt
(Übung)
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
40
Analysen
Analyse
Theorem(Laufzeit)
DerAlgorithmusMergeSorthateineLaufzeitvon
Θ(nlog2n).DieseLaufzeitistdieselbefürdenbesten,
mi5lerenundschlechtestenFall.
Beweis:
ErsteBeobachtung:dieMethodemergehateineLaufzeit
vonΘ(n)wobeindieLängedesgemischtenArraysist
(Übung).NunkannmanleichteineRekursionsgleichungfür
dieLaufzeitvonMergeSortT(n)angeben:
⇢
⇥(1)
n1
T (n) =
2T (n/2) + ⇥(n) sonst
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
41
Analysen
Analyse
T (n) =
⇢
⇥(1)
2T (n/2) + ⇥(n)
n1
sonst
AnwendungdesMaster-Theorems:
2.Fall:Wenn
dann
Hierista=2undb=2undesfolgtnlogba=nlog22=n1=n.
Esistzudemf(n)=nundesgiltfürk=0:
n∈Θ(nldkn)=Θ(n)
EsfolgtT(n)∈Θ(nldk+1n)=Θ(nldn).
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
42
AlgorithmenundDatenstrukturen
6.1.4QUICKSORT
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
43
Algorithmen
QuickSort:Prinzip
Idee:
§  Divide-and-ConquerundrekursiveAu^eilung(wiebei
MergeSort)
§  Aber:VermeidungdesMischvorgangs(speicherintensiv!)
1.  WähleeinElementderListeaus(z.B.dasletzte),dieses
nennenwirPivot-Element
2.  BesCmmediePosiCon,diedasPivot-Elementinder
vollständigsorCertenListehabenmuss
3.  BringedasPivot-ElementandiesePosiConundstellesicher,
dassallekleinerenElementelinksundallegrößerenElement
rechtsvonihmstehen
4.  FahrerekursivmitdenTeillistenrechtsundlinksfort
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
44
Algorithmen
QuickSort:Beispiel
f:
8
9
2
6
7
3
4
1
5
6
7
3
4
1
5
Wählef[8]=5alsPivot-Element
f:
8
9
2
SuchevonlinksanElemente,diekleinerdemPivot-Elementsind
f:
8
9
2
6
7
3
4
1
5
7
3
4
1
5
7
3
4
1
5
VertauschemitdemerstengrößerenElement
f:
2
9
8
6
SuchedasnächstekleinereElement
f:
2
9
8
6
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
45
Algorithmen
QuickSort:Beispiel
SuchedasnächstekleinereElement
f:
2
9
8
6
7
3
4
1
5
VertauschemitdemzweitengrößerenElement
f:
2
3
8
6
7
9
4
1
5
7
9
4
1
5
9
8
1
5
SuchedasnächstekleinereElement
f:
2
3
8
6
Vertauschemitdemdri5engrößerenElement
f:
2
3
4
6
7
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
46
Algorithmen
QuickSort:Beispiel
Vertauschemitdemdri5engrößerenElement
f:
2
3
4
6
7
9
8
1
5
7
9
8
1
5
9
8
6
5
SuchedasnächstekleinereElement
f:
2
3
4
6
VertauschemitdemviertengrößerenElement
f:
2
3
4
1
7
Istmanrechtsangekommen,bringedasPivot-ElementandierichCgePosiCon,
d.h.tauschemitdemfün^engrößerenElement
f:
2
3
4
1
5
9
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
8
6
47
7
Algorithmen
QuickSort:Beispiel
f:
2
3
4
1
5
9
8
6
7
•  Beobachtungen:
–  DasPivot-ElementstehtanseinerfinalenPosiCon
–  AlleElementelinksvomPivot-Elementsindkleiner
–  AlleElementerechtsvomPivotElementsindgrößer
•  NunrekursiverAbsCeg:
–  SorCere
–  SorCere
2
3
4
1
9
8
6
7
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
48
Algorithmen
Sor-erprinzip
•  SorCereneinerFolgef[u...o]nachdem„divide-andconquer“-Prinzip
§  Divide:TeileFolgef[u...o]inzweiTeilfolgenf[u...p-1]
undf[p+1...o]mitderEigenscha^:
w  f[i]≤f[p]fürallei=u,...,p-1
w  f[i]>f[p]fürallei=p+1,…,o
§  Conquer:SorCereTeilfolgenf[u...p-1]undf[p+1...o]
§  Combine:VerbindeTeilfolgenzuf[u...o]
w  KeineVergleicheerforderlich,daTeilfolgenbereitssorCert
sind
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
49
Algorithmen
DasPivot-Element
•  ImPrinzipmussmannichtdasletzteElementalsPivotElementwählen
•  JenachVerteilungderDaten,kannessinnvollseinein
anderesElementzuwählen
–  WennbeispielsweisedieListeschonfastsorCertist,sollteman
immerdasmi5lereElementwählen
–  EineopCmaleRekursionerhältman,wennmanimmerden
MedianalsPivot-Elementwählt(dieseristabernichtdirekt
besCmmbar,dafürmüsstemandieListeerstsorCerthaben)
•  HatmaneinPivot-Elementausgewählt,tauschtmandies
einfachmitdemletztenElementundbenutztden
Algorithmuswiezuvor
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
50
Algorithmen
Algorithmus
class QuickSort implements Sort{
void execute(int[] f){
quickSort(f, 0, f.length-1);
}
p:
Gibtan,anwelcher
PosiCondasPivot-
Elementist.
Hier:o
Genausou,dasmi5lere,
oderjedesandere
Elementmöglich!
void quickSort(int[] f, int u, int o) {
if (u < o) {
int p = o;
int pn = split(f,u,o,p);
quickSort(f,u,pn-1);
quickSort(f,pn+1,o);
}
}
...
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
51
Algorithmen
Algorithmus
...
int split(int[] f, int u, int o, int p) {
int pivot = f[p];
swap(f, p, o);
int pn = u;
for (int j = u; j < o; j++) {
if (f[j] <= pivot) {
swap(f, pn, j);
pn++;
}
}
swap(f, pn, o);
return pn;
}
void swap(int[] f, int x, int y){
int tmp = f[x];
f[x] = f[y];
f[y] = tmp;
}
TauschePivot-Element
mitdemletztenElement
(kannen~allenwenn
immerp=ogewähltwird)
BringekleinereElementenach
vorneundgrößerenachhinten
BringedasPivot-Elementan
dierichCgePosiConundgebe
diesezurück
HilfsmethodezumVertauschen
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
52
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusquickSortterminiertfürjedeEingabe
int[]fnachendlicherZeit.
Beweis
InjedemrekursivenAufrufvonquickSortistdie
Eingabelängeummindestens1kleineralsvorherund
dieRekursionsanfangisterreichtwenndieLängegleich
1ist.InderMethodesplitgibtesnureineforSchleife,dessenZählerjinjedemDurchgang
inkremenCertwird.Dau<owirddiefor-Schleifealso
nurendlicho^durchlaufen.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
53
Analysen
Analyse
Theorem(Korrektheit)
DerAlgorithmusquickSortlöstdasProblemdes
vergleichsbasiertenSorCerens.
Beweis:
DieKorrektheitderMethodeswapistzunächst
offensichtlich.
Zeigenun,dassnachAufrufpn=split(f,u,o,p)füru<ound
p∈[u,o]gilt:
1.  f[p]wurdezuf[pn]verschoben
2.  f[i]≤f[pn]füri=u,...,pn-1
3.  f[i]>f[pn]füri=pn+1,...,o
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
54
Analysen
Analyse
1.  f[p]wurdezuf[pn]verschoben
Diesistklar(vorletzteZeilederMethodesplit)
2.  f[i]≤f[pn]füri=u,...,pn-1
pnwirdzuanfangsmituiniCalisiertundimmerdann
inkremenCert,wenndiePosiConf[pn]durcheinElement,
daskleiner/gleichdemPivot-Elementist,belegtwird.
3.  f[i]>f[pn]füri=pn+1,...,o
FolgtausderBeobachtung,dassin2.)immer„genaudann“
gilt.
Beachtezudem,dassElementimmergetauschtwerden,
alsodieElementeimArraystetsdieselbenbleiben.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
55
Analysen
Analyse
DieKorrektheitderMethodequickSortfolgtnach
IndukConnachderLängevonf(n=f.length):
•  n=1:DerAlgorithmusterminiertsofortundein
einelemenCgesArrayiststetssorCert
•  n→n+1:NachKorrektheitvonsplitstehtdasPivotElementanderrichCgenStelleundlinksundrechts
stehenjeweilsnurkleinere/größereElement.Die
beidenrekursivenAufrufevonquickSorterhalten
jeweilseinArray,dasechtkleineralsn+1ist
(mindestensdasPivot-ElementistnichtmehrTeil
desübergebenenArrays).NachIndukConsannahme
folgtdieKorrektheitvonquickSort.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
56
Analysen
Analyse
Theorem(Laufzeit)
WirdalsPivot-ElementstetsderMediandesaktuell
betrachtetenArraysgewählt,sohatderAlgorithmus
quickSorteineLaufzeitvonΘ(nlogn).
Beweis:
Esgiltzunächst,dasssplit∈Θ(n)(mitn=o-u):
ausschlaggebendisthierdiefor-Schleife,diegenaunmaldurchlaufenwird.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
57
Analysen
Analyse
GiltnachdemAufrufvonsplitstetspn=(u+o)/2(diesist
gleichbedeutenddamit,dassdasPivot-Elementstets
derMedianist),soerhaltenwirfolgende
RekursionsgleichungfürquickSort:
⇢
⇥(1)
n1
T (n) =
2T ((n 1)/2) + ⇥(n) sonst
Diesist(fast)dieselbeRekursionsgleichungwiefür
MergeSortundesfolgtT(n)∈Θ(nlogn).
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
58
Analysen
Analyse
•  WasistwenndieVoraussetzungdesTheoremsnicht
erfülltist?
5
2
3
1
4
•  Beispiel:
5
2
3
1
4
2
5
3
1
4
2
3
5
1
4
2
3
1
5
4
2
3
1
4
5
•  ungleicheRekursionsaufrufe
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
59
Analysen
Analyse
Theorem(Laufzeit)
ImschlechtestenFallhatderAlgorithmusquickSorteine
LaufzeitvonΘ(n2).
Beweis:
Angenommen,dieAu^eilungerzeugteinTeilarraymit
Längen-1undeinTeilarraymitLänge0(Pivot-Elementist
alsoimmerMinimumoderMaximum),dannerhaltenwir
folgendeRekursionsgleichungfürdieLaufzeit:
⇢
⇥(1)
n1
T (n) =
T (n 1) + ⇥(n) sonst
DurchIndukConsbeweiskannleichtgezeigtwerden,dass
T(n)∈Θ(n2).DiesistauchtatsächlichderschlechtesteFall
(Übung).
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
60
Analysen
Analyse
•  Fürdenmi5lerenFallkanngezeigtwerden,dass
quickSorteinenAufwandvonΘ(nlogn)hat(wieim
bestenFall),dieinΘverstecktenKonstantensind
nuretwasgrößer
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
61
AlgorithmenundDatenstrukturen
6.1.5ALLGEMEINEBETRACHTUNGEN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
62
Allgemeines
EigenschabenderbetrachtetenAlgorithmen
§  KomplexitätimDurchschni5sfallundim
SchlechtestenFallistniebesseralsn‧logn
§  SorCerungerfolgtausschließlichdurchVergleichder
Eingabe-Elemente(comparisonsorts)–
vergleichsorien;erteSor;erverfahren
§  Wirzeigennun:n‧lognVergleicheisteineuntere
Schrankefür„ComparisonSort“-Algorithmen
w  Diesheißtdann,dassSorCeralgorithmenmitKomplexität
(schlechtesterFall)vonn‧logn(z.B.MergeSort)
asymptoCschopCmalsind.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
63
Allgemeines
UntereSchranke
§  Problembeschreibung
w  Eingabe:
w  Vergleichstests:
§  VereinfachendeAnnahme:
w  VerschiedeneElemente:
w  RestlicheTests:
•  LiefernallegleichwerCgeInformaCon
è 
è 
è 
SiebesCmmenReihenfolgevon
Könnenunsbeschränkenauf:
BinäreEntscheidung,esgilt:
(1) entweder
(2) oder
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
64
Allgemeines
Entscheidungsbaum
Bedeutung:
a1≤ a2
Beispiel:
Eingabe: a1= 6, a2 = 8, a3 = 5
a1:a2
≤
>
a1:a3
a2:a3
>
≤
⟨a1,a2,a3⟩
a1:a3
≤
⟨a1,a3,a2⟩
>
≤
a2:a3
⟨a2,a1,a3⟩
≤
>
⟨a3,a1,a2⟩
⟨a2,a3,a1⟩
⟨5,6,8⟩
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
65
>
⟨a3,a2,a1⟩
Allgemeines
Entscheidungsbaum-Beobachtungen
§  InnereKnotenvergleichenElementeaiundaj
w  Testobai≤ ajgiltodernicht
§  Blä5er:PermutaConen
§  SorCeren:FindeneinenPfadvonderWurzelzu
einemBla5
w  AnjedeminternenKnotenerfolgteinVergleich
•  Entsprechendlinksoderrechtsweitersuchen
w  IsteinBla5erreicht:SorCeralgorithmushateine
Ordnung/PermutaConderElementeerstellt
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
66
Allgemeines
Folgerung
§  JederSorCeralgorithmusmussjedePermutaCondern
Eingabe-Elementeerreichen→n!
è 
è 
n!Blä5er(dieallevonderWurzelerreichbarsind)
AndernfallskannerzweiunterschiedlicheEingabennicht
unterscheidenundliefertfürbeidedasselbeErgebnis(eins
davonmusssomitfalschklassifiziertsein)
§  AnzahlanVergleichen(schlechtestenFall)istdie
PfadlängevonWurzelbisBla5(HöhedesBaums)
Theorem:
Jeder vergleichsorientierte Sortieralgorithmus benötigt im schlechtesten
Fall mindestens n · log n Vergleiche.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
67
Allgemeines
Folgerung(2)
Beweis
§  Gegeben:
w  SeindieAnzahlderElemente
w  SeiPfadlänge/HöhedesBaums:h
w  SeidieAnzahlvonBlä5ern:b
§  JedePermutaConmussineinemBla5sein:n!≤b
§  BinärbaumderHöhehhatmax.2hBlä5er
è 
Hinweis:folgtaus
SCrlingsApproximaCon
vonn!
n!≤b≤ 2h
§  Logarithmieren:
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
68
AlgorithmenundDatenstrukturen
6.1ALGORITHMENFÜR
VERGLEICHSBASIERTESSORTIEREN
ZUSAMMENFASSUNG
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
69
Zusammenfassung
§  InserConSort
§  BesterFall:Θ(n)
§  Durchschni5licherundschlechtesterFall:O(n2)
§  SelecConSort
§  Bester,durchschni5licherundschlechtesterFall:Θ(n2)
§  MergeSort
§  Bester,durchschni5licherundschlechtesterFall:Θ(nlog2n)
§  QuickSort
§  Besterunddurchschni5licherFall:Θ(nlogn)
§  SchlechtesterFall:O(n2)
§  AllgemeineuntereSchrankefürvergleichsbasierte
SorCerverfahren(schlechtesterFall):n·logn
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
70
AlgorithmenundDatenstrukturen
6.2WEITERESORTIERPROBLEME
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
71
Allgemeines
RückblickundAusblick
§  BisherigeVerfahren:
w  SorCerennZahlenmitn·lognVergleichen
•  z.B.QuickSortimDurchschni5sfall
w  BesCmmenSorCerungdurchVergleiche/VergleichSorCerung
w  Wirhabengezeigt:nlognisteineuntereSchrankefür
SorCeralgorithmendieaufVergleiche/Elementvergleiche
basieren
•  Gehtesbesser?
–  WennwirweitereAnnahmenmachen,ja
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
72
AlgorithmenundDatenstrukturen
6.2.1NICHT-VERGLEICHSBASIERTES
SORTIEREN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
73
Algorithmen
Bucket-Sort
§  Annahme:
§  ElementekommenauseinemvorherfestgelegtemBereich,z.B.
[0...K)füreinenatürlicheZahlK.
§  Siesindin[0..K)ungefährgleichverteilt
GrundideeBucketSort(beieinerEingabevonnZahlen):
1. Erzeugenverke5eteListen(buckets),diedasIntervall
[0...K)innTeilintervallederGrößeK/neinteilen
è 
Diesbedeutet:ZerlegeWertebereichinngleichgroße
Teilintervalle(buckets)
2. FügejedesElementindiepassendeListeein(inein
bucket)
3. Verke5edieListen
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
74
Algorithmen
Bucket-Sort:Beispiel
•  AnnahmeK=100
•  Eingabe[23,54,2,12,65,34,39,94,89,52]
0-9
2
10-19
12
20-29
23
30-39
34
39
40-49
50-59
54
52
60-69
65
70-79
80-89
89
90-99
94
•  Vonlinksnachrechts,verke5eListen(wendeevtl.
vergleichbasiertesSorCerverfahrenaufBucketsmit
mehralseinemElementan)
•  Ausgabe:[2,12,23,34,39,52,54,65,89,94]
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
75
Algorithmen
Algorithmus
class BucketSort implements Sort{
private int bound;
public BucketSort(int bound){ this.bound = bound; }
void execute(int[] f){
int n = f.length;
List<List<Integer>> buckets = createBuckets(n);
for(int i = 0; i < n; i++)
buckets.get(n*f[i]/bound).add(f[i]);
int idx = 0;
for(int i = 0; i < n; i++){
quickSort(buckets.get(i));
for(int j = 0; j < buckets.get(i).size(); j++)
f[idx++] = buckets.get(i).get(j);
}
}
List<List<Integer>> createBuckets(int n){
List<List<Integer>> buckets
= new ArrayList<List<Integer>>();
for(int i = 0; i < n; i++)
buckets.add(new ArrayList<Integer>());
return buckets;
}
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
76
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusBucketSortterminiertfürjedeEingabe
int[]fnachendlicherZeit.
Beweis
AlleSchleifenvariablenhabenwohl-definierteStart-
undEndpunkte.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
77
Analysen
Analyse
Theorem(Korrektheit)
NachAufrufbucketSort(f,bound)istfeinsorCertesArray
mitdengleichenElementenwievordemAufruf.
Beweis
Seii<jbeliebigundbetrachtef[i]undf[j]nachAnwendung
bucketSort(f,bound).Fallsn*f[i]/bound=n*f[j]/boundso
sindf[i]undf[j]imselbenBucketgelandet.NachAnnahme
istQuickSortkorrektundhatdenBucketkorrektsorCert.
Anschliessendwurdezunächstf[i]unddannf[j]indasArray
fgeschrieben,alsofolgtf[i]≤f[j].Falln*f[i]/bound̸=
n*f[j]/boundsomussn*f[i]/bound<n*f[j]/boundgelten
(dai<j),darausfolgtdirektf[i]<f[j].AlsoistfsorCert.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
78
Analysen
Analyse
Theorem(Laufzeit)
Istfmitn=f-lengtheinArraymitElementen,diegleichverteilt
sindin[1..bound]sohatBucketSort(f,bound)eineLaufzeitvon
Θ(n).
Beweis(Skizze)
ImSchni5landetinjedesBucketgenaueinElement(da
Gleichverteilung)unddieAnwendungdes
SorCeralgorithmusaufjedesBucket(unddieinnerste
for-Schleife)kannvernachlässigtwerden.Alleanderen
SchleifenhabengenaunDurchläufe,alsoΘ(n).
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
79
Analysen
Analyse
§  FallsdieAnnahmederGleichverteilungnichtgilt,
wirdkeinelineareKomplexitäterreicht.
w  WiewäredieKomplexitätimschlechtestenFall(bei
VerletzungderAnnahme)?
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
80
AlgorithmenundDatenstrukturen
6.2.2VERTEILTESSORTIEREN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
81
Algorithmen
VerteiltesSor-eren
•  EineLaufzeitvonnlognfürSorCerenistsehreffizient
fürvieleAnwendungen
•  DashäufigeSorCerengroßerMengenvonElementen
kanndennocheinProblemsein
•  HäufigeFestpla5enzugriffe
•  AusnutzungparallelerHardwarekannden
SorCerprozessbeschleunigen
•  AlgorithmenwieMergeSortbietensichzurVerteilungan
•  Problem:Merge-Schri5istnichtdirektparallelisierbar
WirschauenunsverteiltesSorCerenexemplarischam
BatcherSort-Algorithmusan
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
82
Algorithmen
BatcherSort:Idee1/2
•  GrundsätzlicheIdeewiebeiMergeSort:
•  TeiledasArrayinzweigleichgroßeTeilarrays
•  FahrerekursivmitjedemTeilarrayfortundsorCere
•  MischedieresulCerendenTeilarrays
•  DerMerge-Schri5wirdjedochbeiBatcherSortauch
rekursivdurchgeführt
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
83
Algorithmen
BatcherSort:Idee2/2
•  GrundideevonBatcherSort:
•  SeileineListemitElementen1,…,n
9
2
5
1
8
7
3
6
7
8
•  SorCereElemente1,…,n/2undn/2+1,…,n
1
2
5
9
3
6
•  SorCereElemente1,3,5,…,n-1und2,4,6,…,n
1
2
3
6
5
8
7
9
•  Vergleiche/vertauscheElemente2/3,4/5,6/7
1
2
3
5
6
7
8
9
•  ListeistanschliessendsorCert
•  Annahme:ListenhabenLängen=2NfürnatürlicheZahlN
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
84
Algorithmen
Algorithmus1/2
class BatcherSort implements Sort{
void execute(int[] list){
batcherSort(list, 0, list.length-1);
}
void batcherSort(int[] list, int u, int o){
if(u==o) return;
Kannparallel
batcherSort(list, u, (u+o)/2);
ausgeführtwerden
batcherSort(list, (u+o)/2+1,o);
merge(list,u,o,1);
}
...
SorCerphase(ähnlich)wieinMergeSort
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
85
Algorithmen
Algorithmus2/2
void merge(int[] list, int u, int o, int d){
if(2*d>=o-u) compare(list,u,u+d);
else{
merge(list, u, o, 2*d);
merge(list, u+d, o, 2*d);
Kannparallel
ausgeführtwerden
for(int i = u+d; i <= o-d; i += 2*d)
compare(list, i, i+d);
}
}
void compare(int[] list, int k, int l){
if(list[k] > list[l]){
int b = list[k];
list[k] = list[l];
list[l] = b;
}
}
}
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
86
Algorithmen
Beispiel1/5
9
bS(f,0,7)
2
5
1
8
7
3
bS(f,0,3)
9
2
9
bS(f,0,0)
9
bS(f,4,7)
5
1
bS(f,0,1)
8
bS(f,2,3)
2
bS(f,1,1)
2
5
bS(f,2,2)
5
6
7
3
6
bS(f,4,5)
8
1
bS(f,6,7)
7
bS(f,3,3)
bS(f,4,4)
bS(f,5,5)
1
8
7
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
87
3
bS(f,6,6)
3
6
bS(f,7,7)
6
Algorithmen
Beispiel2/5
9
2
5
1
8
7
3
6
m(f,0,1,1)
m(f,2,3,1)
m(f,4,5,1)
m(f,6,7,1)
9
5
8
3
2
1
c(f,1,2)
2
7
c(f,2,3)
9
1
5
c(f,4,5)
7
9
1
c(f,6,7)
3
8
6
m(f,4,7,1)
m(f,0,3,1)
2
6
5
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
7
8
88
3
6
Algorithmen
Beispiel3/5
Nurf[0..3]:
m(f,0,3,1)
2
2
9
1
5
m(f,0,3,2)
m(f,1,3,2)
1
9
c(f,0,2)
1
5
c(f,1,3)
5
2
1
5
2
9
c(f,1,2)
1
2
5
9
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
89
9
Algorithmen
Beispiel4/5
Wiederf[0..7]:
1
m(f,4,7,1)
2
5
9
3
6
7
8
m(f,0,7,1)
1
2
5
9
3
6
7
m(f,0,7,2)
1
5
1
m(f,1,7,2)
3
m(f,0,7,4)
7
5
1
5
5
2
c(f,2,6)
3
3
9
6
m(f,1,7,4)
7
c(f,0,4)
1
2
m(f,2,7,4)
3
8
7
8
m(f,3,7,4)
9
6
c(f,3,7)
c(f,1,5)
2
7
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
8
6
2
8
90
8
6
9
9
Algorithmen
Beispiel5/5
1
5
3
2
7
8
c(f,2,4)
1
3
5
1
2
3
6
5
8
6
7
9
c(f,1,2), c(f,3,4), c(f,5,6)
1
2
9
c(f,2,4)
7
2
6
3
5
6
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
7
8
91
9
8
9
Analysen
Analyse
Theorem(Terminierung)
DerAlgorithmusBatcherSortterminiertfürjede
Eingabeint[]fnachendlicherZeit.
Beweis
AllerekursivenAufrufeerhaltenstetseineecht
kleinereEingabeundterminierenbeieiner
einelemenCgenEingabe.
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
92
Analysen
Analyse
Theorem(Korrekheit)
DerAlgorithmusBatcherSortsorCerteinArrayfkorrekt.
ohneBeweis
Theorem(Laufzeit)
DerAlgorithmusBatcherSorthatbeisequenCellerAbarbeitung
eineLaufzeitvonO(nlog2n).
ohneBeweis
Theorem(Laufzeit)
DerAlgorithmusBatcherSorthatbeiparallelerAbarbeitung
(ParallelisierungvonbatcherSort,merge,undcompareAufrufen)eineLaufzeitvonO(log2n).
ohneBeweis
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
93
AlgorithmenundDatenstrukturen
6.2WEITERESORTIERPROBLEME
ZUSAMMENFASSUNG
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
94
Zusammenfassung
§  BucketSort
§  UnterGleichverteilungsannahmen:O(n)
§  BatcherSort
§  BeiParallelverarbeitung:O(log2n)
AlgorithmenundDatenstrukturen-Ma5hiasThimm(thimm@uni-koblenz.de)
95