## Some theory

Bubble sort is another commonly known sorting algorithm. The idea here is to scan a list of items (say integers) sequentially (from left to right) and compare consecutive pairs of elements starting at index 0.

Example:

```
=
# 92 is index 0 and the consecutive pairs are
# (92,11), (11,45), (45,2234) and so on ...
```

At first we compare elements (list[0],list[1]) then (list[1],list[2]) then (list[2],list[3]) and so on until the end of the list is reached.

When comparing we check if element i is greater than element i + 1, if they are we just swap the two elements and move on to the next pair. If they are not this means that the pair is already sorted, so we also move on to the next pair.

Example:

```
=
# Let's compare my_numbers[0] and my_numbers[1]
# [11, 92, 45, 2234, 0, 7, 65]
```

This process has to be repeated for however many items are on the list. So if the list holds 9 items, it means we need to loop through it 9 times at most. But what if our original list is partially sorted? We might not need 9 passes through the list.

One way for us to know that the list is fully sorted is if we have made no swaps during our pass. For that, we need a variable to keep track of how many swaps were made during a pass.

Example:

```
=
# Elements (0,1) are compared and swapped. List is now 11,92,45,2234,0,7,65
# Elements (1,2) are compared and swapped. List now 11,45,92,2234,0,7,65
# Elements (2,3) are compared and not swapped. List remains the same.
# Elements (3,4) are compared and swapped. List is now 11,45,92,0,2234,0,7,65
# Elements (4,5) are compared and swapped. List is now 11,45,92,0,7,2234,65
# Elements (5,6) are compared and swapped. List is now 11,45,92,0,7,65,2234
# This represents one unique pass through the list.
```

Notice how after each pass the highest value number is pushed at len(list) - 1.

## Some code

Let's look at how to implement Bubble Sort using Python:

```
= False
= True
= ,
, = False
```

This works right and it will sort any list you throw at it. However we can slightly optimise it: We know that, after each pass the highest value element is guaranteed to be sorted and placed at len(some_list) - 1. Because of this, for each subsequent pass, we can stop comparing the last sorted item. instead of comparing pairs that we know are already sorted. This is what it looks like:

```
= False
= - 1
= True
= ,
, = False
-= 1
```

After each pass through the loop, we know the right side of the list is sorted so we decrement the value of last_sorted_item. What this means is that the 1st pass will loop from 0 to len(some_list) -1, the second time, it will be from 0 to len(some_list) - 2 and so on ...

## Time complexity

The rate of growth of this algorithm is quadratic. Expressed as O(n^2) in "big-oh" notation.

```
= False # time here is constant
= - 1
# We go through this first loop n times
= True
# we go through this loop n-1 times
# execution here is constant
= ,
, = False
-= 1 # constant time
```

It's O(n^2) because, for each pass through the loop n times, we loop n times through the consecutive pairs. It's not a very efficient algorithm when used on large samples of data. It should only be used if you have a specific case on a small data set.

Next in the series is QuickSort, another interesting and more efficient sorting algorithm. As always, if you have questions, comments or if you spotted a typo or a mistake, please feel free to let me know on Twitter, I'm @aaqaishtyaq and always happy to help!