C Academy · Les

Enkelvoudig gekoppelde lijsten

Nodes en pointers

Les 1 van 413 stappen

Enkelvoudig gekoppelde lijsten is een gratis C Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.

Wat is een gekoppelde lijst?

Een gekoppelde lijst is een keten van kleine structuren die knopen worden genoemd. Elke knoop bevat een waarde en een aanwijzer naar de volgende knoop.

In tegenstelling tot arrays hoeven de elementen niet aaneengesloten in het geheugen te staan en kan de lijst eenvoudig groeien of krimpen.

#include <stdio.h>

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

int main(void) {
    printf("A node holds a value and a next pointer\n");
    return 0;
}

Een knoop definiëren

De struct van een knoop bevat de gegevens plus een struct Node *next die naar de volgende knoop wijst.

Het type van de aanwijzer verwijst naar dezelfde struct; zo worden de knopen aan elkaar gekoppeld.

#include <stdio.h>

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

int main(void) {
    struct Node n;
    n.value = 42;
    n.next = NULL;
    printf("value=%d, next is NULL: %d\n", n.value, n.next == NULL);
    return 0;
}

De head-aanwijzer

Een lijst wordt geïdentificeerd door één aanwijzer naar de eerste knoop, de head.

Een lege lijst is simpelweg een head die gelijk is aan NULL.

#include <stdio.h>

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

int main(void) {
    struct Node *head = NULL;
    printf("List is empty: %d\n", head == NULL);
    return 0;
}

Een knoop reserveren

Knopen worden meestal op de heap gemaakt met malloc, zodat ze blijven bestaan nadat de functie die ze maakt is afgelopen.

Controleer altijd de geretourneerde waarde en vergeet niet de knopen later vrij te geven.

#include <stdio.h>
#include <stdlib.h>

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

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 7;
    n->next = NULL;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Pijloperator

Als je een aanwijzer naar een struct hebt, gebruik je -> om leden te benaderen. n->value betekent hetzelfde als (*n).value.

Je gebruikt de pijloperator voortdurend met gekoppelde lijsten.

#include <stdio.h>
#include <stdlib.h>

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

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 99;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Twee knopen koppelen

Stel om knopen te verbinden de next van de eerste zo in dat deze naar de tweede wijst. De next van de laatste knoop blijft NULL om het einde aan te geven.

#include <stdio.h>
#include <stdlib.h>

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

int main(void) {
    struct Node *a = malloc(sizeof(struct Node));
    struct Node *b = malloc(sizeof(struct Node));
    a->value = 1; a->next = b;
    b->value = 2; b->next = NULL;
    printf("%d -> %d\n", a->value, a->next->value);
    free(a); free(b);
    return 0;
}

Een hulpfunctie om knopen te maken

Herhaald reserveren is omslachtig, dus verpak dit in een hulpfunctie die een nieuwe knoop reserveert, initialiseert en retourneert.

#include <stdio.h>
#include <stdlib.h>

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

struct Node *make(int v) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = v;
    n->next = NULL;
    return n;
}

int main(void) {
    struct Node *n = make(5);
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Een kleine lijst opbouwen

Gebruik de hulpfunctie om een lijst met drie knopen, 1 -> 2 -> 3, op te bouwen door de next-aanwijzers aan elkaar te koppelen.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    head->next->next = make(3);
    printf("%d %d %d\n", head->value, head->next->value, head->next->next->value);
    return 0;
}

De lijst afdrukken

Begin bij de head en volg de next-aanwijzers totdat je NULL bereikt om elke waarde af te drukken.

Dit doorlooppatroon vormt de basis van vrijwel alle bewerkingen op lijsten.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    for (struct Node *p = head; p; p = p->next)
        printf("%d ", p->value);
    printf("\n");
    return 0;
}

Arrays tegenover gekoppelde lijsten

Arrays bieden snelle toegang via een index, maar hebben een vaste grootte. Gekoppelde lijsten maken invoegen en verwijderen eenvoudig, maar bieden tragere toegang (je moet door de lijst lopen om een element te bereiken).

Kies op basis van de bewerkingen die in je programma het belangrijkst zijn.

#include <stdio.h>

int main(void) {
    printf("Array: O(1) index, costly resize\n");
    printf("List:  O(n) index, cheap insert/delete\n");
    return 0;
}

De hele lijst vrijgeven

Elk knooppunt dat met malloc is toegewezen, moet worden vrijgegeven. Loop door de lijst, maar sla de volgende pointer op voordat je elk knooppunt vrijgeeft; anders raak je de rest van de keten kwijt.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    struct Node *p = head;
    while (p) {
        struct Node *nxt = p->next;
        free(p);
        p = nxt;
    }
    printf("freed all nodes\n");
    return 0;
}

Korte controle

Test je begrip van de structuur van een gekoppelde lijst.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt de basis van enkelvoudig gekoppelde lijsten geleerd:

Een knooppunt bevat een waarde en een next-pointer; de head wijst naar het eerste knooppunt.
Wijs knooppunten toe met malloc en benader leden met ->.
De next van het laatste knooppunt is NULL; doorloop de lijst door de pointers te volgen.
Geef altijd elk knooppunt vrij en sla next op voordat je het knooppunt vrijgeeft.

Gratis beginnen

Leer C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Enkelvoudig gekoppelde lijsten” gratis?

Ja — de volledige tekst van “Enkelvoudig gekoppelde lijsten” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.

Wat leer ik in “Enkelvoudig gekoppelde lijsten”?

Nodes en pointers Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C Academy te beginnen?

Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Enkelvoudig gekoppelde lijsten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C Academy?

Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C Academy