Giriş

Öğrenme Çıktıları

Derse Giriş · kitaplarda yazmaz!

Ders Kitapları ve Kaynaklar

Aynı kitabın üç sürümü: içerik hemen hemen aynı, yalnızca kodların dili değişiyor.

Ek kaynaklar: Cormen ve diğ. (CLRS) Introduction to Algorithms; Sedgewick, Algorithms in C.

Derse Giriş · Okuma parçası

Okuma Parçası: Meslek Sevgisi

“Bir ömür mutlu olmanın yolu, işini sevmektir.” — Çin atasözü

Temeller

Sistem Yaşam Döngüsü (System Life Cycle)

Yazılımlar, aşamaları aşağıdaki gibi olan bir süreçten geçer:

Horowitz–Sahni, Bölüm 1

Temeller

Çözümleme: Aşağıdan Yukarı mı, Yukarıdan Aşağı mı?

Temeller

Kodlama ve Doğrulama

Temeller

Algoritma Nedir?

Algoritma, belirli bir görevi yerine getiren sonlu sayıda komut dizisidir. Her algoritma şu ölçütleri sağlamalıdır:

Horowitz–Sahni, Bölüm 1

Temeller

Soyut Veri Tipi (Abstract Data Type)

Veri tipi = nesneler + işlemler. ADT: nesnelerin ve işlemlerin belirtiminin (specification), gösterimden ve gerçeklemeden (implementation) ayrıldığı veri tipi.

ADT Kesir
  nesneler: pay/payda, payda ≠ 0
  işlemler:
    olustur(p, q)  → Kesir   /* kurucu */
    topla(a, b)    → Kesir   /* dönüştürücü */
    esit(a, b)     → Boolean /* gözlemci */
    yaz(a)                   /* raporlayıcı */
    sil(a)

Horowitz–Sahni, Bölüm 1.3

Temeller

C’de Soyutlama: Başlık Dosyası + struct

/* kesir.h : arayuz (NE?) */
#ifndef KESIR_H
#define KESIR_H
typedef struct kesir Kesir; /* opak */

Kesir *kesir_olustur(int pay, int payda);
Kesir *kesir_topla(const Kesir *a,
                   const Kesir *b);
int  kesir_esit(const Kesir *a,
                const Kesir *b);
void kesir_yaz(const Kesir *k);
void kesir_sil(Kesir *k);
#endif

/* kesir.c : gercekleme (NASIL?) */
#include <stdio.h>
#include <stdlib.h>
#include "kesir.h"

struct kesir { int pay, payda; };

Kesir *kesir_olustur(int pay, int payda) {
  Kesir *k;
  if (payda == 0) return NULL;
  k = malloc(sizeof *k);
  if (k == NULL) return NULL;
  k->pay = pay;
  k->payda = payda;
  return k;
}

Temeller

Gerçeklemenin Kalanı ve Kullanımı

Kesir *kesir_topla(const Kesir *a,
                   const Kesir *b) {
  return kesir_olustur(
      a->pay * b->payda
        + b->pay * a->payda,
      a->payda * b->payda);
}
int kesir_esit(const Kesir *a,
               const Kesir *b) {
  return a->pay * b->payda
      == b->pay * a->payda;
}
void kesir_yaz(const Kesir *k) {
  printf("%d/%d\n", k->pay, k->payda);
}
void kesir_sil(Kesir *k) { free(k); }

/* main.c : yalnizca arayuzu bilir */
#include "kesir.h"
#include <stddef.h> /* NULL */
int main(void) {
  Kesir *a = kesir_olustur(1, 2);
  Kesir *b = kesir_olustur(1, 3);
  Kesir *t = NULL;
  if (a && b) t = kesir_topla(a, b);
  if (t) kesir_yaz(t);  /* 5/6 */
  kesir_sil(a); kesir_sil(b);
  kesir_sil(t);  /* free(NULL) zararsiz */
  return 0;
}

Seçimli Sıralama

Seçimli Sıralama (Selection Sort)

Sıralı olmayan bir diziyi küçükten büyüğe sıralamak istiyoruz. Her turda kalan kısmın en küçüğü bulunur ve başa (i. konuma) taşınır:

for (i = 0; i < n; i++) {
    list[i] .. list[n-1] arasini incele;
    en kucuk tamsayi list[min] olsun;
    list[i] ile list[min]'i takas et;
}

Seçimli Sıralama

Seçimli Sıralama: C Gerçeklemesi

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 101
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))
void sort(int list[], int n);

int main(void) {
  int i, n, list[MAX_SIZE];
  printf("Dizi boyunu giriniz: ");
  if (scanf("%d", &n) != 1 || n < 1 || n > MAX_SIZE) {
    printf("Hatali n degeri!\n");
    return 1;
  }
  for (i = 0; i < n; i++) list[i] = rand() % 100;
  sort(list, n);
  for (i = 0; i < n; i++) printf("%d ", list[i]);
  return 0;
}

void sort(int list[], int n) {
  int i, j, min, temp;
  for (i = 0; i < n - 1; i++) {
    min = i;
    for (j = i + 1; j < n; j++)
      if (list[j] < list[min])
        min = j;
    SWAP(list[i], list[min], temp);
  }
}

Seçimli Sıralama · Sık yapılan hata

Sık Görülen Hatalı sort() Nerede Ayrılıyor?

void sort(int list[], int n) {
  int i, j, min, temp;
  for (i = 0; i < n; i++) {
    min = i;
    for (j = 0; j < n; j++)
      if (list[j] > list[min]) {
        min = j;
        SWAP(list[i], list[min], temp);
      }
  }
}

Seçimli Sıralama

SWAP: Makro mu, Fonksiyon mu?

#define SWAP(x, y, t) \
        ((t) = (x), (x) = (y), (y) = (t))

int temp;
SWAP(list[i], list[min], temp);

void swap(int *x, int *y) {
  int temp = *x;
  *x = *y;
  *y = temp;
}

swap(&list[i], &list[min]);

Seçimli Sıralama · Kodu adım adım çalıştır

Kod İzleme: swap(&a, &b)

void swap(int *x, int *y) {
  int temp = *x;
  *x = *y;
  *y = temp;
}

int main(void) {
  int a = 3, b = 8;
  swap(&a, &b);
  printf("%d %d\n", a, b);
}

Performans Analizi

Bir Programı Nasıl Değerlendiririz?

Performans Analizi

Alan Karmaşıklığı (Space Complexity)

Programın işini tamamlaması için gereken bellek miktarı: S(P) = c + S_P(I)

float abc(float a, float b, float c) {
  return a + b + b * c
         + (a + b - c) / (a + b) + 4.00;
}
/* yalniz sabit bellek: S_abc(I) = 0 */

Performans Analizi

sum ve rsum: Değişken Bellek

float sum(float list[], int n) {
  float tempsum = 0;
  int i;
  for (i = 0; i < n; i++)
    tempsum += list[i];
  return tempsum;
}

float rsum(float list[], int n) {
  if (n)
    return rsum(list, n - 1) + list[n - 1];
  return 0;
}

Performans Analizi

Zaman Karmaşıklığı (Time Complexity)

T(P) = derleme zamanı + işletim zamanı. Derleme bir kez yapılır; biz işletim zamanı t_P ile ilgileniriz.

Performans Analizi

Adım Sayma Tablosu: sum()

Performans Analizi · Kodu adım adım çalıştır

Kod İzleme: count ile sum(list, 3)

float sum(float list[], int n) {
  float tempsum = 0; count++;
  int i;
  for (i = 0; i < n; i++) {
    count++;             /* for testi */
    tempsum += list[i]; count++;
  }
  count++;  /* for'un son testi */
  count++;  return tempsum;
}

Performans Analizi

Adım Sayma Tablosu: rsum()

Performans Analizi · Kodu adım adım çalıştır

Kod İzleme: rsum(list, 3) ve çağrı yığını

float rsum(float list[], int n) {
  count++;               /* if testi */
  if (n) {
    count++;             /* toplama + return */
    return rsum(list, n - 1) + list[n - 1];
  }
  count++;
  return 0;
}

Performans Analizi

Adım Sayma: Matris Toplama add()

“O(rows, cols)” yazmak yanlıştır; doğrusu çarpım: O(rows·cols).

Performans Analizi

En İyi, Ortalama ve En Kötü Durum

Aynı n için adım sayısı girdinin kendisine de bağlı olabilir. Doğrusal aramada:

CLRS Bölüm 2.2

Asimptotik Gösterim

Büyük O (Big-O) Gösterimi

O bir üst sınırdır; “=” burada “elemanıdır” anlamında tek yönlü okunur.

Asimptotik Gösterim

Örnek: f(n) = 3n³ + 6n² + 7n = O(n³)

Asimptotik Gösterim

Alt Sınır Ω ve Sıkı Sınır Θ

• 3n + 2 = Θ(n): n ≥ 2 için 3n ≤ 3n + 2 ≤ 4n.
• 3n + 2 = O(n²) de doğrudur ama bilgi vermez; mümkün olan en küçük g(n)’yi yazarız.
• Seçimli sıralama her girdide n(n−1)/2 karşılaştırma yapar → Θ(n²).

Asimptotik Gösterim

Alışılmış Karmaşıklıklar (Practical Complexities)

Asimptotik Gösterim

n Büyüdükçe: Büyüme Grafiği

Asimptotik Gösterim

Saniyede 1 Milyar Komut İşleyen Makinede Süreler

Her adım 1 ns kabul edildi; 1 yıl = 365 gün, 1 ay = 30 gün. n = 10000 için 2ⁿ yaklaşık 10²⁹⁹² asır.

Asimptotik Gösterim

Amortize Analize Kısa Giriş

Bazı işlemler bazen pahalı, çoğunlukla ucuzdur. Amortize analiz, n işlemlik bir dizinin toplam maliyetini n’e böler. Örnek: doluysa kapasitesi ikiye katlanan dizi (realloc); bu dizinin adım adım izlemesi ve kopya sayımı dinamik dizilerle birlikte işlenir.

CLRS 3. baskı, Bölüm 17 (Amortized Analysis)

Sihirli Kare

Sihirli Kare (Magic Square) Problemi

Sihirli Kare

“Bilgisayar Hızlı, Hemen Çözer!” mi?

Hesap: 25! / (10¹⁰ · 3,15·10⁹) ≈ 4,9·10⁵ asır.

Sihirli Kare · Kodu adım adım çalıştır

Kod İzleme: sihirli(3, k)

void sihirli(int n, int k[][MAX]) {
  int i = 0, j = (n - 1) / 2, s, r, c;
  k[i][j] = 1;        /* k sifirlanmis olmali */
  for (s = 2; s <= n * n; s++) {
    r = (i - 1 < 0) ? n - 1 : i - 1; /* yukari */
    c = (j - 1 < 0) ? n - 1 : j - 1; /* sol */
    if (k[r][c]) i = (i + 1) % n; /* in */
    else { i = r; j = c; }
    k[i][j] = s;
  }
}

Performans Ölçümü

Performans Ölçümü: İki Yöntem

Performans Ölçümü

Uygulama 1: Seçimli Sıralamayı Ölçmek

#include <stdio.h>
#include <time.h>
#define MAX_SIZE 5001
#define ITERATIONS 20
void sort(int list[], int n);   /* secmeli siralama */

int main(void) {
  int i, j, list[MAX_SIZE];
  int sizelist[] = { 0, 100, 300, 600, 900, 1200, 1500, 2000,
    3000, 3100, 3200, 3300, 3400, 3500, 3600, 3700, 3800,
    3900, 4000, 5000 };
  clock_t start, stop;  double ms;
  for (i = 0; i < ITERATIONS; i++) {
    for (j = 0; j < sizelist[i]; j++)
      list[j] = sizelist[i] - j;   /* azalan dizi */
    start = clock();
    sort(list, sizelist[i]);
    stop = clock();
    ms = 1000.0 * (stop - start) / CLOCKS_PER_SEC;
    printf("%4d eleman: %6.1f ms\n", sizelist[i], ms);
  }
  return 0;
}

Performans Ölçümü

Ölçüm Sonuçları ve Tutarsızlıklar

Performans Ölçümü

Uygulama 2: Doğrusal Arama (Bekçi ile)

int seqsearch(int list[], int searchnum, int n) {
  int i;
  list[n] = searchnum;          /* bekci */
  for (i = 0; list[i] != searchnum; i++)
    ;
  return (i < n) ? i : -1;
}

start = clock();
for (j = 0; j < runtimes[i]; j++)
  pos = seqsearch(list, -1, sizelist[i]);
stop = clock();
total = 1000.0 * (stop - start) / CLOCKS_PER_SEC;
ort = 1000.0 * total / runtimes[i];  /* mikro sn */
list[sizelist[i]] = sizelist[i];  /* bekciyi sil */

Performans Ölçümü · Kodu adım adım çalıştır

Kod İzleme: seqsearch({4, 8, 2}, 5, 3)

int seqsearch(int list[], int searchnum, int n) {
  int i;
  list[n] = searchnum;          /* bekci */
  for (i = 0; list[i] != searchnum; i++)
    ;
  return (i < n) ? i : -1;
}

Performans Ölçümü

Tekrarlı Ölçüm: Ortalama Arama Süresi

Ödevler

Ödev Soruları (Özyineleme)

1. n! değerini bulan fonksiyonu özyinelemeli olarak yazınız.
2. Fibonacci serisi f₀ = 0, f₁ = 1, fᵢ = fᵢ₋₁ + fᵢ₋₂ (i > 1) ise fᵢ’yi bulan özyinelemeli yordamı yazınız.
3. C(n, m) = C(n−1, m) + C(n−1, m−1) verildiğine göre C(n, m) = n! / (m!·(n−m)!) değerini hesaplayan özyinelemeli yordamı yazınız.

Ödevler

Ödev Cevapları ve Sık Hatalar

long fakt(long n) {
  if (n <= 1) return 1;
  return n * fakt(n - 1);
}

long fibo(long n) {
  if (n <= 1) return n;   /* f0 = 0, f1 = 1 */
  return fibo(n - 1) + fibo(n - 2);
}

long komb(int n, int m) {
  if (m == 0 || m == n) return 1;
  return komb(n - 1, m) + komb(n - 1, m - 1);
}

Özet

Karmaşıklık Özeti

Özet

Sık Yapılan Hatalar

Özet

Alıştırmalar

1. for (i = 0; i < n; i++) for (j = 0; j < i; j++) x++; parçasında x++ kaç kez işletilir? O(?)
2. 10n² + 100n + 1000 = O(n²) olduğunu c ve n₀ vererek gösteriniz.
3. Seçimli sıralama zaten sıralı bir dizide kaç karşılaştırma yapar? En iyi durumu var mı?
4. O(n log n) bir algoritma n = 1000’de 10 ms sürüyorsa n = 10⁶’da yaklaşık ne kadar sürer?
5. rsum’u n = 10⁶ ile çağırmak neden tehlikelidir?
6. 7×7 sihirli karede ilk satırı Coxeter kuralıyla yazınız (toplam kaç olmalı?).

Özet

Bölüm Özeti

Özet

Kaynaklar

• Horowitz, Sahni, Anderson-Freed, Fundamentals of Data Structures in C, 2. baskı, Bölüm 1.
• Cormen, Leiserson, Rivest, Stein, Introduction to Algorithms, 3. baskı: Bölüm 2–3 (analiz, asimptotik), Bölüm 17 (amortize).
• Kernighan, Ritchie, The C Programming Language, 2. baskı.