C Academy · Ders

Ekleme ve Silme

Listeyi değiştirin

Ekleme ve Silme, CoddyKit'te ücretsiz bir C Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, C Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. C Academy kursu toplamda 4 dersten oluşur.

Listeyi değiştirme

Bağlı listelerin gücü, ekleme ve silme işlemlerinin düşük maliyetli olmasıdır. Bir dizideki gibi öğeleri kaydırmak yerine işaretçileri yeniden düzenlersiniz.

Bu derste çeşitli konumlara düğüm ekleme ve düğüm kaldırma ele alınır.

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

Başa ekleme

Başa ekleme O(1) sürede yapılır. Yeni bir düğüm oluşturun, next değerini mevcut başı gösterecek şekilde ayarlayın, ardından başı yeni düğüm olarak güncelleyin.

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

Neden çift işaretçi kullanılır

Bir işlevin içinden başı değiştirmek için başın adresini bir struct Node ** olarak göndermeniz gerekir.

Aksi hâlde işlev yalnızca yerel bir kopyayı değiştirir ve çağıranın başı değişmeden kalır.

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

Sona ekleme

Sona eklemek için son düğüme kadar ilerlemeniz, ardından yeni düğümü onun next alanına bağlamanız gerekir.

Liste boşsa yeni düğüm baş olur.

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

Bir düğümden sonra ekleme

Ortaya ekleme yapmak için ekleme yapmak istediğiniz düğümü bulun, ardından yeni düğümü bu düğüm ile mevcut ardılı arasına yerleştirin.

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

İşlemlerin sırası önemlidir

Yeni düğümü araya yerleştirirken, önce yeni düğümün next değerini ayarlayın, ardından önceki düğümün next değerini değiştirin.

Aksi sırayla yaparsanız listenin geri kalanına olan başvuruyu kaybedersiniz.

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

İlk düğümü silme

Başı kaldırmak için onu kaydedin, başı head->next değerine ilerletin, ardından eski başı serbest bırakın.

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

Değere göre silme

Belirli bir değere sahip düğümü kaldırmak için önceki düğümü izleyin; böylece prev->next = target->next atamasıyla hedef düğümü atlayabilirsiniz.

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

Baş durumunu ele alma

Hedef baş olduğunda silme işleminin özel bir durumu vardır: önceki düğüm yoktur, bu nedenle baş işaretçisini doğrudan güncellersiniz.

Yukarıda gösterildiği gibi çift işaretçi bu işlemi kolaylaştırır.

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

Bellek sızıntılarından kaçınma

Listeden kaldırdığınız her düğüm free ile serbest bırakılmalıdır. Bir düğümü serbest bırakmadan listeden çıkarmak, kapladığı belleğin sızmasına neden olur.

Aynı şekilde, hâlâ bağlı olan bir düğümü asla serbest bırakmayın; aksi hâlde geçersiz bir işaretçi oluşturursunuz.

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

Eklemede sıralamayı koruma

Sıralı ekleme yaygın bir çeşittir: değerin sığacağı konumu bulana kadar ilerleyin, ardından düğümü oraya yerleştirin.

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

Hızlı Kontrol

Listeyi değiştirme konusundaki anlayışınızı test edin.

Özet

Düğüm eklemeyi ve silmeyi öğrendiniz:

Başa ekleme O(1) sürede yapılır; sona veya sıralı ekleme için listede ilerlemek gerekir.
Baş değişebileceği zaman çift işaretçi kullanın.
Araya yerleştirirken dikkatli olun: yeniden bağlamadan önce yeni düğümün next değerini ayarlayın.
Silme işleminde önceki düğümü izleyin ve kaldırılan düğümleri her zaman free ile serbest bırakın.

Sıkça Sorulan Sorular

“Ekleme ve Silme” dersi ücretsiz mi?

Evet — “Ekleme ve Silme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve C Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. C Academy kursu toplamda 4 dersten oluşur.

“Ekleme ve Silme” dersinde ne öğreneceğim?

Listeyi değiştirin C Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

C Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te C Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Ekleme ve Silme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu C Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her C Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← C Academy Sayfasına Dön