Hoe evalueer je de complexiteit van een algoritme of…

Algoritmın karmaşıklığını değerlendirmek için asymptotik analiz kullanılır, bu algoritmanın verimliliğini giriş verilerinin boyutuna ($n$) bağlı olarak tanımlamaya olanak sağlar. Temel adımlar:

Temel işlemleri tanımlama: $n$'ye bağlı olan işlemler belirlenir (örneğin, karşılaştırmalar, atamalar, aritmetik işlemler).
İşlem sayısını hesaplama: $n$'ye bağlı temel işlemlerin sayısı hesaplanır. Bu, kesin formül veya tahmin olabilir.
Asimptotik sınıfı belirleme: Büyük O ($O$), Omega ($\Omega$) ve Theta ($\Theta$) sembolleri kullanılarak üst, alt ve kesin asimptotik davranışlar tanımlanır.

$O(f(n))$: Algoritma, $f(n)$ ile çarpılmış sabit bir süre içinde çalışır, büyük $n$ için geçerlidir. En kötü durum için kullanılır.
$\Omega(f(n))$: Algoritma, $f(n)$ ile çarpılmış sabit bir süreden az veya ona eşit sürede çalışır, büyük $n$ için geçerlidir. En iyi durum için kullanılır.
$\Theta(f(n))$: Algoritma, $f(n)$ ile orantılı bir sürede çalışır, büyük $n$ için geçerlidir. Ortalama durum veya en iyi ve en kötü durumların aynı asimptotik sıralamaya sahip olduğu durumlar için kullanılır.

En sık kullanılan Büyük $O$ üst sınırını tanımlar ve algoritmanın en kötü durumda nasıl çalıştığını anlamada önemlidir.

Sabitler ve küçük terimleri göz ardı etme: Asimptotik tanımlamada, sabit çarpanlar ve düşük dereceli terimler ihmal edilir, çünkü büyük $n$ için en büyük göstergeye sahip fonksiyon baskın gelir. Örneğin, $3n^2 + 5n + 10$ için asimptotik $O(n^2)$ olur.

Tipik asimptotik sınıflar (karmasiklik artış sırasına göre):

$O(1)$: Sabit karmaşıklık (çalışma süresi $n$'den bağımsız).
$O(\log n)$: Logaritmik karmaşıklık (çalışma süresi $n$ ile çok yavaş artar, ikili arama algoritması gibi).
$O(n)$: Doğrusal karmaşıklık (çalışma süresi $n$ ile doğru orantılı, örneğin, basit tarama).
$O(n \log n)$: Doğrusal-logaritmik karmaşıklık (etkili sıralama algoritmaları için, örneğin, Quick Sort veya Merge Sort).
$O(n^2)$: Kare karmaşıklık (çalışma süresi $n^2$ ile artar, örneğin, Bubble Sort gibi basit sıralama algoritmaları için).
$O(n^c)$ (c > 1 için): Polinomiyal karmaşıklık.
$O(c^n)$ (c > 1 için): Üssel karmaşıklık (çalışma süresi çok hızlı artar, örneğin, tüm olası kombinasyonların denenmesi gibi).
$O(n!)$: Faktöriyel karmaşıklık (en yüksek sınıf, çok hızlı artar).

Döngüsel yapılar için asymptotik belirleme:

Sıralı kod blokları: Blokların karmaşıklığı toplanır. $O(A+B) = O(\max(A, B))$.
İç içe döngüler: Döngülerin tekrar sayısı çarpılır. $n$ iterasyonlu döngü içinde başka bir döngü $m$ iterasyon yaparsa, $O(n \times m)$. Eğer $m=n$ ise, $O(n^2)$.
Giriş boyutunu azaltan döngüler: Örneğin, her iterasyonda 2'ye bölme logaritmik karmaşıklığa yol açar ($O(\log n)$).

Örnek:

Basit dizi taraması:

# Temel işlemleri yeniden hesaplama (karşılaştırmalar, atamalar)
# Ana işlem - döngüde karşılaştırma
def find_max(arr):
    if not arr:
        return None
    max_val = arr[0]  # 1 atama (döngü dışında)
    for i in range(1, len(arr)): # $n-1$ kez çalışır
        # Döngü içinde:
        # 1 karşılaştırma (if arr[i] > max_val)
        # muhtemelen 1 atama (max_val = arr[i])
        if arr[i] > max_val:
            max_val = arr[i]
    return max_val

Dizinin boyutu $n = \texttt{len(arr)}$ ise, döngü $n-1$ kez çalışır. Her iterasyonda sabit sayıda işlem yapılır. Toplam işlem sayısı $n$ ile orantılıdır. Asimptotik karmaşıklık: $O(n)$.

Örnek: Eklemeli sıralama (Insertion Sort)

# Temel işlemleri yeniden hesaplama
# Temel işlemler: karşılaştırmalar ve atamalar/hareketler

def insertion_sort(arr):
    # Dış döngü $n-1$ kez çalışır
    for i in range(1, len(arr)):
        key = arr[i] # 1 atama
        j = i - 1 # 1 atama
        # İç döngü en kötü durumda $i$ kez çalışır
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j] # 1 atama (taşıma)
            j -= 1 # 1 çıkarma ve 1 atama
        arr[j + 1] = key # 1 atama

Dış döngü $n-1$ kez çalışır. İç döngü en kötü durumda (dizi ters sıralanmışsa) her sefer $i$ kez çalışır. Tüm dış döngü iterasyonları boyunca iç döngü işlemlerinin toplam sayısı: $1 + 2 + ... + (n-1) \approx n^2/2$. Asimptotik karmaşıklık: $O(n^2)$ en kötü ve ortalama durumlar için, $O(n)$ en iyi durumda (dizi zaten sıralanmış). Bahsetme sırasında genellikle en kötü durum ($Büyük $O$) dikkate alınır.

Hoe evalueer je de complexiteit van een algoritme of bepaal je de asymptoot?