Big O neyi ölçer?

Big O, bir algoritmanın girdi boyutu $n$ büyürken kaynak tüketiminin hangi hızla arttığını ifade eder. Tam çalışma süresini saniye cinsinden söylemez; donanım, programlama dili ve derleyici gibi ayrıntıları göz ardı ederek büyüme eğilimini gösterir.

Örneğin bir döngü $n$ elemanın tamamını geziyorsa zaman karmaşıklığı $O(n)$ olur. İç içe iki döngünün her biri $n$ kez çalışıyorsa yaklaşık $n \times n=n^2$ işlem yapılır ve sonuç $O(n^2)$ olarak gösterilir.

Big O hesaplanırken sabit katsayılar ve düşük dereceli terimler atılır:

Çünkü büyük $n$ değerlerinde davranışı belirleyen baskın terim $n^2$ olur.

| Karmaşıklık | Tipik örnek | Büyüme davranışı | |—|—|—| | $O(1)$ | Dizide indeksle erişim | Girdiden bağımsız | | $O(\log n)$ grid | İkili arama | Çok yavaş büyür | | $O(n)$ | Doğrusal arama | Girdiyle aynı oranda büyür | | $O(n\log n)$ | Merge Sort | Büyük veriler için genellikle uygundur | | $O(n^2)$ | İç içe döngüler | Büyük girdilerde pahalıdır | l | $O(2^n)$ ring | Alt kümeleri denemek | Küçük girdilerde bile patlayabilir |

Zaman karmaşıklığı nasıl analiz edilir?

Önce temel işlemin kaç kez çalıştığını belirlemek gerekir. Ardışık işlemlerin maliyetleri toplanır, iç içe işlemlerin maliyetleri ise çarpılır. Ardından baskın terim seçilir.

def tekrar_var_mi(liste):
    for i in range(len(liste)):
        for j in range(i + 1, len(liste)):
            if liste[i] == liste[j]:
                return True
    return False

Bu kod, en kötü durumda her elemanı diğer elemanlarla karşılaştırır. Karşılaştırma sayısı yaklaşık $n(n-1)/2$ olduğundan zaman karmaşıklığı $O(n^2)$, ek mekan karmaşıklığı ise $O(1)$ olur.

Bir küme kullanarak zamanı iyileştirebiliriz:

def tekrar_var_mi(liste):
    gorulenler = set()
    for eleman in liste:
        if eleman in gorulenler:
            return True
        gorulenler.add(eleman)
    return False

Kümede arama ve ekleme ortalama $O(1)$ kabul edilir. Bu nedenle toplam süre $O(n)$ seviyesine iner; fakat küme en kötü durumda $n$ mans eleman sakladığı için mekan tüketimi $O(n)$ olur. Yani zamanı kazanırken belleği harcadık.

Mekan karmaşıklığını unutma

Mekan karmaşıklığı,/algo algoritmanın giriş dışında kullandığı ek belleği inceler. Değişkenler, geçici diziler, veri yapıları ve özyinelemeli çağrı yığını hesaba katılmalıdır.

Özyinelemeli bir fonksiyon da görünürde ek koleksiyon oluşturmasa bile çağrı yığını tüketir. Örneğin dengeli bir ikili ağaçta arama derinliği $O(\log n)$ ise yığın alanı da $O(\log n)$ olabilir.

plant ## En verimli algoritmayı seçme yöntemi

Öncelikle gerçek kısıtları belirle: En büyük girdi kaç elemanlı? Bellek sınırı nedir? Sonuç anlık mı üretilmeli? Ardından aday algoritmaların en kötü, ortalama ve gerekiyorsa en iyi durumlarını karşılaştır.

Küçük $n$ değerlerinde basit bir $O(n^2)$ çözüm, düşük sabit maliyetleri sayesinde yeterli olabilir. Buna karşılık $n=1\,000\,000$ olduğunda karesel bir yaklaşım yaklaşık $10^{12}$ işlem anlamına gelir. Bu noktada $O(n\log n)$ veya $O(n)$ seçenekleri belirgin biçimde avantajlıdır.

Son olarak teorik analizi gerçek ölçümlerle doğrula. Profil çıkarma araçları, önbellek davranışı ve veri dağılımı gibi Big O’nun göstermediği ayrıntıları ortaya çıkarır. En iyi seçim her zaman en küçük notasyon değildir; ihtiyaçları karşılayan, anlaşılır ve kaynak dengesini doğru kuran algoritmadır.

``

Dinamik programlama ne zaman kullanılır?

Bir problemi parçalara bölmek tek başına dinamik programlama değildir. Yaklaşımın etkili olabilmesi için genellikle iki özellik aranır:

1. Örtüşen alt problemler: Aynı alt problem farklı hesaplama yollarında tekrar ortaya çıkar.
2. Optimal alt yapı: Büyük problemin en iyi çözümü, alt problemlerin en iyi çözümlerinden oluşturulabilir.

Örneğin Fibonacci dizisi şu bağıntıyla tanımlanır:

ve başlangıç durumları şöyledir:

Saf özyinelemeli çözümde F(n-2) gibi değerler birçok kez hesaplanır. Çağrı ağacı büyüdükçe çalışma süresi yaklaşık $O(2^n)$ seviyesine çıkar. Dinamik programlama sayesinde her değer yalnızca bir kez hesaplanarak süre $O(n)$ olur.

Birinci adım: Alt problemleri belirlemek

Büyük problemin daha küçük sürümleri alt problem olarak seçilir. Fibonacci örneğinde “n sayısının Fibonacci değerini bulmak” ana problemse F(n-1) ve F(n-2) onun alt problemleridir.

Daha gerçekçi bir örnek olan sırt çantası probleminde ise alt problem yalnızca kaç eşyanın incelendiğiyle açıklanamaz. Kalan kapasite de sonucu etkiler. Bu nedenle alt problemleri tanımlarken gelecekteki kararları etkileyen bütün bilgileri korumak gerekir.

İkinci adım: Durumu tanımlamak

Durum, bir alt problemi benzersiz biçimde ifade eden en küçük bilgi kümesidir. İyi durum tanımı, dinamik programlamanın en kritik bölümüdür.

Sırt çantası problemi için şu durum kullanılabilir:

Burada i hangi eşyalara bakabildiğimizi, c ise kalan kapasiteyi belirtir. Gereksiz bilgi eklemek durum sayısını artırır; eksik bilgi kullanmak ise farklı alt problemleri yanlışlıkla aynı kabul eder.

Üçüncü adım: Memoization ile tekrarları önlemek

Memoization, yukarıdan aşağıya çalışan özyinelemeli çözümün sonuçlarını bir önbellekte saklar. Fonksiyon aynı durumla yeniden çağrıldığında hesap yapmak yerine kayıtlı sonuç döndürülür.

def fibonacci(n, memo=None):
    # Sözlük, daha önce çözülen durumların sonuçlarını saklar.
    if memo is None:
        memo = {}

    if n in memo:
        return memo[n]

    if n <= 1:
        return n

    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print(fibonacci(40))

Bu kodda sözlüğün anahtarı durumu, yani n değerini temsil eder. Her durum bir kez çözüldüğü için toplam $n+1$ farklı durum bulunur. Her durumdaki işlem sabit zamanlı olduğundan karmaşıklık $O(n)$ zaman ve $O(n)$ bellek olur.

Memoization ve tabulation farkı

Dinamik programlama ezberlenecek bir kod kalıbı değil, düşünme disiplinidir: Önce alt problemleri keşfet, sonra durumu mümkün olduğunca sade tanımla, geçiş bağıntısını kur ve tekrarları saklayarak ortadan kaldır. Bu adımlar oturduğunda korkutucu görünen pek çok algoritma, düzenli doldurulan bir tabloya dönüşür.

Veri yapısı seçimi neden önemlidir?

Bir veri yapısını değerlendirirken genellikle zaman ve alan karmaşıklığına bakarız. Bir algoritmanın çalışma süresi, girdi büyüklüğü $n$ arttıkça değişir. Örneğin bir dizinin bütün elemanlarını gezmek $T(n)=an+b$ biçiminde modellenebilir ve bu işlem $O(n)$ karmaşıklığındadır.

Sık kullanılan işlemlerin genel karşılaştırması şöyledir:

* Son düğümün adresi ayrıca tutuluyorsa.

Diziler: Hızlı erişimin yıldızı

Diziler elemanları mantıksal olarak yan yana saklar. Bu nedenle $i$ numaralı elemana erişmek için başlangıç adresine belirli bir uzaklık eklemek yeterlidir:

Bu hesaplama sabit zamanda yapılır. Sık sık “beşinci eleman nedir?” diye sorulan problemlerde dizi güçlü bir seçimdir. Buna karşılık dizinin başına eleman eklemek, diğer elemanların kaydırılmasını gerektirdiği için pahalıdır.

Örneğin iki işaretçi tekniği, sıralı bir dizide hedef toplamı ararken iç içe döngü ihtiyacını ortadan kaldırır:

def hedef_cifti_bul(sayilar, hedef):
    sol, sag = 0, len(sayilar) - 1

    while sol < sag:
        toplam = sayilar[sol] + sayilar[sag]
        if toplam == hedef:
            return sayilar[sol], sayilar[sag]
        if toplam < hedef:
            sol += 1
        else:
            sag -= 1

    return None

Bu kod, sıralı dizinin iki ucundan ilerleyerek uygun çifti bulur. Kaba kuvvet yaklaşımının $O(n^2)$ maliyetini $O(n)$ seviyesine indirir.

Bağlı listeler: Esnek vagonlar

Bağlı listeyi, her vagonun bir sonrakinin adresini taşıdığı tren gibi düşünebiliriz. Düğümler bellekte yan yana olmak zorunda değildir. Bir düğüm biliniyorsa araya yeni düğüm eklemek yalnızca bağlantıları değiştirdiği için $O(1)$ sürer.

Ancak belirli bir indekse doğrudan sıçranamaz; düğümler baştan itibaren gezilmelidir. Dolayısıyla rastgele erişimin yoğun olduğu bir problemde bağlı liste kullanmak, kitabın her sayfasını birinciden başlayarak aramaya benzer.

Bağlı listeler; müzik listeleri, tarayıcı geçmişi ve sık ekleme-silme yapılan koleksiyonlar için uygundur. Çift bağlı listeler ileri ve geri hareket sağlarken fazladan işaretçi belleği tüketir.

Yığın: Son gelen ilk çıkar

Yığın, $LIFO$ yani “son giren ilk çıkar” ilkesini uygular. Tabakları üst üste koyduğunuzu düşünün: İlk olarak en üstteki tabağı alırsınız. Fonksiyon çağrıları, geri alma işlemleri ve sözdizimi denetimi yığının doğal kullanım alanlarıdır.

def parantezler_dengeli_mi(metin):
    yigin = []
    eslesme = {')': '(', ']': '[', '}': '{'}

    for karakter in metin:
        if karakter in '([{':
            yigin.append(karakter)
        elif karakter in eslesme:
            if not yigin or yigin.pop() != eslesme[karakter]:
                return False

    return len(yigin) == 0

Burada açılan parantezler yığına eklenir; kapanış görüldüğünde en son açılan parantez çıkarılır. Her karakter bir kez işlendiğinden süre $O(n)$, en kötü durumdaki bellek kullanımı da $O(n)$ olur.

Kuyruk: Sıraya kaynak yapmak yok

Kuyruk $FIFO$, yani “ilk giren ilk çıkar” düzeninde çalışır. Yazdırma görevleri, mesaj sistemleri ve genişlik öncelikli arama bu yapıyı kullanır. Bir grafikte başlangıç düğümüne en yakın noktaları önce keşfetmek istiyorsak kuyruğa komşuları ekler, önden sırayla çıkarırız.

Python’da listenin başından pop(0) kullanmak $O(n)$ maliyetlidir. Bunun yerine collections.deque tercih edilmelidir; append ve popleft işlemleri $O(1)$ zamanda gerçekleşir.

Problem çözerken karar reçetesi

Önce problemin baskın işlemini belirleyin: İndeksle erişim gerekiyorsa dizi, sık bağlantı değişikliği varsa bağlı liste, en son eklenene dönülecekse yığın, geliş sırası korunacaksa kuyruk düşünün. Ardından en kötü durumu analiz edin ve $n$ iki katına çıktığında maliyetin nasıl değiştiğini sorun. Veri yapısı seçimi ezber değil, problemin davranışını doğru okuma sanatıdır.

``

Problemin matematiksel modeli

Bir ağırlıklı grafı $G=(V,E)$ biçiminde tanımlayalım. Burada $V$ düğümleri, $E$ kenarları ve $w(u,v)$ ise $u$ ile $v$ arasındaki geçiş maliyetini gösterir. Bir $P$ yolunun toplam maliyeti:

şeklindedir. Amaç, kaynak $s$ ile hedef $t$ arasındaki yollar içinde maliyeti en küçük olanı bulmaktır:

Kenar ağırlıkları mesafe, süre, ücret veya enerji tüketimi olabilir. Kritik ayrım, negatif ağırlıkların bulunup bulunmamasıdır. Örneğin bir finans modelinde kazanç, negatif maliyet olarak temsil edilebilir.

Üç algoritma, üç farklı yaklaşım

Dijkstra: Hızlı ama seçici

Dijkstra, başlangıç düğümünden erişilebilen en düşük geçici mesafeye sahip düğümü sürekli seçer. Açgözlü çalışır: Kesinleştirilen bir mesafeye tekrar dönmez. Bu karar yalnızca tüm ağırlıklar $w(u,v)\geq 0$ olduğunda güvenlidir.

import heapq

def dijkstra(graph, source):
    dist = {node: float('inf') for node in graph}
    dist[source] = 0
    queue = [(0, source)]

    while queue:
        current, node = heapq.heappop(queue)
        if current != dist[node]:
            continue
        for neighbor, weight in graph[node]:
            candidate = current + weight
            if candidate < dist[neighbor]:
                dist[neighbor] = candidate
                heapq.heappush(queue, (candidate, neighbor))
    return dist

Öncelik kuyruğu, sıradaki en yakın düğümü verimli biçimde seçer. Yol ağları ve internet yönlendirme senaryoları için genellikle en pratik tercihtir.

Bellman-Ford: Yavaş ama kuşkucu

Koşul doğruysa $d(v)$ güncellenir. Bir tur daha yapıldığında hâlâ güncelleme gerçekleşiyorsa erişilebilir bir negatif döngü vardır.

def bellman_ford(vertices, edges, source):
    dist = {v: float('inf') for v in vertices}
    dist[source] = 0

    for _ in range(len(vertices) - 1):
        changed = False
        for u, v, weight in edges:
            if dist[u] + weight < dist[v]:
                dist[v] = dist[u] + weight
                changed = True
        if not changed:
            break

    for u, v, weight in edges:
        if dist[u] + weight < dist[v]:
            raise ValueError('Negatif döngü bulundu')
    return dist

Döviz arbitrajı ve maliyetlerin negatif olabildiği modeller, ek işlem süresine rağmen Bellman-Ford için uygundur.

Floyd-Warshall: Herkes herkese karşı

Floyd-Warshall, dinamik programlama kullanır. $k$ ara düğümüne izin verildiğinde güncelleme kuralı şöyledir:

def floyd_warshall(dist):
    n = len(dist)
    for k in range(n):
        for i in range(n):
            for j in range(n):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
    return dist

Sonuç matrisindeki herhangi bir $D_{ii}<0$ değeri negatif döngüyü gösterir. Bellek maliyeti $O(V^2)$ olduğundan devasa graflarda pahalıdır; fakat tüm çiftlerin sorgulanacağı küçük ulaşım veya ilişki ağlarında son derece kullanışlıdır.

Hangisini seçmeliyiz?

Negatif ağırlık yoksa ve tek kaynak önemliyse Dijkstra, negatif kenarlar varsa Bellman-Ford, bütün düğüm çiftleri gerekiyorsa Floyd-Warshall seçilmelidir. Özetle Dijkstra sprinter, Bellman-Ford temkinli denetçi, Floyd-Warshall ise herkesin rotasını önceden çıkaran takıntılı haritacıdır.

Önce yapıyı tanıyalım

Bir graf, düğümlerden ve bu düğümleri bağlayan kenarlardan oluşur: $G=(V,E)$. Burada $V$ düğüm, $E$ ise kenar kümesidir. Ağaç da çevrim içermeyen, bağlantılı özel bir graftır. Bir ağaçta iki düğüm arasında yalnızca tek bir basit yol bulunurken genel bir grafta birden fazla yol ve çevrim olabilir.

Bu ayrım uygulamada önemlidir. Ağaç üzerinde aşağı doğru ilerlemek çoğunlukla güvenlidir; ancak çevrimli bir grafta ziyaret edilen düğümler kaydedilmezse algoritma A → B → A → B döngüsünde sonsuza kadar kalabilir.

Derinlik öncelikli arama: Yolun sonunu gör

DFS, başlangıç düğümünden hareket ederek erişebildiği en derin noktaya ilerler. Gidecek yeni komşu kalmadığında geri izleme yapar. Bu davranış doğal olarak bir yığın (stack) ile modellenir. Özyinelemeli fonksiyonlarda çağrı yığını aynı görevi üstlenir.

def dfs(graph, start):
    visited = set()
    stack = [start]

    while stack:
        node = stack.pop()
        if node in visited:
            continue

        visited.add(node)
        print(node)  # Düğüm burada işlenir.

        # Ters ekleme, soldaki komşunun önce gezilmesini sağlar.
        for neighbor in reversed(graph[node]):
            if neighbor not in visited:
                stack.append(neighbor)

    return visited

Kod, sıradaki düğümü yığının sonundan alır. Komşular yığına eklendiği için algoritma diğer seçeneklere geçmeden önce bir dal boyunca derinleşir. DFS; çevrim tespiti, topolojik sıralama, bağlı bileşen bulma ve labirent çözme gibi problemlerde kullanışlıdır.

Genişlik öncelikli arama: Katman katman ilerle

BFS, önce başlangıç düğümüne bir kenar uzaklıktaki düğümleri, ardından iki kenar uzaklıktakileri inceler. Bu nedenle kuyruk (queue) kullanır. Ağırlıksız bir grafta en kısa yolu bulabilmesinin nedeni de düğümleri artan uzaklık sırasıyla ziyaret etmesidir.

from collections import deque

def bfs(graph, start):
    visited = {start}
    queue = deque([(start, 0)])

    while queue:
        node, distance = queue.popleft()
        print(node, distance)  # Başlangıca olan uzaklık.

        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, distance + 1))

    return visited

Bir düğüm kuyruğa eklenirken ziyaret edilmiş sayılır. Böylece aynı düğümün farklı komşular tarafından kuyruğa defalarca eklenmesi önlenir.

DFS ve BFS karşılaştırması

Arama ağacının dallanma katsayısı $b$, çözüm derinliği $d$ ise BFS yaklaşık $1+b+b^2+…+b^d$ düğüm üretir; baskın terim nedeniyle bu miktar $O(b^d)$ kabul edilir. DFS ise aynı anda çoğunlukla tek yol ile alternatifleri tuttuğundan bellekte daha tutumlu olabilir.

Hangisini seçmeliyiz?

Hedefin başlangıca yakın olduğu veya ağırlıksız en kısa yolun istendiği durumlarda BFS güçlü seçimdir. Arama alanı çok genişse, çözümün derinde olduğu düşünülüyorsa ya da bütün yapısal ilişkiler araştırılacaksa DFS daha uygun olabilir. Ancak kenarlar farklı ağırlıklara sahipse BFS yerine Dijkstra gibi algoritmalar gerekir.

Özetle DFS meraklı bir mağara kâşifi gibi tek tünele dalar; BFS ise düzenli bir arama ekibi gibi bütün katmanı tarar. Doğru algoritma, yalnızca grafın biçimine değil, aradığınız cevabın türüne ve kullanabileceğiniz belleğe de bağlıdır.

``

İkili aramanın temel mantığı

İkili arama, sıralı bir veri kümesinin ortasındaki elemanı inceler. Aranan değer daha küçükse sağ yarıyı, daha büyükse sol yarıyı eler. Her adımda problem boyutu yarıya indiği için zaman karmaşıklığı:

şeklindedir. Örneğin yaklaşık bir milyon elemanda doğrusal arama bir milyon karşılaştırma yapabilirken ikili arama yaklaşık $\log_2(1.000.000)\approx20$ adımda sonuca ulaşır.

def binary_search(numbers, target):
    left, right = 0, len(numbers) - 1

    while left <= right:
        middle = left + (right - left) // 2

        if numbers[middle] == target:
            return middle
        if numbers[middle] < target:
            left = middle + 1
        else:
            right = middle - 1

    return -1

Bu kod, sıralı dizide hedefin indeksini bulur. left <= right koşulu tek elemanlık son aralığın da kontrol edilmesini sağlar.

Sadece eleman değil, sınır aramak

İkili arama çoğu zaman “değer var mı?” sorusundan fazlasını çözer. Tekrarlı elemanlarda ilk konumu, son konumu veya belirli bir koşulu sağlayan en küçük değeri bulabiliriz. Örneğin [2, 4, 4, 4, 9] dizisinde ilk 4 aranırken eşitlikte durmak yerine sonucu kaydedip sola devam ederiz.

def first_position(numbers, target):
    left, right = 0, len(numbers) - 1
    answer = -1

    while left <= right:
        middle = (left + right) // 2
        if numbers[middle] >= target:
            if numbers[middle] == target:
                answer = middle
            right = middle - 1
        else:
            left = middle + 1

    return answer

Aynı fikir “en az kaç sunucu gerekli?” veya “bir işi tamamlamaya yeten minimum kapasite nedir?” gibi cevap üzerinde arama problemlerine uygulanır. Buradaki kritik şart, kontrol fonksiyonunun monoton olmasıdır: Bir kapasite yeterliyse daha büyük kapasiteler de yeterli olmalıdır. Böylece sonuçlar yanlış, yanlış, doğru, doğru biçiminde ayrılır ve geçiş noktası ikili aramayla bulunur.

İki işaretçi tekniği

İki işaretçi, dizinin farklı bölgelerini temsil eden iki indeks kullanır. İşaretçiler karşılıklı yaklaşabilir veya aynı yönde farklı hızlarla ilerleyebilir.

Sıralı dizide toplamı hedefe eşit iki sayı bulalım:

def find_pair(numbers, target):
    left, right = 0, len(numbers) - 1

    while left < right:
        current = numbers[left] + numbers[right]
        if current == target:
            return numbers[left], numbers[right]
        if current < target:
            left += 1
        else:
            right -= 1

    return None

Toplam küçükse sol işaretçiyi ilerletmek toplamı büyütür; büyükse sağ işaretçiyi geriletmek toplamı küçültür. Böylece $O(n^2)$ olabilecek tüm çiftleri denemek yerine yalnızca $O(n)$ adım kullanılır.

Hangisini seçmeliyiz?

Bir problemde önce “Sonuçlar monoton mu?” diye sorulmalıdır; cevap evetse ikili arama güçlü bir adaydır. “İki sınırı hareket ettirerek seçenekleri güvenle eleyebilir miyim?” sorusunun cevabı evetse iki işaretçi düşünülmelidir. Asıl ustalık kodu ezberlemek değil, hangi hareketin neden güvenli olduğunu kanıtlamaktır.

Özyinelemeli düşünmek ne demektir?

Özyineleme, bir fonksiyonun problemi küçülterek kendisini çağırmasıdır. Sağlıklı bir özyinelemeli çözümün iki temel parçası bulunur:

1. Temel durum: Çağrıların duracağı en küçük problem.
2. Özyinelemeli durum: Problemi daha küçük bir örneğe dönüştüren adım.

Örneğin faktöriyel şu bağıntıyla tanımlanır:

Temel durum ise $0! = 1$ olur. Kod karşılığı oldukça doğaldır:

def faktoriyel(n):
    if n == 0:          # Temel durum
        return 1
    return n * faktoriyel(n - 1)

Buradaki kritik fikir, fonksiyonun sonsuza kadar çağrılmamasıdır. Her çağrı problemi temel duruma yaklaştırmalıdır. Aksi hâlde çağrı yığını büyür ve program sonunda hata verir.

Özyineleme ile geri izleme arasındaki fark

Geri izleme, çoğunlukla özyineleme kullanır; ancak her özyinelemeli algoritma geri izleme değildir. Geri izlemede bir seçim yapılır, sonuç araştırılır ve seçim başarısızsa durum eski hâline getirilir.

Geri izlemenin özeti şu üç komuttur: Seç, keşfet, seçimi geri al. Bu son adım unutulursa algoritma, önceki yolun izlerini sonraki denemelere taşır.

Labirentte yol bulma

Bir hücreden yukarı, aşağı, sağa veya sola gidebildiğimizi varsayalım. Duvarlara ve daha önce ziyaret edilen hücrelere giremeyiz. Aşağıdaki fonksiyon, çıkışa ulaştığında True döndürür:

def yolu_bul(labirent, satir, sutun, cikis, ziyaret):
    if (satir, sutun) == cikis:
        return True

    if (satir, sutun) in ziyaret:
        return False

    if labirent[satir][sutun] == "#":
        return False

    ziyaret.add((satir, sutun))

    for ds, dt in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
        yeni_s, yeni_t = satir + ds, sutun + dt
        if 0 <= yeni_s < len(labirent) and 0 <= yeni_t < len(labirent[0]):
            if yolu_bul(labirent, yeni_s, yeni_t, cikis, ziyaret):
                return True

    ziyaret.remove((satir, sutun))  # Geri izleme
    return False

ziyaret kümesi döngüleri önler. Hücreden çıkışa ulaşılamazsa hücre kümeden silinir; böylece farklı bir yol aynı hücreyi başka bağlamda deneyebilir. Yalnızca herhangi bir yolu arıyorsak hücreyi silmemek de mümkündür. Ancak tüm yolları üretmek istediğimizde geri alma adımı zorunludur.

Tahta doldurma: N-Vezir problemi

N-Vezir probleminde $N \times N$ tahtaya, birbirini tehdit etmeyen $N$ vezir yerleştirilir. Her satıra bir vezir koyup yalnızca güvenli sütunları denemek, arama alanını ciddi ölçüde küçültür.

def vezirleri_yerlestir(n, satir=0, sutunlar=set(), capraz1=set(), capraz2=set()):
    if satir == n:
        return True

    for sutun in range(n):
        if sutun in sutunlar or satir - sutun in capraz1 or satir + sutun in capraz2:
            continue

        sutunlar.add(sutun)
        capraz1.add(satir - sutun)
        capraz2.add(satir + sutun)

        if vezirleri_yerlestir(n, satir + 1, sutunlar, capraz1, capraz2):
            return True

        sutunlar.remove(sutun)
        capraz1.remove(satir - sutun)
        capraz2.remove(satir + sutun)

    return False

Saf denemede olasılık sayısı yaklaşık $N^N$ olabilir. Geçersiz dalları erkenden budamak ise gereksiz çağrıları engeller. Bu nedenle iyi bir geri izleme çözümünün sırrı yalnızca geri dönmek değil, ne zaman devam etmemek gerektiğini erkenden bilmektir.

Özyinelemeli düşünürken önce temel durumu, ardından seçimi ve son olarak geri alma işlemini yazmak yararlıdır. Labirent, Sudoku, N-Vezir ve kelime bulmacaları farklı görünse de aynı macerayı anlatır: Bir kapıyı aç, içeri bak; hazine yoksa kapıyı kapat ve diğerini dene.

Performansı nasıl ölçeriz?

Bir sıralama algoritmasının maliyeti çoğunlukla karşılaştırma ve yer değiştirme sayısıyla değerlendirilir. Girdi boyutu $n$ ise iki iç içe döngü kullanan basit algoritmalar genellikle

karşılaştırma yapar. Böl ve yönet yaklaşımında veri her adımda iki parçaya ayrılır. Yaklaşık $\log_2 n$ seviye oluşur ve her seviyede $n$ eleman işlendiği için maliyet $O(n\log n)$ olur.

Kararlılık, eşit anahtara sahip elemanların başlangıçtaki sırasının korunmasıdır. Örneğin çalışanları önce ada, sonra departmana göre sıralıyorsanız kararlı algoritma önceki düzeni kaybetmez.

Algoritmalar içeride ne yapıyor?

Bubble Sort, komşu elemanları karşılaştırır ve yanlış sıradaysa yer değiştirir. Büyük değerler köpük gibi sona çıkar. Dizi zaten sıralıysa bir swapped bayrağı sayesinde erkenden durabilir.

Insertion Sort, her elemanı soldaki sıralı bölge içinde uygun konuma yerleştirir. Küçük veya neredeyse sıralı dizilerde az sayıda kaydırma yaptığı için teorik olarak daha güçlü görünen algoritmaları geçebilir.

Merge Sort, diziyi tek elemanlı parçalara kadar böler ve parçaları sıralı biçimde birleştirir. Tahmin edilebilir performansı güçlüdür; ancak yardımcı dizi nedeniyle bellek tüketir.

Quick Sort, bir pivot seçerek küçük değerleri sola, büyükleri sağa taşır. Pivot dengeli bölme yaparsa hızlıdır. Sürekli en küçük ya da en büyük elemanın seçilmesi ise bölümleri $0$ ve $n-1$ boyutlarına ayırarak $O(n^2)$ sonucunu doğurur.

Aşağıdaki kod, rastgele pivot kullanarak bu riski azaltır:

import random

def quick_sort(values):
    if len(values) <= 1:
        return values

    pivot = random.choice(values)
    small = [x for x in values if x < pivot]
    equal = [x for x in values if x == pivot]
    large = [x for x in values if x > pivot]

    return quick_sort(small) + equal + quick_sort(large)

Kod okunaklıdır ve rastgele pivot kötü durum olasılığını düşürür. Bununla birlikte yeni listeler oluşturduğu için klasik yerinde Quick Sort uygulamasından daha fazla bellek kullanır.

Optimizasyon sorularına yaklaşım

Soru 1: Bir milyon rastgele eleman ve sınırlı bellek varsa ne seçilir?
Merge Sort’un $O(n)$ ek belleği sorun olabilir. Heap Sort, $O(1)$ yardımcı bellek ve garantili $O(n\log n)$ süresiyle güvenli seçimdir. Pratikte iyi uygulanmış yerinde Quick Sort da önbellek dostu yapısıyla daha hızlı olabilir.

Soru 2: Dizi yüzde 95 sıralıysa?
Insertion Sort değerlendirilmelidir. Çalışma süresi terslik sayısıyla ilişkilidir: $O(n+k)$. Buradaki $k$, yanlış sıradaki eleman çiftlerinin sayısıdır. $k$ küçükse algoritma doğrusal zamana yaklaşır.

Soru 3: Eşit kayıtların sırası korunmalıysa?
Kararlı Merge Sort uygundur. Quick Sort seçilecekse kararlılığı ayrıca sağlamak gerekir; bu da bellek ve uygulama karmaşıklığı getirir.

Sonuç olarak “en hızlı sıralama algoritması” diye evrensel bir şampiyon yoktur. Girdi boyutu, mevcut düzen, bellek sınırı, kararlılık ihtiyacı ve en kötü durum garantisi birlikte değerlendirilmelidir. İyi optimizasyon, yalnızca Big-O seçmek değil, verinin davranışını tanımaktır.

``

Derleme ve transpilation mantığı

TypeScript derleyicisi tsc, .ts ve .tsx dosyalarını inceler, tip hatalarını raporlar ve gerektiğinde çalıştırılabilir JavaScript üretir. Bu işlem çoğunlukla transpilation olarak adlandırılır. Çünkü kaynak ve hedef diller benzer soyutlama seviyelerindedir.

Basitleştirilmiş süreç şöyle gösterilebilir:

Burada önemli bir ayrım vardır: TypeScript tipleri çalışma zamanında JavaScript içinde yaşamaz. Örneğin number veya User gibi tip tanımları çıktı oluşturulurken silinir. Dolayısıyla TypeScript, çalışma zamanı doğrulayıcısı değil, geliştirme zamanında çalışan bir güvenlik ağıdır.

Temel tsconfig.json yapısı

Orta ölçekli bir Node.js projesi için başlangıç yapılandırması şöyle olabilir:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "rootDir": "src",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "sourceMap": true,
    "declaration": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
}

rootDir, kaynak kodun bulunduğu dizini; outDir ise üretilen JavaScript dosyalarının gideceği dizini belirtir. include derlemeye katılacak, exclude göz ardı edilecek dosyaları tanımlar. Böylece derleyici yanlışlıkla dist klasörünü tekrar derleyip dijital bir matruşka bebeğe dönüşmez.

target, module ve moduleResolution

Bu üç ayar sıkça karıştırılır fakat farklı sorumluluklara sahiptir:

Eski tarayıcıları desteklemek daha düşük bir target gerektirebilir. Ancak düşük hedef, daha fazla dönüşüm ve daha büyük çıktı anlamına gelebilir. Kabaca:

Modern Node.js projelerinde ES2022 ve NodeNext; Vite gibi paketleyici kullanan uygulamalarda ise ESNext ile Bundler genellikle mantıklı tercihlerdir.

strict modu neden önemlidir?

strict: true, birden fazla güvenlik seçeneğini topluca etkinleştirir. Bunların arasında strictNullChecks, noImplicitAny ve strictFunctionTypes bulunur.

function kullaniciAdi(ad: string | null): string {
  if (ad === null) {
    return "Misafir";
  }

  return ad.toUpperCase();
}

strictNullChecks açıkken null, sıradan bir string gibi kullanılamaz. Kod önce olası boş değeri kontrol eder. Bu yaklaşım biraz daha fazla kod yazdırsa da üretimdeki “undefined nereden geldi?” dedektifliğini ciddi biçimde azaltır.

Mimariye göre ek ayarlar

Kütüphane geliştiriyorsanız declaration: true, tüketiciler için .d.ts dosyaları üretir. Yalnızca tip kontrolü yapıp çıktıyı Babel, SWC veya Vite’a bırakacaksanız noEmit: true kullanılabilir. sourceMap: true ise çalışan JavaScript hatalarını özgün TypeScript satırlarıyla eşleştirerek hata ayıklamayı kolaylaştırır.

Paylaşılan yapılarda temel ayarları ayrı bir dosyada tutmak da mümkündür:

{
  "extends": "./tsconfig.base.json",
  "compilerOptions": {
    "outDir": "dist/server"
  },
  "include": ["src/server/**/*.ts"]
}

Sonuç olarak iyi bir tsconfig.json, rastgele seçenekler koleksiyonu değil, projenin çalışma ortamını ve kalite beklentisini belgeleyen mimari bir sözleşmedir. Ayarları kopyalayıp geçmek yerine hedef platformu, modül sistemini ve dağıtım yöntemini düşünmek; daha anlaşılır, güvenli ve taşınabilir projeler üretir.

Daraltmanın temel mantığı

Bir değişkenin tipi string | number ise onu matematiksel olarak bir birleşim kümesi gibi düşünebiliriz:

typeof value === "string" kontrolünün doğru olduğu dalda TypeScript, olası tipleri filtreler:

Başka bir ifadeyle çalışma zamanındaki bir koşul, derleme zamanındaki tip bilgisini daha kesin hâle getirir. Koşulun diğer dalında ise geriye number kalır.

function biçimlendir(value: string | number): string {
  if (typeof value === "string") {
    // value burada string olarak daraltılır.
    return value.trim().toUpperCase();
  }

  // String seçeneği elendiği için value artık number'dır.
  return value.toFixed(2);
}

Bu yaklaşım, riskli as string ifadeleriyle derleyiciyi susturmak yerine gerçekten doğrulanmış bilgi üretir.

Üç temel koruma yöntemi

typeof: İlkel tiplerin bekçisi

typeof, özellikle union tipindeki ilkel değerlerde kullanışlıdır. Ancak JavaScript’in tarihî tuzaklarından biri unutulmamalıdır: typeof null sonucu "object" değeridir. Bu nedenle nesne kontrolünde ayrıca value !== null koşulu gerekir.

function uzunluk(value: string | string[] | null): number {
  if (value === null) return 0;

  if (typeof value === "string") {
    return value.trim().length;
  }

  return value.length; // Burada value string[] tipindedir.
}

instanceof: Sınıfları ayırt etmek

instanceof, bir nesnenin belirli bir constructor’ın prototip zincirinden gelip gelmediğini çalışma zamanında sınar. Bu nedenle interface’lerle doğrudan kullanılamaz; interface’ler JavaScript çıktısında bulunmaz.

class Kedi {
  miyavla() {
    return "Miyav!";
  }
}

class Köpek {
  havla() {
    return "Hav hav!";
  }
}

function konuştur(hayvan: Kedi | Köpek): string {
  if (hayvan instanceof Kedi) {
    return hayvan.miyavla();
  }

  return hayvan.havla();
}

Burada TypeScript, ilk dalda Kedi, kalan dalda ise Köpek işlemlerine izin verir. Hayvanat bahçesi küçük, tip güvenliği büyüktür!

in: Özelliğe bakarak seçim yapmak

in operatörü, bir özelliğin nesnede veya prototip zincirinde bulunup bulunmadığını kontrol eder. Özellikle farklı alanlara sahip nesne birleşimlerinde okunaklıdır.

type Araba = { marka: string; sür: () => void };
type Tekne = { ad: string; yüz: () => void };

function hareketEt(araç: Araba | Tekne): void {
  if ("sür" in araç) {
    araç.sür(); // araç artık Araba
  } else {
    araç.yüz(); // araç artık Tekne
  }
}

Özel tip koruması yazmak

Karmaşık doğrulamaları tekrar kullanmak için dönüş tipi değer is Tip biçiminde olan fonksiyonlar yazılabilir:

type Kullanıcı = { id: number; ad: string };

function kullanıcıMı(value: unknown): value is Kullanıcı {
  return (
    typeof value === "object" &&
    value !== null &&
    "id" in value &&
    "ad" in value &&
    typeof value.id === "number" &&
    typeof value.ad === "string"
  );
}

Bu fonksiyon true döndürdüğünde çağıran kapsamda değer Kullanıcı olarak daraltılır. Yine de TypeScript bu söze güvenir; hatalı yazılmış bir koruma sahte güvenlik oluşturabilir. Sonuç olarak doğru koruma, “Ben bunun tipini biliyorum” demek değil, bunu çalışma zamanında kanıtlamaktır.