1// Ornek1: Özyineleme (recursion) — kendini çağıran metotlar.
2// Çalıştırma: java Ornek1.java
3import java.util.HashMap;
4import java.util.Map;
5
6public class Ornek1 {
7
8    // Faktöriyel: n! = n * (n-1)!  — taban durum: 0! = 1
9    static long faktoriyel(int n) {
10        if (n <= 1) return 1;          // TABAN DURUM (recursion'ı durdurur)
11        return n * faktoriyel(n - 1);  // ÖZYİNELEMELİ ADIM (probleme daha küçük hali)
12    }
13
14    // Fibonacci (naive): üstel, çok yavaş -> aynı alt problemleri tekrar tekrar hesaplar.
15    static long fibNaive(int n) {
16        if (n < 2) return n;
17        return fibNaive(n - 1) + fibNaive(n - 2);
18    }
19
20    // Fibonacci (memoization): hesaplananı sakla -> doğrusal, hızlı.
21    static long fibMemo(int n, Map<Integer, Long> bellek) {
22        if (n < 2) return n;
23        if (bellek.containsKey(n)) return bellek.get(n);
24        long sonuc = fibMemo(n - 1, bellek) + fibMemo(n - 2, bellek);
25        bellek.put(n, sonuc);
26        return sonuc;
27    }
28
29    public static void main(String[] args) {
30        System.out.println("5! = " + faktoriyel(5));
31        System.out.println("10! = " + faktoriyel(10));
32
33        System.out.println("\nFibonacci(40):");
34        long t1 = System.currentTimeMillis();
35        System.out.println("  naive  = " + fibNaive(40) + "  (~" + (System.currentTimeMillis() - t1) + " ms)");
36        long t2 = System.currentTimeMillis();
37        System.out.println("  memo   = " + fibMemo(40, new HashMap<>()) + "  (~" + (System.currentTimeMillis() - t2) + " ms)");
38
39        System.out.println("""
40
41                --- Özyineleme (recursion) ---
42                Bir metodun kendini çağırmasıdır. İki parçası vardır:
43                  TABAN DURUM: özyinelemeyi durduran koşul (yoksa sonsuz döngü -> StackOverflowError).
44                  ÖZYİNELEMELİ ADIM: problemi daha küçük bir haline indirgeyip kendini çağırma.
45                Naive fibonacci üsteldir (aynı işi tekrar yapar); MEMOIZATION ile doğrusala iner.
46                Özyineleme; ağaç/grafik gezme, böl-ve-fethet, geri izleme (backtracking) için doğaldır.""");
47    }
48}

1// Ornek2: Özyineleme ile ağaç gezme + StackOverflow ve iteratif alternatif.
2// Çalıştırma: java Ornek2.java
3import java.util.ArrayList;
4import java.util.List;
5
6public class Ornek2 {
7
8    // İç içe (ağaç) yapı: bir klasör, alt klasörler ve dosyalar içerir.
9    static class Klasor {
10        String ad;
11        long dosyaBoyutu;
12        List<Klasor> altKlasorler = new ArrayList<>();
13        Klasor(String ad, long boyut) { this.ad = ad; this.dosyaBoyutu = boyut; }
14        Klasor ekle(Klasor k) { altKlasorler.add(k); return this; }
15    }
16
17    // Özyinelemeli toplam: bu klasör + tüm alt klasörlerin boyutu.
18    static long toplamBoyut(Klasor k) {
19        long toplam = k.dosyaBoyutu;
20        for (Klasor alt : k.altKlasorler) {
21            toplam += toplamBoyut(alt);     // her alt klasör için kendini çağır
22        }
23        return toplam;
24    }
25
26    // Özyinelemeli yazdırma (girintiyle ağaç görünümü).
27    static void yazdir(Klasor k, int derinlik) {
28        System.out.println("  ".repeat(derinlik) + "📁 " + k.ad + " (" + k.dosyaBoyutu + ")");
29        for (Klasor alt : k.altKlasorler) yazdir(alt, derinlik + 1);
30    }
31
32    public static void main(String[] args) {
33        Klasor kok = new Klasor("proje", 0)
34                .ekle(new Klasor("src", 100)
35                        .ekle(new Klasor("main", 500))
36                        .ekle(new Klasor("test", 300)))
37                .ekle(new Klasor("docs", 200));
38
39        System.out.println("Klasör ağacı:");
40        yazdir(kok, 0);
41        System.out.println("Toplam boyut: " + toplamBoyut(kok));
42
43        // Derin özyineleme StackOverflowError'a yol açabilir; iteratif çözüm güvenlidir.
44        System.out.println("\nDerin özyineleme riski:");
45        try {
46            sonsuzDerin(0);
47        } catch (StackOverflowError e) {
48            System.out.println("  StackOverflowError yakalandı! Çok derin özyineleme yığını taşırdı.");
49        }
50        // İteratif faktöriyel (özyinelemesiz) — yığın taşma riski yok:
51        long f = 1; for (int i = 1; i <= 20; i++) f *= i;
52        System.out.println("  iteratif 20! = " + f);
53
54        System.out.println("""
55
56                --- Ağaç gezme + özyineleme sınırları ---
57                Özyineleme, iç içe (ağaç/grafik) yapılar için DOĞAL araçtır: her düğüm için kendini çağır.
58                ANCAK her çağrı yığında (stack) yer kaplar; çok derin/sonsuz özyineleme StackOverflowError verir.
59                Java tail-call optimizasyonu YAPMAZ; çok derin durumlarda İTERATİF çözüm (döngü+yığın) tercih edilir.
60                Kural: özyineleme okunabilirlik kazandırır; derinlik kontrol edilemiyorsa iteratif yaz.""");
61    }
62
63    static void sonsuzDerin(int n) { sonsuzDerin(n + 1); } // taban durum YOK -> taşar
64}