Summary  
This chapter covers how to traverse a singly linked list by iterating from the head node with a while loop until reaching NULL, printing each node’s data field.

General domain of usage  
Data structure manipulation and inspection

Nachdem wir gelernt haben, wie man Knoten erstellt und verbindet, müssen wir überprüfen, ob eine solche Liste korrekt funktioniert!

Dazu schreiben wir eine einfache Funktion, die die gesamte Liste ausgibt.

Die Funktion erhält einen Zeiger auf den Speicherbereich, in dem der Kopf (erste) Knoten der Liste gespeichert ist.
```
void printList(struct Node* head) {}
```
Anschließend wird ein temporärer Knoten current erstellt, mit dem wir die gesamte Liste durchlaufen. Der Inhalt des aktuellen Knotens entspricht dem Inhalt des aktuellen Listenknotens.
```
struct Node* current = head;
```

Zum Durchlaufen der Liste verwenden wir die **while(){}**-Schleife mit der notwendigen Bedingung, nämlich bis ein Knoten gefunden wird, dessen next-Feld **NULL** ist.

Der **temp** (temporäre) Knoten übernimmt die Rolle eines Pufferknotens. Er wird benötigt, um den Inhalt des aktuellen Knotens **vorübergehend zu speichern** (und zu löschen). **Wenn wir den aktuellen Knoten sofort löschen, verlieren wir die Verbindung zum nächsten Knoten und damit den Zugriff auf die Liste.**


Hinweis

```
while (current != NULL) { }
printf("\n");
```
Innerhalb der Schleife geben wir den Inhalt des Datenfeldes des aktuellen Knotens aus und ändern das next-Feld, um zum nächsten Knoten zu wechseln.

```
printf("%d ", current->data);
current = current->next;
```


Sobald ein Knoten gefunden wird, dessen next-Feld gleich NULL ist, stoppt die Schleife die Anzeige der Knoteninhalte und die Funktion endet.

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <cstdio>
#include <cstdlib>
#include <cstring>

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int value);
void addNewNode(struct Node** head, int value);
void printList(struct Node* head);
void freeList(struct Node* head);

// Helper: capture stdout
std::string capturePrintList(struct Node* head) {
    char buffer[1024] = {0};
    FILE* old_stdout = stdout;
    FILE* temp = fmemopen(buffer, sizeof(buffer), "w");
    stdout = temp;

    printList(head);

    fflush(temp);
    fclose(temp);
    stdout = old_stdout;

    return std::string(buffer);
}

// Helper: build list from array
struct Node* buildList(const int* values, int n) {
    struct Node* head = nullptr;
    for (int i = 0; i < n; i++) {
        addNewNode(&head, values[i]);
    }
    return head;
}

TEST_CASE("printList outputs correct elements") {
    int values[] = {1, 2, 3, 4};
    struct Node* head = buildList(values, 4);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(1 2 3 4 
)");

    freeList(head);
}

TEST_CASE("printList on empty list") {
    struct Node* head = nullptr;
    std::string output = capturePrintList(head);
    REQUIRE(output == R"(
)"); // пустая строка с переносом
}

TEST_CASE("freeList does not crash on multiple nodes") {
    int values[] = {10, 20, 30};
    struct Node* head = buildList(values, 3);

    // Просто вызываем freeList, проверяем, что не падает
    REQUIRE_NOTHROW(freeList(head));
}

TEST_CASE("freeList works on empty list") {
    struct Node* head = nullptr;
    REQUIRE_NOTHROW(freeList(head));
}

TEST_CASE("printList after adding nodes incrementally") {
    struct Node* head = nullptr;
    addNewNode(&head, 5);
    addNewNode(&head, 10);
    addNewNode(&head, 15);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(5 10 15 
)");

    freeList(head);
}

TEST_CASE("printList with negative and zero values") {
    int values[] = {0, -1, -20};
    struct Node* head = buildList(values, 3);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(0 -1 -20 
)");

    freeList(head);
}

TEST_CASE("printList with large number of nodes") {
    const int N = 100;
    int values[N];
    for (int i = 0; i < N; i++) values[i] = i;

    struct Node* head = buildList(values, N);

    std::string output = capturePrintList(head);

    std::string expected;
    for (int i = 0; i < N; i++) expected += std::to_string(i) + " ";
    expected += R"(
)";

    REQUIRE(output == expected);

    freeList(head);
}

test.cpp

Erwerben Sie ein fundiertes Verständnis darüber, wie Strukturen in C funktionieren, von grundlegenden Definitionen bis hin zu fortgeschrittenen Speicher-Konzepten. Erforschen Sie, wie Zeiger mit strukturierten Daten interagieren, entdecken Sie effiziente Möglichkeiten zur Organisation von Informationen und gewinnen Sie Sicherheit durch die Implementierung realer Datenstrukturen wie verketteter Listen.

Erkunden Sie die Grundlagen von Structs, verstehen Sie deren Anwendungszwecke und gewinnen Sie Sicherheit beim Definieren, Erstellen und Zugreifen auf strukturierte Daten.

Entdecken Sie, wie Zeiger mit Strukturen interagieren, erfahren Sie, warum diese Verbindung wichtig ist, und beherrschen Sie wichtige Techniken wie dynamische Speicherzuweisung und das Übergeben von Strukturen an Funktionen.

Erwerben Sie ein fundiertes Verständnis dafür, wie Structs im Speicher abgelegt werden, untersuchen Sie Alignment und Padding und erfahren Sie, wie Unions die effiziente Verwaltung gemeinsam genutzter Daten ermöglichen.

Vertiefung in fortgeschrittene Struct-Muster, einschließlich verschachtelter und anonymer Structs, praktische Methoden zur Kombination mit Arrays sowie Einführung in gängige Datenstrukturen.

Stärkung des Selbstvertrauens durch die Implementierung einer verketteten Liste von Grund auf, Untersuchung ihrer Struktur und Erstellung grundlegender Funktionen zum Hinzufügen, Durchlaufen und Verwalten von Listenelementen.

Traversing and Displaying a Linked List

Lösung