Mathematisch-axiomatische und -algebraische Methode

STACK (wird hier definiert)
ELEMENT (ein hier nicht definierter ADT, mit dem der Stack arbeitet)
BOOL

emptyStack: → STACK (erzeugt einen leeren Stack)
isStackEmpty: STACK → BOOL (fragt nach, ob der Stack leer ist)
push: ELEMENT × STACK → STACK (packt ein Element oben auf den Stack)
pop: STACK → STACK (entfernt das oberste Element und gibt den neuen Stack zurück)
top: STACK → ELEMENT (gibt das oberste Element zurück, ohne es zu entfernen)

QUEUE
ELEMENT
BOOL

emptyQueue: → QUEUE
isQueueEmpty: QUEUE → BOOL
enqueue: ELEMENT × QUEUE → QUEUE (fügt ein Element hinten an)
dequeue: QUEUE → QUEUE (entfernt das vorderste Element)
head: QUEUE → ELEMENT (gibt das vorderste Element zurück, ohne es zu entfernen)

Informelle Methode (Java)

public interface IStack<E> {

    public boolean isStackEmpty();
    public IStack<E> push(E elem);
    public IStack<E> pop();
    public E top();
}

public interface IQueue<E> {

    public boolean isQueueEmpty();
    public IQueue<E> enqueue(E elem);
    public IQueue<E> dequeue();
    public E head();
}

Spezifikation durch eine funktionale Programmiersprache (Haskell)

data Stack e = E | S e (Stack e)
isStackEmpty :: Stack a → Bool
push :: e → Stack e → Stack e
pop :: Stack e → Stack e
top :: Stack e → e

data Queue e = E | Q (Queue e) e
isQueueEmpty :: Queue e → Bool
enqueue :: e → Queue e → Queue e
dequeue :: Queue e → Queue e
head :: Queue e → e

Mathematisch-axiomatische Methode

 x: ELEMENT
 s: STACK
 isStackEmpty(emptyStack()) = TRUE
 isStackEmpty(push(x,s)) = FALSE
 pop(emptyStack()) = ERROR
 pop(push(x,s)) = s
 top(emptyStack()) = ERROR
 top(push(x,s)) = x
 push(top(s),pop(s)) = s, falls s nicht leer

 x: ELEMENT
 q: QUEUE
 isQueueEmpty(emptyQueue()) = TRUE
 isQueueEmpty(enqueue(x,q)) = FALSE
 head(emptyQueue()) = ERROR
 head(enqueue(x,q)) = IF isQueueEmpty(q) THEN x ELSE head(q)
 dequeue(emptyQueue()) = ERROR
 dequeue(enqueue(x,q)) = IF isQueueEmpty(q) THEN q ELSE enqueue(x, dequeue(q))

Mathematisch-algebraische Methode

SETS ELEMENT = E (Menge der Elemente) ${\displaystyle x\in E}$
     STACK = S = ${\displaystyle \lbrace \langle \rangle \rbrace \cup \lbrace \langle x_{1}{,}...{,}x_{n}\rangle |x_{i}\in E\land \ n\in \mathbb {N} \land n\geq 1\rbrace }$
FUNCTIONS
    emptyStack      = ${\displaystyle \langle \rangle }$
    isStackEmpty(S) = ${\displaystyle (S==\langle \rangle )}$
    push(S,x)       = ${\displaystyle \langle x\rangle }$, falls ${\displaystyle (S==\langle \rangle )}$
                    = ${\displaystyle \langle x_{1}{,}...{,}x_{n}{,}x\rangle }$, falls ${\displaystyle (S==\langle x_{1}{,}...{,}x_{n}\rangle )}$
    top(S)          = ${\displaystyle \perp }$, falls ${\displaystyle (S==\langle \rangle )}$
                    = ${\displaystyle x_{n}\,}$, falls ${\displaystyle (S==\langle x_{1}{,}...{,}x_{n}\rangle ,n\geq 1)}$
    pop(S)          = ${\displaystyle \perp }$, falls ${\displaystyle (S==\langle \rangle )}$
                    = ${\displaystyle \langle \rangle }$, falls ${\displaystyle (S==\langle x\rangle )}$
                    = ${\displaystyle \langle x_{1}{,}...{,}x_{n-1}\rangle }$, falls ${\displaystyle (S==\langle x_{1}{,}...{,}x_{n}\rangle ,n\geq 2)}$

SETS ELEMENT = E (Menge der Elemente) ${\displaystyle x\in E}$
     QUEUE = Q = ${\displaystyle \lbrace \langle \rangle \rbrace \cup \lbrace \langle x_{1}{,}...{,}x_{n}\rangle |x_{i}\in E\land \ n\in \mathbb {N} \land n\geq 1\rbrace }$
FUNCTIONS
    emptyQueue      = ${\displaystyle \langle \rangle }$
    isQueueEmpty(Q) = ${\displaystyle (Q==\langle \rangle )}$
    enqueue(Q,x)    = ${\displaystyle \langle x\rangle }$, falls ${\displaystyle (Q==\langle \rangle )}$
                    = ${\displaystyle \langle x{,}x_{1}{,}...{,}x_{n}\rangle }$, falls ${\displaystyle (Q==\langle x_{1}{,}...{,}x_{n}\rangle )}$
    head(Q)         = ${\displaystyle \perp }$, falls ${\displaystyle (Q==\langle \rangle )}$
                    = ${\displaystyle x_{n}\,}$, falls ${\displaystyle (Q==\langle x_{1}{,}...{,}x_{n}\rangle ,n\geq 1)}$
    dequeue(Q)      = ${\displaystyle \perp }$, falls ${\displaystyle (Q==\langle \rangle )}$
                    = ${\displaystyle \langle \rangle }$, falls ${\displaystyle (Q==\langle x\rangle )}$
                    = ${\displaystyle \langle x_{1}{,}...{,}x_{n-1}\rangle }$, falls ${\displaystyle (Q==\langle x_{1}{,}...{,}x_{n}\rangle ,n\geq 2)}$

Informelle Methode (Java)

Semantik: durch Angabe von Voraussetzung und Effekt/Ergebnis der Methode (beim objektorientierten Programmieren entfällt meist die Notwendigkeit, als Voraussetzung die Existenz der Datenstruktur anzugeben, da die Methode an ein Objekt gebunden ist, was schon existiert).

public interface IStack<E> {
    // Konstruktor in der konkreten Klasse

    // Ergebnis: true, wenn der Stack leer ist, false andernfalls
    public boolean isStackEmpty();

    // Effekt: Der Stack enthält das Element elem als oberstes Element.
    // Ergebnis: Der Stack nach dem Einfügen des Elements elem.
    public IStack<E> push(E elem);

    // Voraussetzung: Der Stack ist nicht leer.
    // Effekt: Das oberste Element wird vom Stack gelöscht.
    // Ergebnis: Der Stack nach dem Löschen.
    public IStack<E> pop();

    // Voraussetzung: Der Stack ist nicht leer.
    // Ergebnis: Das oberste Element.
    public E top();
}
public interface IQueue<E> {
    public boolean isQueueEmpty();
    public IQueue<E> enqueue(E elem);
    public IQueue<E> dequeue();
    public E head();
}

Spezifikation durch eine funktionale Programmiersprache (Haskell)

emptyStack = E
isStackEmpty E = True
isStackEmpty (S x xs) = False
push e xs = S e xs
pop (S x xs) = xs
top (S x xs) = x

emptyQueue = E
isQueueEmpty E = True
isQueueEmpty (Q xs x) = False
enqueue e xs = Q xs e
dequeue E = E
dequeue (Q (E) x) = E
dequeue (Q (Q ys y) x) = enqueue x (dequeue (Q ys y))
head E = error "Queue ist leer."
head (Q (E) x) = x
head (Q (Q ys y) x) = head (Q ys y)