Before you keep reading...

Runestone Academy can only continue if we get support from individuals like you. As a student you are well aware of the high cost of textbooks. Our mission is to provide great books to you for free, but we ask that you consider a $10 donation, more if you can or less if $10 is a burden.

Support Runestone Academy Today

5.7. The Bubble Sort

The bubble sort makes multiple passes through a list. It compares adjacent items and exchanges those that are out of order. Each pass through the list places the next largest value in its proper place. In essence, each item bubbles up to the location where it belongs.

Figure 1 shows the first pass of a bubble sort. The shaded items are being compared to see if they are out of order. If there are $n$ items in the list, then there are $n-1$ pairs of items that need to be compared on the first pass. It is important to note that once the largest value in the list is part of a pair, it will continually be moved along until the pass is complete.

Figure 1: Bubble Sort: The First Pass

At the start of the second pass, the largest value is now in place. There are $n-1$ items left to sort, meaning that there will be $n-2$ pairs. Since each pass places the next largest value in place, the total number of passes necessary will be $n-1$. After completing the $n-1$ passes, the smallest item must be in the correct position with no further processing required. ActiveCode 1 shows the complete bubble_sort function. It takes the list as a parameter and modifies it by exchanging items as necessary.

The exchange operation, sometimes called a swap, is slightly different in Python than in most other programming languages. Typically, swapping two elements in a list requires a temporary variable (an additional memory location). A code fragment such as

temp = a_list[i]
a_list[i] = a_list[j]
a_list[j] = temp

will exchange the $i$-th and $j$-th items in the list. Without the temporary storage, one of the values would be overwritten.

In Python, it is possible to perform simultaneous assignment. The statement a, b = b, a will result in two assignment statements being done at the same time (see Figure 2). Using simultaneous assignment, the exchange operation can be done in one statement.

Lines 5–7 in ActiveCode 1 perform the exchange of the $i$ and $(i+1)$-th items using the three-step procedure described earlier. Note that we could also have used the simultaneous assignment to swap the items.

Figure 2: Exchanging Two Values in Python

The following activecode example shows the complete bubble_sort function working on the list shown above.

def bubble_sort(a_list): for i in range(len(a_list) - 1, 0, -1): for j in range(i): if a_list[j] > a_list[j + 1]: temp = a_list[j] a_list[j] = a_list[j + 1] a_list[j + 1] = temp a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20] bubble_sort(a_list) print(a_list)

The following animation shows bubble_sort in action.

Initialize Run Stop
Beginning Step Forward Step Backward End

To analyze the bubble sort, we should note that regardless of how the items are arranged in the initial list, $n-1$ passes will be made to sort a list of size $n$. Table 1 shows the number of comparisons for each pass. The total number of comparisons is the sum of the first $n-1$ integers. Recall that the sum of the first $n$ integers is $\frac{1}{2}{n}^2+\frac{1}{2}n$. The sum of the first $n-1$ integers is $\frac{1}{2}{n}^2+\frac{1}{2}n-n$, which is $\frac{1}{2}{n}^2-\frac{1}{2}n$. This is still $O(n^2)$ comparisons. In the best case, if the list is already ordered, no exchanges will be made. However, in the worst case, every comparison will cause an exchange. On average, we exchange half of the time.

Table 1: Comparisons for Each Pass of Bubble Sort

Pass	Comparisons
1	$n-1$
2	$n-2$
3	$n-3$
…	…
$n-1$	$1$

A bubble sort is often considered the most inefficient sorting method since it must exchange items before the final location is known. These “wasted” exchange operations are very costly. However, because the bubble sort makes passes through the entire unsorted portion of the list, it has the capability to do something most sorting algorithms cannot. In particular, if during a pass there are no exchanges, then we know that the list must be sorted. A bubble sort can be modified to stop early if it finds that the list has become sorted. This means that for lists that require just a few passes, a bubble sort may have an advantage in that it will recognize the sorted list and stop. ActiveCode 2 shows this modification, which is often referred to as the short bubble.

def bubble_sort_short(a_list): for i in range(len(a_list) - 1, 0, -1): exchanges = False for j in range(i): if a_list[j] > a_list[j + 1]: exchanges = True a_list[j], a_list[j + 1] = a_list[j + 1], a_list[j] if not exchanges: break a_list = [20, 30, 40, 90, 50, 60, 70, 80, 100, 110] bubble_sort_short(a_list) print(a_list)

Before you keep reading...

Making great stuff takes time and $$. If you appreciate the book you are reading now and want to keep quality materials free for other students please consider a donation to Runestone Academy. We ask that you consider a $10 donation, but if you can give more thats great, if $10 is too much for your budget we would be happy with whatever you can afford as a show of support.

Support Runestone Academy Today

Self Check

Q-4: Suppose you have the following list of numbers to sort: <br> [19, 1, 9, 7, 3, 10, 13, 15, 8, 12] which list represents the partially sorted list after three complete passes of bubble sort?

• [1, 9, 19, 7, 3, 10, 13, 15, 8, 12]
• This answer represents three swaps. A pass means that you continue swapping all the way to the end of the list.
• [1, 3, 7, 9, 10, 8, 12, 13, 15, 19]
• Very Good
• [1, 7, 3, 9, 10, 13, 8, 12, 15, 19]
• A bubble sort contines to swap numbers up to index position passnum. But remember that passnum starts at the length of the list - 1.
• [1, 9, 19, 7, 3, 10, 13, 15, 8, 12]
• You have been doing an insertion sort, not a bubble sort.

You have attempted 1 of 4 activities on this page