Çift Yönlü Bağlı Listeler
İki yönlü bağlantılar
Çift Yönlü Bağlı Listeler, CoddyKit'te ücretsiz bir C Academy dersidir. Bu, 4 dersinin 4. 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.
İki yönlü bağlantılar
Çift yönlü bağlı liste, her düğüme iki işaretçi verir: biri next düğümüne, diğeri prev (önceki) düğüme işaret eder.
Bu, listede iki yönde ilerlemenizi sağlar ve silme işlemini kolaylaştırır.
#include <stdio.h>
struct Node {
int value;
struct Node *prev;
struct Node *next;
};
int main(void) {
printf("Each node links forward and backward\n");
return 0;
}Düğümü tanımlama
Yapıya next işaretçisinin yanında bir prev işaretçisi de eklenir. Listenin uçlarında her ikisi de NULL olur.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
int main(void) {
struct Node *n = malloc(sizeof(struct Node));
n->value = 1; n->prev = NULL; n->next = NULL;
printf("%d\n", n->value);
free(n);
return 0;
}Oluşturma yardımcısı
Daha önce olduğu gibi bir yardımcı, bellek ayırma işlemini merkezileştirir. Hem prev hem de next değerlerini NULL olarak ayarlar.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v) {
struct Node *n = malloc(sizeof(struct Node));
n->value = v; n->prev = NULL; n->next = NULL;
return n;
}
int main(void) {
struct Node *n = make(42);
printf("%d\n", n->value);
free(n);
return 0;
}Düğümleri iki yönde bağlama
İki düğümü bağlarken her iki yönü de güncellemeniz gerekir: ilk düğümün next ve ikinci düğümün prev değerini.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
int main(void) {
struct Node *a = make(1), *b = make(2);
a->next = b;
b->prev = a;
printf("forward %d, back %d\n", a->next->value, b->prev->value);
free(a); free(b);
return 0;
}Başa ekleme
Başa eklerken yeni düğümün next değeri eski baş olur, eski başın prev değeri yeni düğüm olur ve ardından baş yeni düğüme taşınır.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
void push(struct Node **head, int v) {
struct Node *n = make(v);
n->next = *head;
if (*head) (*head)->prev = n;
*head = n;
}
int main(void) {
struct Node *head = NULL;
push(&head, 2); push(&head, 1);
printf("%d %d\n", head->value, head->next->value);
return 0;
}İleriye doğru dolaşma
İleriye doğru ilerlemek tek yönlü bağlı listedekiyle aynıdır: NULL değerine ulaşana kadar next işaretçisini izleyin.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
int main(void) {
struct Node *a = make(1), *b = make(2);
a->next = b; b->prev = a;
for (struct Node *p = a; p; p = p->next) printf("%d ", p->value);
printf("\n");
free(a); free(b);
return 0;
}Geriye doğru dolaşma
En büyük avantaj şudur: herhangi bir düğümden başlayarak prev işaretçilerini izleyip başa ulaşana kadar geriye doğru ilerleyebilirsiniz.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
int main(void) {
struct Node *a = make(1), *b = make(2), *c = make(3);
a->next = b; b->prev = a; b->next = c; c->prev = b;
for (struct Node *p = c; p; p = p->prev) printf("%d ", p->value);
printf("\n");
free(a); free(b); free(c);
return 0;
}Silme daha kolaydır
Her düğüm kendinden önceki düğümü bildiği için önceki düğümü aramadan silme yapabilirsiniz.
node->prev ile node->next değerlerini her iki yönde birbirine bağlamanız yeterlidir.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
void del(struct Node **head, struct Node *n) {
if (n->prev) n->prev->next = n->next; else *head = n->next;
if (n->next) n->next->prev = n->prev;
free(n);
}
int main(void) {
struct Node *a = make(1), *b = make(2), *c = make(3);
a->next=b; b->prev=a; b->next=c; c->prev=b;
struct Node *head = a;
del(&head, b);
printf("%d %d\n", head->value, head->next->value);
return 0;
}Her iki komşuyu güncelleme
Bir düğümü kaldırırken önceki düğümün next değerini ve sonraki düğümün prev değerini her zaman düzeltin.
Var olmayan bir komşunun başvurusunu kaldırmamak için her iki uçta da NULL kontrolü yapın.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
int main(void) {
struct Node *a = make(1), *b = make(2);
a->next = b; b->prev = a;
a->next = NULL;
free(b);
printf("now only %d remains\n", a->value);
free(a);
return 0;
}Son işaretçisini tutma
Birçok çift yönlü bağlı liste, son düğümü gösteren bir son işaretçisi de tutar; bu, O(1) sürede sona eklemeyi ve sondan geriye doğru dolaşmayı sağlar.
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}
int main(void) {
struct Node *head = make(1), *tail = head;
struct Node *n = make(2);
tail->next = n; n->prev = tail; tail = n;
printf("tail = %d\n", tail->value);
free(head); free(n);
return 0;
}Ödünleşimler
Çift yönlü bağlı listeler daha fazla bellek kullanır (düğüm başına bir işaretçi daha) ve her değişiklikte iki bağlantının güncellenmesini gerektirir.
Bunun karşılığında iki yönlü dolaşma ve bilinen bir düğümü O(1) sürede silme olanağı elde edersiniz. İhtiyaçlarınıza göre seçim yapın.
#include <stdio.h>
int main(void) {
printf("Singly: less memory, one-way\n");
printf("Doubly: more memory, two-way + easy delete\n");
return 0;
}Hızlı Kontrol
Çift yönlü bağlı listeleri ne kadar anladığınızı test edin.
Özet
Çift yönlü bağlı listeleri öğrendiniz:
- Her düğümde hem
prevhem denextişaretçisi bulunur. - Bağlama işlemi her iki yönün güncellenmesini gerektirir.
- İleriye ve geriye doğru dolaşabilir, bilinen bir düğümü O(1) sürede silebilirsiniz.
- Maliyeti daha fazla bellek ve daha çok işaretçi güncellemesidir; bir son işaretçisi O(1) sürede sona eklemeyi sağlar.
Sıkça Sorulan Sorular
“Çift Yönlü Bağlı Listeler” dersi ücretsiz mi?
Evet — “Çift 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.
“Çift Yönlü Bağlı Listeler” dersinde ne öğreneceğim?
İki yönlü bağlantılar 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 4. dersidir.
“Çift 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
- Tek Yönlü Bağlı Listeler
- Ekleme ve Silme
- Dolaşma ve Arama
- Çift Yönlü Bağlı Listeler