C Academy · Ders

Dolaşma ve Arama

Liste üzerinde ilerleyin

3. ders / 413 adım

Dolaşma ve Arama, CoddyKit'te ücretsiz bir C Academy dersidir. Bu, 4 dersinin 3. 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.

Listede ilerleme

Dolaşma, her düğümü sırayla ziyaret etmek demektir. Baştan başlar ve NULL değerine ulaşana kadar next işaretçilerini izlersiniz.

Neredeyse her liste algoritması bu basit ilerleme üzerine kuruludur.

#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(10);
    head->next = make(20);
    for (struct Node *p = head; p != NULL; p = p->next)
        printf("%d ", p->value);
    printf("\n");
    return 0;
}

Dolaşma deseni

Standart döngüde hareket eden bir p işaretçisi kullanılır: bu işaretçi head olarak başlatılır, p değeri NULL olmadığı sürece devam edilir ve p = p->next ile ilerlenir.

İlerlerken head değerini asla değiştirmeyin; aksi hâlde listenin başlangıcı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) { printf("%d ", p->value); p = p->next; }
    printf("\n");
    return 0;
}

Düğümleri sayma

Uzunluğu bulmak için listede ilerleyin ve her düğüm için bir sayaç artırın.

Sayı hiçbir yerde tutulmadığından bu işlem O(n) maliyetindedir.

#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 length(struct Node *head) {
    int n = 0;
    for (struct Node *p = head; p; p = p->next) n++;
    return n;
}

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

Değerleri toplama

Dolaşma, verileri bir araya getirmenizi sağlar. Burada listedeki tüm tamsayı değerlerini topluyoruz.

#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(5);
    head->next = make(10);
    int sum = 0;
    for (struct Node *p = head; p; p = p->next) sum += p->value;
    printf("sum = %d\n", sum);
    return 0;
}

Değer arama

Bir değeri bulmak için listede ilerleyin ve her düğümü karşılaştırın. Eşleşme bulduğunuzda düğümü (veya konumunu) döndürün; sona ulaşırsanız başarısızlığı bildirin.

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

struct Node *find(struct Node *head, int v) {
    for (struct Node *p = head; p; p = p->next)
        if (p->value == v) return p;
    return NULL;
}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    printf("found 2: %d\n", find(head, 2) != NULL);
    printf("found 9: %d\n", find(head, 9) != NULL);
    return 0;
}

Konum bulma

Bazen düğüm yerine eşleşmenin dizinini istersiniz. İlerlerken bir sayaç tutun ve değer bulunduğunda bu sayacı döndürü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;}

int index_of(struct Node *head, int v) {
    int i = 0;
    for (struct Node *p = head; p; p = p->next, i++)
        if (p->value == v) return i;
    return -1;
}

int main(void) {
    struct Node *head = make(7);
    head->next = make(8);
    printf("%d\n", index_of(head, 8));
    return 0;
}

n'inci düğüme erişme

Bağlı listelerde doğrudan dizinleme yoktur. n konumuna ulaşmak için baştan başlayarak n kez ilerlemeniz gerekir.

Bu nedenle rastgele erişim, dizideki O(1) değerine kıyasla O(n) maliyetindedir.

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

struct Node *at(struct Node *head, int n) {
    struct Node *p = head;
    for (int i = 0; i < n && p; i++) p = p->next;
    return p;
}

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

Son düğümü bulma

Son düğümü bulmak için p->next değeri NULL olana kadar ilerleyin. Bu düğüm son düğümdür.

head değerinin NULL olduğu boş liste durumuna dikkat edin.

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

Maksimumu bulma

Arama ve toplamayı birleştirerek dolaşma sırasında şimdiye kadarki en iyi değeri izleyip en büyük değeri bulabilirsiniz.

#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(3);
    head->next = make(9);
    head->next->next = make(5);
    int best = head->value;
    for (struct Node *p = head->next; p; p = p->next)
        if (p->value > best) best = p->value;
    printf("max = %d\n", best);
    return 0;
}

Özyinelemeli dolaşma

Listelerde özyinelemeli olarak da ilerlenebilir: mevcut düğümü işleyin, ardından next üzerinde özyinelemeli çağrı yapın.

Bu yöntem zariftir ancak uzunlukla orantılı yığın alanı kullanır; bu nedenle çok uzun listelerde yineleme daha güvenlidir.

#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 print_rec(struct Node *p) {
    if (!p) { printf("\n"); return; }
    printf("%d ", p->value);
    print_rec(p->next);
}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    print_rec(head);
    return 0;
}

Boş listelere karşı önlem alma

Her dolaşma işlevi boş bir listeyi (head == NULL) sorunsuz şekilde ele almalıdır.

Standart döngü bunu zaten yapar: p != NULL koşulu hemen yanlış olur ve gövde hiç çalışmaz.

#include <stdio.h>

struct Node { int value; struct Node *next; };

int length(struct Node *head) {
    int n = 0;
    for (struct Node *p = head; p; p = p->next) n++;
    return n;
}

int main(void) {
    struct Node *head = NULL;
    printf("empty length = %d\n", length(head));
    return 0;
}

Hızlı Kontrol

Liste dolaşmasının maliyeti konusundaki anlayışınızı test edin.

İnteraktif derste cevapla

Özet

Listelerde dolaşmayı ve arama yapmayı öğrendiniz:

İlerleme deseni: head değerinden başlayın, NULL olmadığı sürece döngüyü sürdürün ve p = p->next ile ilerleyin.
Sayma, toplama ve maksimumu bulma işlemlerinin tümü dolaşma üzerine kuruludur.
Arama her düğümü karşılaştırır; dizin erişimi O(n) maliyetindedir.
Dolaşma özyinelemeli olabilir, ancak uzun listelerde yineleme daha güvenlidir; boş liste durumunu her zaman ele alın.

Başlamak ücretsiz

Yapay zeka eğitmeniyle C öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 39
Dersler: 144

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Dolaşma ve Arama” dersi ücretsiz mi?

Evet — “Dolaşma ve Arama” 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.

“Dolaşma ve Arama” dersinde ne öğreneceğim?

Liste üzerinde ilerleyin 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 3. dersidir.

“Dolaşma ve Arama” 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