int toplam(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n + toplam(n - 1);
    }
}

1'den n'ye kadar sayıların toplamı: toplam(n) = n + toplam(n − 1), toplam(1) = 1.

toplam(5) = 5 + toplam(4)
          = 5 + (4 + (3 + (2 + toplam(1))))
          = 5 + (4 + (3 + (2 + 1)))
          = 15

Faktöriyelle aynı kalıp; yalnızca × yerine + ve taban durum farklı. toplam(100) = 5050.

Güvenli sürümde taban durum if (n <= 0) return 0; olur; tüm geçersiz girdiler de yakalanır.

public class Toplam {
    static int toplam(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + toplam(n - 1);   // satır 6
        }
    }
    public static void main(String[] args) {
        System.out.println(toplam(0));
    }
}

Exception in thread "main" java.lang.StackOverflowError
	at Toplam.toplam(Toplam.java:6)
	at Toplam.toplam(Toplam.java:6)
	at Toplam.toplam(Toplam.java:6)
	...

toplam(0): n = 0, −1, −2, … hiçbir zaman 1 olmaz. Her çağrı yeni bir çerçeve açar; yaklaşık on binlerce çağrıdan sonra yığın dolar ve JVM programı durdurur.

Derleyici bu hatayı yakalamaz; çalışma zamanında ortaya çıkar. Yığın izindeki (stack trace) aynı satırın tekrar tekrar görünmesi sonsuz özyinelemenin işaretidir.

Çözüm: taban durumu genişletmek (n <= 1), girdiyi denetlemek ya da derinliği çok büyük olan problemlerde döngüye geçmek.

int rakamlarToplami(int n) {
    if (n < 0) {
        return rakamlarToplami(-n);
    } else if (n < 10) {
        return n;
    } else {
        return rakamlarToplami(n / 10) + (n % 10);
    }
}

• Negatif sayı önce pozitife çevrilir (satır 2–3).
• Tek basamaklı sayı kendisidir: taban durum (satır 4–5).
• Aksi halde: son basamak + kalan basamakların toplamı.

n / 10 tam sayı bölmesi son basamağı atar; n % 10 son basamağı verir. Her çağrıda sayı bir basamak kısalır → ilerleme garantilidir.

static int gcd(int x, int y) {
    if (y == 0) {
        return x;
    }
    return gcd(y, x % y);
}

• Öklid algoritması: EBOB(x, y) = EBOB(y, x mod y).
• Taban durum: y = 0 ise EBOB = x.
• Kalan her adımda küçülür → mutlaka 0'a ulaşır.
• gcd(93, 444): ilk adım gcd(444, 93) olur; sıra önemsizdir.

gcd(444, 93)
  = gcd(93, 72)     // 444 % 93 = 72
  = gcd(72, 21)     // 93 % 72 = 21
  = gcd(21, 9)      // 72 % 21 = 9
  = gcd(9, 3)       // 21 % 9 = 3
  = gcd(3, 0)       // 9 % 3 = 0
  = 3

gcd (greatest common divisor) = EBOB. gcd(48, 18) → 6.

Özyinelemeli

int faktoriyel(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        return n * faktoriyel(n - 1);
    }
}

İlerlemeli (döngü)

int faktoriyel(int n) {
    int carpim = 1;
    for (int i = 1; i <= n; i++) {
        carpim *= i;
    }
    return carpim;
}

Rakamlar toplamı

int rakamlarToplami(int n) {
    int toplam = 0;
    int kalan = Math.abs(n);
    while (kalan > 0) {
        toplam += kalan % 10;
        kalan /= 10;
    }
    return toplam;
}

rakamlarToplami(-48729) → 30: özyinelemeli sürümle aynı. Rakamların toplamı negatif olamaz; işaret yalnızca Math.abs ile atılır.

Palindrom

boolean palindromMu(String s) {
    s = s.toLowerCase();
    int uzunluk = s.length();
    for (int i = 0; i < uzunluk / 2; i++) {
        if (s.charAt(i) != s.charAt(uzunluk - 1 - i)) {
            return false;
        }
    }
    return true;
}

i baştan, uzunluk − 1 − i sondan ilerler. toLowerCase() sayesinde "Kayak" → true.

• Metodun son işlemi özyinelemeli çağrının kendisidir; dönüşte yapılacak iş kalmaz.
• Sonuç, ek bir biriktirici (accumulator) parametrede taşınır.
• Bu biçim, derleyicinin kuyruk çağrısı optimizasyonu (TCO) yapmasını mümkün kılar: çağrı bir döngü gibi işlenir, çerçeveler yığılmaz → bellek verimliliği.
• Java (JVM) bu optimizasyonu yapmaz: kuyruk özyinelemeli Java kodu yine O(n) yığın kullanır. Scheme, Scala (@tailrec), Kotlin (tailrec) gibi dillerde yapılır.

Kuyruk özyinelemeli değil

return n * faktoriyel(n - 1);
// çağrı döndükten SONRA çarpma var

Kuyruk özyinelemeli

return faktoriyel(n - 1, n * birikim);
// çarpma çağrıdan ÖNCE; son iş çağrı

• Tekrarlanan hesaplamaların sonuçlarını saklayıp yeniden kullanma yöntemidir (durum bilgisi taşıma).
• Sonuçlar bir önbelleğe (Map) alınır; aynı argüman tekrar gelince hesaplamadan döndürülür.
• Her n için hesap bir kez yapılır: üstel çağrı sayısı doğrusala iner.
• Map<Integer, Long>: anahtar n, değer F(n).

fibonacci(90) → 2880067194370816120 (anında).

• Aynı kalıp: önce belleğe bak, yoksa hesapla, sakla, döndür.
• long ile 20!'e kadar doğru: faktoriyel(20) = 2432902008176640000.
• Tek bir faktoriyel(n) çağrısında tekrar yoktur; bellek bu çağrıyı hızlandırmaz.
• Kazanç, program birçok kez faktöriyel istediğinde ortaya çıkar: faktoriyel(10)'dan sonra faktoriyel(12) yalnızca 2 yeni çarpma yapar.
• Bedel: bellek. Bellekleme, hız için bellek harcamaktır.