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

Etter at vi har lært hvordan vi oppretter og kobler sammen noder, må vi kontrollere at en slik liste fungerer riktig!

For å gjøre dette, skriver vi en enkel funksjon som viser hele listen.

Funksjonen tar imot en peker til minneområdet der hodet (første) node i listen er lagret.
```
void printList(struct Node* head) {}
```
Deretter opprettes en midlertidig node current, som vi bruker til å gå gjennom hele listen. Innholdet i den midlertidige noden vil være lik innholdet i den nåværende listenoden.
```
struct Node* current = head;
```

For å iterere gjennom listen bruker vi en **while(){}**-løkke med nødvendig betingelse, nemlig til vi finner en node hvor next-feltet er **NULL**.

Den **temp** (midlertidige) noden fungerer som en buffernode. Den brukes til å **midlertidig lagre** (og slette) innholdet i den nåværende noden. **Hvis vi umiddelbart sletter den nåværende noden, mister vi forbindelsen til neste node, og dermed tilgangen til listen.**


Merk

```
while (current != NULL) { }
printf("\n");
```
Inne i løkken viser vi innholdet i data-feltet til den nåværende noden og endrer next-feltet for å gå videre til neste node.

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


Så snart en node blir funnet hvor next-feltet er lik NULL, vil løkken stoppe å vise innholdet i nodene, og funksjonen avsluttes.

#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

Få en solid forståelse av hvordan structs fungerer i C, fra grunnleggende definisjoner til avanserte minnekonsepter. Utforsk hvordan pekere samhandler med strukturerte data, oppdag effektive måter å organisere informasjon på, og bygg selvtillit ved å implementere ekte datastrukturer som lenkede lister.

Utforsk grunnleggende konsepter for structs, forstå hvorfor de brukes, og bygg selvtillit i å definere, opprette og få tilgang til strukturert data.

Utforsk hvordan pekere samhandler med strukturer, lær hvorfor denne forbindelsen er viktig, og behersk sentrale teknikker som dynamisk allokering og overføring av strukturer til funksjoner

Få en solid forståelse av hvordan structs lagres i minnet, utforsk justering og utfylling, og lær hvordan unions bidrar til effektiv håndtering av delt data.

Fordyp deg i avanserte mønstre for structs, inkludert nestede og anonyme structs, utforsk praktiske måter å kombinere dem med arrayer på, og bli kjent med vanlige datastrukturer.

Bygg selvtillit ved å implementere en lenket liste fra bunnen av, utforsk dens struktur, og lag essensielle funksjoner for å legge til, traversere og håndtere listeelementer.

Gjennomgang og visning av en lenket liste

Løsning