The document describes the bubble sort algorithm. Bubble sort works by comparing adjacent elements and swapping them into ascending order. This process is repeated, with each iteration bubbling the largest remaining element to its correct position. The algorithm has an outer loop that repeats the bubbling process N-1 times to fully sort an array of N elements. Each iteration reduces the number of comparisons needed by bubbling one element into place. Though simple, bubble sort is not very efficient for large arrays due to its quadratic time complexity.

1. BUBBLE SORT
Presented By :
Ashish Sadavarti

2. SORTING
Sorting takes an unordered collection and makes
it an ordered one.
1 2 3 4 5 6
1 2 3 4 5 6
12 20 6 66 105 2
2 6 12 20 66 105

3. BUBBLE SORT:
● It uses simple algorithm. It sorts by comparing each pair of
adjacent items and swapping them in the order. This will be
repeated until no swaps are needed . The algorithm got its
name from the way smaller elements “bubble” to the top of
the list.
● It is not much efficient when a list is having more then a few
elements . Among simple sorting algorithms, algorithms like
insertion sort are usually considered as more efficient.
● Bubble sort is little slower compared to other sorting
technique but it is easy because it deals with only two
elements at a time.
3

4. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
12
35
42
77 101
1 2 3 4 5 6

5. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
12
35
42
77 101
1 2 3 4 5 6
Swap
42 77

6. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
12
35
77
42 101
1 2 3 4 5 6
Swap
35 77

7. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
12
77
35
42 101
1 2 3 4 5 6
Swap
12 77

8. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
77
12
35
42 101
1 2 3 4 5 6
No need to swap

9. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
77
12
35
42 101
1 2 3 4 5 6
Swap
5 101

10. "Bubbling Up" the Largest Element
● Traverse a collection of elements
○ Move from the front to the end
○ “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
77
12
35
42 5
1 2 3 4 5 6
101
Largest value correctly placed

11. The “Bubble Up” Algorithm
index <- 1
last_compare_at <- n – 1
loop
exitif(index > last_compare_at)
if(A[index] > A[index + 1]) then
Swap(A[index], A[index + 1])
endif
index <- index + 1
endloop

12. No, Swap isn’t built in.
Procedure Swap(a, b isoftype in/out Num)
t isoftype Num
t <- a
a <- b
b <- t
endprocedure // Swap
LB

13. Items of Interest
● Notice that only the largest value is
correctly placed
● All other values are still out of order
● So we need to repeat this process
77
12
35
42 5
1 2 3 4 5 6
101
Largest value correctly placed

14. Repeat “Bubble Up” How
Many Times?
● If we have N elements…
● And if each time we bubble an
element, we place it in its correct
location…
● Then we repeat the “bubble up”
process N – 1 times.
● This guarantees we’ll correctly
place all N elements.

15. “Bubbling” All the Elements
77
12
35
42 5
1 2 3 4 5 6
101
5
42
12
35 77
1 2 3 4 5 6
101
42
5
35
12 77
1 2 3 4 5 6
101
42
35
5
12 77
1 2 3 4 5 6
101
42
35
12
5 77
1 2 3 4 5 6
101
N
-
1

16. Reducing the Number of
Comparisons
12
35
42
77 101
1 2 3 4 5 6
5
77
12
35
42 5
1 2 3 4 5 6
101
5
42
12
35 77
1 2 3 4 5 6
101
42
5
35
12 77
1 2 3 4 5 6
101
42
35
5
12 77
1 2 3 4 5 6
101

17. Reducing the Number of
Comparisons
● On the Nth “bubble up”, we only need to
do MAX-N comparisons.
● For example:
○ This is the 4th “bubble up”
○ MAX is 6
○ Thus we have 2 comparisons to do
42
5
35
12 77
1 2 3 4 5 6
101

18. Putting It All Together

19. N is … // Size of Array
Arr_Type definesa Array[1..N] of Num
Procedure Swap(n1, n2 isoftype in/out Num)
temp isoftype Num
temp <- n1
n1 <- n2
n2 <- temp
endprocedure // Swap

20. procedure Bubblesort(A isoftype in/out Arr_Type)
to_do, index isoftype Num
to_do <- N – 1
loop
exitif(to_do = 0)
index <- 1
loop
exitif(index > to_do)
if(A[index] > A[index + 1]) then
Swap(A[index], A[index + 1])
endif
index <- index + 1
endloop
to_do <- to_do - 1
endloop
endprocedure // Bubblesort
Inner
loop
Outer
loop

21. Summary
● “Bubble Up” algorithm will move
largest value to its correct location (to
the right)
● Repeat “Bubble Up” until all elements
are correctly placed:
○ Maximum of N-1 times
○ Can finish early if no swapping
occurs
● We reduce the number of elements
we compare each time one is
correctly placed

22. Credits
● https://www.slideshare.net/manekar007/bubbl
e-sort-19001719
22

23. THANKYOU!