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

Kun olemme oppineet luomaan ja yhdistämään solmuja, meidän täytyy tarkistaa, että tällainen lista toimii oikein!

Tätä varten kirjoitetaan yksinkertainen funktio, joka näyttää koko listan.

Funktio vastaanottaa osoittimen muistialueeseen, jossa listan pään (ensimmäisen) solmun tiedot sijaitsevat.
```
void printList(struct Node* head) {}
```
Tämän jälkeen luodaan väliaikainen solmu current, jonka avulla käydään koko lista läpi. Current-solmun sisältö vastaa nykyisen listasolmun sisältöä.
```
struct Node* current = head;
```

Listan läpikäyntiin käytetään **while(){}** -silmukkaa tarvittavalla ehdolla, eli kunnes löytyy solmu, jonka next-kenttä on **NULL**.

**Temp** (väliaikainen) solmu toimii puskurisolmuna. Sitä tarvitaan **nykyisen solmun sisällön väliaikaiseen tallentamiseen** (ja poistamiseen). **Jos tyhjennämme nykyisen solmun heti, menetämme yhteyden seuraavaan solmuun, mikä tarkoittaa, että pääsy listaan menetetään.**


Huomio

```
while (current != NULL) { }
printf("\n");
```
Silmukan sisällä näytetään nykyisen solmun data-kentän sisältö ja muutetaan next-kenttää siirtyäksemme seuraavaan solmuun.

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


Heti kun solmu löytyy, jonka next-kenttä on NULL, silmukka lopettaa solmujen sisällön näyttämisen ja funktio päättyy.

#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

Hanki vankka ymmärrys siitä, miten rakenteet toimivat C:ssä, perusmääritelmistä edistyneisiin muistikonsepteihin. Tutustu osoittimien vuorovaikutukseen jäsennellyn datan kanssa, löydä tehokkaita tapoja järjestää tietoa ja vahvista osaamistasi toteuttamalla oikeita tietorakenteita, kuten linkitettyjä listoja.

Tutustu rakenteiden perusteisiin, ymmärrä niiden käyttötarkoitus ja vahvista osaamistasi rakenteisen datan määrittelyssä, luomisessa ja käsittelyssä.

Opi, miten pointterit ovat vuorovaikutuksessa rakenteiden kanssa, ymmärrä miksi tämä yhteys on tärkeä, ja hallitse keskeiset tekniikat kuten dynaaminen varaaminen ja rakenteiden välittäminen funktioille.

Hanki vankka ymmärrys siitä, miten rakenteet tallennetaan muistiin, tutustu kohdistukseen ja täytebittien käyttöön sekä opi, miten unionit auttavat hallitsemaan jaettua dataa tehokkaasti.

Syvenny edistyneisiin struct-malleihin, mukaan lukien sisäkkäiset ja anonyymit structit, tutustu käytännöllisiin tapoihin yhdistää niitä taulukoihin ja perehdy yleisiin tietorakenteisiin.

Rakenna varmuutta toteuttamalla linkitetty lista alusta alkaen, tutki sen rakennetta ja luo olennaiset funktiot alkioiden lisäämiseen, läpikäyntiin ja hallintaan.

Linkitetyn Listan Läpikäynti ja Näyttäminen

Ratkaisu