Teknik mülakatlarda adayların en sık takıldığı nokta Python sözdizimi değil; doğrusal olmayan veya durum izleme gerektiren problemlerde doğru veri yapısını seçmektir. Dizi (list) ve sözlük (dict) soruları ilk telefon elemesini geçmenizi sağlar; ancak orta ve ileri seviye (Mid/Senior) mülakat turlarının kilidini üç temel veri yapısı açar:

  1. Yığınlar (Stacks, Monotonik Yığın & Heap): İç içe geçmiş yapıları eşleştirmek, "bir sonraki daha büyük/küçük elemanı" O(n) sürede bulmak ve öncelik kuyruğu yönetmek.
  2. Ağaçlar (Binary Trees & BST): Hiyerarşik veriyi modellemek, özyinelemeli (recursive) alt problemlere bölmek ve O(log n) arama/sıralama yapmak.
  3. Graflar (Graphs): Şehir haritalarından ders ön koşullarına, sosyal ağlardan mikroservis bağımlılıklarına kadar her türlü bağlantılı ağı BFS, DFS ve en kısa yol algoritmalarıyla çözmek.

Bu kapsamlı rehberde; Yığın, Ağaç ve Graf veri yapılarını Python'daki en temiz üretim kalıplarıyla inceliyor ve her başlığın sonunda teoriyi hemen tarayıcıda kodlayabileceğiniz canlı PyMülakat soru sayfalarına yönlendiriyoruz.


Hızlı Karar Tablosu: Soruda Hangi İpucu Hangi Veri Yapısını İşaret Eder?

Sorudaki Anahtar İpucu Seçilecek Veri Yapısı / Kalıp Zaman Karmaşıklığı Örnek Soru
Açılıp kapanan parantez, iç içe etiket, geri alma (undo) Yığın (Stack - LIFO) O(n) K14: Geçerli Parantez
"Sağdaki ilk daha büyük/küçük eleman", histogram, yağmur suyu Monotonik Yığın O(n) O27: Günlük Sıcaklıklar
"En büyük/küçük K eleman", K sıralı listeyi birleştirme Öncelik Yığını (heapq) O(n log k) Z26: K Sıralı Liste
Hiyerarşi, derinlik, kökten yaprağa yol, alt ağaç İkili Ağaç (DFS) O(n) K19: Maksimum Derinlik
Sıralı ağaçta arama, aralık sorgusu, K'ıncı en küçük İkili Arama Ağacı (BST) O(h) O34: BST K'ıncı Eleman
Katman katman dolaşma, sağdan/soldan görünüm Ağaçta BFS (deque) O(n) O36: Sağdan Görünüm
Ağırlıksız en kısa yol, minimum adım sayısı, yayılım Grafta BFS O(V + E) O42: Çürük Portakallar
Ada sayısı, bağlı bileşen, bölge boyama Grafta DFS / BFS O(V + E) O43: Ada Sayısı
Ön koşul, görev sırası, döngüsel bağımlılık tespiti Topolojik Sıralama O(V + E) O07: Görev Sırası
Pozitif ağırlıklı kenarlarda en kısa maliyetli yol Dijkstra (heapq) O((V + E) log V) Z35: Ağ Gecikme Süresi

1. Yığınlar (Stacks), Monotonik Yığın ve Heap

1.1 Klasik Yığın (LIFO — Son Giren İlk Çıkar)

Yığın (Stack), üst üste dizilmiş tabaklar gibidir: Yalnızca en üste eleman ekleyebilir (push) ve yalnızca en üstteki elemanı çıkarabilirsiniz (pop). Python'da yerleşik list tipi, sondan ekleme (append) ve sondan çıkarma (pop) işlemlerini amortize O(1) sürede yaptığı için doğrudan yığın olarak kullanılır.

Dikkat: list.pop(0) (baştan çıkarma) tüm elemanları kaydırdığı için O(n) sürer. Hem baştan hem sondan O(1) işlem gerektiğinde collections.deque kullanın.

def gecerli_parantez(s: str) -> bool:
    eslesme = {")": "(", "]": "[", "}": "{"}
    yigin: list[str] = []

    for ch in s:
        if ch in eslesme:
            # Kapanış parantezi: yığın boşsa veya tepedeki eşleşmiyorsa geçersiz
            if not yigin or yigin.pop() != eslesme[ch]:
                return False
        else:
            yigin.append(ch)

    return len(yigin) == 0

print(gecerli_parantez("({[]})"))  # True
print(gecerli_parantez("([)]"))    # False

1.2 Monotonik Yığın: O(n²) Aramayı O(n)'e İndiren Sihir

Bir dizideki her eleman için "sağındaki ilk daha büyük elemanı" bulmak istediğinizde kaba kuvvet çözüm iç içe iki döngüyle O(n²) sürer. Monotonik azalan yığın ise henüz cevabını bulamadığımız indeksleri yığında tutar; daha büyük bir sayı geldiğinde yığının tepesindeki küçük elemanların cevabını tek seferde çözer. Her indeks yığına en fazla bir kez girip bir kez çıktığı için toplam karmaşıklık O(n) olur.

def gunluk_sicakliklar(sicakliklar: list[int]) -> list[int]:
    """Her gün için daha sıcak bir günün kaç gün sonra geleceğini döndürür."""
    n = len(sicakliklar)
    cevap = [0] * n
    yigin: list[int] = []  # cevabını bekleyen günlerin indeksleri (azalan sıra)

    for bugun, derece in enumerate(sicakliklar):
        while yigin and sicakliklar[yigin[-1]] < derece:
            gecmis_gun = yigin.pop()
            cevap[gecmis_gun] = bugun - gecmis_gun
        yigin.append(bugun)

    return cevap

print(gunluk_sicakliklar([73, 74, 75, 71, 69, 72, 76, 73]))
# [1, 1, 4, 2, 1, 1, 0, 0]

1.3 İkili Yığın (Binary Heap / Priority Queue — heapq)

Türkçede hem Stack hem Heap kelimesi zaman zaman "yığın" olarak çevrilse de ikisi farklı yapılardır:

  • Stack: Son giren ilk çıkar (LIFO).
  • Heap (Öncelik Kuyruğu): Her zaman en küçük (Min-Heap) veya en büyük (Max-Heap) eleman ilk çıkar. Python'daki heapq modülü dizi tabanlı bir Min-Heap uygular; heappush ve heappop işlemleri O(log n), en küçük elemana bakmak (heap[0]) ise O(1) sürer.

🎯 Yığın (Stack & Heap) İçin Çözmeniz Gereken Sorular

👉 Tüm modülü incelemek için: Modül 3: Yığın, Kuyruk ve Bağlantılı Listeler


2. Ağaçlar (Binary Trees & İkili Arama Ağaçları - BST)

Ağaçlar; dosya sistemlerinden HTML DOM yapısına, veritabanı indekslerinden karar ağaçlarına kadar her türlü hiyerarşik verinin temelidir. Teknik mülakatlarda ağaç sorularının %90'ı İkili Ağaç (Binary Tree) ve İkili Arama Ağacı (Binary Search Tree — BST) üzerine kuruludur.

2.1 İkili Ağaç Düğümü ve 4 Temel Dolaşma (Traversal)

Her ağaç sorusu şu soruyu yanıtlayarak başlar: "Bilgiyi çocuklardan yukarı mı topluyorum (Postorder), yukarıdan aşağı mı aktarıyorum (Preorder), sıralı mı geziyorum (Inorder), yoksa katman katman mı ilerliyorum (BFS)?"

from collections import deque

class TreeNode:
    def __init__(self, val: int = 0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def max_derinlik_dfs(root: TreeNode | None) -> int:
    """Postorder DFS: Alt ağaçların derinliğini bulup 1 ekler — O(n) zaman, O(h) bellek."""
    if not root:
        return 0
    return 1 + max(max_derinlik_dfs(root.left), max_derinlik_dfs(root.right))

def sagdan_gorunum_bfs(root: TreeNode | None) -> list[int]:
    """Level-Order BFS: Her katmanın son düğümünü toplar."""
    if not root:
        return []
    gorunum: list[int] = []
    kuyruk = deque([root])

    while kuyruk:
        katman_boyutu = len(kuyruk)
        for i in range(katman_boyutu):
            dugum = kuyruk.popleft()
            if i == katman_boyutu - 1:
                gorunum.append(dugum.val)
            if dugum.left:
                kuyruk.append(dugum.left)
            if dugum.right:
                kuyruk.append(dugum.right)
    return gorunum

2.2 İkili Arama Ağacı (BST) Değişmezi ve Klasik Mülakat Tuzağı

Bir İkili Arama Ağacında (BST) her düğüm için şu kural geçerlidir:

  • Sol alt ağaçtaki TÜM düğümler kök değerinden küçük,
  • Sağ alt ağaçtaki TÜM düğümler kök değerinden büyüktür.

Mülakat Tuzağı: Yalnızca node.left.val < node.val < node.right.val kontrolü yapmak yanlıştır! Çünkü sağ alt ağacın sol çocuğunda kökten daha küçük bir değer gizlenmiş olabilir. Doğru çözüm, aşağı inerken (alt_sinir, ust_sinir) aralığını taşımaktır:

def gecerli_bst_mi(root: TreeNode | None,
                   alt: float = float("-inf"),
                   ust: float = float("inf")) -> bool:
    if not root:
        return True
    if not (alt < root.val < ust):
        return False
    return (gecerli_bst_mi(root.left, alt, root.val) and
            gecerli_bst_mi(root.right, root.val, ust))

Ayrıca bir BST'yi Inorder (Sol → Kök → Sağ) sırasıyla dolaştığınızda değerler küçükten büyüğe sıralı gelir.

🎯 Ağaçlar (Trees & BST) İçin Çözmeniz Gereken Sorular

👉 Tüm modülü incelemek için: Modül 4: Ağaçlar (Trees & BST)


3. Graflar (Graphs): BFS, DFS, Topolojik Sıralama ve Dijkstra

Ağaçlar aslında döngü içermeyen bağlı graflardır. Düğümler arasında birden fazla yol veya döngü (cycle) olabildiğinde problem bir graf problemine dönüşür. Bu yüzden graf algoritmalarının altın kuralı şudur: Sonsuz döngüye girmemek için ziyaret edilen düğümleri (visited) mutlaka işaretle.

3.1 Graf Temsili ve Ağırlıksız En Kısa Yol (BFS)

Kenar ağırlıkları eşit (veya ağırlıksız) bir grafta A noktasından B noktasına en az adımla ulaşmanın yolu her zaman Genişlik Öncelikli Arama (BFS) algoritmasıdır:

from collections import defaultdict, deque

def en_kisa_adim_bfs(n: int, kenarlar: list[tuple[int, int]], baslangic: int, hedef: int) -> int:
    graf: dict[int, list[int]] = defaultdict(list)
    for u, v in kenarlar:
        graf[u].append(v)
        graf[v].append(u)

    ziyaret = {baslangic}
    kuyruk = deque([(baslangic, 0)])  # (dugum, adim_sayisi)

    while kuyruk:
        dugum, adim = kuyruk.popleft()
        if dugum == hedef:
            return adim
        for komsu in graf[dugum]:
            if komsu not in ziyaret:
                ziyaret.add(komsu)
                kuyruk.append((komsu, adim + 1))

    return -1

3.2 Topolojik Sıralama (Kahn Algoritması) ve Döngü Tespiti

"B dersini almak için önce A dersini bitirmelisin" veya "B paketi derlenmeden önce A paketi derlenmeli" şeklindeki tüm ön koşul soruları Yönlü Çevrimsiz Graf (DAG) üzerinde Topolojik Sıralama problemidir. Giriş derecesi (in_degree) 0 olan düğümlerden başlayarak bağımlılıkları adım adım çözeriz:

from collections import defaultdict, deque

def gorev_sirasi_bul(gorev_sayisi: int, on_kosullar: list[tuple[int, int]]) -> list[int]:
    """on_kosullar: (hedef, on_kosul) çiftleri. Döngü varsa boş liste döndürür."""
    graf: dict[int, list[int]] = defaultdict(list)
    giris_derecesi = [0] * gorev_sayisi

    for ders, on_kosul in on_kosullar:
        graf[on_kosul].append(ders)
        giris_derecesi[ders] += 1

    kuyruk = deque(i for i, d in enumerate(giris_derecesi) if d == 0)
    sira: list[int] = []

    while kuyruk:
        mevcut = kuyruk.popleft()
        sira.append(mevcut)
        for sonraki in graf[mevcut]:
            giris_derecesi[sonraki] -= 1
            if giris_derecesi[sonraki] == 0:
                kuyruk.append(sonraki)

    return sira if len(sira) == gorev_sayisi else []  # eşit değilse döngü (deadlock) vardır

3.3 Ağırlıklı En Kısa Yol: Dijkstra Algoritması (heapq)

Kenarların farklı maliyetleri (mesafe, gecikme süresi, ücret) olduğunda normal kuyruk (deque) yerine Min-Heap (heapq) kullanırız. Her adımda şu ana kadar bilinen en düşük maliyetli düğümü genişletiriz:

from collections import defaultdict
import heapq

def dijkstra_en_kisa_sure(n: int, kenarlar: list[tuple[int, int, int]], kaynak: int) -> dict[int, int]:
    graf: dict[int, list[tuple[int, int]]] = defaultdict(list)
    for u, v, maliyet in kenarlar:
        graf[u].append((v, maliyet))

    mesafe: dict[int, int] = {}
    heap: list[tuple[int, int]] = [(0, kaynak)]  # (toplam_maliyet, dugum)

    while heap:
        maliyet, u = heapq.heappop(heap)
        if u in mesafe:
            continue  # daha kısa yoldan zaten işlendi
        mesafe[u] = maliyet
        for v, agirlik in graf[u]:
            if v not in mesafe:
                heapq.heappush(heap, (maliyet + agirlik, v))

    return mesafe

🎯 Graflar (Graphs) İçin Çözmeniz Gereken Sorular

👉 Tüm modülü incelemek için: Modül 5: Graflar (Graphs)


Önerilen 3 Haftalık Çalışma Planı

Bu üç veri yapısını kalıcı mühendislik refleksine dönüştürmek için rastgele soru çözmek yerine şu sırayı izleyin:

  1. 1. Hafta — Yığın ve Monotonik Yığın: K14 → O28 → O29 → O27 → Z24 → Z26
  2. 2. Hafta — İkili Ağaçlar ve BST: K19 → K20 → O35 → O34 → O36 → O37 → Z29
  3. 3. Hafta — Graflar ve En Kısa Yol: K24 → O43 → O42 → O45 → O07 → Z35 → Z37

Yukarıdaki her bağlantıya tıklayarak doğrudan PyMülakat'ın tarayıcı içi Python editöründe kodunuzu çalıştırabilir, gizli sınır testleriyle doğrulayabilir ve NeatyAI mülakatçısıyla karmaşıklık analizinizi tartışabilirsiniz.

İnteraktif Pratik İstasyonu

Teoriyi Gerçek Sınav Ortamında Test Etmeye Hazır mısın?

PyMülakat platformunda 10 uzmanlık modülü ve 200 özgün Python mülakat sorusu seni bekliyor. Tarayıcıda kodunu hemen yaz, çalıştır ve gizli sınır testleriyle kendini sına.

İlk Soruyu Çöz (K01) →Modülleri İncele