Algorithm
-
Getting Started with AlgorithmWhat is an Algorithm?
-
Characteristics of Algorithm1 Topic
-
Analysis Framework
-
Performance Analysis3 Topics
-
Mathematical Analysis2 Topics
-
Sorting AlgorithmSorting Algorithm10 Topics
-
Searching Algorithm6 Topics
-
Fundamental of Data StructuresStacks
-
Queues
-
Graphs
-
Trees
-
Sets
-
Dictionaries
-
Divide and ConquerGeneral Method
-
Binary Search
-
Recurrence Equation for Divide and Conquer
-
Finding the Maximum and Minimum
-
Merge Sort
-
Quick Sort
-
Stassen’s Matrix Multiplication
-
Advantages and Disadvantages of Divide and Conquer
-
Decrease and ConquerInsertion Sort
-
Topological Sort
-
Greedy MethodGeneral Method
-
Coin Change Problem
-
Knapsack Problem
-
Job Sequencing with Deadlines
-
Minimum Cost Spanning Trees2 Topics
-
Single Source Shortest Paths1 Topic
-
Optimal Tree Problem1 Topic
-
Transform and Conquer Approach1 Topic
-
Dynamic ProgrammingGeneral Method with Examples
-
Multistage Graphs
-
Transitive Closure1 Topic
-
All Pairs Shortest Paths6 Topics
-
BacktrackingGeneral Method
-
N-Queens Problem
-
Sum of Subsets problem
-
Graph Coloring
-
Hamiltonian Cycles
-
Branch and Bound2 Topics
-
0/1 Knapsack problem2 Topics
-
NP-Complete and NP-Hard Problems1 Topic
Participants2253
Bubble Sort
Bubble sort is an algorithm that compares the adjacent elements and swaps their positions if they are not in the intended order. The order can be ascending or descending.
How Bubble Sort Works?
- Starting from the first index, compare the first and the second elements.If the first element is greater than the second element, they are swapped.
Now, compare the second and the third elements. Swap them if they are not in order.
The above process goes on until the last element.

2. The same process goes on for the remaining iterations. After each iteration, the largest element among the unsorted elements is placed at the end.
In each iteration, the comparison takes place up to the last unsorted element.
The array is sorted when all the unsorted elements are placed at their correct positions.



Bubble Sort Algorithm
bubbleSort(array)
for i <- 1 to indexOfLastUnsortedElement-1
if leftElement > rightElement
swap leftElement and rightElement
end bubbleSort
Bubble Sort Program in C
// Bubble sort in C
#include <stdio.h>
void bubbleSort(int array[], int size)
{
for (int step = 0; step < size - 1; ++step)
{
for (int i = 0; i < size - step - 1; ++i)
{
// To sort in descending order, change">" to "<".
if (array[i] > array[i + 1])
{
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
}
void printArray(int array[], int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
int main()
{
int data[] = {-2, 45, 0, 11, -9};
int size = sizeof(data) / sizeof(data[0]);
bubbleSort(data, size);
printf("Sorted Array in Ascending Order:\n");
printArray(data, size);
}
Optimized Bubble Sort
In the above code, all possible comparisons are made even if the array is already sorted. It increases the execution time.
The code can be optimized by introducing an extra variable swapped. After each iteration, if there is no swapping taking place then, there is no need for performing further loops.
In such case, variable swapped is set false. Thus, we can prevent further iterations.
Algorithm for optimized bubble sort is
bubbleSort(array)
swapped <- false
for i <- 1 to indexOfLastUnsortedElement-1
if leftElement > rightElement
swap leftElement and rightElement
swapped <- true
end bubbleSort
Optimized Bubble Sort Program
// Optimized bubble sort in C
#include <stdio.h>
void bubbleSort(int arrayay[], int size)
{
for (int step = 0; step & lt; size - 1; ++step)
{
// The variable "swapped" is introduced for optimization.
int swapped = 0;
for (int i = 0; i & lt; size - step - 1; ++i)
{
// To sort in descending order, change > to < in this line.
if (arrayay[i] & gt; arrayay[i + 1])
{
int temp = arrayay[i];
arrayay[i] = arrayay[i + 1];
arrayay[i + 1] = temp;
swapped = 1;
}
}
// If there is not swapping in the last swap, then the array is already sorted.
if (swapped == 0)
break;
}
}
void printarrayay(int arrayay[], int size)
{
for (int i = 0; i & lt; size; ++i)
{
printf("%d ", arrayay[i]);
}
printf("\n");
}
int main()
{
int data[] = {-2, 45, 0, 11, -9};
int size = sizeof(data) / sizeof(data[0]);
bubbleSort(data, size);
printf("Sorted Array in Ascending Order:\n");
printarrayay(data, size);
}
Complexity
Bubble Sort is one of the simplest sorting algorithms. Two loops are implemented in the algorithm.
Cycle | Number of Comparisons |
---|---|
1st | (n-1) |
2nd | (n-2) |
3rd | (n-3) |
……. | …… |
last | 1 |
Number of comparisons:(n-1) + (n-2) + (n-3) +.....+ 1 = n(n-1)/2
nearly equals to n2
Complexity: O(n2)
Also, we can analyze the complexity by simply observing the number of loops. There are 2 loops so the complexity is n*n = n2
Time Complexities:
- Worst Case Complexity:
O(n2)
If we want to sort in ascending order and the array is in descending order then, the worst case occurs.
- Best Case Complexity:
O(n)
If the array is already sorted, then there is no need for sorting.
- Average Case Complexity:
O(n2)
It occurs when the elements of the array are in jumbled order (neither ascending nor descending).
Space Complexity:
Space complexity is O(1)
because an extra variable temp is used for swapping.
In the optimized algorithm, the variable swapped adds to the space complexity thus, making it O(2)
.
Bubble Sort Applications
Bubble sort is used in the following cases where
- the complexity of the code does not matter.
- a short code is preferred.