O-Notation: Komplexitätsklassen im Vergleich

O-Notation anschaulich: Wachstum von O(1) bis O(n!) für Ihre Eingabegrößen als Tabelle und Diagramm, mit geschätzter Laufzeit und Zeitbudget.

Operationen und geschätzte Laufzeit
Klassen
Wachstum im Vergleich (logarithmische Achse)
Was schafft jede Klasse im Zeitbudget?
KlasseGrößtes n im Zeitbudget
Typische Laufzeiten bekannter Algorithmen
AlgorithmusZeitkomplexität
Zugriff auf Array-Element per IndexO(1)
Suche in Hash-Tabelle (Mittel)O(1), schlechtester Fall O(n)
Binäre Suche in sortierter ListeO(log n)
Suche in balanciertem Baum (B-Baum, Rot-Schwarz-Baum)O(log n)
Lineare Suche, Maximum findenO(n)
Mergesort, HeapsortO(n log n)
QuicksortMittel O(n log n), schlechtester Fall O(n²)
Bubblesort, InsertionsortO(n²), Insertionsort bei fast sortierten Daten nahe O(n)
Alle Paare vergleichen (verschachtelte Schleifen)O(n²)
Naive Matrixmultiplikation n × nO(n³)
Alle Teilmengen aufzählenO(2ⁿ)
Alle Reihenfolgen (Permutationen) aufzählenO(n!)

Alles läuft in Ihrem Browser. Eingaben verlassen Ihr Gerät nicht.

Komplexitätsklassen verständlich

Die O-Notation beschreibt, wie der Aufwand eines Algorithmus mit der Eingabegröße n wächst. Sie gehört zu den Landau-Symbolen aus der Mathematik und wird in der Informatik vor allem für die Zeitkomplexität und den Speicherbedarf verwendet. Die Big-O-Notation gibt eine obere Schranke an und lässt konstante Faktoren und kleinere Terme weg: Ein Algorithmus mit 3n² + 5n + 7 Schritten liegt in O(n²). Das Werkzeug macht diese Laufzeitkomplexität greifbar, indem es für jede Klasse die Zahl der Operationen und eine grob geschätzte Dauer ausrechnet.

Die Komplexitätsklassen von O(1) über O(log n), O(√n), O(n), O(n log n), O(n²) und O(n³) bis O(2ⁿ) und O(n!) unterscheiden sich gewaltig. Bei n = 1.000.000 braucht O(log n) etwa 20 Schritte, O(n log n) rund 20 Millionen, O(n²) eine Billion. Bei angenommenen 100 Millionen einfachen Operationen pro Sekunde sind das Sekundenbruchteile gegen fast drei Stunden. O(2ⁿ) ist schon bei n = 60 jenseits jeder praktischen Rechenzeit. Die Tabelle „Was schafft jede Klasse im Zeitbudget?“ dreht die Frage um und zeigt, welches n in der vorgegebenen Zeit noch machbar ist.

Die Zeitangaben sind Größenordnungen, keine Messungen. Echte Laufzeiten hängen von Konstanten, Cache-Verhalten, Speicherzugriffen und der Programmiersprache ab; ein O(n log n)-Verfahren kann bei kleinen n langsamer sein als ein einfaches O(n²)-Verfahren. Der Logarithmus ist hier zur Basis 2 gerechnet; in der O-Notation spielt die Basis keine Rolle, weil sie nur einen konstanten Faktor ausmacht. Für große Zahlen in anderen Zahlensystemen hilft der Zahlensysteme-Rechner.

Anleitung: O-Notation in 4 Schritten

  1. Unter „Eingabegrößen n“ die zu vergleichenden Werte eintragen, etwa 10, 1000, 1000000.
  2. Bei „Operationen pro Sekunde“ einen groben Wert für Ihren Rechner angeben, voreingestellt sind 100 Millionen.
  3. Die Tabelle zeigt für jede Komplexitätsklasse Operationen und geschätzte Laufzeit; das Diagramm stellt das Wachstum logarithmisch dar.
  4. Unter „Zeitbudget“ prüfen, welches größte n jede Klasse in der vorgegebenen Zeit schafft.

Typische Anwendungsfälle

  • Abschätzen, ob ein O(n²)-Vergleich aller Datensätze bei 100.000 Einträgen noch in Sekunden fertig wird.
  • Im Unterricht oder Vorstellungsgespräch die Komplexitätsklassen anschaulich erklären.
  • Entscheiden, ob sich ein Index oder eine Hash-Tabelle statt einer linearen Suche lohnt.
  • Grenzen von Brute-Force-Lösungen mit O(2^n) zeigen.
Fragen

Häufige Fragen

Was bedeutet O(n log n)?

Der Aufwand wächst etwas stärker als linear: n-mal ein Faktor log n. Das ist typisch für effiziente Sortierverfahren wie Mergesort. Verdoppelt sich n, wächst der Aufwand auf etwas mehr als das Doppelte.

Was ist der Unterschied zwischen O, Θ und Ω?

O gibt eine obere Schranke an, Ω eine untere und Θ beide zugleich, also das genaue Wachstum. Umgangssprachlich wird O oft gesagt, wenn eigentlich Θ gemeint ist.

Wie realistisch sind die Zeitangaben?

Sie sind grobe Größenordnungen auf Basis der eingetragenen Operationen pro Sekunde. Moderne Prozessoren schaffen je Kern einige Milliarden einfache Befehle pro Sekunde, eine Operation im Algorithmus besteht aber meist aus vielen Befehlen.

Warum wird O(2ⁿ) so schnell unbrauchbar?

Jedes zusätzliche Element verdoppelt den Aufwand. Von n = 30 auf n = 40 wächst er um den Faktor 1.024, von 30 auf 60 um mehr als eine Milliarde.

Ist O(n log n) viel langsamer als O(n)?

Nur um den Faktor log₂ n. Bei einer Million Elementen sind das etwa 20; in der Praxis entscheiden oft Konstanten und Speicherzugriffe stärker als dieser Faktor.

Welche Laufzeit haben Sortieralgorithmen?

Vergleichsbasierte Verfahren wie Mergesort und Heapsort brauchen im schlechtesten Fall O(n log n), Quicksort im Mittel O(n log n), im schlechtesten Fall O(n²). Schneller als n log n geht vergleichsbasiert nicht.

Weitere Werkzeuge

Das könnte auch helfen

Alle 558 Werkzeuge