Arama ve Belleği Serbest Bırakma
Düğümleri bulun ve belleği serbest bırakın.
Arama ve Belleği Serbest Bırakma, 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.
BST'de Arama
Arama, sıralama kuralından yararlanır. Her düğümde hedefi düğümün değeriyle karşılaştırır ve yalnızca bir alt ağaca ilerleriz.
Her adımda kalan düğümlerin yarısını elediğimiz için arama maliyeti ağacın boyutuyla değil, yüksekliğiyle orantılıdır.
Özyinelemeli Arama
Özyinelemeli aramanın iki temel durumu vardır: boş bir alt ağaç değerin bulunamadığı, eşleşen bir değer ise bulunduğu anlamına gelir.
Diğer durumlarda karşılaştırmaya bağlı olarak sola veya sağa doğru özyinelemeli çağrı yapılır.
Node *search(Node *root, int target) {
if (root == NULL || root->value == target)
return root;
if (target < root->value)
return search(root->left, target);
return search(root->right, target);
}Yinelemeli Arama
Arama, özyineleme ek yükünü önleyen basit bir döngüyle de yapılabilir.
Hedefi bulana veya NULL konumunda ağacın sonuna ulaşana kadar işaretçileri ağaç boyunca izleriz.
Node *search_iter(Node *root, int target) {
while (root != NULL) {
if (target == root->value) return root;
root = (target < root->value)
? root->left : root->right;
}
return NULL; /* not found */
}Aramanın Uygulanışı
Bu program bir BST oluşturur ve bulunan ile bulunmayan bir değer için arama yaparak her birinin bulunup bulunmadığını yazdırır.
NULL olmayan bir dönüş, değerin bulunduğu; NULL ise değerin ağaçta olmadığı anlamına gelir.
#include <stdio.h>
#include <stdlib.h>
typedef struct Node { int value; struct Node *left, *right; } Node;
Node *cn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
Node *insert(Node *r,int v){
if(!r) return cn(v);
if(v<r->value) r->left=insert(r->left,v);
else if(v>r->value) r->right=insert(r->right,v);
return r;
}
Node *search(Node *r,int t){
if(!r||r->value==t) return r;
return t<r->value ? search(r->left,t) : search(r->right,t);
}
int main(void){
Node *root=NULL;
int d[]={10,5,15,3,7};
for(int i=0;i<5;i++) root=insert(root,d[i]);
printf("7:%s 99:%s\n",
search(root,7)?"found":"no",
search(root,99)?"found":"no");
return 0;
}En Küçük Değeri Bulma
Bir BST'de en küçük değer en soldaki düğümdedir: left değeri NULL olana kadar onu izlemeye devam ediniz.
Buna simetrik olarak en büyük değer en sağdaki düğümdedir. Bu yardımcı işlevler silme ve aralık sorguları için önemlidir.
Node *find_min(Node *root) {
if (root == NULL) return NULL;
while (root->left != NULL)
root = root->left;
return root;
}Belleği Serbest Bırakmak Neden Önemlidir?
Her düğüm malloc ile oluşturulduğu için her düğüm free ile geri verilmelidir. Belleği serbest bırakmayı unutmak bellek sızıntısına yol açar.
Ancak bir düğümü serbest bıraktıktan sonra çocuk işaretçilerini okuyamazsınız; bu nedenle serbest bırakma sırası kritik öneme sahiptir.
Son-Sıralı Dolaşımla Serbest Bırakma
Ağacı serbest bırakmanın güvenli yolu son-sıralı dolaşımdır: önce her iki çocuğu, ardından düğümün kendisini serbest bırakınız.
Bu yöntem, düğümün belleği serbest bırakılmadan önce left ve right işaretçilerini okumamızı garanti eder.
void free_tree(Node *root) {
if (root == NULL) return;
free_tree(root->left);
free_tree(root->right);
free(root);
}Tehlikeli Bir Yanlış Sıra
Çocuklara özyinelemeli olarak gitmeden önce düğümü serbest bırakırsanız tanımsız davranış oluşturursunuz; alt ağaçlara ulaşmak için serbest bırakılmış belleğin başvurusunu kaldırmanız gerekir.
Bu, serbest bırakma sonrası kullanımın klasik bir hatasıdır. Çocukları her zaman önce serbest bırakınız.
/* WRONG: use-after-free */
void bad_free(Node *root) {
if (!root) return;
free(root); /* freed here */
bad_free(root->left); /* reads freed memory! */
bad_free(root->right);
}Geçersiz İşaretçilerden Kaçınma
free_tree döndükten sonra özgün kök işaretçisi hâlâ eski adresi tutar, ancak bellek artık yoktur.
Çağıran işlevde işaretçiyi yeniden NULL olarak ayarlamak, geçersiz bir işaretçinin yanlışlıkla yeniden kullanılmasını önler.
free_tree(root);
root = NULL; /* avoid a dangling pointer */Serbest Bırakılan Düğümleri Sayma
Son-sıralı dolaşım sırasında düğümleri sayıp her birini serbest bırakarak serbest bırakma işleminin çalıştığını doğrulayabiliriz.
Bu program bir ağaç oluşturur, onu serbest bırakır ve kaç düğümün serbest bırakıldığını bildirir.
#include <stdio.h>
#include <stdlib.h>
typedef struct Node { int value; struct Node *left, *right; } Node;
Node *cn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
Node *insert(Node *r,int v){
if(!r) return cn(v);
if(v<r->value) r->left=insert(r->left,v);
else if(v>r->value) r->right=insert(r->right,v);
return r;
}
int free_count(Node *r){
if(!r) return 0;
int c = free_count(r->left) + free_count(r->right);
free(r);
return c + 1;
}
int main(void){
Node *root=NULL;
int d[]={10,5,15,3,7};
for(int i=0;i<5;i++) root=insert(root,d[i]);
printf("freed=%d\n", free_count(root));
root = NULL;
return 0;
}Arama ve Serbest Bırakmayı Birlikte Yapma
Tam bir yaşam döngüsü şöyledir: ağacı oluşturmak, aramak ve ardından serbest bırakmak. Bu üç işlemi birlikte yapmak programların doğru çalışmasını ve bellek sızıntısı olmamasını sağlar.
Valgrind gibi araçlar her malloc çağrısının bir free çağrısıyla eşleştiğini doğrulayabilir.
/* lifecycle
* 1. insert values (allocate)
* 2. search as needed (read-only)
* 3. free_tree(root) (deallocate)
* 4. root = NULL (avoid dangling)
*/Kısa Kontrol
Güvenli bellek serbest bırakma hakkında düşününüz.
Özet
BST araması her adımda karşılaştırma yapıp tek bir alt ağaçta ilerler; zaman maliyeti yükseklikle orantılıdır. En küçük değer en soldaki düğümde, en büyük değer ise en sağdaki düğümdedir.
Ağacı son-sıralı dolaşımla serbest bırakınız; böylece çocuklar üst düğümden önce serbest bırakılır. Ardından geçersiz bir işaretçiden kaçınmak için kökü NULL olarak ayarlayınız.
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
Sıkça Sorulan Sorular
“Arama ve Belleği Serbest Bırakma” dersi ücretsiz mi?
Evet — “Arama ve Belleği Serbest Bırakma” 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.
“Arama ve Belleği Serbest Bırakma” dersinde ne öğreneceğim?
Düğümleri bulun ve belleği serbest bırakın. 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.
“Arama ve Belleği Serbest Bırakma” 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
- Ağaç Düğümleri ve Yapısı
- BST'ye Ekleme
- Dolaşmalar
- Arama ve Belleği Serbest Bırakma