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

After we have learned how to create and connect nodes, we need to check that such a list works correctly!

To do this, let's write a simple function that will display the entire list.

The function will accept a pointer to the memory area where the head (first) node of the list is stored.
```
void printList(struct Node* head) {}
```
After which a temporary node current will be created, with which we will go through the entire list. The content of the current node will be equal to the content of the current list node.
```
struct Node* current = head;
```

To iterate through the list, we use the **while(){}** loop with the necessary condition, namely, until a node is found whose next field is **NULL**.

The **temp** (temporary) node plays the role of a buffer node. It is needed to **temporarily store** (and delete) the contents of the current node. **If we immediately clear the current node, we will lose connection with the next node, which means access to the list will be lost.**


Note

```
while (current != NULL) { }
printf("\n");
```
Inside the loop, we will display the contents of the data field of the current node and change the next field to move to the next node.

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


As soon as a node is found whose next field equal NULL, the loop will stop displaying the contents of the nodes and the function will end.

#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

Gain a solid understanding of how structs work in C, from basic definitions to advanced memory concepts. Explore how pointers interact with structured data, discover efficient ways to organize information, and build confidence by implementing real data structures such as linked lists.

Explore the fundamentals of structs, understand why they are used, and build confidence in defining, creating, and accessing structured data.

Discover how pointers interact with structs, learn why this connection matters, and master key techniques such as dynamic allocation and passing structs to functions

Gain a solid understanding of how structs are stored in memory, explore alignment and padding, and learn how unions help manage shared data efficiently.

Dive into advanced struct patterns, including nested and anonymous structs, explore practical ways to combine them with arrays, and get familiar with common data structures.

Build confidence by implementing a linked list from scratch, explore its structure, and create essential functions for adding, traversing, and managing list elements.

Traversing and Displaying a Linked List

解答