Ein Weg · ein nächster Schritt

Du kannst das. Jetzt wird geroutet.

Das 17er-Aufgabentraining ist dein Lernkern. Die Hilfen machen die Aufgaben handhabbar; diese Seite klärt nur noch, was zuerst kommt, wann du simulierst und was du geschlossen abrufen musst.

Aktueller Befund: „So schwer ist es dann doch nicht.“ Das ist relevante Evidenz. Nicht wieder bei null anfangen — im funktionierenden Aufgabenloop weitergehen.

Was dich wirklich erwartet

Belegte Fakten, klausurnahe Hinweise und Unbekanntes bleiben sichtbar getrennt. Keine erfundene Sicherheit.

Bestätigt 80 Punkte · 90 Minuten

80 Punkte/90 Minuten: Vorlesungsfolien und Modulkatalog. Termin 20.07.2026 · 13:15 Uhr · H1006: lokaler Prüfungsplan.

Bestätigt Keine Hilfsmittel

Symbole.pdf ist ein Informationsblatt, keine nachgewiesene Formelsammlung. Der Lernzettel unten ist nur zum Einprägen.

Klausurnah 17 Übungsaufgaben

Probeklausur.pdf ist eine Aufgabensammlung mit Lösungen und ohne Vollständigkeitsanspruch — keine echte Alt- oder Probeklausur.

Unbekannt Reale Gewichtung

Aufgabenzahl, Themenpunkte und Bestehensgrenze sind lokal nicht belegt. Häufigkeiten unten sind Trainingssignale, keine Prognose.

Dein nächster Zug

Kein neuer Diagnose-Marathon. Öffne genau die nächste Aufgabe und nutze dort die gestuften Hilfen.

  1. 1 SelectionSort
    Schleifen → Summe → Θ(n²)     offen
  2. 2 Pointer & Liste
    -> lesen → Knoten zählen → Θ(k)     offen
  3. 3 Lineare Rekurrenz
    Basis → ausrollen → geschlossene Form     offen

Wann du prüfungsnah arbeitest

Die Gates sind Lernempfehlungen, keine Sperren. Ein bewusster Test ist erlaubt; unbewusstes Springen nicht.

noch nicht empfohlen

35-Minuten-Mini

Empfohlen, sobald A1–A3 vollständig bis zum korrekten Abschluss gelöst und als Sitzt markiert sind: Schleifenzählen, Pointerlesen, lineare Rekurrenz.

Trotzdem starten
noch nicht empfohlen

90-Minuten-Simulation

Empfohlen nach abgegebener und vollständig bewerteter Mini-Simulation plus zwei schriftlich gelösten, veränderten Transferfällen. Keine Bestehensprognose.

Trotzdem starten

Vier Tage, kein Materialchaos

Der Browserfortschritt entscheidet innerhalb eines Blocks, die Reihenfolge bleibt fix. Wenn etwas schon sitzt, geht es weiter.

Do · 16.07.

Code → Laufzeit

  • A1 SelectionSort
  • A2 Pointer/Liste
  • A3 Rekurrenz
  • je ein Prüfungssatz
Fr · 17.07.

Fälle & Mini-Code

  • A4/A5 Funktionen
  • A6/A7 Big-O
  • A8/A9 Stack/Liste
  • 5–15 Zeilen schreiben
Sa · 18.07.

Strukturen & Mini

  • A10–A12 Bäume/BST
  • A13–A17 Rest
  • 35-Minuten-Mini
  • zwei Fehler wählen
So · 19.07.

Reparatur & 90

  • zwei Transferfälle
  • 90 Minuten ohne Hilfe
  • Fehler statt Note
  • Closed-Book-Abruf

Was die 17 Aufgaben trainieren

Nicht als Klausurwahrscheinlichkeit lesen. Das ist nur die Verteilung in der lokalen Aufgabensammlung.

AufgabenfamilieAufgabenAnzahlSignal in der Sammlung
Laufzeit, Codeanalyse, Big-OA1–A77
Binärbaum/BSTA10–A123
Lineare ADTs implementierenA8–A92
RekursionA13–A142
2-3-4-BäumeA15–A162
Hashing/SondierenA171

Kursstoff wie breiteres Sortieren/Heap, Greedy und Backtracking kommt in Übungsblättern und Folien vor, obwohl er in den 17 Aufgaben kaum oder nicht vertreten ist. Deshalb enthält die 90-Minuten-Runde Transferanteile.

Kurze Videoanker: Begriffe

Kein Podcastpfad. Erst selbst versuchen; nur bei einer konkreten Lücke maximal 68 Sekunden ansehen und sofort zur Aufgabe zurück.

1:06S01 · Big-O als obere Schranke
Wenn die Bedeutung von O unscharf ist. 0:58S02 · Best, Average, Worst
Wenn du den passenden Eingabefall nicht findest. 1:08S03 · Komplexitätsklassen
Wenn die Wachstumsreihenfolge fehlt. AKTIVZurück ins 17er-Training
Hilfen öffnen, einen Zug machen, Sitzt/Wackelt markieren.

Deine drei belegten Lücken

Nicht geraten, sondern aus der Lernsession vom 16.07. abgelesen (lernstand/EineStundeLernenErfolg.txt). Das sind die Stellen, an denen du in 56 Minuten nachweislich danebenlagst — teilweise zweimal.

1:09L01 · n·m ist nicht n²
Zweimal falsch: Zwei verschachtelte Schleifen lösen bei dir automatisch „n²“ aus. Entscheidend ist, ob die innere über dieselbe Größe läuft. 1:26L02 · Kette gegen Verzweigung
„Nein, was? Das verstehe ich nicht.“ — Ein Aufruf ergibt n, zwei ergeben 2ⁿ. Bei derselben Verkleinerung um 1. 1:07L03 · k gegen h
„Dreimal falsch geklickt.“ — Traversierung besucht alle k Knoten, Suche läuft nur einen Pfad der Höhe h. Außer der Baum entartet.

Zweiseitiger ADS-Lernzettel

Zum Abrufen und Faltenlernen. Laut Vorlesungsfolien sind in der Klausur keine Hilfsmittel erlaubt.

Nicht als Klausurhilfsmittel zugelassen. Vor der Simulation aus dem Gedächtnis rekonstruieren, dann abgleichen.

ADS Lernzettel · 1/2

Code → Arbeit → Laufzeit

Lernzettel – in der Klausur nicht als Hilfsmittel zugelassen.

C++-Decoder

T* pp zeigt auf ein T
p->xFeld x des gezeigten Objekts
a[i]Element an Index i
nullptr/0kein gültiger Knoten
++ii um 1 erhöhen
x % mRest von x geteilt durch m
return xFunktion endet mit x
new/deleteanlegen/freigeben

Laufzeit-Rezept

  1. Eingabegröße benennen: n, k, Höhe h …
  2. Zentrale Operation markieren.
  3. Schleifen/rekursive Aufrufe zählen.
  4. Best/Worst durch konkrete Eingaben begründen.
  5. Term vereinfachen; Klasse plus Satz nennen.

Klausursatz: „Der Vergleich läuft …-mal. Da …, gilt im Best/Worst Case Θ(…).“

Zählen

Nacheinander:  T₁ + T₂ → Maximum dominiert
Unabhängig verschachtelt: T₁ · T₂
1+2+…+(n−1) = n(n−1)/2 ∈ Θ(n²)
Halbieren bis 1: log₂(n) Schritte
Frühes return: Best/Worst getrennt

Rekurrenz-Muster

T(n)=T(n−1)+c   → Θ(n)
T(n)=T(n/2)+c   → Θ(log n)
T(n)=2T(n−1)+c  → Θ(2ⁿ)

Immer: Basisfall angeben, 2–3-mal einsetzen, Form ohne T(…) hinschreiben.

Wachstumsordnung

1 < log n < n < n log n < n² < n³ < 2ⁿ < n!
  • Konstanten fallen weg.
  • Dominanter Term bleibt.
  • O ist Schranke, nicht automatisch Worst Case.
  • Θ beschreibt passende obere und untere Schranke.

Sortieren: Mindestwissen

VerfahrenBestWorst
Selectionn²n²
Insertionnn²
Mergen log nn log n
Quickn log nn²
Heapn log nn log n
Countingn+kn+k

ADS Lernzettel · 2/2

Datenstrukturen → Teilpunkte

Lernzettel – in der Klausur nicht als Hilfsmittel zugelassen.

Array, Liste, Stack, Queue

  • Arrayzugriff per Index: Θ(1).
  • Liste vollständig laufen: Θ(k); p=p->next.
  • Stack = LIFO; push/pop am Top: Θ(1).
  • Queue = FIFO; enqueue hinten, dequeue vorne: Θ(1) mit Zeigern.
  • Pointer ändern: alten Rest erst sichern, dann umhängen, dann löschen.

BST & Traversierung

BST: links kleiner | Knoten | rechts größer
InOrder:  links – Knoten – rechts
PreOrder: Knoten – links – rechts
PostOrder: links – rechts – Knoten

Search/Insert/Delete: Θ(h), balanciert Θ(log n), entartet Θ(n). Zwei Kinder löschen: Vorgänger oder Nachfolger übernehmen.

Rekursives Baum-Skelett

f(node* n) {
  if (n == nullptr) return BASIS;
  L = f(n->left);
  R = f(n->right);
  return KOMBINIERE(n,L,R);
}

Höhe mit leer=0: 1+max(L,R). Anzahl: 1+L+R.

Heap

  • Min-Heap: Eltern ≤ Kinder; Form ist vollständig.
  • Einfügen: hinten + bubble-up; Best Θ(1), Worst Θ(log n).
  • delete-min: letztes nach oben + bubble-down; Best Θ(1), Worst Θ(log n).
  • Minimum ansehen Θ(1), Heapbau Θ(n), HeapSort Θ(n log n).
  • Beim bubble-down mit dem kleineren Kind tauschen.

2-3-4 & Hashing

  • 2-3-4: 1–3 Schlüssel; sortiert; alle Blätter gleiche Tiefe.
  • Vollen Knoten splitten: Mitte steigt auf, Ränder werden Kinder.
  • Hashstart meist x mod m.
  • Lineares/quadratisches Sondieren: jeden besuchten Index zeigen.
  • Hashing erwartet Θ(1), bei Kollisionen Worst Θ(n).

Prüfungsantwort & Teilpunkte

  1. Vorbedingung/Eingabegröße nennen.
  2. Mechanik oder Invariante nennen.
  3. Zwischenzustände sichtbar hinschreiben.
  4. Ergebnis mit Begründungssatz abschließen.
  5. Wenn unsicher: Skelett, Basisfall, Schleifenzahl oder korrekten ersten Schritt notieren.

Nicht verwechseln: Funktionswert ≠ Laufzeit; Ergebniswachstum ≠ Aufrufzahl; „O(n²)“ ohne Zählargument verschenkt Begründung.