შეგიძლიათ ჩამოთვალოთ ძირითადი კლასიკური ალგორითმები და მათი მახასიათებლები?

ძირითადი კლასიკური ალგორითმები და მათი მახასიათებლები:

• სორტირება:

  • ფეთქვის სორტი (Bubble Sort) — მარტივი, მაგრამ არასასურველი (O(n²)), სასწავლო მიზნებისთვის.
  • შეყვანის სორტი (Insertion Sort) — ეფექტურია თითქმის სორტირებულ მონაცემებზე.
  • სწრაფი სორტი (Quick Sort) — საშუალოდ სწრაფი (O(n log n)), მაგრამ ყველაზე უარესი შემთხვევა O(n²).
  • შეთავსების სორტი (Merge Sort) — სტაბილური, გარანტირებული O(n log n), საჭიროებს დამატებით მეხსიერებას.

• ძებნა:

  • გადმოსახედული ძებნა — მარტივი, მაგრამ ნელი (O(n)).
  • ბინარული ძებნა — სწრაფი (O(log n)) სორტირებულ მასივებზე.

• გრაფის ალგორითმები:

  • გაფართოება ღრმად (DFS) და გაფართოება სიღრმით (BFS) — გრაფის შემოვლა.
  • დაიკსტრის ალგორითმი — ყველაზე მოკლე გზა ნეგატიური წონების გარეშე გრაფში.

• რეკურსია და დინამიური პროგრამირება:

  • გამოიყენება პრობლემების გადასაჭრელად, სადაც ქვესაშუალებები გადაკვეთილია, მაგალითად, ფიბონაჩჩის რიცხვების გამოთვლა, ზურგჩანთის პრობლემა.

• გრედი ალგორითმები:

  • იღებენ ადგილობრივ ოპტიმალურ გადაწყვეტილებებს, მაგალითად, კრუსკალის ალგორითმი მინიმალური ხისათვის.

მაგალითი: სწრაფი სორტირება C#-ში

void QuickSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int pivot = arr[(left + right) / 2];
    int i = left, j = right;
    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) {
            int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
            i++; j--;
        }
    }
    QuickSort(arr, left, j);
    QuickSort(arr, i, right);
}