Bölüm 1: Giriş

Algoritmalar
Algoritma nedir?Algoritma türleriZaman karmaşıklığıBüyüme tablosu Asallık testiMatris çarpımıPermütasyon ve FibonacciÖklid algoritması
Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Algoritma

Algoritmanın tanımını ve özelliklerini (girdi, çıktı, açıklık, sonluluk, etkinlik) açıklamak; günlük bir işi algoritma olarak yazmak.

Analiz

Çalışma süresini girdi boyutu n'nin fonksiyonu T(n) olarak ifade etmek; büyüme tablosundan n büyürken sürenin nasıl değiştiğini okumak.

Karmaşıklık örnekleri

Kısa kodların işlem sayısını sayarak karmaşıklık sınıfını (1, n, √n, n³, n!, 2ⁿ) bulmak; belleklemenin üstel süreyi nasıl düşürdüğünü görmek.

Öklid algoritması

EBOB hesabını adım adım izlemek; algoritmanın doğruluğunu ve O(log min(a, b)) süresini gerekçelendirmek.

Algoritma Kavramı

Algoritma Nedir?

  • Bir problemi çözmek veya bir görevi yerine getirmek için izlenen adım adım yönergeler dizisidir.
  • Girdi verileri alınır, işlemler yapılır, çıktı elde edilir.
  • Her adım belirli, açık ve anlaşılır olmalı; algoritma sınırlı sayıda adımda sonlanmalıdır.
Girdi (input)Sıfır veya daha fazla değer dışarıdan alınır.
Çıktı (output)En az bir sonuç üretilir; sonuç girdiyle ilişkilidir.
AçıklıkHer adımın tek bir anlamı vardır; yoruma yer bırakmaz.
SonlulukHer girdi için sonlu sayıda adımdan sonra durur.
EtkinlikHer adım temel ve gerçekten yapılabilir bir işlemdir.
DoğrulukHer geçerli girdi için doğru çıktıyı verir.

Algoritma Kavramı

Günlük Hayattan: Çay Hazırlama Algoritması

Girdi: su, çay yaprakları, şeker (isteğe bağlı), süt (isteğe bağlı)
Çıktı: çay

  1. Suyu kaynat.
  2. Kaynamış suyu demliğe koy.
  3. Demliğin içine çay yapraklarını ekle.
  4. Çayın demlenmesini bekle.
  5. Demlenen çayı fincana süzerek koy.
  6. İsteğe bağlı olarak şeker ve süt ekle.
Sıra önemlidirAdım 2 ile 3'ün yeri değişebilir, ama 1 ile 5'in yeri değişemez: algoritma bir sıralı adımlar listesidir.
Açık mı?"Demlenmesini bekle" ne kadar? Bir bilgisayar için adım şöyle olmalıdır: 10 dakika bekle.
KararAdım 6 bir koşul içerir: "şeker isteniyorsa ekle". Algoritmalar karar noktaları da içerir.

Algoritma Kavramı

Ortalama Bulma: Algoritmadan Koda

AlgoritmaGirdi: Sayı1, Sayı2, Sayı3 · Çıktı: Ortalama
1. Toplam = Sayı1 + Sayı2 + Sayı3
2. Ortalama = Toplam / 3
3. Ortalama değerini ekrana yazdır.

Python

def ortalama_hesapla(sayi1, sayi2, sayi3):
    ortalama = (sayi1 + sayi2 + sayi3) / 3
    return ortalama

sayi1 = float(input("Birinci sayıyı girin: "))
sayi2 = float(input("İkinci sayıyı girin: "))
sayi3 = float(input("Üçüncü sayıyı girin: "))
ort = ortalama_hesapla(sayi1, sayi2, sayi3)
print("Girilen sayıların ortalaması:", ort)

Java

public static void main(String[] args) {
  Scanner giris = new Scanner(System.in);
  System.out.println("Birinci sayıyı girin: ");
  double sayi1 = giris.nextDouble();
  System.out.println("İkinci sayıyı girin: ");
  double sayi2 = giris.nextDouble();
  System.out.println("Üçüncü sayıyı girin: ");
  double sayi3 = giris.nextDouble();
  double ortalama = (sayi1 + sayi2 + sayi3) / 3;
  System.out.println("Sayıların ortalaması: "
                     + ortalama);
}

Aynı algoritma farklı dillerde yazılabilir: algoritma dilden bağımsızdır, program onun bir gerçeklemesidir.

Algoritma Kavramı

Algoritmalar Nerede? Başlıca Türler

SıralamaÖğeleri bir düzene koyar: eklemeli sıralama, birleştirme sıralaması, hızlı sıralama.
AramaBir öğeyi bulur: doğrusal ve ikili arama, hash.
ÇizgeEn kısa yol (Dijkstra), minimum kapsayan ağaç, maksimum akış (Ford–Fulkerson).
Dizgi ve sıkıştırmaMetin arama, trie; dosya boyutunu küçültme: Huffman, gzip.
Tasarım teknikleriBöl ve fethet (birleştirme sıralaması, ikili arama, hızlı üs alma), dinamik programlama, açgözlü, geri izleme, dal sınır.
Rastgele ve yaklaşıkAynı girdide farklı yol izleyebilen rastgele algoritmalar; zor problemlere yaklaşık çözüm.
Deterministik algoritma aynı girdi için her zaman aynı adımları izler ve aynı çıktıyı verir (ör. en büyük öğeyi bulma). Rastgele (randomized) algoritma zar atar: hızlı sıralamada pivotu rastgele seçmek gibi.

Algoritma Analizi

Zaman Karmaşıklığı

  • Algoritma analizi, işlemci zamanı ve bellek gibi kaynakların kullanımını değerlendirir; aynı problemi çözen algoritmalar arasında seçim yapmayı sağlar.
  • Çalışma süresi girdi boyutu n ile ilişkilendirilir: T(n). Saniye değil, temel işlem sayısı sayılır: saniye bilgisayara ve dile göre değişir, işlem sayısı değişmez.

Örnek: n öğeli dizinin toplamı, satır satır sayım

int toplam = 0;                   // 1 kez
for (int i = 0; i < n; i++)       // n+1 karşılaştırma
  toplam += dizi[i];              // n kez
return toplam;                    // 1 kez
Neden önemli?10⁶ öğeli sıralı bir dizide arama: doğrusal arama en kötü 1.000.000, ikili arama en fazla 20 karşılaştırma yapar.
n = 10⁶, en kötü karşılaştırma (log ölçek)doğrusal1.000.000ikili20
T(n) = 1 + (n + 1) + n + 1 = 2n + 3. Sabitler makineye bağlıdır; önemli olan T(n)'nin n ile doğrusal büyümesidir → Θ(n).

Algoritma Analizi

Büyüme Tablosu: n Büyürken

f(n)n = 10n = 100n = 1000n = 10⁶süre (n = 10⁶)
111111 ns
log₂ n3,36,610,019,919,9 ns
√n3,21031,61.0001 µs
n101001.0001.000.0001 ms
n log₂ n33,2664,49.9662,0 · 10⁷19,9 ms
n²10010.0001.000.0001,0 · 10¹²16,7 dk
n³1.0001.000.0001,0 · 10⁹1,0 · 10¹⁸≈ 32 yıl
2ⁿ1.0241,3 · 10³⁰≈ 1,1 · 10³⁰¹≈ 10³⁰¹⁰³⁰evrenin yaşından çok
n!3.628.8009,3 · 10¹⁵⁷≈ 10²⁵⁶⁷≈ 10⁵⁵⁶⁵⁷⁰⁸evrenin yaşından çok
Son sütun: saniyede 10⁹ işlem yapan bir bilgisayarda n = 10⁶ için süre. Daha hızlı bir bilgisayar sabiti küçültür; daha iyi bir algoritma büyüme hızını değiştirir. n² yerine n log n, 10⁶ öğede dakikaları milisaniyelere indirir.

Karmaşıklık Örnekleri

Sabit ve Doğrusal Zaman: O(1), O(n)

İlk öğeyi yazdırma T(n) = O(1)

void ilkElemaniYazdir(int[] dizi) {
  if (dizi.length > 0)
    System.out.println("İlk eleman: "
                     + dizi[0]);
  else
    System.out.println("Dizi boş");
}

Dizi 10 öğeli de olsa 10 milyon öğeli de olsa tek karşılaştırma ve tek erişim yapılır: süre n'den bağımsızdır.

En büyük öğeyi bulma T(n) = O(n)

Integer enBuyukBul(int[] dizi) {
  if (dizi.length == 0)
    return null;            // dizi boşsa
  int enBuyuk = dizi[0];
  for (int eleman : dizi)
    if (eleman > enBuyuk)
      enBuyuk = eleman;
  return enBuyuk;
}

Her öğe bir kez incelenir: n karşılaştırma. Ek bellek O(1). Örnek: [5, 8, 12, 4] → 12.

dizienBuyuk55881212412her öğe bir kez: 4 öğe → 4 adım

Karmaşıklık Örnekleri

Asal Sayı Kontrolü: O(√n)

boolean asalMi(int n) {
  if (n <= 1)
    return false;
  else if (n == 2)
    return true;
  else if (n % 2 == 0)
    return false;
  int kokN = (int) Math.sqrt(n) + 1;
  for (int i = 3; i < kokN; i += 2)
    if (n % i == 0)
      return false;
  return true;
}
Neden √n'ye kadar?n = a · b ise a ve b'den biri √n'den küçük ya da eşittir. √n'ye kadar bölen yoksa n asaldır.
Kaç bölme?Çift sayılar baştan elenir; yalnızca tek i denenir: en fazla ≈ √n / 2 bölme → T(n) = O(√n).

n = 97: i = 3, 5, 7, 9 → 4 bölme (2'den 96'ya denense 95).
n = 1.000.000.007: 15.810 bölme.

Not: burada girdi boyutu n sayısının değeridir. Sayının bit uzunluğu b ise √n = 2b/2: bu yöntem bit sayısına göre üstel büyür.

Karmaşıklık Örnekleri · Kodu adım adım çalıştır

asalMi(97): Adım Adım

2—34—56—78—910—ikalan = 97 % içift i'ler (gri) hiç denenmez

n = 97: 1'den büyük, 2'ye eşit değil ve tek. İlk üç kontrolün hiçbiri sonuç döndürmez; 2'nin katları baştan elenmiş olur.

2—34—56—78—910—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

kokN = (int) √97 + 1 = 9 + 1 = 10. Yalnızca 10'dan küçük tek sayılar denenecek: 3, 5, 7, 9.

2—314—56—78—910—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

i = 3: 97 % 3 = 1 ≠ 0 → 3, 97'yi bölmez. i += 2.

2—314—526—78—910—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

i = 5: 97 % 5 = 2 ≠ 0 → 5, 97'yi bölmez. i += 2.

2—314—526—768—910—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

i = 7: 97 % 7 = 6 ≠ 0 → 7, 97'yi bölmez. i += 2.

2—314—526—768—9710—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

i = 9: 97 % 9 = 7 ≠ 0 → 9, 97'yi bölmez. i += 2. Sıradaki aday i = 11.

2—314—526—768—9710—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

i = 11 < 10 sağlanmaz, döngü biter. √97'ye kadar hiçbir tek sayı 97'yi bölmedi.

2—314—526—768—9710—ikalan = 97 % ikokN = 10√97 ≈ 9,85çift i'ler (gri) hiç denenmez

return true: 97 asaldır. Yalnızca 4 bölme yetti; 2'den 96'ya kadar her sayı denenseydi 95 bölme gerekirdi.

boolean asalMi(int n) {
  if (n <= 1)
    return false;
  else if (n == 2)
    return true;
  else if (n % 2 == 0)
    return false;
  int kokN = (int) Math.sqrt(n) + 1;
  for (int i = 3; i < kokN; i += 2)
    if (n % i == 0)
      return false;
  return true;
}

Karmaşıklık Örnekleri

Kübik Zaman: Matris Çarpımı, Θ(n³)

int[][] matrisCarp(int[][] A, int[][] B) {
  int n = A.length, m = B[0].length, p = B.length;
  int[][] sonuc = new int[n][m];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++) {
      int eleman = 0;
      for (int k = 0; k < p; k++)
        eleman += A[i][k] * B[k][j];
      sonuc[i][j] = eleman;
    }
  return sonuc;
}

Girdi: A = [aᵢⱼ], B = [bᵢⱼ] (n × n). Çıktı: C = [cᵢⱼ] = A · B, i, j = 1, 2, …, n.

Tanımcᵢⱼ = Σk=1..n aᵢₖ · bₖⱼ
12
34
·
56
78
=
1922
4350

c₁₁ = 1·5 + 2·7 = 19. Her cᵢⱼ için n çarpma, n² öğe → n³ çarpma: T(n) = Θ(n³).

Karmaşıklık Örnekleri · Kodu adım adım çalıştır

matrisCarp: 2 × 2 Matrisler Adım Adım

A1234·B5678=sonuc

A ve B 2 × 2: n = m = p = 2. sonuc 2 × 2 sıfır matrisi olarak oluşturulur.

A1234·B5678=sonuceleman = 1·5 = 5

i = 0, j = 0: eleman = 0. k = 0: A[0][0] · B[0][0] = 1 · 5 = 5 eklenir.

A1234·B5678=sonuc19eleman = 5 + 2·7 = 19

k = 1: A[0][1] · B[1][0] = 2 · 7 → eleman = 5 + 14 = 19. İç döngü biter: sonuc[0][0] = 19.

A1234·B5678=sonuc19eleman = 1·6 = 6

i = 0, j = 1: eleman = 0. k = 0: A[0][0] · B[0][1] = 1 · 6 = 6 eklenir.

A1234·B5678=sonuc1922eleman = 6 + 2·8 = 22

k = 1: A[0][1] · B[1][1] = 2 · 8 → eleman = 6 + 16 = 22. İç döngü biter: sonuc[0][1] = 22.

A1234·B5678=sonuc1922eleman = 3·5 = 15

i = 1, j = 0: eleman = 0. k = 0: A[1][0] · B[0][0] = 3 · 5 = 15 eklenir.

A1234·B5678=sonuc192243eleman = 15 + 4·7 = 43

k = 1: A[1][1] · B[1][0] = 4 · 7 → eleman = 15 + 28 = 43. İç döngü biter: sonuc[1][0] = 43.

A1234·B5678=sonuc192243eleman = 3·6 = 18

i = 1, j = 1: eleman = 0. k = 0: A[1][0] · B[0][1] = 3 · 6 = 18 eklenir.

A1234·B5678=sonuc19224350eleman = 18 + 4·8 = 50

k = 1: A[1][1] · B[1][1] = 4 · 8 → eleman = 18 + 32 = 50. İç döngü biter: sonuc[1][1] = 50.

A1234·B5678=sonuc19224350

sonuc = [[19, 22], [43, 50]] döner. 8 = 2³ çarpma: n² öğenin her biri için n çarpma → n³.

int[][] matrisCarp(int[][] A, int[][] B) {
  int n = A.length, m = B[0].length, p = B.length;
  int[][] sonuc = new int[n][m];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++) {
      int eleman = 0;
      for (int k = 0; k < p; k++)
        eleman += A[i][k] * B[k][j];
      sonuc[i][j] = eleman;
    }
  return sonuc;
}

Karmaşıklık Örnekleri

Faktöriyel Zaman: Tüm Permütasyonları Üretme

void permutasyon(int[] dizi, int k) {
  if (k == dizi.length) {          // bir permütasyon hazır
    System.out.println(Arrays.toString(dizi));
    return;
  }
  for (int i = k; i < dizi.length; i++) {
    takas(dizi, k, i);             // i. elemanı k. konuma al
    permutasyon(dizi, k + 1);      // geri kalanları diz
    takas(dizi, k, i);             // eski hâline getir
  }
}

[1, 2, 3] → 123, 132, 213, 231, 321, 312. İlk konum için n, ikinci için n−1, … seçenek: n · (n−1) · … · 1 = n! permütasyon.

nn!
36
5120
103.628.800
151,3 · 10¹²
202,4 · 10¹⁸

Her permütasyonu yazmak n adım sürer: toplam Θ(n · n!), kısaca "O(n!) sınıfı". n = 20 bile pratikte imkânsızdır.

Karmaşıklık Örnekleri

Üstel Zaman: Fibonacci Serisi

long fib(int n) {           // saf özyineleme
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}

long[] bellek = new long[N + 1]; // 0: yok
long fibBellek(int n) {     // bellekleme
  if (n <= 1) return n;
  if (bellek[n] == 0)
    bellek[n] = fibBellek(n - 1) + fibBellek(n - 2);
  return bellek[n];
}

F(0) = 0, F(1) = 1, F(n) = F(n−1) + F(n−2).
fib: her çağrı iki çağrı doğurur → O(2ⁿ) (kesin olarak Θ(1,618ⁿ)); fib(30) 2.692.537 çağrı yapar.
fibBellek: her F(k) bir kez hesaplanır, 2n − 1 çağrı → O(n); n = 30 için 59 çağrı.

f5f4f3f2f1f0f1f2f1f0f3f2f1f0f1

Saf özyineleme: 15 çağrı. f3 iki kez, f2 üç kez, f1 beş kez hesaplanır; ağaç her düzeyde yaklaşık ikiye katlanır → üstel büyüme.

f5f4f3f2f1f0f1f2f3

Belleklemeli: 9 çağrı. Turuncu kesikli düğümler (f2, f3) bellek dizisinden hazır döner, alt ağaçları hiç açılmaz → O(n).

Öklid Algoritması

Öklid Algoritması (EBOB)

  • En büyük ortak böleni (EBOB, gcd) bulur.
  • Bilinen en eski algoritmalardan biridir (Öklid, MÖ ~300); en basit EBOB yöntemi.
  • Temel fikir: ebob(a, b) = ebob(b, a mod b), ebob(a, 0) = a.
  1. Adım 1: büyük sayıyı küçüğe böl, kalanı al.
  2. Adım 2: kalan sıfır olana kadar (bölen, kalan) çiftiyle tekrarla.
  3. Adım 3: kalan sıfır olduğunda son bölen EBOB'dur.
int ebob(int a, int b) {
  if (b == 0)
    return a;
  return ebob(b, a % b);
}
Neden doğru?a = q·b + r ise a ile b'yi bölen her sayı r = a − q·b'yi de böler; b ile r'yi bölen her sayı a'yı da böler. Ortak bölenler aynıdır.

Öklid Algoritması · Kodu adım adım çalıştır

ebob(1599, 650): Adım Adım

6506502991599 × 650 dikdörtgen

1599 = 2 · 650 + 299. 1599×650 dikdörtgenden 2 kare kesilir, kalan şerit 650×299 → ebob(650, 299).

29929952650 × 299 dikdörtgen

650 = 2 · 299 + 52. 650×299 dikdörtgenden 2 kare kesilir, kalan şerit 299×52 → ebob(299, 52).

525252525239299 × 52 dikdörtgen

299 = 5 · 52 + 39. 299×52 dikdörtgenden 5 kare kesilir, kalan şerit 52×39 → ebob(52, 39).

391352 × 39 dikdörtgen

52 = 1 · 39 + 13. 52×39 dikdörtgenden 1 kare kesilir, kalan şerit 39×13 → ebob(39, 13).

13131339 × 13 dikdörtgen

39 = 3 · 13 + 0. 39×13 dikdörtgenden 3 kare kesilir, kalan şerit 13×0 → ebob(13, 0).

ebob(13, 0) = 13

b == 0 → return 13. 13, 1599 ile 650'yi tam bölen en büyük sayıdır.

6506502991599 × 650 dikdörtgen

Dönüş değeri 13 tüm çağrılardan aynen geri döner: ebob(1599, 650) = 13. 5 bölme yetti. 13 × 13'lük kareler 1599 × 650'yi tam döşer.

int ebob(int a, int b) {
  if (b == 0)
    return a;
  return ebob(b, a % b);
}

Öklid Algoritması

Öklid Algoritması: Neden Hızlı?

  • Verimli ve hızlı çalışır: her iki adımda büyük sayı en az yarıya iner (a mod b < a/2).
  • Bu yüzden adım sayısı en fazla ≈ 2 log₂ min(a, b): O(log min(a, b)).
  • En kötü senaryo ardışık Fibonacci sayılarıyla oluşur: her bölümde q = 1 çıkar, sayılar en yavaş küçülür (Lamé teoremi).
  • Karşılaştırma: 1'den min(a, b)'ye kadar tüm bölenleri denemek O(min(a, b)) sürer.
En kötü örnek: ebob(55, 34)55 = 1 · 34 + 21
34 = 1 · 21 + 13
21 = 1 · 13 + 8
13 = 1 · 8 + 5
8 = 1 · 5 + 3
5 = 1 · 3 + 2
3 = 1 · 2 + 1
2 = 2 · 1 + 0

8 bölme, EBOB = 1. ebob(1599, 650) ise yalnızca 5 bölme yapar.

Özet

Özet

KonuHatırlanacaklar
Algoritmagirdi → açık, sonlu, etkin adımlar → çıktı; dilden bağımsızdır
AnalizT(n): girdi boyutuna göre temel işlem sayısı; zaman ve bellek
Büyüme1 < log n < √n < n < n log n < n² < n³ < 2ⁿ < n!; daha iyi algoritma büyüme hızını değiştirir
Örneklerilk öğe O(1), en büyük öğe O(n), asallık O(√n), matris çarpımı Θ(n³), permütasyonlar O(n!), saf Fibonacci O(2ⁿ)
Belleklemeaynı alt problemi saklamak Fibonacci'yi O(2ⁿ)'den O(n)'ye indirir
Öklidebob(a, b) = ebob(b, a mod b); O(log min(a, b)); en kötü: ardışık Fibonacci

Özet

Etkileşimli Simülatörler

Algoritma Karmaşıklığı AnaliziO(log n), O(n), O(n log n), O(n²) ve O(n³) örnek JavaScript fonksiyonları ya da yeni bir fonksiyon; beş farklı girdi boyutunda tarayıcıda ölçülen sürelerin grafikte karşılaştırması.

Özet

Sık Yapılan Hatalar

Süreyi saniyeyle ölçmekSaniye makineye bağlıdır; analizde n'ye bağlı işlem sayısı ve büyüme hızı kullanılır.
Belleklemeyi unutmakSaf özyinelemeli Fibonacci O(2ⁿ)'dir; aynı alt problemi saklamak onu O(n)'ye indirir.
√n sınırını eksik kurmaki < (int) Math.sqrt(n) yazılırsa √n'nin kendisi denenmez: 9, 25, 49 gibi kare sayılar asal çıkar.
Girdi boyutunu karıştırmakAsallık testinde n sayının değeridir; b bitlik bir sayı için √n = 2b/2, yani bit sayısına göre üstel süre.
Matris çarpımını n² sanmakSonuçta n² öğe vardır, ama her öğe n çarpma ister: toplam n³ çarpma.
Takası geri almamakPermütasyon üretiminde ikinci takas unutulursa dizi bozulur: [1, 2, 3] için aynı permütasyonlar tekrarlanır, bazıları hiç üretilmez.

Özet

Örnek Problemler

  1. asalMi(221) çağrısında döngüde hangi i değerleri denenir, kaç bölme yapılır, sonuç nedir?
  2. T(n) = 5n² + 100n log₂ n + 7 için Θ sınıfını yazın. n = 1000'de hangi terim baskındır?
  3. İki 3 × 3 matris matrisCarp ile çarpılırken kaç çarpma yapılır? n = 100 için?
  4. permutasyon([1, 2, 3, 4], 0) kaç satır yazdırır? İlk iki satır nedir?
  5. ebob(252, 105)'i Öklid algoritmasıyla bulun.
Cevapları göster
  1. (int) √221 = 14 → kokN = 15; i = 3, 5, 7, 9, 11, 13. 221 % 13 = 0 → false, 6 bölme (221 = 13 · 17).
  2. Θ(n²). n = 1000: 5n² = 5.000.000, 100n log₂ n ≈ 996.578 → 5n² baskın.
  3. Her cᵢⱼ için 3 çarpma, 9 öğe → 27 çarpma (n³). n = 100 → 10⁶ çarpma.
  4. 4! = 24 satır; ilk ikisi [1, 2, 3, 4] ve [1, 2, 4, 3].
  5. 252 = 2·105 + 42; 105 = 2·42 + 21; 42 = 2·21 + 0 → EBOB = 21.

Özet

Alıştırmalar

  1. Bir dizide verilen bir sayının kaç kez geçtiğini bulan algoritmayı yazın; zaman ve alan karmaşıklığını verin.
  2. İç içe döngüler: for i in 0..n-1: for j in i..n-1: işlem kaç kez çalışır? Sınıfı nedir?
  3. enBuyukBul'u dizinin hem en küçük hem en büyük öğesini döndürecek biçimde değiştirin. Kaç karşılaştırma yapar?
  4. Öklid algoritmasını döngüyle (özyinelemesiz) yazın.
  5. Saniyede 10⁹ işlemle 1 saniyede çözülebilecek en büyük n: f(n) = n² ve f(n) = 2ⁿ için bulun.
  6. while (n > 1) n = n / 2; döngüsü kaç kez döner?
Cevaplar / ipuçları
  1. Tek geçiş, sayaç: zaman Θ(n), ek bellek O(1).
  2. n + (n−1) + … + 1 = n(n+1)/2 → Θ(n²).
  3. Her öğe iki kez karşılaştırılırsa 2(n − 1); öğeler çiftler hâlinde işlenirse (önce çift kendi içinde, sonra küçüğü en küçükle, büyüğü en büyükle) ≈ 3n/2. İkisi de Θ(n).
  4. while (b != 0) { int r = a % b; a = b; b = r; } return a;
  5. n² ≤ 10⁹ → n ≈ 31.622; 2ⁿ ≤ 10⁹ → n = 29.
  6. ⌊log₂ n⌋ kez → Θ(log n).

Özet

Kaynaklar

  • Cormen, Leiserson, Rivest ve Stein, Introduction to Algorithms, 4. baskı, MIT Press, 2022 (Bölüm 1–3).
  • Sedgewick ve Wayne, Algorithms, 4. baskı, Addison-Wesley, 2011 (Bölüm 1.4: Analysis of Algorithms).
  • D. E. Knuth, The Art of Computer Programming, Vol. 1: Fundamental Algorithms, 3. baskı, 1997 (algoritmanın özellikleri; Öklid).
  • J. Kleinberg ve É. Tardos, Algorithm Design, Pearson, 2005 (Bölüm 2: Basics of Algorithm Analysis).

Son

Bölüm 1: Giriş
Sonraki bölüm: Bölüm 2: Algoritma Karmaşıklığı · Terim sözlüğü
1 / 1 Sercan KÜLCÜ, Tüm hakları saklıdır.