Rekursion und Mengenoperationen in Racket: Ein Leitfaden für CSCI 301 Lab 4

Einführung in Racket und Rekursion

Willkommen zu deinem Tutorial für CSCI 301 Lab 4 – Racket Programmierung mit Rekursion und Mengenoperationen. Dieses Lab konzentriert sich auf die Implementierung von set-equal?, union und intersect unter Verwendung von Rekursion. Da der Abgabetermin naht und die Olympischen Spiele 2026 in Mailand-Cortina anstehen, lass uns die Logik hinter diesen Funktionen mit einem sportlichen Beispiel veranschaulichen: Stell dir vor, du verwaltest Athleten-IDs aus verschiedenen Disziplinen – Rekursion hilft dir, Dopplungen zu vermeiden und Teams korrekt zu kombinieren.

Warum Rekursion und nicht Iteration?

In Racket ist Rekursion der natürliche Weg, um über Listen zu iterieren, da die Sprache funktional ist. Du darfst keine Seiteneffekte wie set! verwenden. Stattdessen baust du Lösungen, die sich selbst aufrufen, bis ein Basisfall erreicht ist. Das ist wie bei einer Staffellauf-Übergabe: Jeder Läufer gibt den Staffelstab (die Liste) an den nächsten weiter, bis das Ziel (die leere Liste) erreicht ist.

Die Grundlagen: set-equal? implementieren

Die Funktion set-equal? prüft, ob zwei Mengen (dargestellt als Listen) gleich sind. Zwei Mengen sind gleich, wenn sie dieselben Elemente enthalten, unabhängig von der Reihenfolge. Formal: Jedes Element von L1 ist in L2 enthalten und umgekehrt. Wir nutzen die Hilfsfunktion subset?, die rekursiv prüft, ob alle Elemente der ersten Liste in der zweiten vorkommen.

(define (subset? L1 L2)
  (cond
    [(null? L1) #t]
    [(member? (car L1) L2) (subset? (cdr L1) L2)]
    [else #f]))

(define (set-equal? L1 L2)
  (and (subset? L1 L2) (subset? L2 L1)))

Beachte, dass member? in Racket standardmäßig mit equal? vergleicht. Da unsere Listen verschachtelte Elemente enthalten können, reicht member aus. Für tiefe Gleichheit müsstest du equal? selbst rekursiv definieren, aber hier genügt die eingebaute Funktion.

Beispiele aus der Praxis: Gaming-Lootboxen

Stell dir vor, du vergleichst zwei Lootbox-Inhalte aus einem aktuellen Spiel. Box A enthält '(1 (2 3) 4), Box B enthält '((3 2) 1 4). Da die Reihenfolge egal ist, sind sie gleich – set-equal? gibt #t zurück. Ein falsches Beispiel: '(1 2 3) vs. '((1 2 3)) – hier ist die erste Liste eine flache Liste, die zweite eine Liste mit einer Liste als Element. Sie sind nicht gleich, weil die Struktur unterschiedlich ist.

Vereinigung und Schnittmenge: union und intersect

Die Vereinigung zweier Mengen enthält alle Elemente, die in mindestens einer der beiden Mengen vorkommen, ohne Duplikate. Die Schnittmenge enthält nur Elemente, die in beiden Mengen vorkommen. Beide Operationen lassen sich rekursiv implementieren.

Implementierung von union

Die Idee: Gehe die erste Liste durch und füge jedes Element zur Vereinigung hinzu, wenn es nicht bereits in der zweiten Liste enthalten ist. Dann hänge die zweite Liste an (da sie bereits einzigartig ist, wenn wir von Mengen ausgehen).

(define (union S1 S2)
  (cond
    [(null? S1) S2]
    [(member? (car S1) S2) (union (cdr S1) S2)]
    [else (cons (car S1) (union (cdr S1) S2))]))

Beispiel: (union '(1 (2) 3) '(3 2 1)) ergibt '(1 (2) 3 2) oder eine andere Reihenfolge. Die Elemente 1 und 3 sind bereits in S2, also werden sie nicht hinzugefügt; (2) wird hinzugefügt, da es nicht in S2 ist. Beachte, dass 2 (nicht verschachtelt) in S2 vorkommt, aber (2) (eine Liste) nicht – deshalb wird es aufgenommen.

Implementierung von intersect

Für die Schnittmenge durchläufst du die erste Liste und behältst nur die Elemente, die auch in der zweiten Liste vorkommen.

(define (intersect S1 S2)
  (cond
    [(null? S1) '()]
    [(member? (car S1) S2) (cons (car S1) (intersect (cdr S1) S2))]
    [else (intersect (cdr S1) S2)]))

Beispiel: (intersect '((1) (2) (3)) '((2) (3) (4))) ergibt '((2) (3)). Die Elemente (2) und (3) kommen in beiden Listen vor, also werden sie aufgenommen.

Häufige Fehler und Tipps

• Vergleich von verschachtelten Listen: Verwende equal? oder member mit dem eingebauten equal?, nicht eq? oder =.
• Reihenfolge der Ausgabe: Die Reihenfolge der Elemente in deiner Ausgabe kann von den Beispielen abweichen – das ist in Ordnung, solange die Menge korrekt ist.
• Keine Seiteneffekte: Verwende keine set! oder Schleifen. Rekursion ist der einzig erlaubte Weg.
• Basisfall nicht vergessen: Jede rekursive Funktion braucht einen Basisfall, der die leere Liste behandelt.

Trendbezug: KI-gestützte Playlist-Verwaltung

Stell dir vor, du entwickelst eine KI für eine Musik-Streaming-App, die Playlists aus verschiedenen Quellen zusammenführt. Die Playlists sind Mengen von Song-IDs. Mit union erstellst du eine Master-Playlist ohne Duplikate, mit intersect findest du Songs, die in beiden Quellen vorkommen – nützlich für Kollaborationen. Genau diese Logik wendest du in diesem Lab an.

Testen deiner Funktionen

Erstelle eine Datei lab04.rkt mit allen Definitionen. Teste mit den gegebenen Beispielen und eigenen Fällen, besonders mit verschachtelten Listen. Denke daran: Die Funktionen müssen rekursiv sein und ohne Seiteneffekte auskommen.

; Testfälle
(displayln (set-equal? '(1 (2 3)) '((3 2) 1))) ; #t
(displayln (set-equal? '(1 2 3) '((3 2) 1))) ; #f
(displayln (union '((1 2 3)) '((3 2 1)))) ; ((1 2 3))
(displayln (intersect '((1) (2) (3)) '((2) (3) (4)))) ; ((2) (3))

Zusammenfassung

Mit diesen Implementierungen hast du die Grundlagen für Racket-Rekursion und Mengenoperationen gemeistert. Diese Konzepte sind nicht nur für dein Lab wichtig, sondern auch für weiterführende Themen wie funktionale Programmierung und Datenstrukturen. Viel Erfolg bei deiner Abgabe!