``

2-3 ağacı nedir?

Bir 2-3 ağacındaki iç düğüm iki biçimden birine sahiptir:

• 2-düğüm: Bir anahtar ve iki çocuk taşır.
• 3-düğüm: İki sıralı anahtar ve üç çocuk taşır.

Bir 3-düğümde anahtarlar $a < b$ ise sol alt ağaçtaki değerler $a$’dan küçük, ortadakiler $a$ ile $b$ arasında, sağdakiler ise $b$’den büyüktür. Böylece ikili arama ağacının sıralama mantığı korunurken tek seviyede daha fazla bilgi tutulur.

Asıl denge garantisi şu değişmezden gelir: Bütün yapraklar aynı derinliktedir. Ağacın yüksekliği $h$ ve anahtar sayısı $n$ olduğunda en seyrek durumda her düğüm iki çocukludur:

En yoğun durumda ise dallanma üçe yaklaşır. Dolayısıyla yükseklik kabaca

aralığındadır. Arama, ekleme ve silme işlemleri bu nedenle en kötü durumda $O(\log n)$ sürer.

Arama nasıl ilerler?

Her düğümde bir veya iki anahtar karşılaştırılır. Aranan değer küçükse sola, iki anahtarın arasındaysa ortaya, büyükse sağa gidilir. Yani bir seviyede daha çok karşılaştırma yapılabilir; buna karşılık ağaç genellikle daha kısadır.

Ekleme ve düğüm bölme

Yeni anahtar uygun yaprağa eklenir. Yaprak bir 2-düğümse anahtarlar sıralanır ve düğüm 3-düğüme dönüşür. Zaten iki anahtarı varsa geçici olarak üç anahtarlı bir taşma oluşur. Ortadaki anahtar ebeveyne gönderilir; küçük ve büyük anahtarlar iki ayrı düğüme bölünür. Ebeveyn de taşarsa işlem köke kadar devam eder. Kökün bölünmesi ağacın yüksekliğini yalnızca bir artırır.

Aşağıdaki Python kodu bu bölmenin özünü gösterir:

def split_keys(keys):
    """Üç sıralı anahtarı iki düğüm ve bir terfi anahtarına ayırır."""
    if len(keys) != 3:
        raise ValueError("Bölme için tam olarak üç anahtar gerekir")

    left = [keys[0]]
    promoted = keys[1]
    right = [keys[2]]
    return left, promoted, right

keys = sorted([40, 10, 25])
left, promoted, right = split_keys(keys)
print(left, promoted, right)  # [10] 25 [40]

Gerçek uygulamada çocuk işaretçileri de uygun yeni düğümlere dağıtılır. Kodun önemli fikri, ortanca anahtarın yukarı çıkarak sıralamayı ve eşit yaprak derinliğini korumasıdır.

Kırmızı-siyah bağlantısı

Bir 2-3 ağacını sıradan ikili bağlantılarla temsil etmek için 3-düğümdeki iki anahtar birbirine kırmızı bağlantıyla bağlanabilir. Tek başına duran 2-düğüm ise siyah bir düğüm olur:

• Siyah düğüm, bir 2-düğümü temsil eder.
• Siyah düğüm ile kırmızı çocuğu birlikte, bir 3-düğümü temsil eder.
• Kökten yapraklara eşit siyah düğüm sayısı, 2-3 ağacındaki eşit derinliğe karşılık gelir.

Özellikle sola yatık kırmızı-siyah ağaçlarda kırmızı bağlantı yalnızca sola eğilir. Ekleme sırasında yapılan sola döndürme, sağa döndürme ve renk değiştirme işlemleri; 2-3 ağacındaki düğüm birleştirme, bölme ve anahtar terfisinin ikili ağaç üzerindeki karşılıklarıdır.

Sonuç olarak 2-3 ağaçları dengeyi kavramsal olarak zarif biçimde garanti ederken kırmızı-siyah ağaçlar aynı fikri tek anahtarlı düğümlerle, pratik programlama ortamlarına daha uygun şekilde uygular. Renkler süs değil; görünmez 3-düğümleri işaretleyen küçük trafik lambalarıdır.

``

A* algoritmasının temel fikri

A*, ağırlıklı bir graf üzerinde başlangıç düğümünden hedef düğüme giden en düşük maliyetli yolu arar. Her düğüm için üç önemli değer kullanır:

• $g(n)$: Başlangıçtan $n$ düğümüne kadar ödenen gerçek maliyettir.
• $h(n)$: $n$ düğümünden hedefe kalan maliyetin tahminidir.
• $f(n)$: Düğüm üzerinden geçen yolun tahmini toplam maliyetidir.

Algoritma, sıradaki adım olarak $f(n)$ değeri en küçük olan düğümü seçer. Başka bir deyişle geçmişte ödediği maliyet ile gelecekte ödeyeceğini düşündüğü maliyeti birlikte değerlendirir.

Aslında $h(n)=0$ seçilirse A, Dijkstra algoritmasına dönüşür. Dolayısıyla A için Dijkstra’nın hedef bilgisiyle güçlendirilmiş hâli denebilir.

Sezgisel fonksiyon nasıl seçilir?

Kareli ve dört yönde hareket edilen bir haritada Manhattan uzaklığı kullanılabilir:

Çapraz hareket mümkünse Öklid uzaklığı daha uygun olabilir. A*‘ın en kısa yolu garanti etmesi için sezgisel fonksiyonun gerçek kalan maliyeti aşmaması gerekir. Bu özelliğe kabul edilebilirlik denir. Ayrıca tutarlı bir sezgi için her kenarda şu koşul sağlanır:

Tahmin çok küçükse algoritma güvenli fakat Dijkstra’ya yakın çalışır. Tahmin gereğinden büyükse daha hızlı görünebilir, ancak en kısa yol garantisi kaybolabilir.

Python ile A* uygulaması

Aşağıdaki kod, sözlük biçiminde tanımlanmış ağırlıklı bir graf üzerinde çalışır. Öncelik kuyruğu, tahmini toplam maliyeti en düşük düğümü verimli biçimde seçer.

from heapq import heappush, heappop

def a_star(graph, start, goal, heuristic):
    # Kuyruk elemanları: (f maliyeti, düğüm)
    open_set = [(heuristic(start, goal), start)]
    came_from = {}
    g_score = {start: 0}
    visited = set()

    while open_set:
        _, current = heappop(open_set)

        if current in visited:
            continue
        if current == goal:
            path = [current]
            while current in came_from:
                current = came_from[current]
                path.append(current)
            return path[::-1], g_score[goal]

        visited.add(current)

        for neighbor, edge_cost in graph[current]:
            tentative = g_score[current] + edge_cost

            if tentative < g_score.get(neighbor, float("inf")):
                came_from[neighbor] = current
                g_score[neighbor] = tentative
                f_score = tentative + heuristic(neighbor, goal)
                heappush(open_set, (f_score, neighbor))

    return None, float("inf")

Örnek olarak düğümlerin koordinatlarını ve bağlantılarını tanımlayabiliriz:

graph = {
    "A": [("B", 2), ("C", 4)],
    "B": [("A", 2), ("D", 3)],
    "C": [("A", 4), ("D", 1)],
    "D": [("B", 3), ("C", 1), ("E", 2)],
    "E": []
}

coords = {
    "A": (0, 0), "B": (1, 0), "C": (0, 1),
    "D": (1, 1), "E": (2, 1)
}

def manhattan(a, b):
    x1, y1 = coords[a]
    x2, y2 = coords[b]
    return abs(x1 - x2) + abs(y1 - y2)

path, cost = a_star(graph, "A", "E", manhattan)
print(path, cost)

Bu uygulama yolu A, B, D, E veya aynı maliyetli uygun bir alternatif olarak döndürebilir. A* özellikle oyun haritaları, robot navigasyonu ve rota planlama sistemlerinde güçlüdür. Yine de hız avantajı otomatik değildir: kötü bir sezgisel fonksiyon, büyük bellek tüketimi veya düzensiz graf yapısı performansı azaltabilir. İyi bir $h(n)$ seçimi ise A*‘ın gerçek süper gücüdür.

``

Union-Find hangi problemi çözer?

Elimizde başlangıçta birbirinden bağımsız $N$ eleman bulunduğunu düşünelim. Union-Find iki temel işlemi destekler:

• find(p): p elemanının bağlı olduğu kümenin kökünü bulur.
• union(p, q): p ve q elemanlarının kümelerini birleştirir.

Bu yapı; sosyal ağ bağlantıları, bilgisayar ağları, görüntü işleme, labirent üretimi ve Kruskal’ın minimum kapsayan ağaç algoritması gibi birçok alanda kullanılır.

Quick-Union yaklaşımında her eleman, ebeveyninin indeksini saklar. Bir kökte parent[i] == i olur. find, ebeveyn bağlantılarını köke ulaşıncaya kadar takip eder. Ne var ki birleşimler kötü sırayla yapılırsa ağaç bir zincire dönüşebilir.

Buradaki $α(N)$, ters Ackermann fonksiyonudur ve pratik veri boyutlarında neredeyse sabit kabul edilir.

Ağırlık neden işe yarar?

Her kök için ağacındaki eleman sayısını tutan bir size dizisi kullanılır. İki küme birleştirilirken küçük ağacın kökü, büyük ağacın köküne bağlanır. Böylece büyük ağaçtaki düğümlerin derinliği hiç değişmez; yalnızca küçük ağaçtaki düğümlerin derinliği bir artabilir.

Bir düğümün derinliği her arttığında, içinde bulunduğu ağacın büyüklüğü en az iki katına çıkar. Derinlik $h$ ise ağacın en az $2^h$ elemanı olmalıdır:

İşte performans garantisinin kalbi budur. Örneğin $N=1.000.000$ olduğunda zincir biçimli ağaç yaklaşık bir milyon adım gerektirebilirken ağırlıklı ağacın yüksekliği yaklaşık 20 ile sınırlıdır. Algoritmik diyet işe yarıyor: küçük ağaç, büyük ağacın sırtına biniyor!

Java ile uygulama

Aşağıdaki sınıf, ebeveynleri parent, ağaç büyüklüklerini ise size dizisinde saklar:

public class WeightedQuickUnion {
    private final int[] parent;
    private final int[] size;

    public WeightedQuickUnion(int n) {
        parent = new int[n];
        size = new int[n];

        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    public int find(int p) {
        validate(p);
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);

        if (rootP == rootQ) return;

        if (size[rootP] < size[rootQ]) {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        } else {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        }
    }

    private void validate(int p) {
        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException();
        }
    }
}

find yalnızca köke yürür. union önce iki kökü bulur, ardından size değerlerini karşılaştırarak küçük ağacı büyük ağaca bağlar. Boyut bilgisinin yalnızca köklerde anlamlı olduğuna dikkat edilmelidir.

Bir adım daha: yol sıkıştırma

Performansı daha da artırmak için find döngüsüne şu satır eklenebilir:

parent[p] = parent[parent[p]];

Bu işlem, ziyaret edilen düğümü büyük ebeveynine bağlayarak yolu kısaltır. Ağırlıklandırma ağacın baştan fazla uzamasını önlerken yol sıkıştırma mevcut yolları düzleştirir. Birlikte kullanıldıklarında Union-Find işlemleri pratikte sabit zamana yakın çalışır. Sonuç olarak Weighted Quick-Union, küçük bir ek bellek maliyeti karşılığında kontrolsüz ağaç büyümesini engelleyen, basit ama son derece güçlü bir optimizasyondur.

``

Amortize analiz nedir?

Amortize analiz, bir işlemin olasılıksal ortalamasını değil, en kötü durumda oluşabilecek işlem dizisinin ortalama maliyetini inceler. Bu nedenle ortalama durum analizinden farklıdır: Kullanıcı davranışı veya rastgele veri dağılımı hakkında varsayım yapmaz.

$n$ işlemden oluşan bir dizinin toplam maliyeti $T(n)$ ise işlem başına amortize maliyet şöyle hesaplanır:

Örneğin toplam maliyet $T(n)=3n+10$ ise amortize maliyet:

Burada bazı işlemler tek başına pahalı olsa bile uzun vadede her işlem sabit maliyetli kabul edilebilir.

Klasik örnek: Dinamik dizi

Dinamik bir dizinin kapasitesi dolduğunda daha büyük bir alan ayrılır ve eski elemanlar yeni alana kopyalanır. Normal bir ekleme $O(1)$ sürerken yeniden boyutlandırma işlemi $O(n)$ maliyetli olabilir.

class DynamicArray:
    def __init__(self):
        self.capacity = 1
        self.size = 0
        self.data = [None] * self.capacity

    def append(self, value):
        if self.size == self.capacity:
            self._resize()

        self.data[self.size] = value
        self.size += 1

    def _resize(self):
        self.capacity *= 2
        new_data = [None] * self.capacity

        for i in range(self.size):
            new_data[i] = self.data[i]

        self.data = new_data

Bu kodda _resize, mevcut elemanları kopyalayarak kapasiteyi iki katına çıkarır. Boyutlandırmalar $1,2,4,8,\ldots$ elemanda gerçekleşir. $n$ ekleme boyunca yapılan toplam kopyalama sayısı:

Normal eklemelerin maliyeti de $n$ olduğundan toplam maliyet $2n$ civarındadır. Böylece işlem başına maliyet:

Tek bir ekleme $O(n)$ sürebilir; ancak append işleminin amortize maliyeti $O(1)$ olur. Pahalı taşınma masrafı, önceki ucuz eklemelere dağıtılmıştır.

Üç temel amortize analiz yöntemi

1. Toplam maliyet yöntemi

Tüm işlem dizisinin gerçek maliyeti hesaplanır ve işlem sayısına bölünür. Dinamik dizi örneğinde kullandığımız yaklaşım budur.

2. Muhasebe yöntemi

Ucuz işlemlerden gerçek maliyetlerinden biraz daha fazla ücret alınır. Aradaki kredi, gelecekteki pahalı işlemleri karşılamak üzere saklanır. Bir eklemenin gerçek maliyeti $1$ olsa da ona $3$ kredi biçtiğimizi düşünebiliriz. Fazladan kalan krediler yeniden boyutlandırmayı öder; algoritma adeta kendi kumbarasını taşır.

3. Potansiyel yöntemi

Veri yapısında biriken gelecekteki işi matematiksel bir potansiyel fonksiyonuyla gösteririz. Amortize maliyet:

Burada $c_i$ gerçek maliyet, $\Phi(D_i)$ ise işlemden sonraki potansiyeldir. Potansiyel artıyorsa geleceğe kredi bırakılır; azalıyorsa biriktirilen kredi pahalı işlemi karşılar.

Amortize analiz, tek bir kötü ana bakıp paniğe kapılmak yerine filmin tamamını izler. Dinamik diziler, hash tabloları, yığıt işlemleri ve birleşim-bulma yapıları bu yöntemle daha doğru değerlendirilir. Kısacası soru yalnızca “Bu işlem ne kadar pahalı?” değil, “Bu maliyet uzun bir yolculuk boyunca kaç işleme paylaşılıyor?” olmalıdır.

``

Tercihli oylamanın temel fikri

Üç adayımız olsun: Ada, Bora ve Ceren. Seçmenlerden adayları en beğendiklerinden en az beğendiklerine doğru sıralamalarını isteyelim. Sonuçlar şöyle olsun:

Burada yalnızca birinci tercihlere bakarsak Ada 4, Bora 3, Ceren 2 oy alır. Basit çoğulluk yöntemi Ada’yı kazanan ilan eder. Fakat sıralamanın geri kalanını da hesaba katarsak sonuç değişebilir.

Borda sayımı: Her sıraya puan

Borda yönteminde adaylar bulundukları sıraya göre puan kazanır. $m$ aday varsa birinci sıraya $m-1$, ikinci sıraya $m-2$ ve son sıraya $0$ puan verilebilir. Üç aday için puanlar sırasıyla $2$, $1$ ve $0$ olur.

Bir adayın toplam Borda puanı şu şekilde ifade edilir:

Burada $p_i(a)$, $i$ numaralı seçmenin $a$ adayına verdiği sıra puanıdır. Örneğimizde puanlar şöyledir:

Borda kazananı Bora’dır. Ada daha fazla seçmenin ilk tercihi olmasına rağmen birçok seçmen tarafından son sıraya konmuştur. Bora ise geniş bir uzlaşma sağlamıştır. Borda, güçlü sevgiyi ödüllendirirken genel kabulü de önemser.

Condorcet: Bire bir düello

Condorcet yaklaşımı puan toplamak yerine adayları ikili karşılaştırır. Bir aday, diğer bütün adayları bire bir seçimlerde yeniyorsa Condorcet kazananı olur.

Örneğin Bora ile Ada karşılaştırıldığında ilk gruptaki 4 seçmen Ada’yı, diğer 5 seçmen Bora’yı üstün tutar. Bora, Ada’yı $5$–$4$ yener. Bora ile Ceren karşılaşmasında ise ilk iki grup, yani 7 seçmen Bora’yı Ceren’in önüne koyar. Böylece Bora yine kazanır ve Condorcet kazananı olur.

Borda ve Condorcet her zaman aynı sonucu vermez. Ayrıca Condorcet kazananı bulunmayabilir: Ada Bora’yı, Bora Ceren’i, Ceren de Ada’yı yenebilir. Bu duruma Condorcet döngüsü denir; tercihler taş-kâğıt-makas oyununa dönüşür.

Küçük bir Python uygulaması

Aşağıdaki kod, sıralı oyların Borda puanlarını hesaplar:

from collections import defaultdict

oylar = [
    (4, ["Ada", "Bora", "Ceren"]),
    (3, ["Bora", "Ceren", "Ada"]),
    (2, ["Ceren", "Bora", "Ada"]),
]

puanlar = defaultdict(int)
aday_sayisi = len(oylar[0][1])

for secmen, siralama in oylar:
    for sira, aday in enumerate(siralama):
        puanlar[aday] += secmen * (aday_sayisi - sira - 1)

print(dict(puanlar))
print("Kazanan:", max(puanlar, key=puanlar.get))

Döngü, her adayın sıra puanını o tercihi paylaşan seçmen sayısıyla çarpar. Çıktıda Bora 12 puanla kazanır.

Sonuç olarak seçim yöntemi tarafsız bir ayrıntı değil, sonucun parçasıdır. Basit çoğulluk güçlü birinci tercihleri, Borda genel memnuniyeti, Condorcet ise bire bir üstünlüğü ölçer. Bu nedenle “Kim kazandı?” sorusundan önce “Oyları hangi kuralla saydık?” diye sormak gerekir.

``

Döviz piyasasını graf olarak modellemek

Her para birimini bir düğüm, mümkün olan her döviz dönüşümünü de yönlü bir kenar olarak düşünebiliriz. Örneğin USD’den EUR’ya geçiş ayrı, EUR’dan USD’ye geçiş ayrı bir kenardır; çünkü bu iki kur birbirinin tam tersi olmak zorunda değildir.

Elimizde şu dönüşüm zinciri olsun:

Başlangıçta 1 USD varsa zincirin sonunda elde edeceğimiz miktar:

Kurların çarpımı 1’den büyükse başlangıçtakinden daha fazla USD elde ederiz:

Ancak graf algoritmaları toplama işlemleriyle çalışmayı sever. Çarpımları toplama çevirmek için logaritmadan yararlanırız:

Negatif logaritma uygulandığında kârlılık koşulu şu hâle gelir:

Yani arbitraj fırsatı, dönüştürülmüş graf üzerindeki negatif ağırlıklı bir döngüdür.

Neden Bellman-Ford?

Dijkstra algoritması negatif kenar ağırlıklarıyla güvenilir biçimde çalışmaz. Bellman-Ford ise negatif ağırlıkları destekler ve ulaşılabilir negatif döngüleri belirleyebilir.

Algoritma, $V$ düğümlü bir grafta bütün kenarları $V-1$ kez gevşetir. Bu işlemlerden sonra herhangi bir mesafe hâlâ küçültülebiliyorsa negatif döngü vardır. Zaman karmaşıklığı $O(VE)$ seviyesindedir; para birimi sayısının genellikle sınırlı olması nedeniyle pratik bir seçimdir.

Python ile arbitraj tespiti

Aşağıdaki fonksiyon kurları negatif logaritmik ağırlıklara dönüştürür. Bütün düğümlerin başlangıç mesafesini sıfır yapmak, bağlantısız bileşenlerdeki döngüleri de aramamızı sağlar.

import math


def find_arbitrage(currencies, rates):
    n = len(currencies)
    edges = []

    for source, target, rate in rates:
        weight = -math.log(rate)
        edges.append((source, target, weight))

    distance = [0.0] * n
    parent = [-1] * n
    changed = -1

    for _ in range(n):
        changed = -1
        for source, target, weight in edges:
            if distance[target] > distance[source] + weight:
                distance[target] = distance[source] + weight
                parent[target] = source
                changed = target

    if changed == -1:
        return None

    # Düğümü döngünün içine taşır.
    vertex = changed
    for _ in range(n):
        vertex = parent[vertex]

    cycle = [vertex]
    current = parent[vertex]
    while current != vertex:
        cycle.append(current)
        current = parent[current]

    cycle.append(vertex)
    cycle.reverse()
    return [currencies[i] for i in cycle]


currencies = ["USD", "EUR", "GBP"]
rates = [
    (0, 1, 0.92),
    (1, 2, 0.87),
    (2, 0, 1.27),
]

print(find_arbitrage(currencies, rates))

Fonksiyon None döndürürse negatif döngü bulunamamıştır. Bir liste döndürürse listedeki para birimleri olası arbitraj rotasını gösterir. Örnekte kurların çarpımı yaklaşık $0.92 \times 0.87 \times 1.27 = 1.016$ olduğundan teorik olarak yüzde 1,6 civarında brüt kazanç vardır.

Gerçek hayattaki küçük ama önemli canavarlar

Teorik arbitraj ile uygulanabilir arbitraj aynı şey değildir. Alış-satış farkı, işlem komisyonu, ağ gecikmesi, likidite ve kur değişimleri kârı yok edebilir. Komisyon oranı $c$ ise dönüşümde çıplak kur yerine efektif kur kullanılmalıdır:

Ayrıca kayan nokta hataları yüzünden karşılaştırmalara küçük bir tolerans eklemek faydalıdır. Bellman-Ford fırsatı matematiksel olarak bulur; fırsatın gerçekten cüzdanınıza ulaşması ise veri kalitesine ve işlem hızına bağlıdır. Kısacası algoritma hazine haritasını çizer, fakat hazinenin yerinde duracağını garanti etmez!

``

Temel fikir: Neden sondan başlıyoruz?

Elimizde uzunluğu $n$ olan bir metin ve uzunluğu $m$ olan bir kalıp bulunsun. Naif arama, kalıbı metindeki her olası konuma yerleştirir ve karakterleri soldan sağa karşılaştırır. En kötü durumda yaklaşık $O(nm)$ işlem yapılabilir.

Boyer-Moore ise kalıbı metnin üzerine yerleştirir, fakat karşılaştırmaya kalıbın son karakterinden başlar. Sağ tarafta oluşan bir uyuşmazlık, kalıbın tamamını birkaç konum birden kaydırmaya izin verebilir. Bu davranış özellikle kalıp uzadıkça ve alfabe genişledikçe etkili olur.

Kötü karakter sezgisi

Algoritmanın en anlaşılır kuralı kötü karakter kuralıdır. Kalıbın $j$ indeksindeki karakter ile metindeki karakter uyuşmazsa, karşılaşılan metin karakterinin kalıp içindeki en sağ konumuna bakılır.

Bu konumu $last(c)$ ile gösterirsek kaydırma miktarı şöyle hesaplanabilir:

Karakter kalıpta hiç yoksa $last(c)=-1$ kabul edilir. Böylece kalıp, uyuşmayan karakteri tamamen geride bırakacak kadar kaydırılabilir. Örneğin KOD kalıbını ararken karşılaştırılan metin karakteri X ise ve X kalıpta bulunmuyorsa tek tek ilerlemek yerine kalıp birkaç adım ileri taşınır.

Boyer-Moore’un tam sürümünde bir de iyi sonek kuralı vardır. Kalıbın sonunda eşleşmiş bir bölüm bulunup daha solda uyuşmazlık yaşanırsa algoritma, eşleşen sonekin kalıptaki başka bir tekrarını veya uygun bir önekini arar. İki kuralın önerdiği kaydırmalardan büyük olanı seçilir. Bu ek mekanizma güçlüdür; ancak kötü karakter kuralı bile tek başına pratik bir hızlanma sağlar.

Python ile basitleştirilmiş uygulama

Aşağıdaki kod yalnızca kötü karakter sezgisini kullanır. Ön işleme aşaması, kalıptaki her karakterin en sağ indeksini bir sözlükte saklar:

def boyer_moore_ara(metin, kalip):
    if not kalip:
        return 0

    # Her karakterin kalıptaki en sağ konumunu hazırlar.
    son_konum = {karakter: i for i, karakter in enumerate(kalip)}
    n, m = len(metin), len(kalip)
    kayma = 0

    while kayma <= n - m:
        j = m - 1

        # Karakterleri kalıbın sonundan başına doğru karşılaştırır.
        while j >= 0 and kalip[j] == metin[kayma + j]:
            j -= 1

        if j < 0:
            return kayma

        kotu_karakter = metin[kayma + j]
        kayma += max(1, j - son_konum.get(kotu_karakter, -1))

    return -1

metin = "ALGORITMALARLA METIN ARAMA"
print(boyer_moore_ara(metin, "METIN"))

Fonksiyon ilk eşleşmenin başlangıç indeksini, eşleşme yoksa -1 değerini döndürür. Sözlüğün hazırlanması $O(m)$ zaman ve kullanılan farklı karakter sayısı kadar ek alan gerektirir.

Karmaşıklık ve kullanım alanları

Basitleştirilmiş sürümün en kötü durumu yine $O(nm)$ olabilir. Bununla birlikte Boyer-Moore, ortalama senaryolarda metnin bütün karakterlerini incelemeden ilerleyebilir. Tam algoritmanın dikkatli hazırlanmış sürümleri daha güçlü teorik garantiler sunar.

Algoritma; metin editörlerinde arama, log analizi, DNA dizilerinin incelenmesi ve güvenlik araçlarında imza tarama gibi alanlarda kullanılır. Kalıp kısa veya metin çok küçükse ön işleme maliyeti avantajı azaltabilir. Fakat uzun metinlerde Boyer-Moore’un sıçramaları, arama sürecini karakter karakter yürüyen bir kaplumbağadan engellerin üzerinden atlayan çevik bir tavşana dönüştürür.

``

Önce DAG nedir?

Yönlendirilmiş bir grafta kenarlar belirli bir yöne sahiptir. Örneğin $u \rightarrow v$ kenarı, yalnızca $u$ düğümünden $v$ düğümüne geçişi temsil eder. Grafın içinde yönlendirilmiş hiçbir döngü bulunmuyorsa bu yapı bir DAG’dır.

DAG’lar; görev planlama, ders ön koşulları, bağımlılık yönetimi, veri işleme hatları ve sürüm geçmişleri gibi doğal bir ilerleme sırası bulunan problemlerde sıkça görülür.

Döngünün bulunmaması, düğümleri topolojik olarak sıralayabilmemizi sağlar. Böyle bir sıralamada her $u \rightarrow v$ kenarı için $u$, listede $v$’den önce gelir. En kısa yol algoritmasının asıl süper gücü de budur.

Neden topolojik sıralama yeterli?

Başlangıç düğümünün uzaklığını $0$, diğer bütün uzaklıkları $∞$ kabul edelim. Düğümleri topolojik sırayla işlerken her kenar için gevşetme yaparız:

Burada $d[u]$, başlangıçtan $u$ düğümüne bilinen en kısa uzaklık; $w(u,v)$ ise kenarın ağırlığıdır. Bir düğüm işlendiğinde ona gelebilecek bütün önceki düğümler zaten değerlendirilmiştir. Dolayısıyla geriye dönüp uzaklığı tekrar tekrar düzeltmeye gerek kalmaz.

DAG algoritması negatif ağırlıklı kenarlarla da çalışır. Çünkü negatif bir kenarın uzaklıkları sonradan beklenmedik biçimde değiştireceği döngüsel bir geri dönüş yoktur. Negatif döngü zaten DAG tanımı gereği oluşamaz.

Python ile uygulama

Aşağıdaki fonksiyon önce DFS kullanarak topolojik sıralamayı oluşturur, ardından düğümleri bu sırada işleyerek kenarları gevşetir:

def dag_shortest_path(graph, start):
    visited = set()
    order = []

    def dfs(node):
        visited.add(node)
        for neighbor, _ in graph.get(node, []):
            if neighbor not in visited:
                dfs(neighbor)
        order.append(node)

    # Bağlantısız parçalar için tüm düğümleri dolaşır.
    for node in graph:
        if node not in visited:
            dfs(node)

    order.reverse()
    distance = {node: float('inf') for node in graph}
    distance[start] = 0

    for node in order:
        if distance[node] == float('inf'):
            continue

        for neighbor, weight in graph.get(node, []):
            candidate = distance[node] + weight
            if candidate < distance[neighbor]:
                distance[neighbor] = candidate

    return distance


graph = {
    'A': [('B', 4), ('C', 2)],
    'B': [('D', 3)],
    'C': [('B', -1), ('D', 5)],
    'D': []
}

print(dag_shortest_path(graph, 'A'))

Bu örnekte C → B kenarının ağırlığı negatiftir. Buna rağmen sonuç güvenle hesaplanır: A → C → B → D rotasının toplam maliyeti $2 + (-1) + 3 = 4$ olur. Doğrudan görünen yollar her zaman en hesaplı yollar değildir!

Karmaşıklık ve önemli ayrıntılar

Topolojik sıralama $O(V+E)$, bütün kenarların gevşetilmesi de $O(V+E)$ sürer. Böylece toplam zaman karmaşıklığı $O(V+E)$, ek alan gereksinimi ise $O(V)$ olur. Bu, grafın tamamını en azından bir kez incelemek zorunda olduğumuz düşünüldüğünde oldukça verimlidir.

Ancak algoritmayı kullanmadan önce grafın gerçekten asiklik olduğu doğrulanmalıdır. Döngü varsa topolojik sıralama üretilemez. Kahn algoritması sonunda işlenen düğüm sayısını kontrol etmek veya DFS sırasında renk tabanlı döngü tespiti yapmak bu doğrulama için uygundur.

Özetle DAG yapısı, “ilerideki bir düğüm geçmişi etkileyemez” garantisi verir. Bu garanti en kısa yol problemini tek yönlü, doğrusal ve hızlı bir hesaplamaya dönüştürür; bazen döngülerin yokluğu gerçekten de hayatı kolaylaştırır.

``

Karşılaştırma Olmadan Sıralama Fikri

Quick Sort, Merge Sort ve Heap Sort gibi klasik algoritmalar karşılaştırma tabanlıdır. Bu algoritmaların genel alt sınırı $\Omega(N \log N)$ karşılaştırmadır. Dizgi sıralamada her karşılaştırma birden fazla karakterin incelenmesini gerektirebildiği için gerçek maliyet daha da büyüyebilir.

Anahtar-indeks sayımı ise karakterleri, örneğin ASCII kodlarını, küçük tam sayılara dönüştürür. Alfabe büyüklüğü $R$, eleman sayısı $N$ olduğunda tek karakter için temel süreç şöyledir:

1. Her karakterin kaç kez geçtiğini say.
2. Sayımları başlangıç indekslerine dönüştür.
3. Öğeleri yardımcı diziye dağıt.
4. Sonucu ana diziye geri kopyala.

Bu işlemin zaman karmaşıklığı $O(N + R)$ olur. Buradaki önemli ayrıntı, dağıtımın kararlı olmasıdır: Aynı karaktere sahip öğelerin önceki göreli sırası korunur.

def counting_sort_by_char(words, index, alphabet_size=256):
    count = [0] * (alphabet_size + 1)
    output = [None] * len(words)

    for word in words:
        code = ord(word[index])
        count[code + 1] += 1

    for r in range(alphabet_size):
        count[r + 1] += count[r]

    for word in words:
        code = ord(word[index])
        output[count[code]] = word
        count[code] += 1

    return output

Bu yardımcı fonksiyon, sabit bir karakter konumuna göre kararlı sıralama yapar. count dizisindeki bir hücre frekansı, ön toplam işleminden sonra ise başlangıç konumunu temsil eder.

LSD: Sağdan Sola İlerlemek

LSD, yani Least Significant Digit, en sağdaki karakterden başlar ve sola doğru ilerler. Genellikle tüm anahtarların aynı uzunlukta olduğu durumlarda kullanılır. Plaka kodları, sabit uzunluklu kimlikler ve tarih biçimleri iyi örneklerdir.

def lsd_sort(words, width):
    result = list(words)
    for index in range(width - 1, -1, -1):
        result = counting_sort_by_char(result, index)
    return result

codes = ['B12', 'A90', 'B01', 'A12']
print(lsd_sort(codes, 3))

Sağdan başlanmasının nedeni kararlılıktır. Son basamağa göre oluşan düzen, daha önemli bir karakter işlendiğinde aynı karakterli grupların içinde korunur. $W$ karakterli $N$ dizgi için yaklaşık maliyet $O(W(N + R))$ seviyesindedir.

MSD: Soldan Başlayan Böl ve Yönet

MSD, yani Most Significant Digit, önce en soldaki karakteri işler. Ardından aynı karakterle başlayan grupları kendi içlerinde özyinelemeli olarak sıralar. Değişken uzunluktaki kelimelerde özel bir “karakter yok” değeri kullanılır.

Örneğin ar, ara ve armut karşılaştırılırken kısa kelimenin bittiğini gösteren değer, gerçek karakterlerden küçük kabul edilir. Böylece ar, diğer ikisinin önüne gelir.

Ne Zaman Daha Hızlıdır?

Karşılaştırmalı sıralama yaklaşık $N \log N$ adet karar verir; üstelik ortak ön eke sahip dizgilerde aynı karakterleri defalarca okuyabilir. LSD ve MSD ise alfabe küçükken karakterleri kovalar gibi doğrudan kutulara dağıtır. Özellikle $R$ sabit ve anahtar uzunluğu sınırlıysa doğrusal davranışa yaklaşırlar.

Bununla birlikte Unicode gibi çok büyük alfabelerde doğrudan devasa sayım dizileri kullanmak bellek israfına dönüşebilir. Küçük veri kümelerinde de Python’ın yerleşik sorted fonksiyonu, düşük sabit maliyetleri sayesinde daha hızlı olabilir. Kısacası LSD düzenli veri için güvenilir bir maratoncu, MSD ise ortak önekleri ustaca eleyen çevik bir sprinterdir.

``

Temel fikir: Her karakter eşit değildir

Elimizde ABRACADABRA metni olsun. Bu metinde A beş kez görülürken C yalnızca bir kez görünür. Her karakteri eşit uzunlukta kodlamak yerine A için daha kısa bir kod seçmek toplam bit sayısını düşürür.

Huffman algoritması kayıpsızdır: Sıkıştırılan veri açıldığında orijinal verinin birebir aynısı elde edilir. JPEG gibi bazı yöntemlerin aksine hiçbir karakter gözden çıkarılmaz.

Bir sembolün frekansı $f_i$, ona verilen kodun uzunluğu $l_i$ ise toplam maliyet şöyle ifade edilir:

Algoritmanın amacı, önek koşulunu koruyarak $L$ değerini küçültmektir. Önek koşulu, hiçbir kodun başka bir kodun başlangıcı olmaması demektir. Örneğin A = 0 iken B = 01 seçilemez; aksi hâlde bitleri okurken nerede duracağımız belirsizleşir.

Huffman ağacı nasıl kurulur?

Önce her karakterin frekansı hesaplanır ve karakterler bir öncelik kuyruğuna yerleştirilir. Ardından şu döngü uygulanır:

1. En düşük frekanslı iki düğümü kuyruktan çıkar.
2. Frekansları toplamına eşit yeni bir üst düğüm oluştur.
3. İki düğümü bu üst düğümün çocukları yap.
4. Yeni düğümü yeniden kuyruğa ekle.
5. Tek düğüm kalana kadar işlemi tekrarla.

Ağaç tamamlandığında sol dallara 0, sağ dallara 1 verilebilir. Kökten karaktere kadar izlenen yol, karakterin kodudur. Sol ve sağ seçiminin ters yapılması sıkıştırma oranını değiştirmez; yalnızca ortaya çıkan kodları değiştirir.

Python ile uygulama

Aşağıdaki kod, karakter frekanslarından Huffman ağacı üretir ve her karakterin ikili kodunu çıkarır:

from collections import Counter
import heapq

class Node:
    def __init__(self, char=None, freq=0, left=None, right=None):
        self.char = char
        self.freq = freq
        self.left = left
        self.right = right

    def __lt__(self, other):
        return self.freq < other.freq


def huffman_codes(text):
    heap = [Node(char, freq) for char, freq in Counter(text).items()]
    heapq.heapify(heap)

    if len(heap) == 1:
        return {heap[0].char: "0"}

    while len(heap) > 1:
        left = heapq.heappop(heap)
        right = heapq.heappop(heap)
        parent = Node(freq=left.freq + right.freq,
                      left=left, right=right)
        heapq.heappush(heap, parent)

    codes = {}

    def walk(node, code=""):
        if node.char is not None:
            codes[node.char] = code
            return
        walk(node.left, code + "0")
        walk(node.right, code + "1")

    walk(heap[0])
    return codes

text = "ABRACADABRA"
codes = huffman_codes(text)
encoded = "".join(codes[ch] for ch in text)

print(codes)
print(encoded)

Counter frekansları bulur; heapq ise en küçük iki düğüme verimli biçimde ulaşılmasını sağlar. Tek karakterden oluşan girdiye 0 kodu verilmesi, boş kod gibi kullanışsız bir özel durumu önler. $k$ farklı sembol için ağaç oluşturmanın zaman karmaşıklığı yaklaşık $O(k \log k)$ düzeyindedir.

Her zaman kazandırır mı?

Hayır. Karakterlerin frekansları birbirine çok yakınsa kod uzunlukları da benzer olur. Üstelik çözücünün ağacı öğrenebilmesi için frekans tablosu veya kod sözlüğü dosyaya eklenmelidir. Çok küçük verilerde bu ek yük, elde edilen tasarrufu geçebilir.

Buna rağmen Huffman kodlama; ZIP, DEFLATE, PNG ve çeşitli medya biçimlerinde daha büyük sıkıştırma süreçlerinin önemli bir parçasıdır. Basit fikri, matematiksel sağlamlığı ve ağaç yapılarıyla kurduğu bağ sayesinde hem pratik hem de öğretici bir algoritmadır.