C Sharp C# Alqoritmlər və analizi

1. Alqoritmlərin Təhlili və Əsas Xüsusiyyətləri​

Vaxt Təsiri (Time Complexity):​

• O(1) – Sabit vaxt (alqoritm verilənlərdən asılı olmayaraq eyni vaxtda işləyir).
• O(n) – Doğru vaxt (verilənlərin ölçüsünə görə vaxt artır).
• O(n^2) – Kvadrat vaxt (ikiqat dövr strukturunda işləyən alqoritmlər üçün).

Yer Təsiri (Space Complexity):​

2. C#-da Ən Çox İstifadə Edilən Alqoritmlər​

A) Sıralama Alqoritmləri​

1. Bubble Sort (Baloncuk sıralaması)
   • Vaxt Təsiri: O(n²)
   • Yaddaş Təsiri: O(1)
   • İstifadə: Sadə və başa düşülən, amma effektiv olmayan sıralama metodudur.

void BubbleSort(int[] arr)
{
    int n = arr.Length;
    for (int i = 0; i < n-1; i++)
    {
        for (int j = 0; j < n-i-1; j++)
        {
            if (arr[j] > arr[j+1])
            {
                // Swap arr[j] və arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

1. Quick Sort (Tez sıralama)
   • Vaxt Təsiri: O(n log n) (orta halda)
   • Yaddaş Təsiri: O(log n)
   • İstifadə: Böyük verilənlər üçün daha sürətlidir.

void QuickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
        int pi = Partition(arr, low, high);
        QuickSort(arr, low, pi - 1);
        QuickSort(arr, pi + 1, high);
    }
}

int Partition(int[] arr, int low, int high)
{
    int pivot = arr[high];
    int i = (low - 1);

    for (int j = low; j < high; j++)
    {
        if (arr[j] < pivot)
        {
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    int temp1 = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp1;

    return i + 1;
}

B) Axtarış Alqoritmləri​

1. Linear Search (Xətti axtarış)
   • Vaxt Təsiri: O(n)
   • Yaddaş Təsiri: O(1)
   • İstifadə: Kiçik verilənlərdə istifadə olunur.

int LinearSearch(int[] arr, int x)
{
    int n = arr.Length;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] == x)
        {
            return i; // Tapıldı
        }
    }
    return -1; // Tapılmadı
}

1. Binary Search (İkili axtarış)
   • Vaxt Təsiri: O(log n)
   • Yaddaş Təsiri: O(1)
   • İstifadə: Sıralanmış verilənlər üçün istifadə olunur.

int BinarySearch(int[] arr, int x)
{
    int low = 0, high = arr.Length - 1;
    while (low <= high)
    {
        int mid = low + (high - low) / 2;
        
        // Element tapılıb
        if (arr[mid] == x)
            return mid;
        
        // Sol yarıya baxmaq
        if (arr[mid] > x)
            high = mid - 1;
        // Sağ yarıya baxmaq
        else
            low = mid + 1;
    }

    return -1; // Tapılmadı
}

C) Dinamik Proqramlaşdırma (Dynamic Programming)​

1. Fibonacci Sayıları
   • Vaxt Təsiri: O(n)
   • Yaddaş Təsiri: O(n)

int Fibonacci(int n)
{
    int[] fib = new int[n + 1];
    fib[0] = 0;
    fib[1] = 1;

    for (int i = 2; i <= n; i++)
    {
        fib[i] = fib[i - 1] + fib[i - 2];
    }
    
    return fib[n];
}

3. C#-da Alqoritm Təhlili​

Asimptotik Təhlil (Big O Notation)​

• O(1): Sabit vaxt (alqoritm eyni vaxtda işləyir, verilənlərdən asılı olmayaraq).
• O(n): Verilənlərin ölçüsünə görə xətti artan vaxt.
• O(log n): Logaritmik vaxt (məsələn, binary search).
• O(n^2): Kvadrat vaxt (bubble sort, selection sort).

Əlavə Düşünülməsi Gərəkənlər:​

• Həcminin Artması ilə Performansın Dəyişməsi: Nümunə olaraq verilənlər ölçüsü artdıqca alqoritmin performansının necə dəyişəcəyini başa düşmək çox vacibdir.
• İnkişaf etmiş Alqoritmlərin Seçilməsi: Məsələn, O(n^2) vaxt kompleksliyinə malik alqoritm böyüyən verilənlər üçün daha yaxşı optimallaşdırılmış O(n log n)-lik alqoritmlə əvəzlənə bilər.

4. Alqoritmlərin Yaxşılaşdırılması​

• Hibrid Alqoritmlər: Həm dövr, həm də rekursiv yanaşmaların qarışığını istifadə etmək.
• Yaddaşın optimallaşdırılması: Yaddaş istifadəsini azaltmaq üçün müəyyən məlumatları daha effektiv şəkildə saxlamaq.
• Parallel Hesablama: Alqoritmləri paralel olaraq işlətmək, xüsusən böyük verilənlər üzərində.