C Academy · Ders

Tek Yönlü Bağlı Listeler

Düğümler ve işaretçiler

Tek Yönlü Bağlı Listeler, CoddyKit'te ücretsiz bir C Academy dersidir. Bu, 4 dersinin 1. 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.

Bağlı liste nedir?

Bağlı liste, düğüm adı verilen küçük yapılardan oluşan bir zincirdir. Her düğüm bir değer ve sonraki düğümü gösteren bir işaretçi tutar.

Dizilerin aksine, öğelerin bellekte ardışık olması gerekmez; liste kolayca büyüyebilir veya küçülebilir.

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

Bir düğüm tanımlamak

Düğüm yapısı, verilerin yanı sıra sonraki düğümü gösteren struct Node *next alanını içerir.

İşaretçi türü aynı yapıya başvurur; zincirin birbirine bağlanmasını sağlayan şey budur.

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

Baş işaretçisi

Liste, baş adı verilen ilk düğümünü gösteren tek bir işaretçiyle tanımlanır.

Boş liste, NULL değerine eşit bir baş işaretçisinden ibarettir.

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

Bir düğüm ayırmak

Düğümler genellikle malloc ile yığın üzerinde oluşturulur; böylece onları oluşturan işlev sona erdikten sonra da yaşamaya devam ederler.

Dönüş değerini her zaman denetleyin ve düğümleri daha sonra serbest bırakmayı unutmayın.

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

Ok operatörü

Bir yapıya yönelik işaretçiniz olduğunda üyelere erişmek için -> kullanın. n->value, (*n).value ile aynı anlama gelir.

Bağlı listelerle çalışırken ok operatörünü sürekli kullanacaksınız.

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

İki düğümü bağlamak

Düğümleri bağlamak için ilkinin next alanını ikincisini gösterecek şekilde ayarlayın. Son düğümün next alanı, sonu belirtmek üzere NULL olarak kalır.

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

Düğüm oluşturmak için yardımcı işlev

Sürekli bellek ayırmak zahmetlidir; bu nedenle işlemi, yeni bir düğüm ayıran, başlatan ve döndüren bir yardımcı işleve sarın.

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

Küçük bir liste oluşturmak

Yardımcı işlevi kullanarak next işaretçilerini birbirine bağlayıp 1 -> 2 -> 3 biçiminde üç düğümlü bir liste oluşturun.

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

Listeyi yazdırmak

Her değeri yazdırmak için baştan başlayın ve NULL değerine ulaşana kadar next işaretçilerini izleyin.

Bu gezinme deseni, neredeyse tüm liste işlemlerinin temelidir.

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

Diziler ve bağlı listeler

Diziler hızlı dizin erişimi sağlar, ancak boyutları sabittir. Bağlı listeler kolay ekleme ve silme olanağı sağlar, ancak erişim daha yavaştır; bir öğeye ulaşmak için listede gezinmeniz gerekir.

Programınızda hangi işlemlerin ağırlıklı olduğuna göre seçim yapın.

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

Tüm listeyi serbest bırakma

malloc ile ayrılan her düğüm serbest bırakılmalıdır. Listeyi dolaşırken her düğümü serbest bırakmadan önce sonraki işaretçiyi kaydedin; aksi hâlde zincirin geri kalanını 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 *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;
}

Hızlı Kontrol

Bağlı liste yapısını ne kadar anladığınızı test edin.

Özet

Tek yönlü bağlı listelerin temellerini öğrendiniz:

Bir düğüm bir değer ve bir next işaretçisi tutar; baş ilk düğümü gösterir.
Düğümleri malloc ile ayırın ve üyelere -> ile erişin.
Son düğümün next değeri NULL olur; işaretçileri izleyerek dolaşın.
Her düğümü serbest bırakmadan önce next değerini kaydederek tüm düğümleri her zaman serbest bırakın.

Sıkça Sorulan Sorular

“Tek Yönlü Bağlı Listeler” dersi ücretsiz mi?

Evet — “Tek Yönlü Bağlı Listeler” 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.

“Tek Yönlü Bağlı Listeler” dersinde ne öğreneceğim?

Düğümler ve işaretçiler 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 1. dersidir.

“Tek Yönlü Bağlı Listeler” 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