Summary  
This chapter explains how to define a singly linked list node in C, showing how to use pointers to link nodes dynamically and prevent self-referential memory allocation errors.

General domain of usage  
Data structures

En **lenket liste** i C er en enkel dynamisk datastruktur som består av elementer kalt noder.
Hver node inneholder data (for eksempel en variabel eller et objekt) samt en peker til neste node i listen.


Slik ser en typisk node i en enkelt lenket liste ut i C:

c3RydWN0IE5vZGUgewogICAgaW50IGRhdGE7ICAgICAgICAgICAvLyBkYXRhIGluIG5vZGUKICAgIHN0cnVjdCBOb2RlKiBuZXh0OyAgLy8gcG9pbnRlciB0byBuZXh0IG5vZGUKfTs=

Hvis du i stedet for en peker til neste node prøver å opprette en ny node-instans direkte, vil du få en feil.

Kompilatoren klarer ikke å allokere minne for en slik struktur, siden den inneholder seg selv. Det er som å prøve å se på seg selv utenfra med sine egne øyne.

Å bruke en peker løser dette problemet fordi kompilatoren vet hvor mye minne som skal allokeres for en pekervariabel.

Pekeren til den siste noden vil alltid være `NULL`.

Merk

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

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

struct Node* createNode(int value);

// Helper: free a list
void freeList(struct Node* head) {
    struct Node* current = head;
    while (current != nullptr) {
        struct Node* tmp = current;
        current = current->next;
        free(tmp);
    }
}

TEST_CASE("createNode returns non-null and correct data") {
    struct Node* node = createNode(42);
    REQUIRE(node != nullptr);
    REQUIRE(node->data == 42);
    REQUIRE(node->next == nullptr);
    free(node);
}

TEST_CASE("createNode multiple nodes and link manually") {
    struct Node* head = createNode(10);
    struct Node* second = createNode(20);
    struct Node* third = createNode(30);

    REQUIRE(head != nullptr);
    REQUIRE(second != nullptr);
    REQUIRE(third != nullptr);

    head->next = second;
    second->next = third;

    REQUIRE(head->data == 10);
    REQUIRE(head->next == second);
    REQUIRE(second->data == 20);
    REQUIRE(second->next == third);
    REQUIRE(third->data == 30);
    REQUIRE(third->next == nullptr);

    freeList(head);
}

TEST_CASE("Single node list") {
    struct Node* node = createNode(100);
    REQUIRE(node != nullptr);
    REQUIRE(node->data == 100);
    REQUIRE(node->next == nullptr);
    free(node);
}

TEST_CASE("Link nodes incrementally") {
    struct Node* head = createNode(1);
    struct Node* second = createNode(2);
    head->next = second;

    struct Node* current = head;
    REQUIRE(current->data == 1);
    current = current->next;
    REQUIRE(current->data == 2);
    REQUIRE(current->next == nullptr);

    freeList(head);
}

TEST_CASE("Create nodes with negative and zero values") {
    struct Node* head = createNode(0);
    struct Node* second = createNode(-10);
    head->next = second;

    REQUIRE(head->data == 0);
    REQUIRE(head->next == second);
    REQUIRE(second->data == -10);
    REQUIRE(second->next == nullptr);

    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.

Grunnleggende Konsept og Struktur

Grunnleggende Konsept og Struktur

Løsning