 GFG App
Open App Browser
Continue

# Bubble Sort in C

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity is quite high. Bubble sorting in C programming plays a vital role as it is quite easy to understand and is one of the most basic sorting algorithms.

### Approach for Bubble Sort

Follow the below steps to solve the problem:

• Run a nested for loop to traverse the input array using two variables i and j, such that 0 ≤ i < n-1 and 0 ≤ j < n-i-1
• If arr[j] is greater than arr[j+1] then swap these adjacent elements, else move on
• Print the sorted array Bubble Sort in C

Recommended Practice

## Bubble Sort Example

Let us check on an example for understanding the concept of bubble sort before getting into the programming part as a dry run.

### Input

`arr[] = {5, 1, 4, 2, 8}`

#### First Traversing

Bubble sort starts with very first two elements, comparing them to check which one is greater.

• ( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.
• ( 1 5 4 2 8 ) –>  ( 1 4 5 2 8 ), Swap since 5 > 4
• ( 1 4 5 2 8 ) –>  ( 1 4 2 5 8 ), Swap since 5 > 2
• ( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.

#### Second Traversing

Now, during second iteration it should look like this:

• ( 1 4 2 5 8 ) –> ( 1 4 2 5 8 )
• ( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2
• ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
• ( 1 2 4 5 8 ) –>  ( 1 2 4 5 8

#### Third Traversing

Now, the array is already sorted, but our algorithm does not know if it is completed.

The algorithm needs one whole pass without any swap to know it is sorted.

• ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
• ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
• ( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
• ( 1 2 4 5 8 ) –> ( 1 2 4 5 8

### Output

`arr = [1,2,4,5,8]`

## Program for Bubble Sort in C

Below is the implementation of bubble sort in C:

## C

 `// C program for implementation  ` `// of Bubble sort ` `#include ` ` `  `// Swap function ` `void` `swap(``int` `*arr,``int` `i,``int` `j){ ` `    ``int` `temp=arr[i]; ` `      ``arr[i]=arr[j]; ` `      ``arr[j]=temp; ` `} ` ` `  `// A function to implement bubble sort ` `void` `bubbleSort(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `i, j; ` `    ``for` `(i = 0; i < n - 1; i++) ` ` `  `        ``// Last i elements are already  ` `        ``// in place ` `        ``for` `(j = 0; j < n - i - 1; j++) ` `            ``if` `(arr[j] > arr[j + 1]) ` `                ``swap(arr,j,j + 1); ` `} ` ` `  `// Function to print an array  ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``int` `i; ` `    ``for` `(i = 0; i < size; i++) ` `      ``printf``(``"%d "``,arr[i]); ` `    ``printf``(``"\n"``); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 1, 4, 2, 8}; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``bubbleSort(arr, N); ` `    ``printf``(``"Sorted array: "``); ` `    ``printArray(arr, N); ` `    ``return` `0; ` `}`

Output

```Sorted array:
1 2 4 5 8 ```

Time Complexity: O(N2)
Auxiliary Space: O(1)

## Optimized Implementation of Bubble Sort

The above function always runs O(N2) time even if the array is sorted. It can be optimized by stopping the algorithm if the inner loop didn’t cause any swap.

Below is the implementation for the above approach:

## C

 `//  C Program with Optimized  ` `// implementation of Bubble sort ` `#include ` ` `  `// Swap function ` `void` `swap(``int``* arr, ``int` `i, ``int` `j) ` `{ ` `    ``int` `temp = arr[i]; ` `    ``arr[i] = arr[j]; ` `    ``arr[j] = temp; ` `} ` ` `  `// An optimized version of Bubble Sort ` `void` `bubbleSort(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `i, j; ` `    ``bool` `swapped; ` `    ``for` `(i = 0; i < n - 1; i++) { ` `        ``swapped = ``false``; ` `        ``for` `(j = 0; j < n - i - 1; j++) { ` `            ``if` `(arr[j] > arr[j + 1]) { ` `                ``swap(arr, j, j + 1); ` `                ``swapped = ``true``; ` `            ``} ` `        ``} ` ` `  `        ``// IF no two elements were swapped ` `        ``// by inner loop, then break ` `        ``if` `(swapped == ``false``) ` `            ``break``; ` `    ``} ` `} ` ` `  `// Function to print an array ` `void` `printArray(``int` `arr[], ``int` `size) ` `{ ` `    ``int` `i; ` `    ``for` `(i = 0; i < size; i++) ` `        ``printf``(``" %d"``, arr[i]); ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `arr[] = { 5, 3, 1, 9, 8, 2, 4, 7 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// bubbleSort function called ` `    ``bubbleSort(arr, N); ` ` `  `    ``printf``(``"Sorted array: "``); ` `    ``printArray(arr, N); ` `    ``return` `0; ` `}`

## Recursive Method to Implement Bubble Sort

There is another method using recursion to implement Bubble Sort. It is quite easy to understand bubble sort using recursion. As arr is passed to recursive function till there are no further elements to sort.

Below is the implementation of the above approach:

## C

 `// C code for recursive bubble sort algorithm ` `#include ` ` `  `// Swap function ` `void` `swap(``int``* arr, ``int` `i, ``int` `j) ` `{ ` `    ``int` `temp = arr[i]; ` `    ``arr[i] = arr[j]; ` `    ``arr[j] = temp; ` `} ` ` `  `// BubbleSort function ` `void` `bubblesort(``int` `arr[], ``int` `n) ` `{ ` `    ``if` `(n == 0 || n == 1) { ` `        ``return``; ` `    ``} ` ` `  `    ``for` `(``int` `i = 0; i < n - 1; i++) { ` `        ``if` `(arr[i] > arr[i + 1]) { ` `            ``swap(arr, i, i + 1); ` `        ``} ` `    ``} ` ` `  `    ``bubblesort(arr, n - 1); ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``int` `arr = { 2, 5, 1, 6, 9 }; ` `   `  `      ``// Function call ` `    ``bubblesort(arr, 5); ` ` `  `    ``for` `(``int` `i = 0; i < 5; i++) { ` `        ``printf``(``"%d "``, arr[i]); ` `    ``} ` ` `  `    ``return` `0; ` `}`

Output

`1 2 5 6 9 `

### 1. What is the Boundary Case for Bubble sort?

Bubble sort takes minimum time (Order of n) when elements are already sorted. Hence it is best to check if the array is already sorted or not beforehand, to avoid O(N2) time complexity.

### 2. Does sorting happen in place in Bubble sort?

Yes, Bubble sort performs the swapping of adjacent pairs without the use of any major data structure. Hence Bubble sort algorithm is an in-place algorithm.

### 3. Is the Bubble sort algorithm stable?

Yes, the bubble sort algorithm is stable.

### 4. Where is the Bubble sort algorithm used?

Due to its simplicity, bubble sort is often used to introduce the concept of a sorting algorithm. In computer graphics, it is popular for its capability to detect a tiny error (like a swap of just two elements) in almost-sorted arrays and fix it with just linear complexity (2n).

My Personal Notes arrow_drop_up