Thank you for printing our content at www.domain-name.com.
Please check back soon for
Try hands-on Interview (h!ps://programiz.pro/course/python-interview-q
CODING utm_source=programiz-top-
Preparation with
PRO bar&utm_campaign=programiz&utm_medium=re
Programiz PRO
36% OFF
Claim Discount Now
Search tutorials & examples
(/)
www.domain-name.com
Bubble Sort
In this tutorial, you will learn about the bubble sort algorithm and its
implementation in Python, Java, C, and C++.
Bubble sort is a sorting algorithm
(h!ps://www.programiz.com/dsa/sorting-algorithm) that compares two
adjacent elements and swaps them until they are in the intended order.
Just like the movement of air bubbles in the water that rise up to the
surface, each element of the array move to the end in each iteration.
Therefore, it is called a bubble sort.
Working of Bubble Sort
Suppose we are trying to sort the elements in ascending order.
1. First Iteration (Compare and Swap)
1. Starting from the first index, compare the first and the second
elements.
2. If the first element is greater than the second element, they are
swapped.
3. Now, compare the second and the third elements. Swap them if they
are not in order.
4. The above process goes on until the last element.
Compare the Adjacent Elements
2. Remaining Iteration
The same process goes on for the remaining iterations.
A&er each iteration, the largest element among the unsorted elements is
placed at the end.
Put the largest element at the end
In each iteration, the comparison takes place up to the last unsorted
element.
Compare the adjacent elements
The array is sorted when all the unsorted elements are placed at their
correct positions.
The array is sorted if all elements are kept in the right order
Bubble Sort Algorithm
bubbleSort(array)
for i <- 1 to indexOfLastUnsortedElement-1
if leftElement > rightElement
swap leftElement and rightElement
end bubbleSort
Bubble Sort Code in Python, Java and C/C++
Python Java C C++
# Bubble sort in Python
def bubbleSort(array):
# loop to access each array element
for i in range(len(array)):
# loop to compare array elements
for j in range(0, len(array) - i - 1):
# compare two adjacent elements
# change > to < to sort in descending order
if array[j] > array[j + 1]:
# swapping elements if elements
# are not in the intended order
temp = array[j]
array[j] = array[j+1]
array[j+1] = temp
data = [-2, 45, 0, 11, -9]
bubbleSort(data)
print('Sorted Array in Ascending Order:')
print(data)
Optimized Bubble Sort Algorithm
In the above algorithm, all the comparisons are made even if the array is
already sorted.
This increases the execution time.
To solve this, we can introduce an extra variable swapped . The value of
swapped is set true if there occurs swapping of elements. Otherwise, it is
set false.
A!er an iteration, if there is no swapping, the value of swapped will be
false. This means elements are already sorted and there is no need to
perform further iterations.
This will reduce the execution time and helps to optimize the bubble sort.
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 in Python, Java, and C/C++
Python Java C C++
# Optimized Bubble sort in Python
def bubbleSort(array):
# loop through each element of array
for i in range(len(array)):
# keep track of swapping
swapped = False
# loop to compare array elements
for j in range(0, len(array) - i - 1):
# compare two adjacent elements
# change > to < to sort in descending order
if array[j] > array[j + 1]:
# swapping occurs if elements
# are not in the intended order
temp = array[j]
array[j] = array[j+1]
array[j+1] = temp
swapped = True
# no swapping means the array is already sorted
# so no need for further comparison
if not swapped:
break
Bubble Sort Complexity
Time Complexity
Best O(n)
Worst O(n2)
Average O(n2)
Space Complexity O(1)
Stability Yes
Complexity in Detail
Bubble Sort compares the adjacent elements.
Cycle Number of Comparisons
1st (n-1)
2nd (n-2)
3rd (n-3)
....... ......
last 1
Hence, the number of comparisons is
(n-1) + (n-2) + (n-3) +.....+ 1 = n(n-1)/2
nearly equals to n2
Hence, Complexity: O(n2)
Also, if we observe the code, bubble sort requires two loops. Hence, the
complexity is n*n = n2
1. 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).
2. Space Complexity
Space complexity is O(1) because an extra variable is used for
swapping.
In the optimized bubble sort algorithm, two extra variables are used.
Hence, the space complexity will be O(2) .
Bubble Sort Applications
Bubble sort is used if
complexity does not ma#er
short and simple code is preferred
Similar Sorting Algorithms
Quicksort (/dsa/quick-sort)
Insertion Sort (/dsa/insertion-sort)
Merge Sort (/dsa/merge-sort)
Selection Sort (/dsa/selection-sort)
Previous Tutorial: Next
(/dsa/bellman- Tutorial:
Bellman Ford's (/dsa/selection-
ford-algorithm) Selection
Algorithm sort)
Sort
Share on:
(h#ps://www.facebook.com/sharer/sharer.php? (h#ps://twi#er.com/intent/twe
u=h#ps://www.programiz.com/dsa/bubble-sort) text=Check%20this%20amazi
sort)
Did you find this article helpful?
Related Tutorials
DS & Algorithms DS & Algorithms
Selection Sort Algorithm Insertion Sort Algorithm
(/dsa/selection-sort) (/dsa/insertion-sort)
DS & Algorithms DS & Algorithms
Shell Sort Algorithm Quicksort Algorithm
(/dsa/shell-sort) (/dsa/quick-sort)
