Algorithmen setzen

Der gerahmte und nummerierte Pseudocode „Algorithm 1“, den man in Aufsätzen und Lehrbüchern sieht, ist keine eingebaute LaTeX-Funktion, sondern kommt aus Paketen. Die erste Hürde sind mehrere ähnlich benannte Pakete. Entscheidend ist eine Arbeitsteilung: Ein Paket liefert den Container, also einen schwebenden nummerierten Kasten, ein anderes den Inhalt, also den Pseudocode selbst. Diese Seite ordnet diese Landschaft und behandelt dann die klassische Paarung, den algorithm-Float um einen algpseudocode-Körper, sowie den selbständigen Rivalen algorithm2e, jeweils mit tatsächlich kompilierbarem Code. Da es hier keinen Live-Renderer gibt, beschreibt der Text, was jeweils entsteht.

Zwei Schichten: Container und Inhalt

Pseudocode-Satz teilt sich in zwei Schichten mit unterschiedlichen Aufgaben. Die erste ist der Container: ein Kasten, der wie figure oder table auf der Seite schwebt und eine „Algorithm 1“-Beschriftung mit laufender Nummer, Querverweisen und auf Wunsch sogar einem Algorithmenverzeichnis trägt. Das liefert das Paket algorithm (\usepackage{algorithm}), das die Umgebung \begin{algorithm} … \end{algorithm} hinzufügt.

Die zweite Schicht ist der Inhalt: Befehle wie \State (eine Zeile), \While (eine Schleife) und \If (eine Verzweigung), die den Pseudocode selbst mit Einrückung und Zeilennummern setzen. Hier verzweigen sich die Optionen: das alte Paket algorithmic, sein besser anpassbarer Nachfolger algorithmicx (praktisch nutzt man das darauf aufbauende Layout algpseudocode) und das separate, unabhängige Ökosystem algorithm2e.

Entscheidend ist: Für den Körper wählst du genau ein Paket. algpseudocode und algorithm2e unterscheiden sich völlig in Syntax und Denkweise, und Mischen führt zu Konflikten. Der Container algorithm ist dagegen für die Paarung mit algpseudocode gedacht; algorithm2e bringt eigenen Container und Körper mit, braucht also algorithm nicht, und die Kombination ist eher abzuraten. Die Tabelle zeigt das Gesamtbild.

Beachte: algorithm wird im algorithms bundle ausgeliefert, das auch algorithmic enthält. algorithmicx wird separat verteilt, aber algpseudocode lädt es intern automatisch, sodass du algorithmicx nie selbst per \usepackage laden musst.

Die Befehle von algpseudocode

algpseudocode-Pseudocode schreibst du in der Umgebung \begin{algorithmic} … \end{algorithmic}. Der Umgebungsname unterscheidet sich also vom Paketnamen (algpseudocode); die Umgebung heißt einfach algorithmic. Das optionale Argument [1] steuert Zeilennummern: 0 für keine, 1 für jede Zeile, n für jede n-te Zeile. Alle Befehle sind mit großem Anfangsbuchstaben geschrieben (\State, \While, …), was sie am leichtesten vom alten komplett großgeschriebenen algorithmic (\STATE, \WHILE) unterscheidet.

Der Arbeitspferd-Befehl ist \State; er markiert den Beginn jeder Zeile im Pseudocode. Pro Anweisung, etwa Zuweisung oder Prozeduraufruf, setzt du ein \State. Vor blocköffnende Befehle wie \While oder \If gehört kein \State, denn diese beginnen selbst eine neue Zeile. Blockinhalte werden automatisch eingerückt, und Einrückung in der Quelle beeinflusst die Ausgabe nicht. Die wichtigsten Befehle:

• \State — Beginn einer Anweisung (Zeile); etwa \State $x \\gets 1$.
• \For{cond} … \EndFor — eine for-Schleife; die Ausgabe beginnt mit „for … do“ und endet mit „end for“. \ForAll{cond} gibt es ebenfalls.
• \While{cond} … \EndWhile — eine while-Schleife; „while … do“ / „end while“.
• \If{cond} … \ElsIf{cond} … \Else … \EndIf — eine Verzweigung; „if … then“, „else if … then“, „else“, „end if“. \ElsIf und \Else sind optional.
• \Function{name}{args} … \EndFunction — eine Funktion; „function name(args)“ / „end function“. Die Prozedurform \Procedure{name}{args} … \EndProcedure hat dieselbe Gestalt.
• \Return — ein Rückgabewert, gesetzt als „return …“ mit aufrechtem fettem Schlüsselwort.
• \Comment{...} — ein Kommentar am Zeilenende, nach einem nach rechts zeigenden Dreieck ▷.
• \Require / \Ensure — Vor- und Nachbedingungen, jeweils mit fettem Label „Require:“ / „Ensure:“ davor.

Diese Schlüsselwörter lassen sich ersetzen. Wenn die Labels statt „Require:“ und „Ensure:“ lieber „Input:“ und „Output:“ heißen sollen, definiere sie in der Präambel neu: \renewcommand{\algorithmicrequire}{\textbf{Input:}} und \renewcommand{\algorithmicensure}{\textbf{Output:}}. Ebenso kannst du durch Umdefinieren von \algorithmicwhile, \algorithmicdo und verwandten Befehlen die Wörter für Schleifen und Verzweigungen beliebig ändern.

Ein ausgearbeitetes Beispiel: algorithm + algpseudocode

Kombiniert sehen die beiden Schichten so aus: außen ein algorithm-Float, dazu \caption{…} und \label{…} für Verweise, innen die Umgebung algorithmic mit dem Pseudocode. Hier ist der klassische Algorithmus zur Berechnung der Potenz y = xⁿ.

\documentclass{article}
\usepackage{algorithm}
\usepackage{algpseudocode}
\begin{document}

\begin{algorithm}
  \caption{Calculate $y = x^n$}\label{alg:power}
  \begin{algorithmic}[1]
    \Require $n \geq 0$
    \Ensure $y = x^n$
    \State $y \gets 1$
    \State $X \gets x$
    \State $N \gets n$
    \While{$N \neq 0$}
      \If{$N$ is even}
        \State $X \gets X \times X$
        \State $N \gets N / 2$ \Comment{even case}
      \Else
        \State $y \gets y \times X$
        \State $N \gets N - 1$
      \EndIf
    \EndWhile
    \State \Return $y$
  \end{algorithmic}
\end{algorithm}

アルゴリズム~\ref{alg:power} は累乗を計算する。

\end{document}

Beim Kompilieren entsteht ein oben und unten gerahmter Kasten, der als Float auf der Seite steht und oben „Algorithm 1 Calculate y = xⁿ“ trägt (die Nummer ist automatisch). Innen werden die Zeilen links mit 1, 2, 3 … nummeriert, und die ersten beiden Zeilen zeigen Vorbedingung und Ergebnis nach fettem „Require:“ und „Ensure:“. Die \While-Zeile wird mit fettem while und abschließendem do gesetzt, der Körper eine Stufe eingerückt. Die \Comment-Notiz steht am Zeilenende nach einem nach rechts zeigenden Dreieck, und die letzte Zeile lautet return gefolgt von y. Im Text löst sich \ref{alg:power} zur Kastennummer auf (hier 1), also etwa „Algorithm 1 is…“.

Mathematik im Pseudocode ($N \\neq 0$, $y \\gets 1$) wird wie im normalen Mathematikmodus in $…$ eingeschlossen. \gets ist ein Linkspfeil (←), die übliche Schreibweise für Zuweisung. Wie immer kompilierst du ein Dokument mit algorithm zweimal, damit Nummern und Querverweise stabil werden.

Der Rivale: algorithm2e

Die andere wichtige Option ist algorithm2e. Es ist ein eigenes Ökosystem, in einem Paket selbständig, mit Container und Inhalt zugleich, und wird vor \begin{document} mit \usepackage[...]{algorithm2e} geladen. Seine Umgebung algorithm ist selbst der Float, also gibt es keine innere Körperumgebung. Auch die Syntax unterscheidet sich deutlich von algpseudocode.

Zwei Unterschiede fallen besonders auf. Erstens verwenden Eingabe und Ausgabe eigene Befehle \KwIn{…} und \KwOut{…} (oder \KwData{…} und \KwResult{…}), gesetzt als fettes „Input:“, „Output:“, „Data:“ oder „Result:“. Zweitens bekommen Verzweigungen und Schleifen ihren Körper als Klammerargument. Ein if–then–else ist \eIf{cond}{then part}{else part}; der Blockinhalt steht in { } (das e bedeutet „mit else“). \For{cond}{body} und \While{cond}{body} funktionieren genauso.

Eine weitere wichtige Regel: Jede Anweisung muss mit \\; enden (Backslash-Semikolon). Vergisst du das, läuft die nächste Anweisung in derselben Zeile weiter. Hier ein kurzes Beispiel.

\documentclass{article}
\usepackage[ruled,linesnumbered]{algorithm2e}
\begin{document}

\begin{algorithm}[H]
  \caption{Sum of positive entries}
  \KwIn{an array $a[1..n]$}
  \KwOut{the sum $s$ of its positive entries}
  $s \gets 0$\;
  \For{$i \gets 1$ \KwTo $n$}{
    \eIf{$a[i] > 0$}{
      $s \gets s + a[i]$\;
    }{
      skip\;
    }
  }
  \Return $s$\;
\end{algorithm}

\end{document}

Hier zeichnet die Option ruled Linien oben und unten mit einer Beschriftungszeile oben, und linesnumbered nummeriert jede Zeile. [H] ist ein Platzierungsparameter wie bei Abbildungen: Er fixiert den Algorithmus an Ort und Stelle, statt ihn schweben zu lassen (h, t, b, p sind ebenfalls möglich). Beachte, dass algorithm2e [H] selbst implementiert, du also das Paket float nicht separat laden musst (anders als beim älteren Paket algorithm, wo [H] \usepackage{float} erfordert). Der Kasten beginnt mit fettem „Input:“ und „Output:“; die \For-Zeile lautet for i ← 1 to n do mit eingerücktem Körper; \eIf setzt den wahren if … then-Block über den falschen else-Block. An jedem \; entsteht ein Zeilenumbruch, und die letzte Zeile gibt return s aus.

Einige Befehle verfeinern das Aussehen. \SetAlgoLined (früher \SetLine) zeichnet vertikale Linien, die Blockstruktur markieren, und \DontPrintSemicolon verhindert, dass das Zeilenende \\; in der Ausgabe erscheint. \KwTo setzt „to“ und \Return setzt „return“ als eingebaute Schlüsselwörter; auch diese lassen sich etwa ins Japanische umdefinieren. Kommentare kommen mit \tcc{…} (Form /* … */) oder \tcp{…} (Form //) hinein.

Welches verwenden?

Beide sind weit verbreitet; es geht eher um Stil als um besser oder schlechter. algorithm + algpseudocode bietet ein geradliniges, auf \State basierendes Befehlssystem und passt zu allen, die den traditionellen Pseudocode-Look mögen: Schlüsselwörter am Zeilenanfang, umrahmt von do, then, end …, oder wenn eine Konferenzvorlage ihn voraussetzt. algorithm2e ist beliebt bei expliziten Ein-/Ausgabe-Deklarationen, dem Stil mit Klammerkörpern und vertikalen Linien, sowie bei vielsprachigen Schlüsselwörtern und feiner Anpassung.

Noch einmal: Die Faustregel lautet, sich auf ein Körperpaket festzulegen. Lädt man algpseudocode und algorithm2e zugleich, kollidieren gemeinsame Befehlsnamen wie \For und \If, und es gibt Fehler. Vereinheitliche das ganze Dokument auf eines. Wenn du algorithm2e verwendest, brauchst du den Container algorithm nicht; algorithm2e definiert seine eigene Umgebung algorithm, daher kollidieren beide beim Umgebungsnamen.