Ağaç Temelleri Tree Fundamentals

Ağaç terminolojisi, ağaç oluşturma, özyinelemeli tanım ve ağaç türlerine kapsamlı giriş.

🗂️ Veri Yapıları 📅 21 February 2026 👁️ 6 görüntülenme

Neden Ağaç?

Şimdiye kadar incelediğimiz yapılar — dizi, bağlı liste, stack, kuyruk — hep doğrusal (linear) yapılardı: elemanlar bir sıra halinde dizilir, her birinin en fazla bir önceki ve bir sonraki vardır. Ancak gerçek dünya verilerinin büyük kısmı doğrusal değil hiyerarşiktir: dosya sistemi (klasörler içinde klasörler), organizasyon şeması (müdür → şefler → çalışanlar), HTML DOM (etiketler içinde etiketler), soyağacı...

Doğrusal (Linear)

Dizi, bağlı liste, stack, kuyruk
A → B → C → D → E
Tek boyutlu sıra — arama O(n)

Hiyerarşik (Tree)

İkili ağaç, BST, heap, B-tree...
A / \ B C / \ D E
Dallanma yapısı — arama O(log n)

Ağaç, doğrusal yapılardan farklı olarak bir düğümün birden fazla alt düğüme sahip olmasına izin verir. Bu dallanma yapısı arama, sıralama ve organizasyon işlemlerini dramatik olarak hızlandırır. 1.000.000 elemanlı sıralı bir dizide ikili arama 20 adım alır — aynı veri ağaç yapısında da ~20 adımda bulunur, ama ekleme ve silme O(log n)'de kalır (dizide O(n)).

Tanım — Özyinelemeli (Recursive)

Ağaç (Tree): Boş (empty) olabilen ya da bir kök düğüm (root) ve sıfır veya daha fazla alt ağaçtan (subtree) oluşan, döngü içermeyen bağlantılı bir yapıdır. Her alt ağaç da kendi başına bir ağaçtır — bu tanımı özyinelemeli (recursive) yapar.

Biçimsel olarak: bir ağaç T ya boş kümedir (T = ∅) ya da bir kök düğüm r ve sıfır veya daha fazla boş olmayan alt ağaç T₁, T₂, ..., Tₖ'dan oluşur. Her Tᵢ'nin kökü r'ye bir kenarla (edge) bağlıdır.

Ağaç Terminolojisi

Aşağıdaki ağaç üzerinde tüm temel terimleri tanımlayacağız:

Referans Ağaç — Tüm Terimler Bu Görsel Üzerinde
Seviye 0Seviye 1Seviye 2Seviye 3Akök (root)BCDEyaprakFyaprakGyaprakHyaprakkenar (edge)
8 düğüm, 7 kenar | Yükseklik = 3 | Kök = A, Yapraklar = E, F, G, H

Temel Terimler

Kök (Root)
Ağacın en üst düğümü. Ebeveynı yoktur. Örnek: A. Her ağacın tam olarak bir kökü vardır.
Düğüm (Node)
Ağacın her bir elemanı. Veri ve alt düğümlere referans taşır. Örnek: A, B, C, D, E, F, G, H — toplam 8 düğüm.
Kenar (Edge)
İki düğüm arasındaki bağlantı. n düğümlü ağaçta tam olarak n - 1 kenar vardır. Örnek: A–B, A–C, B–D, ... (7 kenar).
Ebeveyn (Parent)
Bir düğümün doğrudan üstündeki düğüm. Örnek: B'nin ebeveyni A, D'nin ebeveyni B. Kökün ebeveyni yoktur.
Çocuk (Child)
Bir düğümün doğrudan altındaki düğümler. Örnek: A'nın çocukları B, C. D'nin çocukları G, H.
Kardeş (Sibling)
Aynı ebeveyni paylaşan düğümler. Örnek: B ve C kardeş (ebeveyn: A). G ve H kardeş (ebeveyn: D).
Yaprak (Leaf)
Çocuğu olmayan düğüm — ağacın "uç"ları. Dış düğüm (external node) de denir. Örnek: E, F, G, H.
İç Düğüm (Internal)
En az bir çocuğu olan düğüm — yaprak olmayan tüm düğümler. Örnek: A, B, C, D.
Ata (Ancestor)
Kökten bir düğüme giden yol üzerindeki tüm düğümler. Örnek: G'nin ataları: D, B, A.
Torun (Descendant)
Bir düğümden yapraklara giden yol üzerindeki tüm düğümler. Örnek: B'nin torunları: D, E, G, H.
Alt Ağaç (Subtree)
Herhangi bir düğüm ve tüm torunlarından oluşan ağaç. Örnek: B'nin alt ağacı: B→{D→{G,H}, E}.
Yol (Path)
Bir düğümden diğerine kenarlar boyunca gidilen rota. Örnek: A→B→D→G yolu uzunluğu 3 (3 kenar).

Derinlik, Yükseklik ve Seviye

Bu üç kavram sıkça karıştırılır. Aşağıdaki görsel ve tablo ayrımı netleştirir:

Derinlik (↓ yukarıdan aşağı) vs Yükseklik (↑ aşağıdan yukarı)
d=0d=1d=2d=3derinlikh=3h=2h=1h=0yükseklikABCDEFG
TerimTanımYönÖrnekler
Derinlik (depth)Kökten o düğüme kadar kenar sayısı↓ Yukarıdan aşağıA:0, B:1, D:2, G:3
Yükseklik (height)O düğümden en uzak yaprağa kadar kenar sayısı↑ Aşağıdan yukarıG:0, D:1, B:2, A:3
Seviye (level)Derinlikle aynı (bazı kaynaklarda +1)↓ Yukarıdan aşağıA:0, B,C:1, D,E,F:2
Ağaç yüksekliğiKökün yüksekliği = en derin yaprağın derinliğiheight(T) = 3
Derinlik vs yükseklik karışıklığı: Derinlik yukarıdan aşağı ölçülür (kökün derinliği 0), yükseklik aşağıdan yukarı ölçülür (yaprakların yüksekliği 0). Kökün derinliği her zaman 0'dır ama yüksekliği ağacın boyutuna bağlıdır. Karıştırmamak için: derinlik → "ne kadar derin gömülü" (kökten uzaklık), yükseklik → "ne kadar uzun" (altındaki en uzun dal).

Derece (Degree)

Derece kavramı iki düzeyde kullanılır:

KavramTanımÖrnekler (referans ağaç)
Düğüm derecesiBir düğümün çocuk sayısıA:2, B:2, C:1, D:2, E:0, F:0, G:0, H:0
Ağaç derecesiTüm düğümlerin en büyük derecesimax(2,2,1,2,0,0,0,0) = 2
Derece ve ağaç türü: Ağaç derecesi yapının türünü belirler. Derece 2 olan ağaca ikili ağaç (binary tree), derece 3'e üçlü ağaç (ternary tree), derece n'ye n'li ağaç (n-ary tree) denir. B-tree'lerde derece yüzlere çıkabilir.

Temel Özellikler

ÖzellikFormülAçıklama
Kenar sayısın - 1n düğümlü ağaçta her düğüm (kök hariç) tam bir ebeveyne bağlıdır
Min yükseklik (ikili)⌊log₂ n⌋Tam dengeli ağaçta: n=7 → h=2, n=15 → h=3
Max yükseklikn - 1Dejenere (zincir) ağaçta: her düğümün 1 çocuğu
Max düğüm (ikili, h seviye)2^(h+1) - 1h=2 → max 7 düğüm, h=3 → max 15 düğüm
Yaprak sayısı (tam ikili)⌊n/2⌋ + 1Tam ikili ağaçta yaprak sayısı ≈ düğüm sayısının yarısı

Ağaç Oluşturma

Ağaç düğümlerini bellekte temsil etmenin iki temel yolu vardır: bağlı yapı (linked — her düğüm pointer ile çocuklarına bağlı) ve dizi (array — indeks aritmetiği ile ebeveyn-çocuk ilişkisi). Bu bölümde ikili ağaç (binary tree) üzerinden her iki yöntemi göreceğiz.

Yöntem 1 — Bağlı Yapı (Linked)

Her düğüm bir struct'tır: veri + sol çocuk pointer + sağ çocuk pointer. Çocuğu olmayan yönler NULL'dur. Bu en yaygın ve en esnek gösterimdir.

Düğüm Yapısı — Bellekte Görünüm
left*
→ sol
data
42
right*
sağ →
Her düğüm: int data + Node* left + Node* right
tree.c — düğüm yapısı ve oluşturma
#include <stdio.h>
#include <stdlib.h>

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

/* ── Yeni düğüm oluştur ── */
Node* yeniDugum(int data) {
    Node* n = (Node*)malloc(sizeof(Node));
    if (!n) { fprintf(stderr, "Bellek hatası!\n"); exit(1); }
    n->data  = data;
    n->left  = NULL;
    n->right = NULL;
    return n;
}

Şimdi referans ağacımızı elle oluşturalım:

Oluşturacağımız Ağaç
123456
ağacı elle oluşturma
int main() {
    // Düğümleri oluştur
    Node* kok  = yeniDugum(1);
    Node* n2   = yeniDugum(2);
    Node* n3   = yeniDugum(3);
    Node* n4   = yeniDugum(4);
    Node* n5   = yeniDugum(5);
    Node* n6   = yeniDugum(6);

    // Bağlantıları kur
    kok->left  = n2;      //     1
    kok->right = n3;      //    / \
    n2->left   = n4;      //   2   3
    n2->right  = n5;      //  / \   \
    n3->right  = n6;      // 4   5   6

    printf("Kök: %d\n", kok->data);
    printf("Sol: %d\n", kok->left->data);
    printf("Sağ: %d\n", kok->right->data);
    printf("Sol-Sol: %d\n", kok->left->left->data);
    printf("Sol-Sağ: %d\n", kok->left->right->data);
    printf("Sağ-Sağ: %d\n", kok->right->right->data);

    return 0;
}

/* Çıktı:
   Kök: 1
   Sol: 2
   Sağ: 3
   Sol-Sol: 4
   Sol-Sağ: 5
   Sağ-Sağ: 6
*/

Yöntem 2 — Dizi Gösterimi (Array)

İkili ağaç bir dizide saklanabilir. Kök indeks 0'da bulunur. Herhangi bir i indeksindeki düğüm için:

İndeks formülleri (0-tabanlı):
Sol çocuk: 2*i + 1
Sağ çocuk: 2*i + 2
Ebeveyn: (i - 1) / 2 (tamsayı bölme)
Ağacın Dizi Gösterimi
123456
[0]
1
[1]
2
[2]
3
[3]
4
[4]
5
[5]
[6]
6
[5] boş → 3'ün sol çocuğu yok
Örnek: düğüm [1] (data=2) → sol çocuk: 2×1+1 = [3] (data=4), sağ çocuk: 2×1+2 = [4] (data=5), ebeveyn: (1-1)/2 = [0] (data=1)

Bağlı Yapı (Linked)

✓ Herhangi bir şekil, boşluk israfı yok
✓ Ekleme/silme pointer ile O(1)
✗ Ebeveyne erişim yok (tek yönlü)
✗ Extra bellek (2 pointer/düğüm)
Kullanım: BST, AVL, genel ağaçlar

Dizi (Array)

✓ Cache-friendly, pointer yok
✓ Ebeveyn-çocuk O(1) indeks hesabı
✗ Dengesiz ağaçta büyük israf
✗ Ekleme/silme kaydırma gerektirebilir
Kullanım: Heap, tam/complete ağaçlar

Ağaç Türlerine Genel Bakış

Ağaç yapısının çeşitli özelleşmiş türleri vardır. Her biri belirli bir problemi çözmek için tasarlanmıştır. Önce ikili ağaç (binary tree) alt türlerini, sonra ileri düzey yapıları tanıyalım.

İkili Ağaç (Binary Tree) Alt Türleri

5 Temel İkili Ağaç Türü
Full (Tam)
Her düğüm 0 veya 2 çocuk
Complete (Eksiksiz)
Son seviye hariç dolu,
soldan sağa dolmuş
Perfect (Mükemmel)
Tüm seviyeler tamamen dolu
n = 2^(h+1) - 1
Dejenere (Skewed)
Her düğümde 1 çocuk
→ bağlı listeye dönüşür
Dengeli (Balanced)
Sol-sağ yükseklik farkı ≤ 1
h = O(log n) garantisi
TürTanımÖzellik
Full (Tam)Her düğüm ya 0 ya 2 çocuğa sahipTek çocuklu düğüm yok
Complete (Eksiksiz)Son seviye hariç tüm seviyeler dolu, son seviye soldan doluDizi gösteriminde boşluk yok → heap için ideal
Perfect (Mükemmel)Tüm iç düğümler 2 çocuklu, tüm yapraklar aynı seviyeden = 2^(h+1) - 1 (h=3 → n=15)
Dejenere (Skewed)Her düğümde en fazla 1 çocukFiilen bağlı liste → arama O(n)
Dengeli (Balanced)Her düğümde sol-sağ alt ağaç yükseklik farkı ≤ 1Arama/ekleme O(log n) garantisi

İleri Düzey Ağaç Yapıları — Yol Haritası

İkili ağaç temel yapıdır; üzerine inşa edilen özelleşmiş yapılar farklı problemleri çözer:

BST (Binary Search Tree)

Sol < Kök < Sağ kuralı. Sıralı veri saklama, arama, ekleme, silme hep O(h). Dengesizse h = n → O(n).
→ Bölüm 6.3'te

AVL Ağacı

Kendini dengeleyen BST. Denge faktörü |h_sol - h_sağ| ≤ 1. Rotasyon ile dengesizlik giderilir. Tüm operasyonlar O(log n).
→ Bölüm 6.4'te

Heap (Yığın)

Complete binary tree + heap özelliği (min veya max). Priority queue'nun asıl implementasyonu. Dizi üzerinde saklanır.
→ Bölüm 6.5'te

B-Tree

Disk tabanlı veritabanları için optimize edilmiş, yüksek dereceli (high-order) dengeli ağaç. Her düğümde yüzlerce anahtar. MySQL InnoDB, PostgreSQL indeksleri B-tree kullanır.
→ İleri bölümlerde

Red-Black Tree

Renkli düğümlerle (kırmızı/siyah) dengelenen BST. AVL'den daha gevşek denge, ama insert/delete daha hızlı. Java TreeMap, C++ std::map.
→ İleri bölümlerde

Trie (Prefix Tree)

String anahtarları karakter karakter saklar. Autocomplete, spell-check, IP routing tablolarının temeli. Arama O(m) — m = kelime uzunluğu.
→ İleri bölümlerde

Ağaçların Gerçek Dünya Kullanımları

AlanAğaç TürüKullanım
Dosya sistemiGenel ağaç (n-ary)Klasörler ve dosyalar hiyerarşisi (/, /home, /usr...)
HTML/XMLGenel ağaç (DOM)Etiket yapısı: <html> → <body> → <div> → ...
Veritabanı indeksiB-tree / B+treeMySQL, PostgreSQL, SQLite — milyonlarca satırda O(log n) arama
DerleyiciAST (Abstract Syntax Tree)Kaynak kodu ayrıştırma: 3 + 4 * 5 → ağaç yapısı
Oyun AIMinimax / Game TreeSatranç, Go: hamle ağacı dallandırma + budama (alpha-beta)
Ağ yönlendirmeTrieIP routing: en uzun önek eşleşmesi (longest prefix match)
SıkıştırmaHuffman TreeZIP, JPEG: frekansa göre değişken uzunluklu kodlama
İşletim sistemiHeapProcess scheduling: priority queue → binary heap

Sonuç

Ağaç, doğrusal veri yapılarından hiyerarşik dünyaya geçiştir. Kök, yaprak, derinlik, yükseklik ve derece gibi temel terimler ağaç ailesi boyunca kullanılır. Bağlı yapı (pointer tabanlı) esneklik sağlarken, dizi gösterimi heap gibi complete ağaçlar için idealdir.

İkili ağacın beş alt türü — full, complete, perfect, dejenere ve dengeli — farklı yapısal garantiler sunar. Bu temeller üzerine BST, AVL, heap, B-tree, Red-Black tree ve trie gibi güçlü yapılar inşa edilir. Bir sonraki bölümde ikili ağacı derinlemesine inceleyeceğiz: dolaşma (traversal) yöntemleri, ekleme, silme ve ağaç ölçümleri.

Bölüm 6.1 özeti: Ağaç = hiyerarşik, döngüsüz, bağlantılı yapı. Temel terimler: kök, yaprak, derinlik (↓ kökten), yükseklik (↑ yapraktan), derece (çocuk sayısı). İki gösterim: bağlı yapı (pointer) ve dizi (indeks formülleri). İkili ağaç türleri: full, complete, perfect, dejenere, dengeli. İleri yapılar: BST, AVL, heap, B-tree, trie.
← Veri Yapıları