# How Does Bubble Sort Work In C++? | Code & Algorithm Explained

Do you know what is Bubble Sort in C++ and how it works? In this article, we are going to learn about the implementation of Bubble Sort with code and algorithms.

Also, if you are stuyding C++ course in your college and  looking for C++ assignment help then you can always reach CodingZap to get your task done from best experts.

But before we jump-start our topic, let us try to find the process of Bubble Sort in C++ from an example of our daily life.

Let us assume one scenario.

Suppose, your friend provided you with one task. You have to sort the wooden boxes from descending to ascending order. There will be some numbers printed on the boxes. Based on the number, you have to sort the boxes. But there are some limitations.

Your friend will provide you with the boxes one by one. This means you don’t have any clue about the number of coming packages. And the sorting need to be completed in one go only.

What will do in the case?

In this case, you need to first compare two initial boxes. Then when one extra box will come to you, you need to again compare among those. In this way, you are comparing in a bubble. Where in the first case, there were two boxes in the bubble for comparison. In the second step, there will be three boxes in the bubble. In this way, you will try to sort the boxes.

The same thing goes for the Bubble Sort in C++. Bubble sort comparisons help to find out the smaller one from the array. Bubble sort comparisons are the main driving force behind the Bubble Sort in C++.

Let us first know about the Bubble sort. Then we try to implement Bubble Sort in C++.

To know more about the world of sorting you can check out our article on “Quick Sort Algorithm

## What Is Bubble Sort? Read Below

Bubble sort is a special type of sorting algorithm. There are many sorting algorithms present. like there are Quick Sort Algorithms, Selection Sort Algorithm, etc. Bubble sort types are similar types of sorting algorithms. The sorting algorithm works on a set of numbers. There the numbers are sorted in a particular manner. Mostly the sorting algorithms sort the number from descending from to ascending from.

Bubble sort types work on the same method. It also helps to sort the numbers from descending to ascending order. It generally compares two numbers. Those numbers must be adjacent to each other. Based on the comparison, the minimum number is placed in the first place or at the first index. Then again it compares two adjacent numbers. There it again finds out the minimum one. Then it is placed at the second index of the sequence. In this way, the total operation goes on. Till the process is completed.

## What Is Algorithm Of Bubble Sort?

Before we move ahead, let us have a look on the algorithm of the Bubble sort algorithm. Algorithms are the smallest blueprint to implement any process. This helps to implement the code in the future. Let us try to make the algorithm for the Bubble sort.

1. For i = 0 to n-1 Repeat 2nd Step
2. For j = i + 1 to n – i Repeat This Step
3. if A[j] > A[k] à Swap A[j] and A[k] à [end of inner for loop] à [end if outer for loop]
4. End Of The Process

The above is the process of the Bubble sort algorithm. With the help of the above algorithm, we need to implement the code.

Is it difficult to understand the Bubble sort algorithm? Let us look at the procedure of Bubble sorting in detail.

## What is the Procedure Of Bubble Sort Algorithm? Get To Know

After knowing about the Bubble Sort algorithm, let us try to find out the procedure of the Bubble Sort in C++. The bubble sort algorithm goes on many rounds. In every round, it will check the adjacent numbers from the array. When there are no changes needed in the adjacent number, it will stop checking.

Let us take one example. Suppose, in an array, there are three elements present. they are placed in an unsorted format. They are placed as 3,2,1. So, we need to make them sorted using the Bubble sort algorithm. There will be two rounds to complete the process.

• Round 1: This is the round 1. Here, the checking will happen throughout the total length of the array. Based on the result, we have to swap the element’s index position.
1. At first, there will be a comparison between Element 3 & element 2. As these two elements are adjacent to each other.
2. As element 2 is minimum than element 3, it will swap their position. After swapping, element 2 will occupy the index number of element 3.
3. Again, a new comparison will start between Element 3 & element 1. As these two elements are adjacent to each other.
4. As element 1 is minimum than element 3, it will swap its position. After swapping, element 1 will occupy the index number of element 3.

So, now the position of elements is 2,1,3. This is after the completion of Round 1. There is Round 2 also.

• Round 2: This is Round 2. This round intends to check numbers throughout the array. But if no other swapping is needed in the array, this round will get stopped. As there is no other need to find the minimum & swap it.
1. At first, there will be a comparison between Element 2 & element 1. As these two elements are adjacent to each other.
2. As element 1 is minimum than element 2, it will swap their position. After swapping, element 1 will occupy the index number of element 2.

So, now the position of the elements is 1,2,3. This is now in the sorted format. So, this round will close. As there is no other need to find minimum & swap.

If you wish to know the procedure of selection sort then you can check our article on “Selection Sort in C++

## How to do Implementation Of Bubble Sort In C++?

Here, we need to take one array. There we need to declare the array in the unsorted format. Then we need to first print the unsorted array. After that, we need to call the bubble sort function.

In the bubble sort function, we need to create two loops. These loops will help to find the minimum of the adjacent numbers. Also, these for loops will help to swap the adjacent numbers there. At last, we need to print the sorted array.

Example:

```#include <bits/stdc++.h>

using namespace std;

void bubbleSort(int arr[], int n){ // Function To Implement Bubble Sort

int i, j;

for (i = 0; i < n - 1; i++){

// Finding Minimum & Swapping

for (j = 0; j < n - i - 1; j++){

if (arr[j] > arr[j + 1])

swap(arr[j], arr[j + 1]);

}}}

void printArray(int arr[], int size){ // Function to Print The Array

int i;

for (i = 0; i < size; i++)

cout << arr[i] << " ";

cout << endl;}

int main(){

int arr[] = { 90, 10, 20, 30, 110}; // Declaration Of The Array

int N = sizeof(arr) / sizeof(arr[0]); cout << "Unsorted array: ";

printArray(arr, N); // Printing Unsorted Array

bubbleSort(arr, N); // Calling Bubble Sort Function

cout << "Sorted array: "; printArray(arr, N); // Printing Sorted Array

return 0;}```

Let us take a look at the output of the above code. It will help to understand the implementation of Bubble sort in C++

Output:

### Complexities Of Bubble Sort Algorithm:

There are two types of complexities are there in the Bubble sort algorithms. Mainly the time complexity plays an important role there. There are two types of time complexities in Bubble sort algorithms.

• The Best-Case Time Complexity: O(N)
• The Average-Case & Worst-Case Time Complexity: O(N2)

## Conclusion:

As we saw Bubble Sort in C++ is a very important topic.

Bubble sort comparisons are the main driving force of the Bubble sort algorithm. This should always be remembered. This will help us a lot in the future. Sorting can be learned in different programming languages like Bubble Sort in JavaQuick Sort in Python, and Merge Sort in Java. They are really important topics and it will help you to become a good coding expert.

Bubble sort types are the most important among the other sorting algorithms. We need to first clear the basics of the C programming language & Data Structures.

So, hope you have liked this piece of article. Share your thoughts in the comments section and let us know if we can improve more.