C# Recursive (Tekrarlamalı) Metotlar Nedir ve pratik için bol bol örnekler :)

C# programlama dilinde, bir fonksiyonun kendini çağırdığı ve bu işlemin tekrarlandığı bir programlama teknikleri türüne “Recursive Fonksiyonlar” denir. Bu teknik, birçok farklı algoritma ve programlama probleminin çözümünde kullanılabilir. Bu yazıda, C# programlama dili ile recursive fonksiyonlar hakkında detaylı bilgi vereceğiz.

Recursive Fonksiyonların Tanımı

Recursive fonksiyonlar, bir fonksiyonun kendi kendini çağırdığı fonksiyonlardır. Bu, fonksiyonun bir koşul sağlanana kadar kendini tekrar tekrar çağırabileceği anlamına gelir. Bu koşulun sağlandığı durumlarda fonksiyon geri döndürülür ve çağıran fonksiyona geri dönülür.

Recursive Fonksiyonların Özellikleri

Recursive fonksiyonların birkaç önemli özelliği vardır:

• Recursive fonksiyonlar bir koşulu sağlamadıkça kendilerini çağırmaya devam ederler.
• Recursive fonksiyonlar bir koşul sağlandığında sonlandırılırlar ve geri dönüş yaparlar.
• Recursive fonksiyonların kendilerini çağırmaları nedeniyle, bu fonksiyonlar performans açısından biraz yavaş olabilirler. Bu nedenle, bazı durumlarda iterative (yineleyici) fonksiyonlar kullanmak daha avantajlı olabilir.

Recursive Fonksiyonların Kullanım Alanları

Recursive fonksiyonlar, birçok farklı algoritma ve programlama probleminin çözümünde kullanılabilir. Bu özellikle, ağaç yapıları gibi hiyerarşik veri yapıları üzerinde çalışırken önemlidir. Recursive fonksiyonlar, aşağıdaki problemlerin çözümünde sıklıkla kullanılır:

• Faktöriyel hesaplama
• Fibonacci sayıları
• Üst alma
• Hanoi kuleleri
• Ağaç yapıları üzerinde dolaşma
• Derinlik öncelikli arama (DFS)
• Merge sort ve quick sort gibi sıralama algoritmaları

Aşağıda, bir dizindeki tüm dosya adlarını yazdırmak için kullanılabilecek bir C# örneği verilmiştir:

public static void ListFiles(string path)
{
    foreach (string file in Directory.GetFiles(path))
    {
        Console.WriteLine(file);
    }

    foreach (string directory in Directory.GetDirectories(path))
    {
        ListFiles(directory);
    }
}

Bu fonksiyon, parametre olarak verilen dizindeki tüm dosya adlarını yazdırmak için kendisini tekrar çağırır. İlk olarak, dizindeki tüm dosya adları yazdırılır. Ardından, dizindeki tüm alt dizinlerdeki dosya adlarını yazdırmak için her alt dizinde kendisini tekrar çağırır. Bu işlem, tüm alt dizinlerdeki dosya adları yazdırılana kadar devam eder.

Fonksiyonun kullanımı için örnek kod:

string path = @"C:\Users\Username\Desktop\TestFolder";
ListFiles(path);

Bu örnekte, “C:\Users\Username\Desktop\TestFolder” dizinindeki tüm dosya adları yazdırılacaktır.

Burada C# programlama dili ile bazı örnek recursive fonksiyonlara göz atabilirsiniz:

1- Recursive ile iç içe kategori örneği

Konsoldan kategori örneği yapmak için, bir kategori ağacı yapısı oluşturabiliriz. Her kategori, alt kategorilere sahip olabilir. Aşağıda, kategori ağacı yapısı için bir C# sınıfı verilmiştir:

public class Category
{
    public string Name { get; set; }
    public List<Category> Subcategories { get; set; }

    public Category(string name)
    {
        Name = name;
        Subcategories = new List<Category>();
    }

    public void Print(int indent = 0)
    {
        Console.WriteLine(new string(' ', indent) + Name);

        foreach (Category subcategory in Subcategories)
        {
            subcategory.Print(indent + 2);
        }
    }
}

Bu sınıf, bir kategori ismi ve alt kategorilerin listesi içerir. Ayrıca, Print() metodu, kategoriyi ekrana yazdırmak için bir girinti değeri alır.

Kategori ağacını oluşturmak için, kullanıcıdan kategori adları alarak recursive fonksiyon kullanabiliriz. Aşağıdaki örnekte, kullanıcının alt kategoriler ekleyebileceği bir C# konsol uygulaması verilmiştir:

class Program
{
    static void Main(string[] args)
    {
        Category rootCategory = new Category("Root");

        AddSubcategories(rootCategory);

        Console.WriteLine("Kategori Ağacı:");
        rootCategory.Print();
    }

    static void AddSubcategories(Category category)
    {
        Console.WriteLine("'{0}' kategorisi için alt kategori ekleyin (boşlukla ayrılmış):", category.Name);
        string input = Console.ReadLine();

        while (!string.IsNullOrEmpty(input))
        {
            string[] subcategoryNames = input.Split(' ');

            foreach (string subcategoryName in subcategoryNames)
            {
                Category subcategory = new Category(subcategoryName);
                category.Subcategories.Add(subcategory);
                AddSubcategories(subcategory);
            }

            Console.WriteLine("'{0}' kategorisi için alt kategori ekleyin (boşlukla ayrılmış):", category.Name);
            input = Console.ReadLine();
        }
    }
}

Bu örnekte, kullanıcıya ilk olarak “Root” kategorisi için alt kategori eklemesi istenir. Kullanıcı, boşlukla ayrılmış alt kategori adları girdiğinde, her bir alt kategori için bir Category nesnesi oluşturulur ve üst kategoriye eklenir. Ardından, her bir alt kategori için AddSubcategories() metodu recursive olarak çağrılır, böylece kullanıcı alt kategori ağacını istediği kadar derinleştirebilir.

Programın çıktısı, kategori ağacını girintili bir şekilde yazdırır. Örneğin, kullanıcı “Root Category” için “Child Category 1” ve “Child Category 2” alt kategorilerini eklediğinde, program aşağıdaki çıktıyı verir:

Kategori Ağacı:
Root
  Child Category 1
  Child Category 2

2- Fibonacci Sayıları

Fibonacci sayıları, her sayının kendinden önceki iki sayının toplamı olduğu bir dizi sayıdır. Örneğin, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, … şeklinde devam eder. Fibonacci sayılarını recursive fonksiyon ile hesaplamak mümkündür.

 public static int Fibonacci(int n)
{
    if (n <= 1)
    {
        return n;
    }
    else
    {
        return Fibonacci(n - 1) + Fibonacci(n - 2);
    }
}

Bu fonksiyon, özyinelemeli olarak kendisini çağırarak Fibonacci dizisini hesaplar. Fonksiyonun her bir çağrısı, bir önceki iki Fibonacci sayısının toplamını hesaplamak için kendisini tekrar çağırır. Bu fonksiyonun zaman karmaşıklığı O(2^n) şeklindedir, bu nedenle büyük Fibonacci sayıları hesaplanırken performans problemleri oluşabilir.

3- Üst Alma

Üst alma işlemi, bir sayının üssünü hesaplamak için kullanılır. Örneğin, 2⁴ = 2 x 2 x 2 x 2 = 16 şeklinde hesaplanabilir. Üst alma işlemini recursive fonksiyon ile hesaplamak mümkündür.

public static int Power(int x, int y)
{
    if (y == 0)
    {
        return 1;
    }
    else if (y % 2 == 0)
    {
        int result = Power(x, y / 2);
        return result * result;
    }
    else
    {
        int result = Power(x, (y - 1) / 2);
        return result * result * x;
    }
}

Bu fonksiyon, y değerini 2'ye bölerek her adımda hesaplama yapar. Eğer y değeri çift sayı ise, x^y = (x^(y/2))² şeklinde hesaplanır. Eğer y değeri tek sayı ise, x^y = (x^((y-1)/2))² x şeklinde hesaplanır. Bu fonksiyonun zaman karmaşıklığı O(log n) şeklindedir.

4- Ağaç Yapıları Üzerinde Dolaşma

Ağaç yapıları, birçok programlama probleminin çözümünde kullanılır. Ağaç yapısı üzerinde recursive fonksiyon kullanarak dolaşmak mümkündür.

public class TreeNode
{
    public int Value { get; set; }
    public TreeNode Left { get; set; }
    public TreeNode Right { get; set; }
}

public static void TraverseTree(TreeNode node)
{
    if (node == null)
    {
        return;
    }
    TraverseTree(node.Left);
    Console.WriteLine(node.Value);
    TraverseTree(node.Right);
}

Bu fonksiyon, inorder traversal (sola git, düğümü işle, sağa git) algoritmasını kullanarak ağaç yapısı üzerinde dolaşır. Fonksiyonun her çağrısı, sol alt ağacı işlemek için kendisini tekrar çağırır, ardından düğümün değerini yazdırır ve sağ alt ağacı işlemek için kendisini tekrar çağırır.

5- Faktöriyel

Faktöriyel, bir sayının kendisinden önceki tüm pozitif tam sayıların çarpımıdır. Örneğin, 5! = 5 x 4 x 3 x 2 x 1 = 120 şeklinde hesaplanabilir. Faktöriyel hesaplamak için recursive fonksiyon kullanılabilir.

public static int Factorial(int n)
{
    if (n == 0)
    {
        return 1;
    }
    else
    {
        return n * Factorial(n - 1);
    }
}

Bu fonksiyon, n sayısının faktöriyelini hesaplamak için kendisini tekrar çağırır. Fonksiyonun her çağrısı, n sayısını bir azaltarak kendisini tekrar çağırır. Fonksiyonun zaman karmaşıklığı O(n) şeklindedir.