Labor 6: Strukturen Teil 2 & Rekursion - Fortgeschrittene Programmierung

Zurück zur Startseite

Lernziele

In diesem Labor werden Sie:

Teil 1 - Strukturen: Arrays von Strukturen erstellen und durchlaufen
Teil 1 - Strukturen: Strukturen an Funktionen übergeben (Call by Value)
Teil 1 - Strukturen: Zeiger auf Strukturen und den Pfeil-Operator verwenden
Teil 2 - Rekursion: Verstehen, was Rekursion ist (Funktion ruft sich selbst auf)
Teil 2 - Rekursion: Basisfall und Rekursionsfall erkennen
Teil 2 - Rekursion: Einfache rekursive Funktionen implementieren

Wichtige Konzepte

Array von Strukturen: struct Person klasse[30];
Zugriff: klasse[i].name - erst Index, dann Komponente
Pfeil-Operator: ptr->name statt (*ptr).name
Rekursion = Funktion ruft sich selbst auf
Jede Rekursion braucht: Basisfall (wann aufhören?) + Rekursionsfall (Selbstaufruf mit kleinerem Problem)

Teil 1: Arrays von Strukturen & Funktionen (ca. 60 Min)

1 Studentenliste erstellen

Aufgabenstellung

Erstellen Sie ein Array von Strukturen für 3 Studenten und geben Sie alle Daten aus.

Array von Strukturen

Statt einzelner Variablen können wir viele Strukturen in einem Array speichern:

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

// Array mit 3 Studenten
struct Student klasse[3] = {
    {"Anna", 12345, 1.7},
    {"Ben", 12346, 2.3},
    {"Clara", 12347, 1.0}
};

// Zugriff: klasse[0].name -> "Anna"

Anforderungen

Definieren Sie eine Struktur Student mit name, matrikelnummer, note
Erstellen Sie ein Array mit 3 Studenten (initialisiert)
Geben Sie alle Daten mit einer Schleife aus

Beispielausgabe

--- Studentenliste ---
Student 1: Anna, Matr: 12345, Note: 1.70
Student 2: Ben, Matr: 12346, Note: 2.30
Student 3: Clara, Matr: 12347, Note: 1.00

Musterlösung Falsches Passwort!

#include <stdio.h>

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

int main() {
    // Array mit 3 Studenten initialisieren
    struct Student klasse[3] = {
        {"Anna", 12345, 1.7},
        {"Ben", 12346, 2.3},
        {"Clara", 12347, 1.0}
    };

    printf("--- Studentenliste ---\n");

    for (int i = 0; i < 3; i++) {
        printf("Student %d: %s, Matr: %d, Note: %.2f\n",
               i + 1,
               klasse[i].name,
               klasse[i].matrikelnummer,
               klasse[i].note);
    }

    return 0;
}

2 Struktur an Funktion übergeben

Aufgabenstellung

Schreiben Sie eine Funktion, die einen Studenten ausgibt (Call by Value).

Call by Value bei Strukturen

Bei der Übergabe wird eine Kopie der gesamten Struktur erstellt:

void zeigeStudent(struct Student s) {
    printf("Name: %s\n", s.name);
    printf("Note: %.2f\n", s.note);
}

// Aufruf:
zeigeStudent(klasse[0]);  // Kopie von klasse[0] wird übergeben

Anforderungen

Schreiben Sie eine Funktion zeigeStudent(struct Student s)
Die Funktion gibt alle Daten des Studenten aus
Rufen Sie die Funktion für jeden Studenten im Array auf

Musterlösung Falsches Passwort!

#include <stdio.h>

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

// Funktion: Struktur als Parameter (Call by Value)
void zeigeStudent(struct Student s) {
    printf("Name: %s\n", s.name);
    printf("Matrikelnummer: %d\n", s.matrikelnummer);
    printf("Note: %.2f\n", s.note);
    printf("---\n");
}

int main() {
    struct Student klasse[3] = {
        {"Anna", 12345, 1.7},
        {"Ben", 12346, 2.3},
        {"Clara", 12347, 1.0}
    };

    printf("=== Alle Studenten ===\n");

    for (int i = 0; i < 3; i++) {
        zeigeStudent(klasse[i]);  // Kopie wird übergeben
    }

    return 0;
}

3 Der Pfeil-Operator

Aufgabenstellung

Verwenden Sie einen Zeiger auf eine Struktur und den Pfeil-Operator.

Pfeil-Operator (->)

Bei Zeigern auf Strukturen verwenden wir -> statt dem Punkt:

struct Student s = {"Max", 99999, 1.0};
struct Student *ptr = &s;  // Zeiger auf s

// Mit Pfeil-Operator:
printf("%s\n", ptr->name);     // einfach!

// Äquivalent (aber umständlich):
printf("%s\n", (*ptr).name);   // erst dereferenzieren, dann Punkt

Anforderungen

Erstellen Sie einen Studenten
Erstellen Sie einen Zeiger auf diesen Studenten
Geben Sie die Daten mit dem Pfeil-Operator aus
Ändern Sie die Note über den Zeiger auf 1.3

Musterlösung Falsches Passwort!

#include <stdio.h>

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

int main() {
    struct Student s = {"Max", 99999, 2.0};

    // Zeiger auf die Struktur
    struct Student *ptr = &s;

    // Zugriff mit Pfeil-Operator
    printf("Name: %s\n", ptr->name);
    printf("Matrikel: %d\n", ptr->matrikelnummer);
    printf("Note vorher: %.2f\n", ptr->note);

    // Note ändern über Zeiger
    ptr->note = 1.3;

    printf("Note nachher: %.2f\n", ptr->note);
    printf("Original auch geändert: %.2f\n", s.note);

    return 0;
}

4 Struktur ändern (Call by Reference)

Aufgabenstellung

Schreiben Sie eine Funktion, die die Note eines Studenten verbessert.

Call by Reference für Änderungen

Um das Original zu ändern, übergeben wir die Adresse:

void verbessereNote(struct Student *s) {
    s->note -= 0.3;  // Original wird geändert!
}

// Aufruf:
verbessereNote(&student);  // Adresse übergeben

Anforderungen

Schreiben Sie verbessereNote(struct Student *s)
Die Funktion soll die Note um 0.3 verbessern (verringern)
Minimum ist 1.0
Testen Sie mit einem Studenten

Musterlösung Falsches Passwort!

#include <stdio.h>

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

// Call by Reference: Zeiger auf Struktur
void verbessereNote(struct Student *s) {
    s->note -= 0.3;

    // Minimum ist 1.0
    if (s->note < 1.0) {
        s->note = 1.0;
    }
}

int main() {
    struct Student s = {"Lisa", 11111, 2.0};

    printf("Note vorher: %.2f\n", s.note);

    verbessereNote(&s);  // Adresse übergeben!

    printf("Note nachher: %.2f\n", s.note);

    // Nochmal verbessern
    verbessereNote(&s);
    printf("Nach 2. Verbesserung: %.2f\n", s.note);

    return 0;
}

5 Besten Studenten finden

Aufgabenstellung

Finden Sie den Studenten mit der besten Note in einem Array.

Anforderungen

Array mit 4 Studenten erstellen
Studenten mit der niedrigsten Note (= beste Note) finden
Name und Note des besten Studenten ausgeben

Beispielausgabe

Beste/r Student/in: Clara mit Note 1.00

Musterlösung Falsches Passwort!

#include <stdio.h>

struct Student {
    char name[50];
    int matrikelnummer;
    double note;
};

int main() {
    struct Student klasse[4] = {
        {"Anna", 12345, 1.7},
        {"Ben", 12346, 2.3},
        {"Clara", 12347, 1.0},
        {"David", 12348, 1.3}
    };
    int n = 4;

    // Besten finden (kleinste Note = beste)
    int bestIndex = 0;

    for (int i = 1; i < n; i++) {
        if (klasse[i].note < klasse[bestIndex].note) {
            bestIndex = i;
        }
    }

    printf("Beste/r Student/in: %s mit Note %.2f\n",
           klasse[bestIndex].name,
           klasse[bestIndex].note);

    return 0;
}

Teil 2: Rekursion (ca. 60 Min)

Schema: So schreibst du rekursive Funktionen

Basisfall definieren: Bei welchem Wert hört die Rekursion auf? (z.B. n == 0)
Rekursionsfall schreiben: Wie wird das Problem kleiner? (z.B. n - 1)
Ergebnis kombinieren: Was passiert mit dem Rückgabewert? (z.B. n * fakultaet(n-1))

6 Rekursiver Countdown

Aufgabenstellung

Schreiben Sie eine rekursive Funktion für einen Countdown.

Rekursion: Funktion ruft sich selbst auf

Jede rekursive Funktion braucht:

Basisfall: Wann hört die Rekursion auf?
Rekursionsfall: Aufruf mit kleinerem Problem

void countdown(int n) {
    if (n == 0) {           // Basisfall
        printf("Start!\n");
        return;
    }
    printf("%d...\n", n);
    countdown(n - 1);       // Rekursionsfall: kleineres n
}

Anforderungen

Funktion countdown(int n) schreiben
Bei n=0: "Start!" ausgeben und zurückkehren
Sonst: n ausgeben und countdown(n-1) aufrufen

Beispielausgabe für countdown(5)

..
..
..
..
..
Start!

Musterlösung Falsches Passwort!

#include <stdio.h>

void countdown(int n) {
    // Basisfall: Bei 0 aufhören
    if (n == 0) {
        printf("Start!\n");
        return;
    }

    // Rekursionsfall
    printf("%d...\n", n);
    countdown(n - 1);  // Selbstaufruf mit n-1
}

int main() {
    countdown(5);
    return 0;
}

7 Fakultät rekursiv

Aufgabenstellung

Berechnen Sie die Fakultät n! rekursiv.

Rekursive Definition der Fakultät

n! = n * (n-1)!
0! = 1  (Basisfall)

Beispiel: 5! = 5 * 4! = 5 * 4 * 3! = 5 * 4 * 3 * 2! = 5 * 4 * 3 * 2 * 1! = 5 * 4 * 3 * 2 * 1 * 0!
        = 5 * 4 * 3 * 2 * 1 * 1 = 120

Anforderungen

Funktion int fakultaet(int n) schreiben
Basisfall: 0! = 1
Rekursionsfall: n! = n * (n-1)!

Musterlösung Falsches Passwort!

#include <stdio.h>

int fakultaet(int n) {
    // Basisfall
    if (n == 0) {
        return 1;
    }

    // Rekursionsfall: n! = n * (n-1)!
    return n * fakultaet(n - 1);
}

int main() {
    for (int i = 0; i <= 6; i++) {
        printf("%d! = %d\n", i, fakultaet(i));
    }
    return 0;
}

8 Summe 1 bis n rekursiv

Aufgabenstellung

Berechnen Sie die Summe 1 + 2 + 3 + ... + n rekursiv.

Rekursive Definition

summe(0) = 0 (Basisfall)
summe(n) = n + summe(n-1)

Beispiel

summe(5) = 5 + summe(4) = 5 + 4 + summe(3) = ... = 5+4+3+2+1+0 = 15

Musterlösung Falsches Passwort!

#include <stdio.h>

int summe(int n) {
    // Basisfall
    if (n == 0) {
        return 0;
    }

    // Rekursionsfall: n + Summe der vorherigen
    return n + summe(n - 1);
}

int main() {
    int n = 5;
    printf("Summe 1 bis %d = %d\n", n, summe(n));

    n = 10;
    printf("Summe 1 bis %d = %d\n", n, summe(n));

    return 0;
}

Zusammenfassung

Thema	Wichtige Punkte
Array von Strukturen	`struct X arr[n];` - Zugriff: `arr[i].feld`
Funktion + Struktur	Call by Value = Kopie, Call by Reference = Adresse (&)
Pfeil-Operator	`ptr->feld` statt `(*ptr).feld`
Rekursion	Funktion ruft sich selbst auf: Basisfall + Rekursionsfall
Rekursive Beispiele	Countdown, Fakultät, Summe 1 bis n