Bubblesort

Erstellt von Mario Mayr
Bubblesort
Bubblesort bezeichnet einen einfachen, stabilen Sortieralgorithmus, der eine Reihe linear
angeordneter Elemente (etwa Zahlen) der Größe nach anordnet.
Bubblesort wird von Donald E. Knuth als vergleichsbasierter Sortieralgorithmus bezeichnet
[1] . Das bedeutet, dass der Sortieralgorithmus sämtliche Entscheidungen alleine auf Basis des
Größenvergleichs je zweier Elemente fällt, nicht etwa aufgrund der Inspektion der
Binärdarstellung eines Elements.
Bubblesort ist der einfachste solcher Algorithmen. Einzige Anforderung an den
Vergleichsoperator ist, dass er eine Totalordnung der Liste ermöglicht.
Bubblesort gehört zur Klasse der In-place-Verfahren, was bedeutet, dass der Algorithmus zum
Sortieren keinen zusätzlichen Arbeitsspeicher außer den lokalen Laufvariablen der Prozedur
benötigt.
Wegen der einerseits mangelhaften Effizienz und anderseits breiten Verfügbarkeit deutlich
besserer Alternativen wird Bubblesort meistens nur als Beispiel für einen schlechten oder
naiven Sortieralgorithmus verwendet.
Prinzip
Der Algorithmus vergleicht der Reihe nach zwei benachbarte Elemente und vertauscht sie,
falls sie in der falschen Reihenfolge vorliegen. Dieser Vorgang wird solange wiederholt, bis
keine Vertauschungen mehr nötig sind. Hierzu sind in der Regel mehrere Durchläufe
erforderlich.
Je nachdem, ob auf- oder absteigend sortiert wird, steigen die größeren oder kleineren
Elemente wie Blasen im Wasser (daher der Name) immer weiter nach oben, das heißt, an das
Ende der Reihe. Auch werden immer zwei Zahlen miteinander in „Bubbles“ vertauscht.
Schlimmster Fall:
Umgekehrt sortierte Liste: Bubblesort Im Falle der umgekehrt sortierten Liste (n,n-1,...,2,1)
werden maximal viele Vertauschungen ausgeführt: um das erste (und größte) Element n ganz
nach rechts zu bewegen, werden n − 1 Vertauschungen vorgenommen.
Laufzeit Θ(n 2 ) für Listen der Länge n
Bester Fall
Falls die Liste bereits sortiert ist wird Bubblesort die Liste nur einmal durchgehen um
festzustellen, dass die Liste bereits sortiert ist, weil keine benachbarten Elemente vertauscht
werden mussten. Daher benötigt Bubblesort Θ(n) Schritte um eine bereits sortierte Liste zu
bearbeiten.
Falls die Elemente der Liste bereits nah den Stellen sind, die sie nach der Sortierung
bekommen sollen, ist die Laufzeit erheblich besser als Θ(n 2 ).

Erstellt von Mario Mayr
Hasen und Schildkröten
Die Positionen der Elemente vor dem Sortieren entscheiden maßgeblich den Sortieraufwand.
Große Elemente am Anfang wirken sich nicht gravierend aus, da sie schnell nach unten
getauscht werden, kleine Elemente am Ende bewegen sich jedoch eher langsam nach oben.
Darum spricht man bei diesen Elementen von Hasen und Schildkröten.
Beispiel
Eine Reihe von fünf Zahlen soll aufsteigend sortiert werden.
Die fett gedruckten Zahlen werden jeweils verglichen. Ist die linke größer als die rechte, so
werden beide vertauscht; das Zahlenpaar ist dann blau markiert. Im ersten Durchlauf wandert
somit die größte Zahl ganz nach rechts. Der zweite Durchlauf braucht somit die letzte und
vorletzte Position nicht mehr zu vergleichen. --> Dritter Durchlauf: kein Vergleich
letzte/vorletzte/vorvorletzte....
55 07 78 12 42 1. Durchlauf
07 55 78 12 42
07 55 78 12 42
07 55 12 78 42
07 55 12 42 78 2. Durchlauf
07 55 12 42 78
07 12 55 42 78
07 12 42 55 78 3. Durchlauf
07 12 42 55 78
07 12 42 55 78 4. Durchlauf
07 12 42 55 78 Fertig sortiert.
Formaler Algorithmus
Der Algorithmus sieht im Pseudocode so aus:
prozedur bubbleSort( A : Liste sortierbarer Elemente ) definiert als:
n := Länge( A ) - 1
wiederhole
vertauscht := falsch
für jedes i in 0 bis n wiederhole:
falls A[ i ] > A[ i + 1 ] dann
vertausche( A[ i ], A[ i + 1 ] )
vertauscht := wahr
falls ende
für ende
n := n - 1
während vertauscht
prozedur ende
Quelle: Wikipedia

Erstellt von Mario Mayr
Quicksort
Quicksort ist ein schneller, rekursiver, nicht-stabiler Sortieralgorithmus, der nach dem
Prinzip Teile und herrsche arbeitet. Der Algorithmus hat den Vorteil, dass er über eine sehr
kurze innere Schleife verfügt (was die Ausführungsgeschwindigkeit stark erhöht) und ohne
zusätzlichen Speicherplatz auskommt (abgesehen von dem für die Rekursion zusätzlichen
benötigten Platz auf dem Aufruf-Stack).
Eine zufällige Permutation des Umfangs n, in der jedes Element von 1 bis n lediglich einmal
vorkommt, wird mit Quicksort sortiert.
Prinzip
Quicksort wählt ein Element aus der zu sortierenden Liste aus (Pivotelement) und zerlegt die
Liste in zwei Teillisten, eine untere, die alle Elemente kleiner und eine obere, die alle
Elemente gleich oder größer dem Pivotelement enthält. Diese Teillisten werden rekursiv
sortiert. Anschließend wird das Ergebnis zusammengesetzt. Es besteht (in der Reihenfolge)
aus der unteren Liste, dem Pivotelement und der oberen Liste.
Eine direkte Implementation dieses Prinzips hat allerdings den Nachteil, dass sie zum einen
zusätzlichen Speicher benötigt und zum anderen unnötig viele Operationen durchführt.
Deshalb wird ein Verfahren verwendet, das als teilen oder auch partitionieren bezeichnet
wird. Dieses arbeitet in-place.
Hierbei wird nach der Wahl des Pivotelementes zunächst ein Element vom Anfang der Liste
beginnend gesucht, das größer als (oder gleichgroß wie) das Pivotelement und damit für die
untere Liste zu groß ist. Entsprechend wird vom Ende der Liste beginnend ein kleineres
Element als das Pivotelement gesucht. Die beiden Elemente werden dann vertauscht und
landen damit in der jeweils richtigen Liste. Der Vorgang wird fortgesetzt, bis sich die untere
und obere Suche treffen. Auf diese Art und Weise entstehen die beiden Teillisten aus der
Gesamtliste. Sie haben auch schon die richtige Position. Es müssen nur noch die Teillisten
sortiert werden.

Erstellt von Mario Mayr
Laufzeit
Die Laufzeit des Algorithmus hängt im wesentlichen von der Wahl des Pivotelementes ab.
Im Worst Case (schlechtesten Fall) wird das Pivotelement stets so gewählt, dass es das größte
oder das kleinste Element der Liste ist. Dies ist etwa der Fall, wenn als Pivotelement stets das
Element am Ende der Liste gewählt wird und die zu sortierende Liste bereits sortiert vorliegt.
Die zu untersuchende Liste wird dann in jedem Rekursionsschritt nur um eins kleiner und die
benötigte Rechenzeit ist asymptotisch genau n 2 .
Im Best Case (bester Fall) wird das Pivotelement stets so gewählt, dass die entstehenden
Teillisten beide gleich groß sind. In diesem Fall ist die Laufzeit des Algorithmus durch
O(n·log(n)) nach oben beschränkt. Auch für den durchschnittlichen Fall gilt diese obere
Schranke.
Wahl des Pivot-Elemts:
erstes, letztes oder mittleres Element wählen -> sehr ineffizient
Median -> beste Variante aber aufwendiger (Effizientz = ?)
Random -> einfach und effizient
Der Worst Case tritt nur sehr selten auf und im mittleren Fall ist Quicksort schneller, da die
innerste Schleife von Quicksort nur einige wenige, sehr einfache Operationen enthält.
( Heute ist Quicksort für ein breites Spektrum von praktischen Anwendungen die bevorzugte
Sortiermethode, weil er schnell ist und, sofern Rekursion zur Verfügung steht, einfach zu
implementieren ist )
Quicksort setzt jedoch voraus, dass effizient (d.h. mit Aufwand O(1)) über einen Index auf die
Elemente zugegriffen werden kann. Dies ist jedoch meist nur bei Arrays der Fall

Erstellt von Mario Mayr
Quicksort an einem Beispiel
Um ein Array zu sortieren, wählt QuickSort zunächst eine spezielle Zahl im Array, die wir
Pivot nennen wollen. Wie das Pivot gewählt wird, sehen wir uns später an. Dann werden alle
Zahlen, welche kleiner als das Pivot sind, auf die linke Seite des Arrays gebracht, alle Zahlen,
welche größer als das Pivot sind, werden auf die rechte Seite des Arrays gebracht. Als
Beispiel betrachten wir das Array mit den Zahlen
7 10 8 6 11 4 9 3 1 5 2 12
Der Übersichtlichkeit halber haben wir die Zahlen kleiner als 7, welches wir als Pivotelement
wählen, blau markiert. Die Zahlen größer 7 haben wir rot markiert. Dass die 7 gerade am
Anfang des Arrays steht, betrachten wir zunächst als Zufall. Als ersten Schritt ändert
QuickSort das Array nun folgendermaßen:
3 2 5 6 1 4 7 9 11 8 10 12
Nun sind alle Zahlen, welche kleiner sind als 7, links von ihr. Alle Zahlen welche größer sind
als die 7, sind rechts von ihr. Dabei interessiert es uns im Moment gar nicht, in welcher
Reihenfolge die Zahlen links und rechts von der 7 stehen. Alles was wir fordern, ist, dass alle
blauen Zahlen links von der 7 sind, die roten Zahlen rechts von der 7.
Als nächstes sortieren wir den Teil links von der 7 wieder mit QuickSort. Als Pivot wählen
wir die 3. Wieder markieren wir die Zahlen kleiner als drei mit blau, die grösseren Zahlen mit
rot. Die Zahl 7 und die grösseren Zahlen betrachten wir im Moment nicht, deshalb markieren
wir sie gelb:
3 2 5 6 1 4 7 9 11 8 10 12
QuickSort bringt die blauen und die roten Zahlen wieder in die richtige Ordnung. Man erhält
dann das Folgende:
1 2 3 6 5 4 7 9 11 8 10 12
Das wird fortgesetzt bis der linke Teil des Arrays sortiert ist. Das sieht dann wie folgt aus:
1 2 3 4 5 6 7 9 11 8 10 12
Nun wird rechts von der 7 sortiert. Wieder wird ein Pivot gewählt, hier die 9, und die
kleineren und grösseren Zahlen auf die jeweils richtige Seite gebracht.

Erstellt von Mario Mayr
Wir können nun bereits den grundsätzlichen Algorithmus mit PseudoCode beschreiben:
procedure QuickSort( int[] Array, int L, int R )
if ( L < R)
{
mitte := partitioniere(Array, L, R)
QuickSort(Array, L, mitte-1)
QuickSort(Array, mitte+1, R)
}
endprocedure
Dabei wählt die Prozedur partitioniere ein Pivot, und bringt die Zahlen, die kleiner sind, auf
die linke Seite von dem Pivot und die grösseren Zahlen auf die rechte Seite des Pivots. Sie
partioniert das Array. Als Rückgabewert gibt partitioniere die neue Position des Pivots
zurück.
Wir müssen uns noch zwei Dinge überlegen:
1. Wie partitionieren wir ein Array?
2. Wie wählen wir das Pivot?
Wir wenden uns zunächst der Wahl des Pivot-Elements zu.
Wahl des Pivot-Elements (schon beschrieben in LAUFZEIT)
Die Wahl des Pivotelements ist offensichtlich wichtig. Bei einer QuickSortAnalyse? bemerkt
man, dass man am Besten das Element als Pivot wählt, welches am Schluss genau in der
Mitte zu liegen kommt. In diesem Fall ist die Laufzeit von Quicksort O(n log(n)). Leider ist
dieses Element nicht ganz einfach zu finden. Die schlechteste Wahl des Pivots ist das
Element, welches ganz am linken oder ganz am rechten Rand des zu sortierenden Intervals
endet. Falls man immer dieses Element wählt so ist die Laufzeit von Quicksort O(n^2), also
wesentlich schlechter als O(n log(n)).
Man sollte deshalb nicht immer das linke Element als Pivot wählen, so wie wir das in
unseren Beispielen getan haben. Falls nämlich das Array bereits sortiert ist, oder nahezu
sortiert ist, führt dies zu dem einem äußerst langsamen "QuickSort".
Als Kompromiss wird oft ein zufälliges Element als Pivot-Element genommen. Eine
DetaillierteQuickSortAnalyse? zeigt, dass wir dann erwarten können, dass QuickSort in O(n
log(n)) läuft. Noch besser kann es sein, von drei zufällig gewählten Elementen jeweils das
mittlere zu nehmen.
In unserem Text fahren wir fort und nehmen das linke Element als Pivot, obwohl das in jeder
praktischen Implementation schlecht ist.

Erstellt von Mario Mayr
Partitionierung
Wir wenden uns jetzt der Frage zu, wie man bei gewählten Pivot das Array partitioniert. Also
der Frage: wie kommt man effizient von
7 10 8 6 11 4 9 3 1 5 2 12
auf
2 5 6 1 4 3 7 9 11 8 10 12
Die effiziente Implementation dieses Schrittes ist übrigens der Grund, weshalb QuickSort
instabil sortiert. StabilesSortieren ist fast unmöglich mit QuickSort.
Der Einfachheit halber nehmen wir an, dass das Pivot am linken Rand des Arrays steht. Falls
dies nicht so ist, so kann man zuerst das linke Element des Arrays mit dem Pivotelement
vertauschen.
Die Partitionierung macht man nun üblicherweise folgendermaßen. Man verwendet zwei
Zeiger, einen links und einen rechts auf das Array:
7 10 8 6 11 4 9 3 1 5 2 12
^ ^
L R
Nun geht man mit dem linken Zeiger soweit nach rechts, bis er auf eine rote Zahl zeigt. Mit
dem rechten Zeiger geht man soweit nach links, bis er auf eine blaue Zahl zeigt. Danach sieht
die Situation wie folgt aus:
7 10 8 6 11 4 9 3 1 5 2 12
^ ^
L R
Jetzt vertauscht man die Elemente auf welche die Zeiger zeigen:
7 2 8 6 11 4 9 3 1 5 10 12
^ ^
L R
immer: weiter und vertauschen
...
Und ein letzes Mal vertauschen:
7 2 5 6 1 4 3 9 11 8 10 12
^ ^
L R
Jetzt ziehen wir nochmals weiter (aufpassen, Reihenfolge!)
7 2 5 6 1 4 3 9 11 8 10 12
^
LR
Und stoppen hier, weil beide Zeiger auf dasselbe Element zeigen. Nun vertauschen wir noch
das Pivotelement mit dem Element, auf welches gezeigt wird, und sind fertig:
3 2 5 6 1 4 7 9 11 8 10 12
^
LR

Erstellt von Mario Mayr
In PseudoCode könnte das Ganze so aussehen:
procedure partitioniere( int[] Array, int L, int R )
L0 := L // Wählt als Pivot-Element Array[L0]. Dies
// ist für praktische Anwendungen
// SCHLECHT !!! (siehe Wahl des
// Pivot-Elements)
While ( L < R )
{
if ( Array[R] > Array[L0] )
{
R := R – 1
}
Else
{
if ( Array[L]