Memoisation (engl.: Memoization) oder Memoisierung ist eine Technik, um Computerprogramme zu beschleunigen, indem Rückgabewerte von Funktionen zwischengespeichert anstatt neu berechnet werden. Memoisation ähnelt Dynamischer Programmierung, bewahrt jedoch im Gegensatz zu dieser die grundlegende Vorgehensweise des zu beschleunigenden Verfahrens.

Funktionen können nur memoisiert werden, wenn sie referenziell transparent sind, d. h., sie geben bei gleichen Eingaben immer dieselben Ausgaben zurück. Operationen, die nicht referenziell transparent sind, aber bei denen Abweichungen in der Ausgabe relativ selten zu erwarten sind, können mit anderen Methoden (wie Cache) zwischengespeichert werden. Generell haben memoisierte Ausgaben kein Ablaufdatum und müssen nicht neu berechnet werden, wie das bei Caches im Allgemeinen der Fall ist. In imperativen Programmiersprachen wird Memoisation üblicherweise in Form eines assoziativen Arrays implementiert.

In einer funktionalen Programmiersprache ist es möglich, eine Funktion höherer Ordnung memoize für jede referenziell transparente Funktion zu konstruieren. In Sprachen ohne die Möglichkeit einer Funktion höherer Ordnung muss die Memoisation separat in jede Funktion implementiert werden, die davon Gebrauch macht.

Das englische Wort memoization entstand 1968 durch Donald Michie aus seinem Artikel Memo functions and machine learning in der Zeitschrift Nature.

Memoisation ist aus dem lateinischen Wort Memorandum abgeleitet, was so viel wie „das zu Erinnernde“ bedeutet. Im allgemeinen Sprachgebrauch wird Memorandum auch Memo genannt und man kann Memoisation als eine Funktion in eine Memo umwandeln verstehen.

Das Wort Memoisation wird oft mit dem englischen Wort Memorization verwechselt, welches eine ähnliche Bedeutung aufweist.

Ein einfaches Programm, das die Fibonacci-Zahlen berechnet, ist

function fib(n)
    if (n <= 2)
        return 1
    return fib(n-1) + fib(n-2)

(Dieses Beispiel soll keine effiziente Implementierung darstellen. Es dient ausschließlich der Illustration der Memoisation.)

Weil fib mit denselben Parametern mehrmals aufgerufen wird, ist die Laufzeit der Funktion größer als O(1.6ⁿ). Falls man die Werte von fib bei der ersten Berechnung memoisiert und die Speicherreservierung und -initialisierung in O(n) vorgenommen werden kann, sinkt die Laufzeit auf O(n).

Speicher für Memo-Array memo reservieren und alle Werte darin auf 0 setzen.
Initialisiere memo[1] und memo[2] auf 1.

function fib(n)
    if (memo[n] ≠ 0) return memo[n]
    memo[n] = fib(n-1) + fib(n-2)
    return memo[n]

Anstelle eines Arrays soll nun ein assoziatives Array zur Verwendung stehen. Bietet die Programmiersprache die Möglichkeit zur Formulierung von Closures, so lässt sich eine Funktion memoize schreiben, die das Prinzip der Memoisation von fib abstrahiert.

function memoize(f)
    var memo = { }
    return function(n)
        if (n not in memo) memo[n] = f(n)
        return memo[n]

fib = memoize(fib)

Zusätzlich zur Memoisation tritt bei diesem Beispiel gleichzeitig Rekursion auf. Hierbei ist zu beachten, dass fib auch innerhalb ihrer eigenen Definition eine Variable sein muss, deren Inhalt mit der memoisierten Version überschrieben wurde. Wenn das nicht möglich ist, kann man die Memoisation alternativ in den Fixpunkt-Kombinator einbauen. Dieser ist zunächst gegeben durch:

function fix(F)
    return function f(n)
        return F(f,n)

Der modifizierte Algorithmus beinhaltet nun das zuvor beschriebene Verfahren:

function fix(F)
    var memo = { }
    return function f(n)
        if (n not in memo) memo[n] = F(f,n)
        return memo[n]

fib = fix(function(f,n))
    return 1 if n <= 2 else f(n-1) + f(n-2))

• Peter Norvig: Paradigms of Artificial Intelligence Programming. 1. Auflage. Morgan Kaufmann, 1991, ISBN 1-55860-191-0, S. 269–275. 
• Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest und Clifford Stein, 2001. Introduction to Algorithms. 2. Auflage, MIT Press & McGraw-Hill. ISBN 0-262-03293-7. S. 347ff.

• Memoize – Memoize ist eine kleine Bibliothek für Memoisation in Common Lisp. Es wurde von Tim Bradshaw geschrieben.
• Memoize.pm – ein Perl-Modul, welches memoisierte Unterroutinen enthält.
• Java Memoisation – ein Beispiel in Java, welches eine dynamische Proxyklasse benutzt.
• memoize – ein Ruby-Modul mit Memoise-Methoden.
• Python Memoisation – ein Beispiel der Memoisation in Python.