{"id":3175,"date":"2025-06-06T10:58:55","date_gmt":"2025-06-06T10:58:55","guid":{"rendered":"https:\/\/diznr.com\/?p=3175"},"modified":"2025-06-06T10:58:55","modified_gmt":"2025-06-06T10:58:55","slug":"data-structures-and-algorithm-best-sorting-algorithms-bubble-sort-algorithm-bubble-sort-c-in","status":"publish","type":"post","link":"https:\/\/www.reilsolar.com\/pdf\/data-structures-and-algorithm-best-sorting-algorithms-bubble-sort-algorithm-bubble-sort-c-in\/","title":{"rendered":"DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C"},"content":{"rendered":"

DATA STRUCTURES AND ALGORITHM – Best Sorting Algorithms – Bubble sort Algorithm Bubble sort in C<\/p>\n

[fvplayer id=”287″]<\/p>\n

Bubble Sort Algorithm in C – Explanation & Code<\/strong><\/h3>\n

Bubble Sort<\/strong> is one of the simplest sorting algorithms. It repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This process is repeated until the list is sorted.<\/p>\n

\u00a0How Bubble Sort Works?<\/strong><\/h3>\n
    \n
  1. Compare adjacent elements.<\/li>\n
  2. Swap them if they are in the wrong order.<\/li>\n
  3. Move to the next pair and repeat.<\/li>\n
  4. Continue this process for every element.<\/li>\n
  5. Repeat the entire process for multiple passes until the array is sorted.<\/li>\n<\/ol>\n

    Best Case (Already Sorted):<\/strong> O(n)<\/strong>
    Worst Case (Reverse Sorted):<\/strong> O(n\u00b2)<\/strong>
    Average Case:<\/strong> O(n\u00b2)<\/strong>
    Stable Sort:<\/strong> Yes
    In-Place Algorithm:<\/strong> Yes<\/p>\n

    \u00a0Bubble Sort Algorithm in C<\/strong><\/h3>\n
    \n
    \n

    #include<\/span><\/span> <stdio.h><\/span><\/code><\/p>\n

    \/\/ Function to perform Bubble Sort<\/span>
    \nvoid<\/span> bubbleSort<\/span>(int<\/span><\/span> arr[], int<\/span> n) {
    \nint<\/span> i, j, temp;
    \nint<\/span> swapped;<\/p>\n

    for<\/span> (i = 0<\/span>; i < n – 1<\/span>; i++) {
    \nswapped = 0<\/span>; \/\/ Flag to check if swapping happened<\/span><\/p>\n

    for<\/span> (j = 0<\/span>; j < n – i – 1<\/span>; j++) {
    \nif<\/span> (arr[j] > arr[j + 1<\/span>]) { \/\/ Swap if the current element is greater than the next<\/span>
    \ntemp = arr[j];
    \narr[j] = arr[j + 1<\/span>];
    \narr[j + 1<\/span>] = temp;
    \nswapped = 1<\/span>;
    \n}
    \n}<\/p>\n

    \/\/ If no two elements were swapped, break the loop (Optimization)<\/span>
    \nif<\/span> (swapped == 0<\/span>)
    \nbreak<\/span>;
    \n}
    \n}<\/p>\n

    \/\/ Function to print an array<\/span>
    \nvoid<\/span> printArray<\/span>(int<\/span><\/span> arr[], int<\/span> n) {
    \nfor<\/span> (int<\/span> i = 0<\/span>; i < n; i++)
    \nprintf<\/span>(“%d “<\/span>, arr[i]);
    \nprintf<\/span>(“\\n”<\/span>);
    \n}<\/p>\n

    \/\/ Main function<\/span>
    \nint<\/span> main<\/span>()<\/span> {
    \nint<\/span> arr[] = {64<\/span>, 25<\/span>, 12<\/span>, 22<\/span>, 11<\/span>};
    \nint<\/span> n = sizeof<\/span>(arr) \/ sizeof<\/span>(arr[0<\/span>]);<\/p>\n

    printf<\/span>(“Original array: “<\/span>);
    \nprintArray(arr, n);<\/p>\n

    bubbleSort(arr, n);<\/p>\n

    printf<\/span>(“Sorted array: “<\/span>);
    \nprintArray(arr, n);<\/p>\n

    return<\/span> 0<\/span>;
    \n}<\/p>\n<\/div>\n<\/div>\n

    Explanation of Code<\/strong><\/h3>\n
      \n
    1. Outer Loop:<\/strong> Runs for (n-1) passes<\/strong> to move the largest element to the end.<\/li>\n
    2. Inner Loop:<\/strong> Compares adjacent elements and swaps them if they are out of order.<\/li>\n
    3. Optimization:<\/strong> If no swaps occur in a pass, the array is already sorted, and the loop breaks.<\/li>\n
    4. Function Usage:<\/strong>\n