C Academy · Lektion

Einfach verkettete Listen

Knoten und Zeiger

Einfach verkettete Listen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine verkettete Liste?

Eine verkettete Liste ist eine Kette kleiner Strukturen, die Knoten genannt werden. Jeder Knoten enthält einen Wert und einen Pointer auf den nächsten Knoten.

Anders als bei Arrays müssen die Elemente nicht zusammenhängend im Speicher liegen, und die Liste kann einfach wachsen oder schrumpfen.

#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;
}

Einen Knoten definieren

Die Knotenstruktur enthält die Daten sowie einen struct Node *next, der auf den folgenden Knoten zeigt.

Der Pointer-Typ verweist auf dieselbe Struktur. So werden die Knoten miteinander verknüpft.

#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;
}

Der Head-Pointer

Eine Liste wird durch einen einzelnen Pointer auf ihren ersten Knoten identifiziert, den sogenannten Head.

Eine leere Liste ist einfach ein Head mit dem Wert 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;
}

Einen Knoten allokieren

Knoten werden normalerweise mit malloc auf dem Heap erstellt, damit sie die Funktion überdauern, in der sie erzeugt wurden.

Prüfen Sie immer den Rückgabewert und denken Sie daran, die Knoten später freizugeben.

#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;
}

Pfeiloperator

Wenn Sie einen Pointer auf eine Struktur haben, verwenden Sie ->, um auf deren Member zuzugreifen. n->value bedeutet dasselbe wie (*n).value.

Bei verketteten Listen werden Sie den Pfeiloperator ständig verwenden.

#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;
}

Zwei Knoten verknüpfen

Um Knoten zu verbinden, lassen Sie next des ersten auf den zweiten zeigen. next des letzten Knotens bleibt NULL, um das Ende zu kennzeichnen.

#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;
}

Eine Hilfsfunktion zum Erstellen von Knoten

Wiederholtes Allokieren ist mühsam. Kapseln Sie es daher in einer Hilfsfunktion, die einen neuen Knoten allokiert, initialisiert und zurückgibt.

#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;
}

Eine kleine Liste erstellen

Erstellen Sie mithilfe der Hilfsfunktion eine Liste mit drei Knoten, 1 -> 2 -> 3, indem Sie die next-Pointer verketten.

#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;
}

Die Liste ausgeben

Um jeden Wert auszugeben, beginnen Sie am Head und folgen Sie den next-Pointern, bis Sie NULL erreichen.

Dieses Durchlaufmuster bildet die Grundlage für fast alle Listenoperationen.

#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 und verkettete Listen

Arrays bieten schnellen Zugriff über Indizes, haben aber eine feste Größe. Verkettete Listen ermöglichen einfaches Einfügen und Entfernen, bieten jedoch langsameren Zugriff, da Sie zum gewünschten Element laufen müssen.

Treffen Sie Ihre Wahl danach, welche Operationen in Ihrem Programm überwiegen.

#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;
}

Die gesamte Liste freigeben

Jeder mit malloc angelegte Knoten muss freigegeben werden. Durchlaufen Sie die Liste, speichern Sie jedoch den nächsten Zeiger vorher, bevor Sie jeden Knoten freigeben, da Sie sonst den Rest der Kette verlieren.

#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;
}

Kurztest

Testen Sie Ihr Verständnis der Struktur verketteter Listen.

Zusammenfassung

Sie haben die Grundlagen einfach verketteter Listen gelernt:

Ein Knoten enthält einen Wert und einen next-Zeiger; der Kopf verweist auf den ersten Knoten.
Reservieren Sie Knoten mit malloc und greifen Sie mit -> auf Mitglieder zu.
Der next-Zeiger des letzten Knotens ist NULL; durchlaufen Sie die Liste, indem Sie den Zeigern folgen.
Geben Sie immer jeden Knoten frei und speichern Sie next, bevor Sie ihn freigeben.

Häufig gestellte Fragen

Ist die Lektion „Einfach verkettete Listen“ kostenlos?

Ja — der vollständige Text von „Einfach verkettete Listen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Einfach verkettete Listen“?

Knoten und Zeiger Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Einfach verkettete Listen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy