203 und 205 etwa fertig

200_Sortieralgorithmen.tex

@@ -6,5 +6,6 @@ zu brechen.
 
 \input{201_quicksort}
 \include{202_mergesort}
-%\include{203_Untere_Schranke_Sortieralgorithmen}
-%\include{204_Radixsort}
+\include{203_Untere_Schranke_Sortieralgorithmen}
+\include{204_Radixsort}
+\include{205_Eigenschaften_von_Sortieralgorithmen}

203_Untere_Schranke_Sortieralgorithmen.tex

 \section{Die untere Laufzeitschranke für vergleichsbasierte Sortieralgorithmen}
 
-
-Viele verwendete schnelle Sortierverfahren (z.B.: \emph{MERGESORT},
-\emph{HEAPSORT}) besitzen eine Laufzeit von $O(n\log n)$. Die Frage,
-die sich dabei stellt, lautet: Geht es besser?
-
-\noindent Man kann beweisen, dass jedes Sortierverfahren, das mittels
-Vergleichen arbeitet%
-\footnote{ D.h., bei dem die Information über die korrekte Anordnung der Elemente dadurch gewonnen wird, dass jeweils einzelne Elemente direkt miteinander verglichen
-werden.%
-}, mindestens $c\cdot n\log n$ Vergleiche im \textbf{worst
-case} braucht (wobei $c>0$ und konstant ist). 
-
-
-\subsection{Herleiten der unteren Schranke $\Omega\left(n\log n\right)$ }
+Wir haben in der analyse von \texttt{mergesort} gesehen, dass die worst-case-Laufzeit $\mathcal{O}(n \log n)$ nicht
+unterschreitet. Es ist auch die best-case-Laufzeit von \texttt{quicksort}. Schneller als $\mathcal{O}(n)$ kann ein
+Sortieralgorithmus sicherlich nicht sortieren: Er muss ja jeden Input mindestens einmal angeschaut haben. Aber geht es,
+im worst-case, schneller als $\mathcal{O}(n \log n)$?
+
+Die Antwort ist - für vergleichsbasierte Algorithmen - nein, und wir werden in diesem Kapitel den Beweis dazu skizzieren.
+
+Doch was ist ein vergleichsbasierter Algorithmus? 
+All unsere bisherigen Sortieralgorithmen verglichen stets zwei Elemente, um ihre entsprechende Reihenfolge untereinander zu
+bestimmen. Das impliziert, dass die Elemente eine sogenannte totale Quasiordnung haben mussten;
+\begin{definition}[totale Quasiordnung]
+  \label{def:totale_Quasiordnung}
+  Sei $A$ eine Menge. Eine totale Quasiordnung auf $X$ ist eine binäre Relation $\leq$, für welche gilt:
+  \begin{itemize}
+    \item $a \leq a$ für alle $a \in A$ (\emph{Reflexifität}).
+    \item $a \leq b$ und $b \leq c$ impliziert  $a \leq c$ für alle $a,b,c \in A$ (\emph{Transitivität}).
+    \item $a \leq b$ oder $b \leq a$ für alle $a,b \in A$ (\emph{Totalität}).
+  \end{itemize}
+\end{definition}
+Insbesondere erfüllt jede totale Ordnung (also beispielsweise die normale Ordnung auf den ganzen oder reellen Zahlen)
+die Axiome der totalen Quasiordnung.  
+Für eine ``echte'' Quasiordnung betrachten wir $X = \{x,y,z\}$, mit $\leq$ definiert durch $y \leq x$, $y \leq z$, $x \leq z$ und $z \leq x$.
+Nun sind $x$ und $z$ ``gleich'', wir benutzen das Symbol $x \equiv z$.
+
+Für ein praktisches Beispiel können wir Spielkarten anschauen, die wir allein nach den numerischen Werten ordnen. Dann
+ist mit $x = $ Herz 8, $y = $ Herz 7 und $z = $ Pik 8 klar, dass $x \equiv z$, aber nicht unbedingt $x = z$, wie es bei
+einer totalen Ordnung der Fall wäre.
+
+Vergleichsbasierte Sortieralgorithmen vergleichen daher nur immer genau zwei Elemente miteinander. Dies geschieht bei
+\texttt{quicksort} beispielsweise in Zeile 4 der Partition, oder bei \texttt{mergesort} in Zeile 4 von \texttt{merge}.
+
+
+\subsection{Beweisskizze}
+Wir betrachten im Folgenden die Anzahl der nötigen Vergleiche für das Sortieren des Inputs. Da der Aufwand eines
+vergleichsbasierten Sortieralgorithmus mindestens so schnell wächst wie die Anzahl der nötigen Vergleiche, haben wir damit eine
+untere Schranke für den zeitlichen Aufwand.
 
 Der Kontrollfluss eines vergleichenden Sortierverfahrens kann mittels
 eines sogenannten \emph{Entscheidungsbaummodells} dargestellt werden.
-Darin scheinen alle möglichen und nötigen Entscheidungen auf, um ein
+In einem Entscheidungsbaummodell werden alle möglichen und nötigen Entscheidungen dargestellt, um ein
 sortiertes lineares Feld zu erhalten. Beispiel: Es liegt eine Sequenz
-von 3 Zahlen vor $<a_{1},a_{2},a_{3}>$ (z.B. $<5,8,2>$). Dann schaut
+von 3 Zahlen vor $[a_{1},a_{2},a_{3}]$, ganz konkret also möglicherweise $[5,8,2]$. Dann schaut
 der zugehörige Entscheidungsbaum folgendermaßen aus:
 
 \begin{center}
 \includegraphics[scale=0.2]{bilder/Entschdeidungsbaummodell}
 \par\end{center}
 
-\noindent Die Blätter stellen alle möglichen Permutationen des Inputs dar. Die Anzahl der Blätter ist daher gleich $n!$.
+Die Blätter stellen alle möglichen Permutationen des Inputs dar. Die Anzahl der Blätter ist daher gleich $n!$.
 
-\noindent Das worst-case Verhalten entspricht dem längsten Ast im
-Entscheidungsbaum (Anzahl der inneren Knoten = Anzahl der Vergleiche).
-Der ideale Sortieralgorithmus enspricht einem vollständigen, ausgeglichenen
-Baum. Dadurch wird der längste Ast ( = worst case) minimiert. Die
-Höhe beträgt $h\geq\log(n!).$ Mit Hilfe der Stirling-Approximation
-$n!>(\frac{n}{e})^{n}$ erhält man:
+Das worst-case Verhalten eines Algorithmus entspricht dem längsten Ast im
+Entscheidungsbaum, die Anzahl der inneren Knoten ist dabei genau die Anzahl der notwendigen Vergleiche.
 
+Ein idealer Sortieralgorithmus enspricht einem vollständigen, ausgeglichenen
+Baum. Dadurch wird der längste Ast, also der worst case, minimiert. Die
+Höhe beträgt $h \geq \log_2(n!)$. Aber wir haben bereits in einer Übungsaufgabe berechnet, dass gilt:
 \[
-h\geq\log\left(\frac{n}{e}\right)^{n}=n\cdot\log n-n\cdot\log e=\Omega(n\cdot\log n)\]
-
-
-\bigskip{}
-
-\noindent $\Omega(n\cdot\log\: n)$ ist die \textbf{untere
-Schranke} für die Anzahl der im worst case zum Sortieren notwendigen Vergleiche
-(und somit für die worst case Laufzeit vergleichender Sortierverfahren).
+  h \geq \log_2(n!) \in Θ(n \log n).
+\]
+Also sind wir damit fertig.
+
+\begin{theorem}
+  Für vergleichsbasierte Sortieralgorithmen liegt die worst-case Laufzeit immer in $Ω(n \log_n)$.
+  \label{theorem:untere_schranke_sortieralgorithmen}
+\end{theorem}
 
 
 \subsection{worst-case optimal}

205_Eigenschaften_von_Sortieralgorithmen.tex

+\section{Eigenschaften von Sortieralgorithmen}
+
+\subsection{Laufzeit}
+Wir haben bereits umfangreiche Laufzeitanalysen von Sortieralgorithmen durchgeführt. Die Qualität eines
+Sortieralgorithmus anhand seines best/worst/average-case-Verhaltens zu beurteilen, scheint also naheliegend.
+
+\subsection{worst-case-optimal}
+Im Zusammenhang von vergleichsbasierten Sortieralgorithmen bedeutet die Eigenschaft worst-case-optimal, dass die
+Untergrenze von $Ω(n \log n)$ \emph{immer} eingehalten wird.
+
+\subsection{Stabilität}
+Ein Sortieralgorithmus ist stabil, wenn durch das Sortieren die Reihenfolge innerhalb bezüglich der Quasiordnung
+gleicher Elemente gewährleistet ist. 
+Formaler:
+\begin{definition}[Stabilität]
+  Sei $[x_0, x_1, \cdots, x_{n-1}]$ ein Array bzw eine Sequenz von $n$ Elementen aus der Menge $X$. Unterhalte
+  $X$ eine totale Quasiordnung, unter derer ``Gleichheit'' von $x, x' \in X$ mit $x \equiv x'$ bezeichnet wird. Sei das
+  Wirken des Sortieralgorithmus $f$ eine Permutation $π \in \text{Perm}(n)$, also $f([x_0, \cdots x_{n-1}]) =
+  [x_{π(0)}, x_{π(1)}, \cdots, x_{π(n-1)}]$.
+
+  Dann ist unser Sortieralgorithmus stabil, wenn gilt:
+  \[
+    x_i \equiv x_{i'} \text{ und } i \leq i' \text{ impliziert } π(i) \leq π(i').
+  \]
+\end{definition}
+
+\subsection{in-place}
+Als \emph{in-place} bezeichnet man die Eigenschaft eines Sortieralgorithmus, neben dem Speicherverbrauch des Inputarrays
+nur einen konstanten zusätzlichen Speicherverbrauch zu haben. Es ist also $S_{\text{alg}} \in \mathcal{O}(1)$.
+Gelegentlich wird auch Speicherverbrauch von $\mathcal{O}(\log n)$ noch als \emph{in-place} bezeichnet.
+
+\subsection{Adaptivität}
+Als adaptiv bezeichnet man einen Sortieralgorithmus, der kürzere Laufzeiten hat, wenn Teile des Arrays bereits sortiert
+sind. Insbesondere muss der best-case also in $\mathcal{O}(n)$ liegen.
+
+\subsection{Parallelisierbarkeit}
+Sowohl auf dem PC, als auch im Smartphone und inbesondere in einem Rechenzentrum wird zusätzliche Rechenleistung fast
+nurnoch durch parallele Architekturen erreicht. Damit gewinnt auch die Frage nach paralleisierbarkt größere Bedeutung.
+Aus einer theoretischen Perspektive nimmt man dabei oftmals unbegrenzt viele parallele Prozessoren an. 
+
+
+