সর্টিং এলগরিদম (Sorting Algorithms in C)

Sorting Algorithms হল এমন পদ্ধতি যা ডেটা (যেমন অ্যারে বা লিস্ট) কে একটি নির্দিষ্ট ক্রমে (অবস্থান, মান ইত্যাদি) সাজানোর জন্য ব্যবহৃত হয়। বিভিন্ন ধরনের সর্টিং এলগরিদম রয়েছে, যেমন Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, এবং Quick Sort।

নিচে কিছু জনপ্রিয় সার্টিং অ্যালগরিদমের তালিকা দেওয়া হলো:

১. বাবল সার্ট (Bubble Sort)

• প্রতিবার পার্শ্ববর্তী দুটি উপাদানের মধ্যে তুলনা করে যদি তারা ভুল ক্রমে থাকে, তবে তাদের স্থান পরিবর্তন করা হয়।
• টাইম কমপ্লেক্সিটি: O(n²)

২. সিলেকশন সার্ট (Selection Sort)

• অপসোর্টেড অংশ থেকে প্রতিবার সবচেয়ে ছোট উপাদানটি নির্বাচন করে, সেটিকে সঠিক স্থানে স্থাপন করা হয়।
• টাইম কমপ্লেক্সিটি: O(n²)

৩. ইনসারশন সার্ট (Insertion Sort)

• প্রতিবার একটি উপাদান তুলে নিয়ে সেটিকে সঠিক স্থানে স্থাপন করে সর্টেড তালিকা তৈরি করা হয়।
• টাইম কমপ্লেক্সিটি: O(n²)

৪. মার্জ সার্ট (Merge Sort)

• তালিকাটিকে দুই ভাগে ভাগ করে, প্রতিটি অংশকে রিকার্সিভভাবে সর্ট করা হয় এবং তারপর একত্রিত করা হয়।
• টাইম কমপ্লেক্সিটি: O(n log n)

৫. কুইক সার্ট (Quick Sort)

• একটি "পিভট" উপাদান নির্বাচন করে, তালিকাকে পিভটের চারপাশে ভাগ করা হয় এবং রিকার্সিভভাবে সর্ট করা হয়।
• টাইম কমপ্লেক্সিটি: গড়ে O(n log n), সবচেয়ে খারাপ ক্ষেত্রে O(n²)

৬. হিপ সার্ট (Heap Sort)

• একটি ম্যাক্স হিপ তৈরি করে এবং বারবার সবচেয়ে বড় উপাদানটি হিপ থেকে বের করে, সেটিকে তালিকার শেষে স্থাপন করা হয়।
• টাইম কমপ্লেক্সিটি: O(n log n)

৭. র‍্যাডিক্স সার্ট (Radix Sort)

• সংখ্যাগুলোকে তাদের ডিজিটগুলির ভিত্তিতে সর্ট করে, সবচেয়ে কম গুরুত্বপূর্ণ ডিজিট থেকে শুরু করে।
• টাইম কমপ্লেক্সিটি: O(d * (n + k)), যেখানে d হলো ডিজিটের সংখ্যা এবং k হলো ডিজিটের পরিসীমা।

৮. বাকেট সার্ট (Bucket Sort)

• উপাদানগুলোকে একাধিক বাকেটে ভাগ করে, প্রতিটি বাকেট আলাদাভাবে সর্ট করে এবং শেষে সমস্ত বাকেট একত্রিত করা হয়।
• টাইম কমপ্লেক্সিটি: O(n + k), যেখানে n হলো উপাদানের সংখ্যা এবং k হলো বাকেটের সংখ্যা।

৯. কাউন্টিং সার্ট (Counting Sort)

• প্রতিটি উপাদানের উপস্থিতির সংখ্যা গণনা করে এবং সঠিক অবস্থানে তাদের স্থাপন করা হয়।
• টাইম কমপ্লেক্সিটি: O(n + k), যেখানে k হলো ইনপুট মানের পরিসীমা।

১০. শেল সার্ট (Shell Sort)

• ইনসারশন সর্টের একটি সাধারণীকরণ, যেখানে দূরবর্তী উপাদানগুলির মধ্যে তুলনা করা হয় যাতে কম তুলনা করে সর্ট করা যায়।
• টাইম কমপ্লেক্সিটি: গ্যাপ সিকোয়েন্সের উপর নির্ভর করে, সাধারণত O(n log² n) থেকে O(n³/²)

১১. কম্ব সার্ট (Comb Sort)

• বাবল সর্টের একটি উন্নত সংস্করণ, যেখানে তুলনা করা হয় দূরবর্তী উপাদানগুলির মধ্যে।
• টাইম কমপ্লেক্সিটি: সবচেয়ে খারাপ ক্ষেত্রে O(n²)

১২. টিম সর্ট (Tim Sort)

• মার্জ সর্ট এবং ইনসারশন সর্টের একটি হাইব্রিড অ্যালগরিদম, যা পাইথনের sorted() এবং জাভার Arrays.sort() এ ব্যবহৃত হয়।
• টাইম কমপ্লেক্সিটি: O(n log n)

১৩. গনোম সর্ট (Gnome Sort)

• ইনসারশন সর্টের মত, তবে প্রতিবার পার্শ্ববর্তী উপাদানগুলি একে অপরের সাথে তুলনা করে স্থান পরিবর্তন করা হয়।
• টাইম কমপ্লেক্সিটি: O(n²)

১৪. বোর্গো সর্ট (Bogo Sort) (অত্যন্ত অদক্ষ)

• এলোমেলোভাবে তালিকাটি সঠিকভাবে সাজানো না হওয়া পর্যন্ত এলোমেলোভাবে শাফল করে।
• টাইম কমপ্লেক্সিটি: O(n!)

১৫. সাইকেল সর্ট (Cycle Sort)

• যত কম সংখ্যক মেমোরি রাইট সম্ভব তার উপর নির্ভর করে সর্টিং করা হয়, মেমোরি রাইট ব্যয়বহুল হলে এই অ্যালগরিদমটি ব্যবহার করা যায়।
• টাইম কমপ্লেক্সিটি: O(n²)

এগুলো হলো বেশ কয়েকটি পরিচিত এবং গুরুত্বপূর্ণ সার্টিং অ্যালগরিদম, যেগুলো বিভিন্ন ক্ষেত্রে ব্যবহার করা হয়।

Bubble Sort একটি সহজ এবং মৌলিক সর্টিং অ্যালগরিদম। এটি তালিকার প্রতিটি উপাদানকে একে একে তুলনা করে এবং যদি দুটি পরস্পরের থেকে বড় হয় তবে তাদের স্থান পরিবর্তন করে। এই প্রক্রিয়া চলতে থাকে যতক্ষণ না সমস্ত উপাদান সাজানো হয়।

১. Bubble Sort এর ইমপ্লিমেন্টেশন

১.১ C প্রোগ্রামে Bubble Sort উদাহরণ

#include <stdio.h>

// Function to perform Bubble Sort
void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j + 1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, size);

    printf("Sorted array: \n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

১.২ কোড বিশ্লেষণ

bubbleSort ফাংশন:

• ইনপুট হিসেবে একটি অ্যারে এবং এর সাইজ গ্রহণ করে।
• প্রথম লুপ (i) প্রতিটি পাসের জন্য নিয়ন্ত্রণ করে, এবং দ্বিতীয় লুপ (j) প্রতিটি উপাদানকে তুলনা করে।
• যদি arr[j] arr[j + 1] এর থেকে বড় হয়, তাহলে তাদের স্থান পরিবর্তন করে।

main ফাংশন:

• একটি নমুনা অ্যারে তৈরি করে এবং bubbleSort ফাংশন কল করে।
• ফলস্বরূপ সাজানো অ্যারে প্রিন্ট করে।

২. Bubble Sort এর বিশ্লেষণ

২.১ সময় জটিলতা (Time Complexity)

Worst Case: O(n²)
(যখন তালিকা সম্পূর্ণরূপে বিপরীত ক্রমে সাজানো থাকে, প্রতিটি উপাদানকে তুলনা করতে হয়।)

Best Case: O(n)
(যখন তালিকা ইতিমধ্যেই সাজানো থাকে এবং শুধুমাত্র একটি পাস প্রয়োজন।)

Average Case: O(n²)
(গড় ক্ষেত্রে, প্রায় n² তুলনা করতে হয়।)

২.২ স্থান জটিলতা (Space Complexity)

• Space Complexity: O(1)
  (Bubble Sort স্থান সঞ্চয় করে, কারণ এটি ইনপুট অ্যারে ছাড়া অতিরিক্ত স্থান ব্যবহার করে না।)

২.৩ কার্যকারিতা

• সহজতা: সহজ এবং বুঝতে সহজ।
• প্রয়োগ: ছোট তালিকার জন্য কার্যকর, কিন্তু বড় তালিকার জন্য কার্যকরী নয়।

২.৪ দুর্বলতা

• কম কার্যকরী: সময়ের দৃষ্টিকোণ থেকে এটি অন্যান্য সর্টিং অ্যালগরিদমের চেয়ে ধীর।
• অনেক তুলনা: প্রতিটি উপাদানকে তুলনা করতে হয়, তাই এর কার্যকারিতা কম।

Selection Sort এবং Insertion Sort হল দুটি সহজ এবং মৌলিক সর্টিং অ্যালগরিদম। উভয়ই সাধারণত শিক্ষার উদ্দেশ্যে ব্যবহৃত হয় এবং ছোট ডেটা সেটের জন্য কার্যকরী।

১. Selection Sort

১.১ Selection Sort এর ধারণা

Selection Sort হল একটি সর্টিং অ্যালগরিদম যা প্রতিটি ধাপে সর্বনিম্ন (বা সর্বাধিক) উপাদানকে খুঁজে বের করে এবং সেটিকে প্রথম অবস্থানে স্থাপন করে। এটি n সংখ্যক ধাপে কাজ করে, যেখানে প্রতিটি ধাপে একটি ন্যূনতম উপাদান খোঁজা হয়।

১.২ C প্রোগ্রামে Selection Sort উদাহরণ

#include <stdio.h>

// Function to perform Selection Sort
void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int minIndex = i; // Assume the minimum is the first element
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // Update minIndex if a smaller element is found
            }
        }
        // Swap the found minimum element with the first element
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int size = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, size);

    printf("Sorted array: \n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

১.৩ Selection Sort এর বিশ্লেষণ

Worst Case Time Complexity: O(n²)
(সবচেয়ে খারাপ ক্ষেত্রে, প্রতিটি উপাদানের জন্য পুরো তালিকাটি অনুসন্ধান করতে হয়।)

Best Case Time Complexity: O(n²)
(এটি কোন ভাল পরিস্থিতিতে উন্নতি করে না, কারণ প্রতিটি উপাদানকে পরীক্ষা করতে হয়।)

Average Case Time Complexity: O(n²)
(গড় ক্ষেত্রে, আবার n² তুলনা করতে হয়।)

Space Complexity: O(1)
(এই অ্যালগরিদম স্থান সঞ্চয় করে, কারণ এটি ইনপুট অ্যারে ছাড়া অতিরিক্ত স্থান ব্যবহার করে না।)

২. Insertion Sort

২.১ Insertion Sort এর ধারণা

Insertion Sort হল একটি সর্টিং অ্যালগরিদম যা একটি তালিকার উপাদানগুলোকে একটি সাজানো অংশে একে একে যুক্ত করে। এটি কার্যকরভাবে কাজ করে এবং বিশেষ করে ছোট ডেটা সেটের জন্য খুব কার্যকরী।

২.২ C প্রোগ্রামে Insertion Sort উদাহরণ

#include <stdio.h>

// Function to perform Insertion Sort
void insertionSort(int arr[], int size) {
    for (int i = 1; i < size; i++) {
        int key = arr[i];
        int j = i - 1;

        // Move elements of arr[0..i-1], that are greater than key, to one position ahead
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key; // Insert key at the correct position
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int size = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, size);

    printf("Sorted array: \n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

২.৩ Insertion Sort এর বিশ্লেষণ

Worst Case Time Complexity: O(n²)
(যখন তালিকা পুরোপুরি বিপরীত ক্রমে সাজানো থাকে।)

Best Case Time Complexity: O(n)
(যখন তালিকা ইতিমধ্যেই সাজানো থাকে।)

Average Case Time Complexity: O(n²)
(গড় ক্ষেত্রে, এটি প্রায় n² তুলনা করতে হয়।)

Space Complexity: O(1)
(Insertion Sort স্থান সঞ্চয় করে, কারণ এটি ইনপুট অ্যারে ছাড়া অতিরিক্ত স্থান ব্যবহার করে না।)

৩. Selection Sort এবং Insertion Sort এর তুলনা

Merge Sort এবং Quick Sort হল দুটি অত্যন্ত কার্যকরী বিভাজন ও বিজয় (Divide and Conquer) ভিত্তিক সর্টিং অ্যালগরিদম। এই উভয় অ্যালগরিদম বড় ডেটা সেটের জন্য দ্রুত এবং কার্যকরী, এবং তারা সাধারণত বাস্তব জীবনের পরিস্থিতিতে ব্যবহৃত হয়। নিচে তাদের ধারণা এবং C প্রোগ্রামে তাদের প্রয়োগের উদাহরণ দেওয়া হলো।

১. Merge Sort

১.১ Merge Sort এর ধারণা

Merge Sort হল একটি বিভাজন ও বিজয় ভিত্তিক সর্টিং অ্যালগরিদম যা তালিকাকে দুইটি অংশে ভাগ করে, প্রতিটি অংশকে পৃথকভাবে সাজিয়ে পরে উভয় অংশকে একত্রিত করে। এটি নিম্নলিখিত ধাপগুলো অনুসরণ করে:

1. যদি তালিকার মধ্যে ১টির বেশি উপাদান থাকে, তবে এটি তালিকাকে দুটি অংশে বিভক্ত করে।
2. প্রতিটি অংশকে পুনরায় সাজানো হয় (Recursive step)।
3. দুটি সাজানো অংশকে একত্রিত করা হয় (Merging step)।

১.২ C প্রোগ্রামে Merge Sort উদাহরণ

#include <stdio.h>

// Function to merge two subarrays
void merge(int arr[], int left, int mid, int right) {
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int L[n1], R[n2];

    // Copy data to temporary arrays L[] and R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // Merge the temporary arrays back into arr[left..right]
    i = 0; // Initial index of first subarray
    j = 0; // Initial index of second subarray
    k = left; // Initial index of merged subarray
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // Copy the remaining elements of L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // Copy the remaining elements of R[], if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// Function to perform Merge Sort
void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        // Sort first and second halves
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // Merge the sorted halves
        merge(arr, left, mid, right);
    }
}

int main() {
    int arr[] = {38, 27, 43, 3, 9, 82, 10};
    int size = sizeof(arr) / sizeof(arr[0]);

    mergeSort(arr, 0, size - 1);

    printf("Sorted array: \n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

১.৩ Merge Sort এর বিশ্লেষণ

• Worst Case Time Complexity: O(n log n)
• Best Case Time Complexity: O(n log n)
• Average Case Time Complexity: O(n log n)
• Space Complexity: O(n) (কারণ এটি অতিরিক্ত স্থান ব্যবহার করে, মূলত মর্জিংয়ের জন্য)

২. Quick Sort

২.১ Quick Sort এর ধারণা

Quick Sort হল একটি দ্রুত এবং কার্যকরী সর্টিং অ্যালগরিদম যা তালিকাকে একটি পিভট (pivot) উপাদানের ভিত্তিতে বিভক্ত করে। পিভটের মাধ্যমে ডেটাকে দুটি অংশে ভাগ করা হয়: একটিতে পিভটের চেয়ে ছোট উপাদান এবং অন্যটিতে বড় উপাদান। এটি নিম্নলিখিত ধাপগুলো অনুসরণ করে:

1. একটি পিভট উপাদান নির্বাচন করুন।
2. তালিকাকে পিভটের ভিত্তিতে দুটি উপ-তালিকায় বিভক্ত করুন।
3. উভয় উপ-তালিকার জন্য Quick Sort প্রয়োগ করুন (Recursive step)।

২.২ C প্রোগ্রামে Quick Sort উদাহরণ

#include <stdio.h>

// Function to swap two elements
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// Partition function
int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // Choosing the rightmost element as pivot
    int i = (low - 1); // Index of smaller element

    for (int j = low; j < high; j++) {
        // If current element is smaller than or equal to pivot
        if (arr[j] <= pivot) {
            i++; // Increment index of smaller element
            swap(&arr[i], &arr[j]); // Swap elements
        }
    }
    swap(&arr[i + 1], &arr[high]); // Swap the pivot element with the element at i+1
    return (i + 1); // Return the partitioning index
}

// Function to perform Quick Sort
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high); // Partitioning index

        // Recursively sort elements before and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 80, 30, 90, 40, 50, 70};
    int size = sizeof(arr) / sizeof(arr[0]);

    quickSort(arr, 0, size - 1);

    printf("Sorted array: \n");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

২.৩ Quick Sort এর বিশ্লেষণ

• Worst Case Time Complexity: O(n²) (যখন পিভট প্রতিবার সর্বাধিক বা সর্বনিম্ন নির্বাচিত হয়, যেমন সন্নিবেশিত তালিকায়)
• Best Case Time Complexity: O(n log n)
• Average Case Time Complexity: O(n log n)
• Space Complexity: O(log n) (কিছু সীমিত স্ট্যাক ব্যবহার করে)

৩. তুলনা এবং উপসংহার

Merge Sort এবং Quick Sort উভয়ই কার্যকরী এবং জনপ্রিয় সর্টিং অ্যালগরিদম। Merge Sort সর্বদা O(n log n) সময় জটিলতা বজায় রাখে, তবে এটি অতিরিক্ত স্থান প্রয়োজন। অন্যদিকে, Quick Sort সাধারণত দ্রুত কিন্তু এর worst-case সময় জটিলতা O(n²) হতে পারে, বিশেষত যখন পিভট অকার্যকরভাবে নির্বাচিত হয়। আপনার সমস্যা এবং ডেটার প্রয়োজন অনুসারে সঠিক এলগরিদম নির্বাচন করা গুরুত্বপূর্ণ।

Time Complexity এবং Space Complexity হল অ্যালগরিদমের কার্যকারিতা পরিমাপ করার জন্য ব্যবহৃত দুটি মূল ধারণা। এটি আমাদের জানায় যে একটি অ্যালগরিদম কতটা কার্যকর এবং কীভাবে এটি ইনপুটের আকারের উপর নির্ভর করে।

১. Time Complexity

Time Complexity হল একটি পরিমাপ যা নির্দেশ করে একটি অ্যালগরিদম কত সময় নিতে পারে নির্দিষ্ট ইনপুটের আকারের উপর ভিত্তি করে। এটি সাধারণত Big O notation ব্যবহার করে প্রকাশ করা হয়, যা অ্যালগরিদমের সবচেয়ে খারাপ সময় জটিলতাকে বোঝায়।

১.১ Time Complexity এর বিভিন্ন শ্রেণী

O(1): কনস্ট্যান্ট টাইম

• ইনপুটের আকারের উপর নির্ভর করে না। যেমন, অ্যারের প্রথম উপাদান অ্যাক্সেস করা।

O(n): লিনিয়ার টাইম

• ইনপুটের আকারের সাথে সরাসরি অনুপাতিত। যেমন, একটি অ্যারে লুপ করে সমস্ত উপাদান পরীক্ষা করা।

O(n²): কোয়াড্রাটিক টাইম

• ইনপুটের আকারের বর্গের সাথে অনুপাতিত। যেমন, নেস্টেড লুপ ব্যবহার করে সমস্ত উপাদানগুলির মধ্যে তুলনা করা।

O(log n): লগারিদমিক টাইম

• ইনপুটের আকারের লগারিদমের সাথে সম্পর্কিত। যেমন, Binary Search অ্যালগরিদম।

O(n log n): লিনিয়ার লগারিদমিক টাইম

• এটি সাধারণত Merge Sort এবং Quick Sort-এর মতো কার্যকরী সর্টিং অ্যালগরিদমের জন্য দেখা যায়।

১.২ Time Complexity উদাহরণ

• Linear Search: O(n)
• Binary Search: O(log n)
• Bubble Sort: O(n²)
• Merge Sort: O(n log n)

২. Space Complexity

Space Complexity হল একটি পরিমাপ যা নির্দেশ করে একটি অ্যালগরিদম কতটা মেমরি ব্যবহার করে নির্দিষ্ট ইনপুটের আকারের উপর ভিত্তি করে। এটি মূল মেমরি (অ্যালগরিদমের কার্যক্রম চলাকালীন ব্যবহৃত স্থান) এবং ইনপুটের জন্য প্রয়োজনীয় অতিরিক্ত স্থানকে বোঝায়।

২.১ Space Complexity এর বিভিন্ন শ্রেণী

O(1): কনস্ট্যান্ট স্পেস

• অ্যালগরিদমের জন্য স্থান ব্যবহারের পরিমাণ ইনপুটের আকারের উপর নির্ভর করে না। যেমন, কিছু ভেরিয়েবল ডিফাইন করা।

O(n): লিনিয়ার স্পেস

• অ্যালগরিদমের জন্য স্থান ব্যবহারের পরিমাণ ইনপুটের আকারের উপর নির্ভর করে। যেমন, একটি নতুন অ্যারে তৈরি করা।

O(n²): কোয়াড্রাটিক স্পেস

• কিছু পরিস্থিতিতে, অ্যালগরিদমের জন্য স্থান ব্যবহারের পরিমাণ ইনপুটের আকারের বর্গের সাথে সম্পর্কিত।

২.২ Space Complexity উদাহরণ

• Linear Search: O(1)
• Binary Search: O(1) (যদি ইনপুটে কোন অতিরিক্ত স্থান না নেওয়া হয়)
• Bubble Sort: O(1)
• Merge Sort: O(n) (কারণ এটি নতুন অ্যারের জন্য অতিরিক্ত স্থান ব্যবহার করে)

৩. তুলনা এবং উপসংহার

Time Complexity এবং Space Complexity উভয়ই অ্যালগরিদমের কার্যকারিতা বোঝার জন্য গুরুত্বপূর্ণ। একটি ভাল অ্যালগরিদম প্রায়শই দ্রুত (কম সময় জটিলতা) এবং কার্যকর (কম স্থান জটিলতা) হতে হয়। সমস্যা সমাধানের সময় এই দুটি বিষয়ে সচেতন থাকা উচিত।