added a few pictures

304_Halden.tex

@@ -33,9 +33,9 @@ definiert als $h(n) := \floor*{\log_2 n}$. Eine leere Halde hat die Höhe $h(0)
   \label{fig:halde_array}
 \end{figure}
 
-\begin{figure}[h]
+\begin{figure}[H]
   \centering
-  \includegraphics[scale=0.25]{bilder/Halde_baum}
+  \input{bilder/heap_tree_representation.tex}
   \caption{Eine Halde aus Baumperspektive. Kindbeziehungen anstelle der Pfeile aus Abbildung~\ref{fig:halde_array}}
   \label{fig:halde_baum}
 \end{figure}
@@ -152,6 +152,62 @@ n)$ hat. Die Laufzeit wird von den $\frac{n}{2}$ aufrufen von $\texttt{heapify}$
 hat, eh dominiert. Also liegt die Laufzeit in $\mathcal{O}(n \log n)$. Damit ist $\texttt{heapsort}$ also worst-case
 optimal. 
 
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_1.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im ersten Schritt wird
+    (nacheinander, in dieser Reihenfolge) \texttt{heapify} auf die Blätter mit den Werten $2$, $8$ und $1$ ausgeführt,
+    was jeweils keinerlei Effekt hat.}
+  \label{fig:heapsort_1}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_2.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im zweiten Schritt wird
+    \texttt{heapify} auf den Knoten mit dem Wert $3$ ausgeführt, also die Haldenbedingung zu seinem Kind $2$ überprüft.
+    Da die Haldenbedingung für diesen Unterbaum nicht verletzt ist, passiert weiter nichts.}
+  \label{fig:heapsort_2}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_3.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im dritten Schritt wird
+    \texttt{heapify} auf den Knoten mit dem Wert $7$ ausgeführt, also die Haldenbedingung zu seinem Unterbaum
+    überprüft und gegenbenenfalls repariert. Da $8$ größer ist als $7$, werden die beiden Werte getauscht.}
+  \label{fig:heapsort_3}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_4.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im dritten Schritt wird
+    \texttt{heapify} auf den Knoten mit dem Wert $7$ ausgeführt, also die Haldenbedingung zu seinem Unterbaum
+    überprüft und gegenbenenfalls repariert. Da $8$ größer ist als $7$, werden die beiden Werte getauscht.}
+  \label{fig:heapsort_4}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_5.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im dritten Schritt wird
+    \texttt{heapify} auf den Knoten mit dem Wert $7$ ausgeführt, also die Haldenbedingung zu seinem Unterbaum
+    überprüft und gegenbenenfalls repariert. Da $8$ größer ist als $7$, werden die beiden Werte getauscht.}
+  \label{fig:heapsort_5}
+\end{figure}
+
+
+\begin{figure}[H]
+  \centering
+  \input{bilder/heapsort_6.tex}
+  \caption{Der Algorithmus \texttt{heapsort} auf den Array $\mathcal{A} = [5,7,3,1,8,2]$. Im dritten Schritt wird
+    \texttt{heapify} auf den Knoten mit dem Wert $7$ ausgeführt, also die Haldenbedingung zu seinem Unterbaum
+    überprüft und gegenbenenfalls repariert. Da $8$ größer ist als $7$, werden die beiden Werte getauscht.}
+  \label{fig:heapsort_6}
+\end{figure}
+
+
 
 \subsection{Wartschlange (Priority Queue)*}
 Eine der häufigsten Anwendungen von Halden: Warteschlangen mit einer Priorität, bei der immer das dringenste (also das