Skript bis einschließlich Abschnitt 7.1: Stack und FIFO

script/hp-2016ws.tex

@@ -5576,14 +5576,78 @@
   Auch die Übergabe des Objekt-Zeigers \lstinline{this} an Methoden
   erfolgt in C++ automatisch: Aus \lstinline{object[i]->base.print (object[i]);}
   wird \lstinline{object[i]->print ();}.
-  Der Quelltext wird dadurch kürzer und weniger fehleranfällig.
 
-  \section{Datenstrukturen}
+  Dadurch daß der Compiler viele Aufgaben übernimmt,
+  die der Programmierer ansonsten manuell abarbeiten müßte,
+  wird der Quelltext kürzer und weniger fehleranfällig.
 
-  \underconstruction
+  \section{Datenstrukturen}
 
   \subsection{Stack und FIFO}
+
+  Eine häufige Situation beim Programmieren ist,
+  daß man ein Array für eine gewisse Maximalmenge von Einträgen anlegt,
+  aber nur zum Teil nutzt.
+
+  Einem derartigen Array ein Element hinzuzufügen, ist einfach:
+  Man erhöht die Variable, die die Auslastung des Arrays speichert.
+  Ebenso einfach ist das Entfernen des zuletzt eingefügten Elements:
+  Man erniedrigt die Variable, die die Auslastung des Arrays speichert.
+
+  "`Einfach"' bedeutet hier, daß die benötigte Rechenzeit gering ist.
+  Genaugenommen ist die Rechenzeit immer gleich groß,
+  egal wie viele Elemente sich bereits im Array befinden.
+  Die Komplexität (Landau-Symbol) der Operation,
+  am Ende des Arrays ein Element einzufügen oder zu entfernen,
+  ist $\mathcal{O}(1)$.
+
+  Eine derartige Struktur eignet sich gut,
+  um Elemente in der Reihenfolge des Eintreffens zu speichern,
+  sie aber in \lstinline{umgekehrter\/} Reihenfolge wieder abzuarbeiten.
+  Man "`stapelt"' gewissermaßen die Elemente in dem Array.
+  Aus diesem Grunde heißt diese Struktur \newterm{Stack\/} (engl.: \emph{Stapel})
+  oder \newterm{LIFO\/} für \emph{last in, first out}.
+
+  Andere Operationen -- z.\,B.\ das Einfügen oder Löschen von Elementen
+  in der Mitte -- sind aufwendiger, da man die im Array befindlichen Elemente
+  in einer Schleife beiseiteschieben muß.
+  Die Rechenzeit ist proportional zur Anzahl der Elemente,
+  die sich bereits im Array befinden: $\mathcal{O}(n)$.
+
+  Das Suchen in einem bereits sortieren Array ist hingegen in $\mathcal{O}(\log n)$
+  möglich: Man beginnt die Suche in der Mitte und prüft,
+  ob sich das gesuchte Element in der unteren oder in der oberen Hälfte befindet.
+  In der ermittelten Hälfte beginnt man die Suche wieder in der Mitte --
+  so lange, bis man nur noch ein einzelnes Element vor sich hat.
+
+  Das Beispiel-Programm \gitfile{20170116}{stack-11.c} illustriert,
+  wie man einen Stack mit den o.\,g.\ Funktionalitäten implementieren kann.
+
+  \breath
+
+  Eine weitere wichtige Situation ist,
+  daß man anfallende Daten zwischenspeichern
+  und \emph{in derselben Reihenfolge\/} wieder abarbeiten möchte.
+  Eine Struktur, die dies ermöglicht, heißt \newterm{FIFO\/}
+  für \emph{first in, first out}.
+
+  Um einen FIFO zu realisieren, verwendet man nicht eine einzelne Variable,
+  die den genutzten Teil des Arrays speichert, sondern zwei:
+  Ein Schreib-Index markiert, an welcher Stelle Platz
+  für das nächste einzufügende Element ist;
+  ein Lese-Index markiert das zuerst eingefügte Element.
+  Beide Indizes werden bei Verwendung hochgezählt.
+  Wenn sie gleich sind, ist der FIFO leer.
+
+  Der entscheidende Trick: Wenn eine der beiden Indexvariablen
+  das Ende des Arrays erreicht, wird sie wieder auf 0 gesetzt.
+  Die beiden Indexvariablen arbeiten also \emph{ringförmig\/}; 
+  der FIFO wird durch einen \newterm{Ringpuffer\/} realisiert.
+
+  Beispiel-Programm: \gitfile{20170116}{fifo-8.c}
+
   \subsection{Verkettete Listen}
+  \underconstruction
   \subsection{Bäume}
 
 \end{document}