Bir ayçiçeğinin merkezine, çam kozalağının pullarına veya yüzyıllardır hayranlık uyandıran bir tabloya baktığımızda benzer bir düzen hissedebiliriz. Bu düzenin arkasındaki en ünlü matematiksel adaylardan biri altın orandır. Yaklaşık $1.618$ değerindeki bu sayı; geometriyi, Fibonacci dizisini ve estetik tartışmalarını aynı masada buluşturan büyüleyici bir köprüdür.

``

Altın oran nedir?

Bir doğru parçasını uzun ve kısa olmak üzere iki parçaya ayıralım. Bütün uzunluğun uzun parçaya oranı, uzun parçanın kısa parçaya oranına eşitse altın oran ortaya çıkar. Uzun parça $a$, kısa parça $b$ olmak üzere:

Bu eşitlik çözüldüğünde pozitif kök şöyledir:

Altın oranın ilginç özelliklerinden biri, karesi ve tersiyle kurduğu sade ilişkilerdir:

Sanki sayı kendi içinde küçük bir matematiksel yapboz taşıyor!

Fibonacci dizisiyle bağlantısı

Fibonacci dizisinde her sayı kendisinden önce gelen iki sayının toplamıdır:

Ardışık Fibonacci sayılarının büyük olanını küçük olana böldüğümüzde sonuç giderek altın orana yaklaşır. Örneğin $13/8 = 1.625$, $34/21 ≈ 1.619$ ve $89/55 ≈ 1.618$ olur. Bu yakınlaşma, altın oranın doğadaki spiral düzenlerle ilişkilendirilmesinin temel nedenlerinden biridir.

Bu yakınsamayı Python ile gözlemleyebiliriz:

# Fibonacci sayıları arasındaki oranların
# altın orana nasıl yaklaştığını gösterir.
a, b = 1, 1

for adim in range(2, 12):
    a, b = b, a + b
    oran = b / a
    print(f'{adim}. adım: {b}/{a} = {oran:.8f}')

Döngü her adımda yeni Fibonacci sayısını üretir ve ardışık iki değerin oranını yazdırır. Çıktıda oranların bir süre altın değerin üstüne ve altına geçtiğini, ardından $1.618$ çevresinde dengelendiğini görürüz.

Doğadaki izleri

Ayçiçeği çekirdekleri ve çam kozalağı pulları, çoğu zaman birbirine zıt yönlerde ilerleyen spiral aileleri oluşturur. Bu spirallerin sayıları sıklıkla $34$, $55$ veya $89$ gibi Fibonacci sayılarına yakındır. Böyle bir yerleşim, bitkinin sınırlı alana çok sayıda tohum ya da yaprak sığdırmasına yardımcı olabilir.

Yaprakların gövde çevresindeki dizilimi de güneş ışığına erişimi artıran açılar oluşturabilir. Altın açı olarak bilinen değer yaklaşık olarak:

Ancak her spiral altın spiral değildir. Nautilus kabuğu sıkça kusursuz örnek olarak sunulsa da gerçek kabukların büyüme oranları türden türe değişir. Doğa cetvelle çizilmiş tek bir formülden çok, çevresel koşulların ve biyolojik süreçlerin birlikte çalıştığı esnek bir sistemdir.

Sanat ve mimaride altın oran

Altın dikdörtgenin kısa kenarı $1$ ise uzun kenarı yaklaşık $1.618$ olur. Bu biçimin Mona Lisa, Parthenon ve çeşitli Rönesans eserlerinde kullanıldığı sıkça ileri sürülür. Bazı tasarımlarda oran bilinçli biçimde uygulanmış olsa da tarihsel kanıt bulunmayan örnekler de vardır.

Altın oran, güzelliği otomatik olarak üreten sihirli bir düğme değildir. Asıl değeri; büyüme, oran, geometri ve görsel düzen arasındaki bağlantıları incelememizi sağlamasıdır. Kısacası $φ$, doğanın gizli şifresinden ziyade çevremizdeki örüntüleri okumak için kullanabileceğimiz zarif bir matematiksel mercektir.

Bir sayı listesini sıralarken ilk refleksimiz sayıları ikişer ikişer karşılaştırmaktır. Radix Sort ise masaya farklı bir fikir koyar: “Sayıların tamamını karşılaştırmak yerine basamaklarını sırayla incelesek?” Bu yaklaşım sayesinde uygun koşullarda karşılaştırmaya dayalı algoritmaların $O(n \log n)$ sınırını aşarak doğrusal zamana yaklaşabiliriz.

``

Temel fikir: Sayının tamamına değil, basamaklarına bak

Basamaklı Sıralama, sayıları birler, onlar, yüzler gibi basamaklarına göre gruplandırır. En yaygın sürüm olan LSD Radix Sort, işleme en sağdaki, yani en az anlamlı basamaktan başlar.

Örneğin şu sayıları ele alalım:

170, 45, 75, 90, 802, 24, 2, 66

İlk turda birler basamağına, ikinci turda onlar basamağına, üçüncü turda yüzler basamağına bakılır. Her turun sonunda sayılar ilgili basamağa göre düzenlenir. Son basamak işlendiğinde liste tamamen sıralanmış olur.

Buradaki kritik ayrıntı, her basamak sıralamasının kararlı olmasıdır. Kararlı bir sıralama, aynı anahtar değerine sahip elemanların önceki göreli sırasını korur. Aksi hâlde önceki basamaklarda oluşturulan düzen bozulur ve algoritmanın sihri, pek de sihirli olmayan bir şekilde kaybolur.

Neden doğrusal olabilir?

$n$ eleman, en büyük sayıda $d$ basamak ve kullanılan sayı tabanında $b$ farklı rakam bulunsun. Her basamak için Counting Sort benzeri bir işlem uygulanırsa zaman karmaşıklığı şöyledir:

Ondalık sayılarda $b=10$ sabittir. Basamak sayısı $d$ de sınırlıysa karmaşıklık yaklaşık olarak $O(n)$ kabul edilir. Ancak sayıların basamak sayısı veri büyüklüğüyle birlikte ciddi biçimde artıyorsa “her zaman doğrusal” demek doğru değildir.

Python ile Radix Sort

Aşağıdaki uygulama negatif olmayan tam sayıları LSD yaklaşımıyla sıralar. Her turda on adet kova oluşturulur; sayılar ilgili basamaklarına göre bu kovalara dağıtılır ve aynı sırayla yeniden birleştirilir.

def radix_sort(numbers):
    if not numbers:
        return []

    result = numbers.copy()
    maximum = max(result)
    place = 1

    while maximum // place > 0:
        buckets = [[] for _ in range(10)]

        # Sayıları mevcut basamağa göre kovalara dağıt.
        for number in result:
            digit = (number // place) % 10
            buckets[digit].append(number)

        # Kovaların sırası korunarak listeyi yeniden oluştur.
        result = [number for bucket in buckets for number in bucket]
        place *= 10

    return result

values = [170, 45, 75, 90, 802, 24, 2, 66]
print(radix_sort(values))

Kovaların liste olarak kullanılması kararlılığı doğal biçimde sağlar. Aynı rakama sahip sayılar kovaya giriş sıralarını koruyarak çıkar.

Ne zaman tercih edilmeli?

Radix Sort; kimlik numaraları, sabit uzunluktaki sayısal kodlar, IP adresleri veya çok sayıda tam sayı gibi yapılandırılmış verilerde oldukça etkilidir. Buna karşılık değişken uzunluklu veriler, ondalıklı sayılar ve negatif değerler ek uyarlamalar gerektirir. Negatif sayılar genellikle mutlak değerlerine göre ayrı sıralanıp ters çevrilerek pozitiflerle birleştirilir.

Kısacası Radix Sort, karşılaştırma yapmadan sıralamanın mümkün olduğunu gösteren zarif bir algoritmadır. Doğru veri türünde kullanıldığında basamakları tek tek tırmanır ve listenin zirvesine beklenmedik bir hızla ulaşır.

`` Diziyi oluşturmaya tek bir 0 ile başlayalım. Her adımda mevcut bölümün bitlerini ters çevirip sonuna ekleyelim:

0
01
0110
01101001
0110100110010110

Burada ters çevirme işlemi 0 → 1 ve 1 → 0 biçimindedir. Örneğin 0110 kelimesinin tümleyeni 1001 olur; ikisini birleştirince 01101001 elde edilir. Bu üretim kuralı matematiksel olarak

şeklinde yazılabilir. $\overline{T_k}$, $T_k$ içindeki bütün bitlerin tümleyenini temsil eder. Her turda uzunluk iki katına çıktığı için $k$ adımından sonra $2^k$ eleman bulunur.

Sayıların ikili gösterimiyle bağlantısı

Thue-Morse dizisinin yalnızca önceki parçayı kopyalayarak tanımlanması gerekmez. Sıfırdan başlayan $n$ indeksli terim, $n$ sayısının ikili gösterimindeki 1 sayısının tek veya çift olmasına göre hesaplanabilir.

$n$ içindeki 1 bitlerinin sayısına $s_2(n)$ dersek:

Yani 1 sayısı çiftse sonuç 0, tekse 1 olur.

Bu tanımdan kullanışlı iki bağıntı çıkar:

Çift indeksler önceki değerleri tekrar ederken tek indeksler onların tersini taşır. Dizinin fraktal karakterinin cebirsel özeti tam olarak budur.

Neden fraktala benziyor?

Fraktallarda bütünün daha küçük ölçekli kopyalarını görürüz. Thue-Morse dizisinde de her blok, daha önce oluşmuş bir bloğu ve onun renkleri değiştirilmiş hâlini içerir. Bitleri siyah ve beyaz kareler olarak çizersek farklı ölçeklerde yinelenen desenler ortaya çıkar. Ancak bu tekrar tam anlamıyla periyodik değildir.

Dizi deterministiktir; yani rastgele değildir. Buna karşın sonsuza kadar tekrar eden sabit bir periyoda da sahip değildir. Dahası, belirli türde aşırı tekrarları engelleyen overlap-free özelliğiyle kelime kombinatoriğinde önemli bir yere sahiptir.

Python ile üretelim

Aşağıdaki fonksiyon, her turun sonuna mevcut bitlerin tümleyenini ekler:

def thue_morse(iterations: int) -> str:
    sequence = "0"

    for _ in range(iterations):
        complement = "".join(
            "1" if bit == "0" else "0"
            for bit in sequence
        )
        sequence += complement

    return sequence

print(thue_morse(4))
# 0110100110010110

Tek bir terime ihtiyaç duyulduğunda bütün diziyi üretmek gereksizdir. Python’daki bit_count() yöntemi daha doğrudan bir çözüm sunar:

def thue_morse_term(n: int) -> int:
    # İkili gösterimdeki 1 sayısının paritesini döndürür.
    return n.bit_count() % 2

print([thue_morse_term(n) for n in range(16)])

İlk yöntem görsel deseni ve öz-benzerliği incelemek için, ikinci yöntemse büyük indekslerde hızlı sorgulama yapmak için uygundur.

Thue-Morse ardışıklığı, karmaşıklığın mutlaka karmaşık kurallardan doğmadığını gösteren zarif bir örnektir. Bir bit, bir tümleyen işlemi ve tekrar: Dijital dünyanın bu küçük tarifi, sonsuz ve periyotsuz bir matematik manzarası üretmeye yeter.

``

Königsberg Köprüleri Problemi

Prusya’nın Königsberg şehri, Pregel Nehri’nin ayırdığı dört kara parçası ve bunları birbirine bağlayan yedi köprüden oluşuyordu. Şehir halkının sorusu basitti: Her köprüden tam bir kez geçilen bir yürüyüş yapılabilir miydi?

Euler, kara parçalarının şekli veya köprülerin uzunluğu gibi ayrıntıların önemsiz olduğunu fark etti. Her kara parçasını bir düğüm, her köprüyü ise iki düğümü bağlayan bir kenar olarak temsil etti. Böylece fiziksel şehir, matematiksel bir grafa dönüştü.

Aynı iki kara parçası arasında birden fazla köprü bulunabildiği için ortaya çıkan yapı teknik olarak bir çoklu graftır.

Düğüm Derecesi Neden Önemlidir?

Bir düğümün derecesi, o düğüme bağlı kenarların sayısıdır ve $\deg(v)$ ile gösterilir. Bir yol sırasında ara düğüme bir kenardan girip başka bir kenardan çıkmak gerekir. Dolayısıyla kullanılan kenarlar çiftler hâlinde eşleşir. Tek dereceli düğümler ise bu eşleşmenin bozulduğu başlangıç veya bitiş noktaları olabilir.

Grafın bütün düğüm dereceleri için şu önemli eşitlik geçerlidir:

Her kenar iki uca sahip olduğundan dereceler toplamına iki katkı yapar. Bu sonuç, tek dereceli düğüm sayısının her zaman çift olduğunu da gösterir.

Königsberg grafındaki dört düğümün dereceleri $3, 3, 3$ ve $5$ idi. Yani dört düğüm de tek dereceliydi. Oysa her köprüden yalnızca bir kez geçen bir rota için tek dereceli düğüm sayısı en fazla iki olmalıdır. Sonuç: İstenen yürüyüş imkânsızdı!

Euler Yolu ve Euler Devresi

Bu koşullarda grafın, izole düğümler göz ardı edildiğinde, bağlantılı olduğu kabul edilir. Euler yolu her kenarı tam bir kez kullanır. Bu nedenle her düğümü bir kez ziyaret etmeye çalışan Hamilton yoluyla karıştırılmamalıdır.

Python ile Euler Yolu Kontrolü

Aşağıdaki fonksiyon, komşuluk listesiyle verilen bağlantılı bir grafın Euler özelliğini dereceler üzerinden sınıflandırır:

def euler_durumu(graf):
    tek_dereceliler = []

    for dugum, komsular in graf.items():
        if len(komsular) % 2 == 1:
            tek_dereceliler.append(dugum)

    if len(tek_dereceliler) == 0:
        return "Euler devresi var"
    elif len(tek_dereceliler) == 2:
        return f"Euler yolu var: {tek_dereceliler}"
    else:
        return "Euler yolu yok"

sehir = {
    "A": ["B", "B", "C"],
    "B": ["A", "A", "D"],
    "C": ["A", "D", "D"],
    "D": ["B", "C", "C", "D", "D"]
}

print(euler_durumu(sehir))

Listelerde aynı komşunun tekrarlanması paralel köprüleri temsil eder. Bir öz döngü ise düğüm derecesine iki katkı yaptığı için listede iki kez gösterilmiştir. Gerçek bir uygulamada ayrıca DFS veya BFS kullanarak grafın bağlantılı olup olmadığı doğrulanmalıdır.

Euler’in büyük başarısı belirli bir rotayı denemek değil, böyle bir rotanın var olup olamayacağını yapısal olarak kanıtlamaktı. Bugün aynı fikir; çöp toplama rotaları, ağ analizi, devre tasarımı ve DNA dizileme gibi pek çok alanda karşımıza çıkıyor. Bazen bir köprüden geçmeden önce dereceleri saymak, saatlerce dolaşmaktan çok daha akıllıcadır.

Bir satıcının ziyaret etmesi gereken şehirler, sınırlı yakıtı ve eve dönmeden önce yetişmesi gereken bir akşam yemeği olduğunu düşünün. Amaç, her şehre tam bir kez uğrayıp başlangıç noktasına dönen en kısa rotayı bulmaktır. Gezgin Satıcı Problemi, yani TSP, basit görünen kurallarının altında devasa bir arama uzayı saklayan klasik bir optimizasyon problemidir.

``

TSP neden bu kadar zor?

Şehirleri düğüm, aralarındaki yolları da ağırlıklı kenar olarak gösterirsek problem bir grafik üzerinde tanımlanabilir. $n$ şehir için turun toplam maliyeti şöyle yazılır:

Burada $\pi$, şehirlerin ziyaret sırasını; $d(a,b)$ ise iki şehir arasındaki uzaklığı temsil eder. Aradığımız sonuç, bütün olası sıralamalar içindeki minimum değerdir:

Simetrik uzaklıklarda başlangıç ve yön tekrarları elendiğinde bile yaklaşık $(n-1)!/2$ farklı tur bulunur. Yalnızca 20 şehir için seçenek sayısı astronomik seviyeye çıkar. TSP’nin karar sürümü NP-tam, optimizasyon sürümü ise NP-zordur. Bu nedenle büyük girdilerde bütün turları denemek yerine hızlı ve yeterince iyi yaklaşık çözümler kullanılır.

Açgözlü düşünce ve en yakın komşu

Açgözlü algoritmalar, gelecekte oluşabilecek etkileri kapsamlı biçimde hesaplamadan o an en avantajlı seçimi yapar. TSP için en bilinen açgözlü yöntem en yakın komşu algoritmasıdır:

1. Bir başlangıç şehri seç.
2. Ziyaret edilmemiş en yakın şehre git.
3. Bütün şehirler bitene kadar işlemi tekrarla.
4. Başlangıç şehrine dön.

Bu strateji hızlıdır; ancak kısa adımların toplamı her zaman en kısa tur değildir. Algoritma ucuz yolları erkenden tüketip sona birbirinden çok uzak iki şehir bırakabilir. Başka bir deyişle, yerel olarak iyi karar küresel olarak kötü olabilir.

Aşağıdaki Python kodu uzaklık matrisi üzerinde yöntemi uygular:

def nearest_neighbor(distances, start=0):
    n = len(distances)
    unvisited = set(range(n))
    unvisited.remove(start)
    route = [start]
    total = 0
    current = start

    while unvisited:
        next_city = min(
            unvisited,
            key=lambda city: distances[current][city]
        )
        total += distances[current][next_city]
        route.append(next_city)
        unvisited.remove(next_city)
        current = next_city

    total += distances[current][start]
    route.append(start)
    return route, total

unvisited henüz gidilmeyen şehirleri tutar. min işlemi mevcut konuma en yakın şehri seçer. Bu seçim her şehir için en fazla $O(n)$ karşılaştırma yaptığından toplam zaman karmaşıklığı $O(n^2)$, ek bellek ihtiyacı ise $O(n)$ olur.

Sonucu biraz daha akıllandırmak

Başlangıç şehri sonucu ciddi biçimde değiştirebilir. Bu nedenle algoritmayı her şehirden başlatıp en kısa turu seçmek, çoklu başlangıç adı verilen pratik bir iyileştirmedir. Ardından 2-opt uygulanabilir: Turdaki iki kenar kaldırılır, aradaki rota ters çevrilir ve toplam mesafe azalıyorsa değişiklik korunur.

Örneğin $(A,B)$ ve $(C,D)$ kenarları için şu karşılaştırma yapılır:

Eşitsizlik doğruysa kenarlar değiştirilerek gereksiz çaprazlaşmalar giderilebilir. Böylece en yakın komşunun hızlı başlangıcı, yerel aramanın düzeltme yeteneğiyle birleşir.

TSP bize önemli bir algoritma dersi verir: Kusursuz çözüm her zaman pratik çözüm değildir. Navigasyon, lojistik, robot rotalama ve devre tasarımı gibi alanlarda birkaç saniyede bulunan kaliteli bir tur, yıllarca beklenecek optimum turdan çok daha değerlidir.

``

Graf renklendirme nedir?

Bir graf $G=(V,E)$ ile gösterilir. Burada $V$ düğüm kümesini, $E$ ise düğümler arasındaki kenarları temsil eder. Düğüm renklendirmede her $v \in V$ düğümüne bir renk atanır. Bir $(u,v) \in E$ kenarı varsa temel koşul şudur:

Buradaki $c(v)$, $v$ düğümünün rengidir. Grafı geçerli biçimde boyamak için gereken en küçük renk sayısına kromatik sayı denir ve $\chi(G)$ ile gösterilir.

Genel bir grafın kromatik sayısını kesin olarak bulmak hesaplama açısından zordur. Welch-Powell çoğu zaman az renk kullanan bir çözüm üretir; ancak her graf için gerçek minimumu garanti etmez. Dolayısıyla elde ettiği renk sayısı $k$ ise genellikle

ifadesini söyleyebiliriz.

Welch-Powell nasıl çalışır?

Algoritmanın arkasındaki fikir, en fazla komşuya sahip düğümleri önce ele almaktır. Çünkü yüksek dereceli bir düğümü sona bırakmak, kullanılabilir renk seçeneklerini ciddi biçimde azaltabilir.

1. Düğümleri derecelerine göre azalan sırada diz.
2. İlk boyanmamış düğüme yeni bir renk ata.
3. Aynı renkle boyanmış düğümlere komşu olmayan diğer düğümlere de bu rengi ver.
4. Boyanmamış düğüm kalmayana kadar yeni renklerle işlemi tekrarla.

Python ile uygulama

Aşağıdaki fonksiyon, grafı komşuluk kümelerinden oluşan bir sözlük olarak alır. Sonuçta her düğümün hangi renk numarasını aldığını döndürür:

def welch_powell(graph):
    # Düğümleri, komşu sayısına göre büyükten küçüğe sırala.
    ordered = sorted(graph, key=lambda node: len(graph[node]), reverse=True)
    colors = {}
    color_id = 0

    while len(colors) < len(graph):
        # Her tur yeni bir renk grubunu temsil eder.
        for node in ordered:
            if node in colors:
                continue

            conflict = any(
                colors.get(neighbor) == color_id
                for neighbor in graph[node]
            )

            if not conflict:
                colors[node] = color_id

        color_id += 1

    return colors


graph = {
    'A': {'B', 'C'},
    'B': {'A', 'C', 'D'},
    'C': {'A', 'B', 'D'},
    'D': {'B', 'C', 'E'},
    'E': {'D'}
}

result = welch_powell(graph)
print(result)
print('Kullanılan renk:', len(set(result.values())))

conflict kontrolü, incelenen düğümün komşularından herhangi birinin mevcut rengi kullanıp kullanmadığını belirler. Çakışma yoksa aynı renk güvenle atanır. Sıralama yaklaşık $O(\vert V\vert \log \vert V\vert )$ maliyetindedir; komşuluk kontrolleriyle toplam süre kullanılan veri yapısına ve grafın yoğunluğuna bağlıdır.

Nerelerde kullanılır?

Graf renklendirme; sınavların aynı saate çakışmadan yerleştirilmesinde, işlemci yazmaçlarının dağıtılmasında, kablosuz ağ kanallarının atanmasında ve harita boyamada kullanılabilir. Welch-Powell özellikle hızlı, kabul edilebilir ve açıklanabilir bir çözüm gerektiğinde güçlü bir başlangıçtır. Daha iyi sonuç için farklı eşit derece sıralamaları denenebilir ve bulunan çözümler arasından en az renk kullanan seçilebilir.

``

Önce grafın temelini kuralım

Bir graf, $G=(V,E)$ biçiminde tanımlanır. Burada $V$ düğümler, $E$ ise düğümler arasındaki kenarlardır. Düğüm sayısını $\vert V\vert =n$, kenar sayısını da $\vert E\vert =m$ ile gösterelim.

Bir grafın sahip olabileceği kenar sayısı, yönsüz ve öz döngüsüz durumda en fazla:

olur. Eğer $m$, bu üst sınıra yakınsa grafa yoğun graf; kenar sayısı düğüm sayısına yakınsa seyrek graf denir. Temsil yöntemi seçilirken asıl belirleyici çoğu zaman bu yoğunluktur.

Komşuluk matrisi

Komşuluk matrisi, $n \times n$ boyutunda iki boyutlu bir tablodur. matris[i][j] değeri, i ile j arasında kenar varsa 1, yoksa 0 olur. Ağırlıklı graflarda bu hücreye kenarın ağırlığı yazılabilir.

# Dört düğümlü yönsüz bir grafın komşuluk matrisi
matris = [
    [0, 1, 1, 0],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [0, 1, 1, 0]
]

# 0 ve 2 arasında doğrudan kenar var mı?
print(matris[0][2] == 1)

Bu yöntemin yıldız özelliği, iki düğüm arasında kenar bulunup bulunmadığını $O(1)$ zamanda söylemesidir. Ancak grafın yalnızca birkaç kenarı olsa bile bütün hücreler ayrılır. Dolayısıyla bellek karmaşıklığı her durumda $O(V^2)$ olur.

Bir düğümün tüm komşularını bulmak için ilgili satırın tamamı gezilir. Bu işlem $O(V)$ zaman alır. Matris, özellikle yoğun graflarda ve sık kenar sorgusu yapılan uygulamalarda güçlüdür.

Komşuluk listesi

Komşuluk listesinde her düğüm için yalnızca bağlantılı olduğu düğümler tutulur. Boş bağlantılar bellekte yer kaplamaz; yani kullanılmayan koltuklara bilet kesilmez.

# Aynı grafın komşuluk listesi gösterimi
liste = {
    0: [1, 2],
    1: [0, 3],
    2: [0, 3],
    3: [1, 2]
}

# 0 düğümünün komşularını dolaş
for komsu in liste[0]:
    print(komsu)

Bu yapının bellek maliyeti $O(V+E)$ düzeyindedir. Bir düğümün komşularını dolaşmak, düğümün derecesi $d(v)$ olmak üzere $O(d(v))$ sürer. Buna karşılık belirli iki düğümün komşu olup olmadığını aramak, kullanılan liste yapısına göre $O(d(v))$ zaman alabilir. Komşular bir set içinde saklanırsa ortalama sorgu süresi $O(1)$ seviyesine indirilebilir; fakat ek bellek maliyeti oluşur.

Hızlı karşılaştırma

Hangisini seçmeliyiz?

Grafınızda binlerce düğüm fakat az sayıda bağlantı varsa komşuluk listesi açık ara daha ekonomiktir. Örneğin yol ağları, web bağlantıları ve sosyal ağların büyük bölümü seyrektir. Bu yapılarda BFS ve DFS gibi algoritmalar listeyle $O(V+E)$ zamanda çalışır; matris kullanılırsa süre $O(V^2)$ seviyesine çıkabilir.

Düğüm sayısı küçükse, graf yoğunsa veya uygulama sürekli “Bu iki düğüm bağlı mı?” diye soruyorsa komşuluk matrisi daha pratik olabilir. Floyd–Warshall gibi matris tabanlı algoritmalar da doğal olarak bu gösterimle uyumludur.

Kısacası evrensel bir kazanan yoktur: matris sorgu hızını, liste ise bellek verimliliğini öne çıkarır. Doğru seçim, grafın yoğunluğuna ve en sık yapılacak işleme bağlıdır.

Bir polinomun belirli bir noktadaki değerini hesaplamak ilk bakışta yalnızca üsleri, çarpımları ve toplamları sırayla uygulamak gibi görünür. Ancak derece büyüdükçe klasik yöntem gereksiz işlem kalabalığına dönüşür. Horner şeması, polinomu akıllıca parantezleyerek aynı sonucu daha az çarpma işlemiyle bulur. Üstelik yöntem hem kâğıt üzerinde hem de bilgisayar programlarında son derece kullanışlıdır.

``

Temel fikir: Polinomu iç içe geçirmek

Derecesi $n$ olan genel bir polinomu şöyle yazabiliriz:

Doğrudan hesaplamada $x^2$, $x^3$ ve diğer kuvvetler ayrı ayrı üretilebilir. Horner şeması ise ortak $x$ çarpanlarını dışarı alarak polinomu şu biçime dönüştürür:

Bu ifade biraz matruşka bebeğine benzer: Her parantezin içinden başka bir çarpma ve toplama çıkar. İşleme en yüksek dereceli katsayıdan başlanır; mevcut sonuç $x$ ile çarpılır ve sıradaki katsayı eklenir.

Örneğin

polinomunu Horner biçiminde yazalım:

$x=3$ için adımlar şöyledir:

1. İlk katsayıyla başla: $2$
2. $2\cdot3-6=0$
3. $0\cdot3+2=2$
4. $2\cdot3-1=5$

Dolayısıyla $P(3)=5$ bulunur. Küp veya kareyi ayrıca hesaplamaya hiç gerek kalmaz.

İşlem sayısı neden azalır?

Standart yaklaşımda her terimin kuvveti bağımsız hesaplanırsa çok sayıda çarpma yapılabilir. Horner yönteminde derece $n$ olan bir polinom için tam olarak $n$ çarpma ve $n$ toplama yeterlidir. Bu nedenle zaman karmaşıklığı $O(n)$ olur.

Kuvvetlerin önceden verimli biçimde hesaplanması doğrudan yöntemi iyileştirebilir. Yine de Horner şeması sade yapısı ve düşük sabit maliyeti sayesinde çoğu durumda daha avantajlıdır.

Python ile uygulama

Katsayıları en yüksek dereceden sabit terime doğru saklayabiliriz. Aşağıdaki fonksiyon, birikmiş sonucu her adımda $x$ ile çarpıp yeni katsayıyı ekler:

def horner(katsayilar, x):
    sonuc = 0

    for katsayi in katsayilar:
        sonuc = sonuc * x + katsayi

    return sonuc

katsayilar = [2, -6, 2, -1]
print(horner(katsayilar, 3))  # 5

Buradaki sonuc, işlenmiş katsayıların oluşturduğu ara polinomun değeridir. Döngü değişmezi olarak düşünüldüğünde algoritmanın doğruluğu daha net görülür: Her tur sonunda bir derece daha polinoma dâhil edilir.

Ara değerleri görmek istersek fonksiyonu biraz genişletebiliriz:

def horner_adimlari(katsayilar, x):
    sonuc = katsayilar[0]
    print(sonuc)

    for katsayi in katsayilar[1:]:
        sonuc = sonuc * x + katsayi
        print(sonuc)

    return sonuc

Bu sürüm eğitim ve hata ayıklama için yararlıdır; ekrana sırasıyla $2$, $0$, $2$ ve $5$ yazdırır.

Sadece değer hesaplamakla kalmaz

Horner şeması polinom bölmede de kullanılabilir. $P(x)$ polinomunu $(x-r)$ ifadesine sentetik bölme ile böldüğümüzde oluşan son değer $P(r)$, yani kalandır. Bu ilişki kalan teoreminden gelir:

Sonuç sıfırsa $r$ polinomun köküdür. Böylece aynı kısa algoritma; değer hesaplama, kök denetleme ve sentetik bölme gibi farklı görevlerde kullanılabilir. Horner şeması, iyi bir algoritmanın yalnızca hızlı değil, aynı zamanda fikren zarif olabileceğini gösteren klasik örneklerden biridir.

``

İki parçalı graf nedir?

Bir grafın düğümleri, kendi içlerinde bağlantı bulunmayan iki ayrı kümeye ayrılabiliyorsa bu grafa iki parçalı graf denir. Grafı

şeklinde gösterebiliriz. Burada $L$ sol grubu, $R$ sağ grubu, $E$ ise iki grup arasındaki uygunluk bağlantılarını temsil eder. Örneğin $L$ adaylar, $R$ işler olabilir.

Bir eşleştirme, hiçbir düğümün birden fazla seçilmiş kenarda yer almadığı kenarlar kümesidir. Aradığımız maksimum eşleştirme, mümkün olan en fazla kenarı içeren eşleştirmedir.

Hall Evlenme Teoremi

Teorinin kalbinde Hall Teoremi bulunur. Sol gruptaki herhangi bir $S$ alt kümesinin erişebildiği sağ düğümler $N(S)$ ile gösterilsin. Sol taraftaki herkesin eşleşebilmesi için şu koşul gereklidir ve yeterlidir:

Yani üç adayın toplamda yalnızca iki uygun işe erişimi varsa üçünü birden yerleştirmek imkânsızdır. Sandalye kapmaca oyununda üç kişinin önüne iki sandalye koymak gibi: algoritma çok zeki olabilir ama yeni sandalye üretemez.

Artırma yolu yaklaşımı

Kuhn algoritması her sol düğüm için uygun bir sağ düğüm arar. İstenen sağ düğüm boşsa eşleşme kurulur. Doluysa, mevcut eşleşmenin başka bir yere taşınıp taşınamayacağı derinlik öncelikli arama ile kontrol edilir. Böylece eşleşme sayısını bir artıran artırma yolu bulunabilir.

def maksimum_eslesme(graf):
    # sag_eslesme[is] = o işe yerleştirilen aday
    sag_eslesme = {}

    def yer_bul(aday, ziyaret):
        for is_adi in graf.get(aday, []):
            if is_adi in ziyaret:
                continue

            ziyaret.add(is_adi)
            mevcut_aday = sag_eslesme.get(is_adi)

            # İş boşsa veya mevcut aday başka işe taşınabiliyorsa
            if mevcut_aday is None or yer_bul(mevcut_aday, ziyaret):
                sag_eslesme[is_adi] = aday
                return True

        return False

    for aday in graf:
        yer_bul(aday, set())

    return {aday: is_adi for is_adi, aday in sag_eslesme.items()}


graf = {
    "Ayşe": ["Python", "Veri"],
    "Can": ["Python", "Java"],
    "Ece": ["Veri"],
    "Mert": ["Java", "DevOps"]
}

print(maksimum_eslesme(graf))

Buradaki ziyaret kümesi, aynı arama sırasında bir işe tekrar gidilmesini önleyerek döngüleri ve gereksiz denemeleri engeller. Her aday için yeni bir küme oluşturulur; çünkü sonraki aday alternatif yolları yeniden değerlendirebilmelidir.

Karmaşıklık ve doğru algoritma seçimi

Bu DFS tabanlı çözümün zaman karmaşıklığı yaklaşık olarak

olur. Küçük ve orta ölçekli problemler için anlaşılır ve yeterince hızlıdır.

Önemli ayrım şudur: Kuhn algoritması eşleşen çift sayısını büyütür; tercih puanlarının toplamını optimize etmez. Her bağlantının puanı veya maliyeti varsa ağırlıklı eşleştirme algoritmaları kullanılmalıdır. Böylece “en fazla kaç çift?” ile “toplamda en iyi çiftler hangileri?” sorularını birbirine karıştırmamış oluruz.

Önce temel kavram: Karmaşıklık

Bir algoritmanın çalışma süresini yalnızca saniyeyle ölçmek yanıltıcıdır; işlemci, programlama dili ve sistem yükü sonucu etkiler. Bu nedenle girdi boyutu $n$ arttığında işlem sayısının nasıl değiştiğini anlatan asimptotik karmaşıklık kullanılır.

Örneğin iç içe iki döngü yaklaşık

karşılaştırma yapıyorsa baskın terim $n^2$ olur ve karmaşıklık $O(n^2)$ şeklinde yazılır. Veri miktarını iki katına çıkarmak, çalışma süresini kabaca dört katına çıkarabilir. Küçük listelerde önemsiz görünen bu fark, $n=100.000$ olduğunda algoritmik bir drama dönüşür.

Dört algoritmanın çalışma mantığı

Kabarcık sıralaması, komşu elemanları karşılaştırır ve yanlış sıradaysalar yer değiştirir. Büyük değerler her turda listenin sonuna doğru “kabarcık” gibi yükselir. Takas yapılmayan turda durdurulursa sıralı veride $O(n)$ performans gösterebilir; fakat rastgele büyük verilerde çok fazla karşılaştırma ve takas üretir.

Seçmeli sıralama, her turda sıralanmamış bölümün en küçük elemanını bulup başa taşır. Karşılaştırma sayısı veri zaten sıralı olsa bile pek değişmez. Buna karşılık az takas yapması, yazma maliyetinin yüksek olduğu özel ortamlarda avantaj sağlayabilir.

Yerleştirmeli sıralama, iskambil kâğıtlarını elde dizerken kullandığımız yönteme benzer. Her yeni elemanı soldaki sıralı bölümde uygun konuma yerleştirir. Neredeyse sıralı verilerde az kaydırma yaptığı için oldukça hızlıdır. Bu nedenle gelişmiş sıralama algoritmalarında küçük alt dizileri işlemek amacıyla sıkça kullanılır.

Shell sıralaması ise yerleştirmeli sıralamanın sabırsız kuzenidir. Önce birbirinden uzak elemanları belirli aralıklarla sıralar, ardından aralığı küçültür. Son aşamada aralık $1$ olur; fakat liste önceden büyük ölçüde düzenlendiği için işlem hızlanır.

Python ile karşılaştırmalı deney

Aşağıdaki kod, algoritmaları aynı rastgele verinin kopyaları üzerinde çalıştırır. Böylece bir algoritmanın sıraladığı listenin diğerlerini haksız biçimde avantajlı duruma getirmesi önlenir.

import random
import time

def insertion_sort(a):
    for i in range(1, len(a)):
        value = a[i]
        j = i - 1
        while j >= 0 and a[j] > value:
            a[j + 1] = a[j]
            j -= 1
        a[j + 1] = value
    return a

def shell_sort(a):
    gap = len(a) // 2
    while gap > 0:
        for i in range(gap, len(a)):
            value, j = a[i], i
            while j >= gap and a[j - gap] > value:
                a[j] = a[j - gap]
                j -= gap
            a[j] = value
        gap //= 2
    return a

for size in (100, 1000, 5000):
    data = [random.randint(0, 100000) for _ in range(size)]
    for function in (insertion_sort, shell_sort):
        sample = data.copy()
        start = time.perf_counter()
        function(sample)
        elapsed = time.perf_counter() - start
        print(size, function.__name__, elapsed)

perf_counter() kısa süreleri hassas ölçer; copy() ise deney adaletini korur. Güvenilir sonuç için her testi birçok kez çalıştırıp ortalama veya medyan almak gerekir.

Sonuç

Kabarcık sıralaması öğretici, seçmeli sıralama az takaslı, yerleştirmeli sıralama küçük veya düzenli veride çevik, Shell sıralaması ise orta ölçekli rastgele veride güçlüdür. Yine de büyük gerçek dünya verilerinde $O(n\log n)$ sınıfındaki hızlı sıralama, birleştirmeli sıralama veya dilin yerleşik sıralama fonksiyonu genellikle daha doğrudur. Kısacası kazanan tek bir algoritma değil; verinin yapısını tanıyıp doğru aracı seçen programcıdır.