Bubble sort

1
8.3 Description
Suppose we have an array of data which is
unsorted:
 Starting at the front, traverse the array, find the
largest item, and move (or bubble) it to the top

 With each subsequent iteration, find the next largest

item and bubble it up towards the top of the array
 Bubble sort
2
8.3 Description
As well as looking at good algorithms, it is often
useful too look at sub-optimal algorithms
 Bubble sort is a simple algorithm with:
 a memorable name, and
 a simple idea

 It is also significantly worse than insertion sort

 Bubble sort
3
8.3.1 Implementation
The default algorithm:
template <typename Type>
void bubble( Type *const array, int const n ) {
for ( int i = n - 1; i > 0; --i ) {
for ( int j = 0; j < i; ++j ) {
if ( array[j] > array[j + 1] ) {
std::swap( array[j], array[j + 1] );
}
}
}
}
 Bubble sort
4
8.3.1 The Basic Algorithm
Here we have two nested loops, and therefore
calculating the run time is straight-forward:
n 1 n n  1 n n  1
 n  k  n n  1 
k 1 2

2
(n 2 )
 Bubble sort
5
8.3.1 Example
Consider the unsorted array to
the right

We start with the element in

the first location, and move
forward:
 if the current and next items are
in order, continue with the next
item, otherwise
 swap the two entries
 Bubble sort
6
8.3.1 Example
After one loop, the largest
element is in the last location
 Repeat the procedure
 Bubble sort
7
8.3.1 Example
Now the two largest elements
are at the end
 Repeat again
 Bubble sort
8
8.3.1 Example
With this loop, 5 and 7 are
swapped
 Bubble sort
9
8.3.1 Example
Finally, we swap the last two
entries to order them
 At this point, we have a sorted
array
 Bubble sort
10
8.3.2 Implementations and Improvements

The next few slides show some

implementations of bubble sort together with a
few improvements:
 reduce the number of swaps,
 halting if the list is sorted,
 limiting the range on which we must bubble, and
 alternating between bubbling up and sinking down
 Bubble sort
11
8.3.2.1 First Improvement
We could avoid so many swaps...
template <typename Type>
void bubble( Type *const array, int const n ) {
for ( int i = n - 1; i > 0; --i ) {
Type max = array[0]; // assume a[0]
is the max

for ( int j = 1; j <= i; ++j ) {

if ( array[j] < max ) {
array[j - 1] = array[j]; // move
} else {
array[j – 1] = max; // store the
old max
max = array[j]; // get the
new max
}
}

array[i] = max; // store the

max
}
}
 Bubble sort
12
8.3.2.2 Flagged Bubble Sort
One useful modification would be to check if no
swaps occur:
 If no swaps occur, the list is sorted
 In this example, no swaps occurred
during the 5th pass

Use a Boolean flag to check if no

swaps occurred
 Bubble sort
13
8.3.2.2 Flagged Bubble Sort
Check if the list is sorted (no swaps)
template <typename Type>
void bubble( Type *const array, int const n ) {
for ( int i = n - 1; i > 0; --i ) {
Type max = array[0];
bool sorted = true;

for ( int j = 1; j < i; ++j ) {

if ( array[j] < max ) {
array[j - 1] = array[j];
sorted = false;
} else {
array[j – 1] = max;
max = array[j];
}
}

array[i] = max;

if ( sorted ) {
break;
}
}
}
 Bubble sort
14
8.3.2.3 Range-limiting Bubble Sort
Intuitively, one may believe that limiting the loops
based on the location of the last swap may
significantly speed up the algorithm
 For example, after the second pass,
we are certain all entries after 4 are
sorted

The implementation is easier than that for using

a Boolean flag
 Bubble sort
15
8.3.2.3 Range-limiting Bubble Sort
Update i to at the place of the last swap
template <typename Type>
void bubble( Type *const array, int const n ) {
for ( int i = n - 1; i > 0; ) {
Type max = array[0];
int i = 0;

for ( int j = 1; j < i; ++j ) {

if ( array[j] < max ) {
array[j - 1] = array[j];
i = j - 1;
} else {
array[j – 1] = max;
max = array[j];
}
}

array[i] = max;
}
}
 Bubble sort
16
8.3.2.3 Range-limiting Bubble Sort
Unfortunately, in practice, this does little to
affect the number of comparisons
 Bubble sort
17
8.3.2.4 Alternating Bubble Sort
One operation which does significantly improve
the run time is to alternate between
 bubbling the largest entry to the top, and
 sinking the smallest entry to the bottom

This does, we will see, make a significant

improvement
 Bubble sort
18
8.3.2.4 Alternating Bubble Sort
Alternating between bubbling and sinking:
template <typename Type>
void bubble( Type *const array, int n ) {
int lower = 0;
int upper = n - 1;

while ( true ) {
int new_upper = lower;

for ( int i = lower; i < upper; ++i ) {

if ( array[i] > array[i + 1] ) {

Bubble up to the back

Type tmp = array[i];
array[i] = array[i + 1];
array[i + 1] = tmp;
new_upper = i;
}
}

upper = new_upper;

if ( lower == upper ) {
break;
}

int new_lower = upper;

for ( int i = upper; i > lower; --i ) {

if ( array[i - 1] > array[i] ) {
Type tmp = array[i];
array[i] = array[i - 1]; Sink down to the front
array[i - 1] = tmp;
new_lower = i;
}
}

lower = new_lower;

if ( lower == upper ) {
break;
}
}
}
 Bubble sort
19
8.3.2.4 Run-time Analysis
Because the bubble sort simply swaps
adjacent entries, it cannot be any better than
insertion sort which does n + d comparisons
where d is the number of inversions

Unfortunately, it isn’t that easy:

 There are numerous unnecessary comparisons
 Bubble sort
20
8.3.4 Summary
In this topic, we have looked at bubble sort

From the description, it sounds as if it is as

good as insertion sort
 it has the same asymptotic behaviour
 in practice, however, it is significantly worse
 it is also much more difficult to code...