C Academy · Lektion

Einfügen und Löschen

Die Liste ändern

Einfügen und Löschen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Eine Liste ändern

Die Stärke verketteter Listen liegt im kostengünstigen Einfügen und Löschen. Sie ordnen Zeiger neu, anstatt wie bei einem Array Elemente zu verschieben.

In dieser Lektion geht es um das Einfügen und Entfernen von Knoten an verschiedenen Positionen.

#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(2);
    printf("start: %d\n", head->value);
    free(head);
    return 0;
}

Am Anfang einfügen

Das Einfügen am Kopf ist O(1). Erstellen Sie einen neuen Knoten, lassen Sie seinen next-Zeiger auf den aktuellen Kopf zeigen und setzen Sie den Kopf anschließend auf den neuen Knoten.

#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(2);
    struct Node *fresh = make(1);
    fresh->next = head;
    head = fresh;
    printf("%d -> %d\n", head->value, head->next->value);
    return 0;
}

Warum ein Doppelzeiger übergeben wird

Um den Kopf innerhalb einer Funktion zu ändern, müssen Sie seine Adresse übergeben: einen struct Node **.

Andernfalls ändert die Funktion nur eine lokale Kopie und der Kopf des Aufrufers bleibt unverändert.

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

void push(struct Node **head, int v) {
    struct Node *n = make(v);
    n->next = *head;
    *head = n;
}

int main(void) {
    struct Node *head = NULL;
    push(&head, 5);
    push(&head, 4);
    printf("%d %d\n", head->value, head->next->value);
    return 0;
}

Am Ende einfügen

Zum Anhängen müssen Sie bis zum letzten Knoten laufen und anschließend den neuen Knoten an dessen next-Zeiger anhängen.

Ist die Liste leer, wird der neue Knoten zum Kopf.

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

void append(struct Node **head, int v) {
    struct Node *n = make(v);
    if (!*head) { *head = n; return; }
    struct Node *p = *head;
    while (p->next) p = p->next;
    p->next = n;
}

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

Nach einem Knoten einfügen

Um einen Knoten in der Mitte einzufügen, suchen Sie den Knoten, nach dem eingefügt werden soll, und fügen Sie den neuen Knoten zwischen diesem und seinem bisherigen Nachfolger ein.

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

void insert_after(struct Node *node, int v) {
    struct Node *n = make(v);
    n->next = node->next;
    node->next = n;
}

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

Die Reihenfolge der Operationen ist wichtig

Beim Einfügen müssen Sie den next-Zeiger des neuen Knotens immer vorher setzen, bevor Sie den next-Zeiger des vorherigen Knotens ändern.

Wenn Sie es umgekehrt machen, verlieren Sie den Verweis auf den Rest der Liste.

#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 *a = make(1), *c = make(3);
    a->next = c;
    struct Node *b = make(2);
    b->next = a->next;
    a->next = b;
    printf("%d %d %d\n", a->value, b->value, c->value);
    return 0;
}

Den ersten Knoten löschen

Den Kopf zu entfernen bedeutet, ihn zu speichern, den Kopf auf head->next weiterzusetzen und anschließend den alten Kopf freizugeben.

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

void pop(struct Node **head) {
    if (!*head) return;
    struct Node *old = *head;
    *head = old->next;
    free(old);
}

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

Nach Wert löschen

Um einen Knoten mit einem bestimmten Wert zu entfernen, speichern Sie den vorherigen Knoten, damit Sie das Zielelement umgehen können, indem Sie prev->next = target->next setzen.

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

void del(struct Node **head, int v) {
    struct Node *cur = *head, *prev = NULL;
    while (cur && cur->value != v) { prev = cur; cur = cur->next; }
    if (!cur) return;
    if (prev) prev->next = cur->next; else *head = cur->next;
    free(cur);
}

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

Den Fall des Kopfes behandeln

Beim Löschen gibt es einen Sonderfall, wenn das Zielelement der Kopf ist: Es gibt keinen vorherigen Knoten, daher aktualisieren Sie den Kopfzeiger direkt.

Der Doppelzeiger macht dies unkompliziert, wie oben gezeigt.

#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 *old = head;
    head = head->next;
    free(old);
    printf("head now %d\n", head->value);
    free(head);
    return 0;
}

Speicherlecks vermeiden

Jeder Knoten, den Sie aus der Liste entfernen, muss mit free freigegeben werden. Wenn Sie einen Knoten entfernen, ohne ihn freizugeben, geht der von ihm belegte Speicher verloren.

Geben Sie außerdem niemals einen Knoten frei, solange er noch verknüpft ist, da Sie sonst einen baumelnden Zeiger erzeugen.

#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 *n = make(7);
    free(n);
    printf("node freed, no leak\n");
    return 0;
}

Beim Einfügen die Reihenfolge beibehalten

Das Einfügen in sortierter Reihenfolge ist eine häufige Variante: Durchlaufen Sie die Liste, bis Sie die Stelle finden, an der der Wert passt, und fügen Sie ihn dort ein.

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

void insert_sorted(struct Node **head, int v) {
    struct Node *n = make(v);
    if (!*head || (*head)->value >= v) { n->next = *head; *head = n; return; }
    struct Node *p = *head;
    while (p->next && p->next->value < v) p = p->next;
    n->next = p->next; p->next = n;
}

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

Kurztest

Testen Sie Ihr Verständnis der Änderung von Listen.

Zusammenfassung

Sie haben gelernt, Knoten einzufügen und zu löschen:

Das Einfügen am Anfang ist O(1); zum Anhängen oder sortierten Einfügen muss die Liste durchlaufen werden.
Verwenden Sie einen Doppelzeiger, wenn sich der Kopf ändern kann.
Fügen Sie sorgfältig ein: Setzen Sie den next-Zeiger des neuen Knotens, bevor Sie die Verknüpfung neu herstellen.
Speichern Sie beim Löschen den vorherigen Knoten und geben Sie entfernte Knoten immer mit free frei.

Häufig gestellte Fragen

Ist die Lektion „Einfügen und Löschen“ kostenlos?

Ja — der vollständige Text von „Einfügen und Löschen“ 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 „Einfügen und Löschen“?

Die Liste ändern 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 2 von 4.

Wie lange dauert die Lektion „Einfügen und Löschen“?

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