``

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.

``

Problemin kuralları

Dairede $n$ kişi bulunsun. Saymaya birinci kişiden başlayalım ve her $k$ adımda ulaşılan kişiyi eleyelim. Elenen kişinin hemen yanındaki kişiyle saymaya yeniden devam edelim. Amaç iki farklı sonucu hesaplamak olabilir:

1. Kişilerin elenme sırası,
2. Oyunda hayatta kalan son kişi.

Örneğin $n=7$ ve $k=3$ olsun. Kişiler 1, 2, 3, 4, 5, 6, 7 biçiminde numaralandırılır. İlk elenen kişi 3, sonraki kişi 6 olur. Dairenin sonuna gelindiğinde sayma başa döner.

Böylece elenme sırası $[3,6,2,7,5,1]$, kazanan ise 4 olur.

Matematiksel düşünce

Yalnızca kazananı arıyorsak problemi daha küçük problemlere indirebiliriz. Sıfır tabanlı indeks kullanan Josephus bağıntısı şöyledir:

Buradaki mod işlemi, dairenin sonundan sonra tekrar başa dönmemizi sağlar. İnsanları 1’den başlayarak numaralandırmak istediğimiz için nihai sonuca 1 ekleriz:

Bu yaklaşım $O(n)$ zamanda ve $O(1)$ ek bellekte çalışır. Ancak yalnızca kazananı verir; bütün elenme sırasını öğrenmek için daireyi ayrıca simüle etmeliyiz.

Python ile daireyi simüle etmek

Python’daki deque, iki uçtan hızlı ekleme ve çıkarma yapabilen bir kuyruktur. rotate metodu sayesinde sıradaki kişiyi kuyruğun başına taşıyabiliriz.

from collections import deque


def josephus_sirasi(kisi_sayisi, adim):
    if kisi_sayisi < 1 or adim < 1:
        raise ValueError("Kişi sayısı ve adım pozitif olmalıdır.")

    daire = deque(range(1, kisi_sayisi + 1))
    elenenler = []

    while len(daire) > 1:
        # İlk kişi zaten birinci sayıldığı için k-1 konum ilerliyoruz.
        daire.rotate(-(adim - 1))
        elenenler.append(daire.popleft())

    return elenenler, daire[0]


elenenler, kazanan = josephus_sirasi(7, 3)
print("Elenenler:", elenenler)
print("Kazanan:", kazanan)

Programın çıktısı şöyledir:

Elenenler: [3, 6, 2, 7, 5, 1]
Kazanan: 4

rotate(-(adim - 1)) işlemi kuyruğu sola döndürür. Böylece elenecek kişi başa gelir; popleft() da onu daireden çıkarır. Negatif döndürme miktarı büyük olsa bile deque, döngüsel davranışı korur.

Yalnızca kazananı bulmak

Büyük girişlerde elenme listesini saklamak istemiyorsak bağıntıyı döngüyle uygulayabiliriz:

def josephus_kazanan(n, k):
    konum = 0
    for mevcut_boyut in range(2, n + 1):
        konum = (konum + k) % mevcut_boyut
    return konum + 1

Josephus Problemi küçük bir oyun gibi görünse de modüler aritmetik, kuyruklar, yinelemeli bağıntılar ve performans karşılaştırmaları için güçlü bir örnektir. Adım değerini veya başlangıç kişisini değiştirerek farklı senaryolar üretmek, algoritmanın döngüsel mantığını iyice pekiştirir.

Sıra istatistiği nedir?

Bir dizinin küçükten büyüğe sıralanmış hâlindeki belirli konumlara sıra istatistikleri denir. En küçük eleman birinci, en büyük eleman n. sıra istatistiğidir. Ortanca da merkezi sıra istatistiğidir.

$n$ tekse ortancanın sıfır tabanlı indeksi şöyledir:

$n$ çiftse istatistiksel ortanca, ortadaki iki elemanın aritmetik ortalamasıdır:

Burada önemli bir ayrıntı bulunur: Günlük dilde “k. en küçük” ifadesinde saymaya 1’den başlanır; Python dizilerinde ise indeksler 0’dan başlar. Dolayısıyla kullanıcı 3. en küçük elemanı istediğinde algoritmaya $k=2$ verilmelidir.

Quickselect nasıl çalışır?

Algoritma bir pivot seçer ve diziyi pivot değerinden küçük, eşit ve büyük elemanlar olarak düşünür. Bölümleme tamamlandığında pivot nihai sıralı konumuna yerleşmiş olur. Pivotun indeksi aranan $k$ indeksine eşitse işlem biter. Pivot fazla soldaysa yalnızca sağ bölümde, fazla sağdaysa yalnızca sol bölümde arama sürdürülür.

Quick Sort iki tarafı da işlerken Quickselect sadece gerekli tarafı işler. Hız kazancı tam olarak buradan gelir.

Python uygulaması

Aşağıdaki uygulama, kötü pivot seçimlerinin olasılığını azaltmak için rastgele bir elemanı sona taşıyor. Ardından Lomuto bölümleme yöntemiyle pivotun doğru indeksini buluyor.

import random

def partition(values, left, right):
    pivot_index = random.randint(left, right)
    values[pivot_index], values[right] = values[right], values[pivot_index]
    pivot = values[right]

    store = left
    for index in range(left, right):
        if values[index] < pivot:
            values[store], values[index] = values[index], values[store]
            store += 1

    values[store], values[right] = values[right], values[store]
    return store


def quickselect(values, k):
    if not 0 <= k < len(values):
        raise IndexError("k geçerli bir indeks olmalıdır")

    left, right = 0, len(values) - 1
    while left <= right:
        pivot_index = partition(values, left, right)

        if pivot_index == k:
            return values[pivot_index]
        if pivot_index < k:
            left = pivot_index + 1
        else:
            right = pivot_index - 1

Örneğin quickselect([9, 2, 7, 1, 5], 2) çağrısı 5 döndürür. Fonksiyon diziyi yerinde değiştirdiği için özgün sıralama korunacaksa quickselect(values.copy(), k) kullanılmalıdır.

Karmaşıklığın arkasındaki fikir

Dengeli pivotlar seçildiğinde incelenen eleman sayısı yaklaşık olarak şu seriyi oluşturur:

Bu nedenle beklenen zaman karmaşıklığı $O(n)$ olur. Buna karşılık pivot sürekli en küçük veya en büyük eleman seçilirse $n+(n-1)+\cdots+1$ işlem oluşur ve sonuç $O(n^2)$ seviyesine çıkar. Rastgele pivot pratikte bu talihsiz senaryoyu oldukça düşük olasılıklı hâle getirir.

Quickselect; büyük veri kümelerinde yüzdelik dilim, ortanca, liderlik sırası ve eşik değeri hesaplamak için güçlü bir araçtır. Tüm sıralamaya ihtiyacınız yoksa algoritmik valizinize koymaya kesinlikle değer.

``

Matris neden “seyrek” olur?

Graf bağlantı matrisleri, öneri sistemleri, sonlu eleman analizleri ve doğal dil işleme modelleri çoğunlukla seyrek veri üretir. Örneğin bir sosyal ağda milyonlarca kullanıcı bulunabilir; ancak her kullanıcı yalnızca birkaç yüz kişiyle bağlantılıdır.

Bir $A \in \mathbb{R}^{m \times n}$ matrisi ile $x \in \mathbb{R}^{n}$ vektörünün çarpımı şöyledir:

Yoğun gösterimde her satırdaki bütün sütunlar dolaşılır. Böylece zaman karmaşıklığı $O(mn)$ olur. Oysa yalnızca sıfır olmayan elemanları işlersek maliyet yaklaşık olarak

seviyesine iner. Buradaki $\operatorname{nnz}(A)$, matrisin sıfır olmayan eleman sayısıdır.

Popüler gösterim biçimleri

Matris-vektör çarpımı, yani SpMV, çoğunlukla satırlar üzerinden ilerlediği için CSR biçimi yaygın bir tercihtir.

CSR mantığını parçalarına ayıralım

Aşağıdaki matrisi düşünelim:

CSR gösteriminde üç dizi kullanılır:

• values = [5, 2, 3, 1, 4]
• col_indices = [0, 3, 1, 0, 2]
• row_ptr = [0, 2, 3, 5]

row_ptr, her satırın values dizisinde nerede başlayıp bittiğini belirtir. Böylece algoritma sıfırların bulunduğu hücrelere hiç uğramaz.

def csr_matvec(values, col_indices, row_ptr, vector):
    rows = len(row_ptr) - 1
    result = [0.0] * rows

    for row in range(rows):
        start = row_ptr[row]
        end = row_ptr[row + 1]

        for k in range(start, end):
            column = col_indices[k]
            result[row] += values[k] * vector[column]

    return result

values = [5, 2, 3, 1, 4]
columns = [0, 3, 1, 0, 2]
row_ptr = [0, 2, 3, 5]
x = [1, 2, 3, 4]

print(csr_matvec(values, columns, row_ptr, x))
# [13.0, 6.0, 13.0]

Kod, her satır için yalnızca ilgili değer aralığını gezer. Örneğin ilk sonuç $5 \cdot 1 + 2 \cdot 4 = 13$ şeklinde hesaplanır.

Bellek kazancı gerçekten büyük mü?

Bir $10{,}000 \times 10{,}000$ matris, 64 bit kayan noktalı sayılarla yoğun biçimde yaklaşık 800 MB yer kaplar. Matrisin yalnızca yüzde biri doluysa bir milyon anlamlı değer vardır. CSR biçiminde değerler ile 32 bit indisler kabaca 12 MB, satır işaretçileri ise yaklaşık 40 KB gerektirir. Ek yapılar hesaba katılsa bile fark dramatiktir.

Seyrek yapı her zaman otomatik zafer değildir. Matris yeterince doluysa indislerin bellek maliyeti avantajı azaltabilir. Ayrıca SpMV çoğu sistemde işlemciden çok bellek bant genişliğiyle sınırlıdır. Bu nedenle doğru format; matrisin doluluk oranına, erişim yönüne ve güncellenme sıklığına göre seçilmelidir. Kısacası hızın sırrı, sıfırlarla daha hızlı çarpışmak değil, onları tamamen görmezden gelmektir.

``

Kararlılık tam olarak nedir?

Bir dizide $a_i$ ve $a_j$ elemanlarının sıralama anahtarları eşitse ve başlangıçta $a_i$, $a_j$ elemanından önce geliyorsa kararlı algoritma bu ilişkiyi sıralamadan sonra da korur.

Matematiksel olarak koşulu şöyle gösterebiliriz:

Burada $k(a)$ elemanın sıralama anahtarını, $p(a)$ ise sıralanmış dizideki yeni konumunu temsil eder. Algoritma bu koşulu garanti etmiyorsa kararsız olarak adlandırılır. Kararsızlık, sonucun yanlış sıralandığı anlamına gelmez; yalnızca eşit elemanların kendi aralarında yer değiştirebileceğini söyler.

Küçük ama açıklayıcı bir örnek

Bir yarışma listesinin geliş sırasıyla kaydedildiğini düşünelim:

Listeyi puana göre azalan biçimde sıraladığımızda kararlı sonuç şöyledir:

Ada ile Mert eşit puanlıdır ve Ada başlangıçta önce geldiği için yeni listede de öndedir. Benzer şekilde Ece, Can’ın önünde kalmıştır. Kararsız bir algoritma aynı puan sıralamasını üretirken bu ikililerin yerlerini değiştirebilir.

Hangi algoritmalar kararlıdır?

Algoritmanın klasik uygulanışı dikkate alındığında genel görünüm şöyledir:

Bu özellik algoritmanın isminden çok uygulama biçimine bağlıdır. Örneğin Merge Sort, eşitlik durumunda sağ taraftaki elemanı önce seçerse kararlılığını kaybedebilir.

Kod üzerinde kararlı sıralama

Python’daki sorted fonksiyonu kararlıdır. Bu sayede kayıtları aşamalı olarak güvenle sıralayabiliriz:

users = [
    {'name': 'Ada', 'department': 'Yazılım', 'age': 28},
    {'name': 'Mert', 'department': 'Tasarım', 'age': 28},
    {'name': 'Ece', 'department': 'Yazılım', 'age': 24},
]

# Önce ikincil anahtara göre sıralanır.
users = sorted(users, key=lambda user: user['name'])

# Kararlılık sayesinde isim sırası eşit bölümlerde korunur.
users = sorted(users, key=lambda user: user['department'])

İkinci sıralama bölümleri düzenlerken aynı bölümdeki kullanıcıların önceden oluşturulmuş isim sırasını bozmaz. Böylece birden fazla ölçüte göre sıralama yapılabilir. Bunun tek çağrılı karşılığı key=lambda user: (user['department'], user['name']) biçiminde bir demet kullanmaktır.

Neden önemlidir?

Kararlılık özellikle veritabanı sonuçları, e-ticaret ürün listeleri, günlük kayıtları ve tablo arayüzlerinde önem kazanır. Kullanıcı ürünleri önce tarihe, ardından fiyata göre sıraladığında eşit fiyatlı ürünlerin tarih düzeninin korunmasını bekleyebilir. Düzen rastgele değişirse uygulama hatalı olmasa bile öngörülemez görünür.

Bununla birlikte her problem kararlı algoritma gerektirmez. Elemanlar benzersizse veya yalnızca sayısal nihai sıra önemliyse daha hızlı, daha az bellek kullanan kararsız bir yöntem tercih edilebilir. Doğru seçim; zaman karmaşıklığı, bellek tüketimi ve kararlılık beklentisinin birlikte değerlendirilmesiyle yapılır. Kısacası kararlılık, eşitlerin sıkıcı bir teknik detayı değil, verinin hikâyesini koruyan görünmez bir nezaket kuralıdır.

Soyut Veri Tipi nedir?

Soyut Veri Tipi veya kısaca ADT (Abstract Data Type), bir veri koleksiyonunu yalnızca değerleri ve izin verilen işlemleri üzerinden tanımlar. ADT, doğrudan bir sınıf ya da belirli bir kod parçası değildir; daha çok uygulanması gereken davranışsal bir sözleşmedir.

Bir ADT kabaca şu bileşenlerle ifade edilebilir:

Burada $D$ olası değerler kümesini, $O$ sunulan işlemleri, $A$ ise bu işlemlerin uyması gereken kuralları belirtir. Örneğin yığın ADT’sinde push, pop, peek ve isEmpty işlemleri bulunur. Ancak elemanların bir diziyle mi, bağlı listeyle mi tutulduğu sözleşmenin parçası değildir.

Temsil bağımsızlığı ve kapsülleme

ADT tasarımının süper gücü temsil bağımsızlığıdır. İstemci kodu iç depolama biçimine erişemiyorsa uygulama daha sonra değiştirilebilir. Başlangıçta dizi kullanan bir yığın, performans ihtiyacı nedeniyle bağlı listeye geçirilebilir; arayüz aynı kaldığı sürece kullanıcı bunu fark etmez.

İç veriyi doğrudan dışarı açmak ise değişmezlerin bozulmasına yol açar. Örneğin istemci yığının eleman dizisini temizleyip sayaç değerini değiştirmezse nesne tutarsız hâle gelir. Bu nedenle veri private, güvenli işlemler ise public tutulmalıdır.

interface Stack<T> {
  push(value: T): void;
  pop(): T;
  peek(): T;
  isEmpty(): boolean;
  size(): number;
}

class ArrayStack<T> implements Stack<T> {
  private items: T[] = [];

  push(value: T): void {
    this.items.push(value);
  }

  pop(): T {
    if (this.isEmpty()) {
      throw new Error("Boş yığından eleman çıkarılamaz");
    }
    return this.items.pop() as T;
  }

  peek(): T {
    if (this.isEmpty()) {
      throw new Error("Boş yığının tepesi yoktur");
    }
    return this.items[this.items.length - 1];
  }

  isEmpty(): boolean {
    return this.items.length === 0;
  }

  size(): number {
    return this.items.length;
  }
}

Bu kodda Stack<T> davranış sözleşmesini, ArrayStack<T> ise dizi tabanlı uygulamayı temsil eder. items alanının özel olması, istemcinin yığını kuralları atlayarak değiştirmesini engeller.

Ön koşullar, son koşullar ve değişmezler

Güvenli bir arayüz tasarlanırken her işlem için üç soru sorulabilir:

• Ön koşul: İşlem çağrılmadan önce ne doğru olmalı?
• Son koşul: İşlem tamamlandığında ne garanti edilir?
• Değişmez: Nesnenin ömrü boyunca hangi kural korunur?

Yığın için pop işleminin ön koşulu $size > 0$ olabilir. Başarılı işlemden sonra:

Ayrıca LIFO kuralı gereği son eklenen eleman ilk çıkar. Ön koşul sağlanmadığında sessizce undefined döndürmek yerine açık bir hata üretmek, hatanın kaynağını görünür kılar.

İyi bir ADT için kısa kontrol listesi

Arayüzü mümkün olduğunca küçük tutun, metotlara niyet belirten adlar verin ve iç nesnelerin değiştirilebilir kopyalarını dışarı sızdırmayın. Geçersiz durumları mümkünse oluşturulamaz hâle getirin; mümkün değilse girişleri doğrulayın. Son olarak testleri iç diziye göre değil, gözlemlenebilir davranışa göre yazın.

Özetle ADT tasarlamak yalnızca veriyi saklamak değildir. Asıl amaç, yanlış kullanımı zorlaştıran ve uygulama ayrıntılarının özgürce değişmesine izin veren bir sözleşme kurmaktır. İyi bir ADT, kullanıcıya düğmeleri gösterir; kablo karmaşasını ise kapağın altında bırakır.