C/C++ İkili Ağaçta Level Order Traversal (Seviye Sıralı Dolaşım) Rehberi 🌳

🎯 Bu Rehberde Ne Öğreneceksiniz?

Bu kılavuzda, İkili Ağaç (Binary Tree) üzerinde Level Order Traversal (Seviye Sıralı Dolaşım) algoritmasının nasıl çalıştığını öğreneceksiniz.
Ağacın yüksekliğini hesaplamaktan her seviyedeki düğümleri yazdırmaya kadar tüm süreci adım adım açıklayacağız.
Bu yöntem, Genişlik Öncelikli Arama (BFS) mantığını temel alır.

---

🧠 Teknik Özet

• Ana konu: İkili ağaçta seviye bazlı dolaşım algoritması
• Amaç: Düğümleri kökten başlayarak her seviyede soldan sağa doğru sıralı biçimde gezmek
• Yöntem: Ağacın yüksekliğini özyinelemeli olarak bulmak → her seviye için print_level() fonksiyonuyla yazdırmak
• Yaklaşım: Recursive (özyinelemeli) yöntem
• Zaman Karmaşıklığı: Ortalama O(N²), iteratif BFS sürümünde O(N)

---

🌲 İkili Ağaç Temelleri

İkili Ağaç (Binary Tree), her düğümün en fazla iki alt düğüme (sol ve sağ) sahip olabildiği hiyerarşik bir veri yapısıdır.
En üstteki düğüm root (kök) olarak adlandırılır.

Seviye (Level):
Bir düğümün köke olan uzaklığıdır.

• Kökün seviyesi 0
• Kökün çocukları 1
• Onların çocukları 2 şeklindedir.

Yükseklik (Height):
Kökten en derin düğüme kadar olan en uzun yoldur.
Bu değer, dolaşım algoritmamızın kaç seviyeyi işleyeceğini belirler.

---

⚙️ Algoritmanın Mantığı

Seviye sıralı dolaşımda düğümler şu sırayla gezilir: Seviye 0 → Seviye 1 → Seviye 2 → ...

Örnek ağaç için dolaşım sırası:

10 -> 20 -> 30 -> 40 -> 50

Bu işlemi yapmak için üç temel fonksiyon kullanacağız:

1. tree_height() → Ağacın yüksekliğini hesaplar.
2. print_level() → Belirtilen seviyedeki düğümleri yazdırır.
3. print_tree_level_order() → Tüm seviyeleri sırasıyla ekrana basar.

---

🧮 1. Adım – Ağacın Yüksekliğini Hesaplama

Bu fonksiyon, kökten başlayarak tüm alt ağaçların yüksekliğini hesaplar.
En büyük yüksekliğe +1 eklenerek toplam ağaç yüksekliği bulunur.

// Ağacın yüksekliğini hesaplar.
int tree_height(Node* root) {
    if (root == NULL)
        return 0;
    else {
        int sol_yukseklik = tree_height(root->left);
        int sag_yukseklik = tree_height(root->right);
        return (sol_yukseklik > sag_yukseklik ? sol_yukseklik : sag_yukseklik) + 1;
    }
}

📝 Açıklama: Her dalın yüksekliği ayrı ayrı hesaplanır, daha yüksek olan seçilir.

---

🖨️ 2. Adım – Belirli Bir Seviyedeki Düğümleri Yazdırma

print_level() fonksiyonu, istenen seviyeye ulaşana kadar seviye numarasını azaltarak çalışır.

// Belirli bir seviyedeki düğümleri yazdırır.
void print_level(Node* root, int level_no) {
    if (!root)
        return;

    if (level_no == 0)
        printf("%d -> ", root->value);
    else {
        print_level(root->left, level_no - 1);
        print_level(root->right, level_no - 1);
    }
}

🧩 Açıklama: Seviye 0’a gelince düğüm değeri yazdırılır; değilse alt seviyelere inilir.

---

🔁 3. Adım – Tüm Seviyeleri Dolaşmak

print_tree_level_order() fonksiyonu, 0. seviyeden başlar ve her seviye için print_level() fonksiyonunu çağırır.

// Tüm seviyeleri sırayla dolaşır.
void print_tree_level_order(Node* root) {
    if (!root)
        return;
    int height = tree_height(root);
    printf("Level Order Traversal: ");
    for (int i = 0; i < height; i++) {
        print_level(root, i);
    }
    printf("\n");
}

🧰 Tam Kod Uygulaması

Aşağıdaki örnek, düğüm oluşturma, yükseklik hesaplama ve seviye sıralı yazdırmayı içeren tam C programıdır.

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int value;
    struct Node* left;
    struct Node* right;
} Node;

// Yeni bir düğüm oluşturur.
Node* create_node(int data) {
    Node* node = (Node*) malloc(sizeof(Node));
    node->value = data;
    node->left = node->right = NULL;
    return node;
}

// Yukarıda tanımlanan diğer fonksiyonlar burada çağrılır (tree_height, print_level, print_tree_level_order)

int main() {
    Node* root = create_node(10);
    root->left = create_node(20);
    root->right = create_node(30);
    root->left->left = create_node(40);
    root->left->right = create_node(50);

    print_tree_level_order(root);
    return 0;
}

Beklenen Çıktı:

Level Order Traversal: 10 -> 20 -> 30 -> 40 -> 50 ->

---

⚡ Performans Analizi

Özellik	Açıklama
Yaklaşım	Özyinelemeli (recursive)
Zaman Karmaşıklığı	O(N²)
Alternatif Yöntem	Kuyruk (Queue) kullanarak O(N)
Verimlilik	Küçük ağaçlarda yeterli, büyük yapılarda iteratif BFS önerilir

---

❓ Sıkça Sorulan Sorular (SSS)

1. Özyinelemeli yöntem neden yavaş olabilir?

Çünkü aynı düğüm birden fazla kez ziyaret edilir; bu da işlem yükünü artırır.

2. Daha hızlı bir yöntem var mı?

Evet, Queue (Kuyruk) veri yapısı kullanan iteratif çözüm O(N) hızındadır.

3. Level Order Traversal hangi durumlarda kullanılır?

Ağaç genişliği ölçme, seviyelere göre işlem yapma veya grafiksel görselleştirme durumlarında.

4. Binary Tree ile Binary Search Tree farkı nedir?

Binary Search Tree, sol dalda küçük, sağ dalda büyük değerler tutar. Binary Tree’de bu kural yoktur.

5. Bellek yönetimi nasıl yapılmalı?

Tüm düğümler free() ile serbest bırakılmalıdır; aksi halde bellek sızıntısı olur.

---

🏁 Sonuç

Bu rehberde, C/C++ ile İkili Ağaçta Seviye Sıralı Dolaşım (Level Order Traversal) algoritmasını adım adım öğrendiniz. Yüksekliği hesapladık, her seviyeyi gezdik ve tam bir örnek kod çalıştırdık.

🚀 Rabisu Bulut platformunda C/C++ geliştirme ortamınızı hemen oluşturun ve kendi ağaç yapınızı test edin.