Bubble sort

Analysis

Performance

Bubble sort has a worst-case and average complexity of ${\displaystyle O(n^2)}$, where ${\displaystyle n}$ is the number of items being sorted. Most practical sorting algorithms have substantially better worst-case or average complexity, often ${\displaystyle O(n\log n)}$. Even other ${\displaystyle O(n^2)}$ sorting algorithms, such as insertion sort, generally run faster than bubble sort, and are no more complex. For this reason, bubble sort is rarely used in practice.

Like insertion sort, bubble sort is adaptive, which can give it an advantage over algorithms like quicksort. This means that it may outperform those algorithms in cases where the list is already mostly sorted (having a small number of inversions), despite the fact that it has worse average-case time complexity. For example, bubble sort is ${\displaystyle O(n)}$ on a list that is already sorted, while quicksort would still perform its entire ${\displaystyle O(n\log n)}$ sorting process.

While any sorting algorithm can be made ${\displaystyle O(n)}$ on a presorted list simply by checking the list before the algorithm runs, improved performance on almost-sorted lists is harder to replicate.

Rabbits and turtles

The distance and direction that elements must move during the sort determine bubble sort's performance because elements move in different directions at different speeds. An element that must move toward the end of the list can move quickly because it can take part in successive swaps. For example, the largest element in the list will win every swap, so it moves to its sorted position on the first pass even if it starts near the beginning. On the other hand, an element that must move toward the beginning of the list cannot move faster than one step per pass, so elements move toward the beginning very slowly. If the smallest element is at the end of the list, it will take ${\displaystyle n-1}$ passes to move it to the beginning. This has led to these types of elements being named rabbits and turtles, respectively, after the characters in Aesop's fable of The Tortoise and the Hare.

Various efforts have been made to eliminate turtles to improve the speed of bubble sort. Cocktail sort is a bi-directional bubble sort that goes from beginning to end, and then reverses itself, going end to beginning. It can move turtles fairly well, but it retains ${\displaystyle O(n^2)}$ worst-case complexity. Comb sort compares elements separated by large gaps, and can move turtles extremely quickly before proceeding to smaller and smaller gaps to smooth out the list. Its average speed is comparable to faster algorithms like quicksort.

Step-by-step example

Take an array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest number using bubble sort. In each step, elements written in bold are being compared. Three passes will be required:

First pass

( 5 1 4 2 8 ) → ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.

( 1 5 4 2 8 ) → ( 1 4 5 2 8 ), Swap since 5 > 4

( 1 4 5 2 8 ) → ( 1 4 2 5 8 ), Swap since 5 > 2

( 1 4 2 5 8 ) → ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.

Second pass

( 1 4 2 5 8 ) → ( 1 4 2 5 8 )

( 1 4 2 5 8 ) → ( 1 2 4 5 8 ), Swap since 4 > 2

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

Now, the array is already sorted, but the algorithm does not know if it is completed. The algorithm needs one additional whole pass without any swap to know it is sorted.

Third pass

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

Implementation

Pseudocode implementation

In pseudocode the algorithm can be expressed as (0-based array):

<span id="mwow"></span><span class="k" id="mwpA">procedure</span><span class="w" id="mwpQ"> </span><span class="nf" id="mwpg">bubbleSort</span><span class="p" id="mwpw">(</span><span class="n" id="mwqA">A</span><span class="w" id="mwqQ"> </span><span class="o" id="mwqg">:</span><span class="w" id="mwqw"> </span><span class="n" id="mwrA">list</span><span class="w" id="mwrQ"> </span><span class="k" id="mwrg">of</span><span class="w" id="mwrw"> </span><span class="n" id="mwsA">sortable</span><span class="w" id="mwsQ"> </span><span class="n" id="mwsg">items</span><span class="p" id="mwsw">)</span> <span class="w" id="mwtA"> </span><span class="n" id="mwtQ">n</span><span class="w" id="mwtg"> </span><span class="o" id="mwtw">:=</span><span class="w" id="mwuA"> </span><span class="nb" id="mwuQ">length</span><span class="p" id="mwug">(</span><span class="n" id="mwuw">A</span><span class="p" id="mwvA">)</span> <span class="w" id="mwvQ"> </span><span class="k" id="mwvg">repeat</span> <span class="w" id="mwvw"> </span><span class="n" id="mwwA">swapped</span><span class="w" id="mwwQ"> </span><span class="o" id="mwwg">:=</span><span class="w" id="mwww"> </span><span class="k" id="mwxA">false</span> <span class="w" id="mwxQ"> </span><span class="k" id="mwxg">for</span><span class="w" id="mwxw"> </span><span class="n" id="mwyA">i</span><span class="w" id="mwyQ"> </span><span class="o" id="mwyg">:=</span><span class="w" id="mwyw"> </span><span class="mi" id="mwzA">1</span><span class="w" id="mwzQ"> </span><span class="k" id="mwzg">to</span><span class="w" id="mwzw"> </span><span class="n" id="mw0A">n</span><span class="o" id="mw0Q">-</span><span class="mi" id="mw0g">1</span><span class="w" id="mw0w"> </span><span class="n" id="mw1A">inclusive</span><span class="w" id="mw1Q"> </span><span class="k" id="mw1g">do</span> <span class="w" id="mw1w"> </span><span class="cm" id="mw2A">{ if this pair is out of order }</span> <span class="w" id="mw2Q"> </span><span class="k" id="mw2g">if</span><span class="w" id="mw2w"> </span><span class="n" id="mw3A">A</span><span class="p" id="mw3Q">[</span><span class="n" id="mw3g">i</span><span class="o" id="mw3w">-</span><span class="mi" id="mw4A">1</span><span class="p" id="mw4Q">]</span><span class="w" id="mw4g"> </span><span class="o" id="mw4w">></span><span class="w" id="mw5A"> </span><span class="n" id="mw5Q">A</span><span class="p" id="mw5g">[</span><span class="n" id="mw5w">i</span><span class="p" id="mw6A">]</span><span class="w" id="mw6Q"> </span><span class="k" id="mw6g">then</span> <span class="w" id="mw6w"> </span><span class="cm" id="mw7A">{ swap them and remember something changed }</span> <span class="w" id="mw7Q"> </span><span class="nb" id="mw7g">swap</span><span class="p" id="mw7w">(</span><span class="n" id="mw8A">A</span><span class="p" id="mw8Q">[</span><span class="n" id="mw8g">i</span><span class="o" id="mw8w">-</span><span class="mi" id="mw9A">1</span><span class="p" id="mw9Q">]</span><span class="o" id="mw9g">,</span><span class="w" id="mw9w"> </span><span class="n" id="mw-A">A</span><span class="p" id="mw-Q">[</span><span class="n" id="mw-g">i</span><span class="p" id="mw-w">])</span> <span class="w" id="mw_A"> </span><span class="n" id="mw_Q">swapped</span><span class="w" id="mw_g"> </span><span class="o" id="mw_w">:=</span><span class="w" id="mwAQA"> </span><span class="k" id="mwAQE">true</span> <span class="w" id="mwAQI"> </span><span class="k" id="mwAQM">end</span><span class="w" id="mwAQQ"> </span><span class="k" id="mwAQU">if</span> <span class="w" id="mwAQY"> </span><span class="k" id="mwAQc">end</span><span class="w" id="mwAQg"> </span><span class="k" id="mwAQk">for</span> <span class="w" id="mwAQo"> </span><span class="k" id="mwAQs">until</span><span class="w" id="mwAQw"> </span><span class="k" id="mwAQ0">not</span><span class="w" id="mwAQ4"> </span><span class="n" id="mwAQ8">swapped</span> <span class="k" id="mwARA">end</span><span class="w" id="mwARE"> </span><span class="k" id="mwARI">procedure</span>

Optimizing bubble sort

The bubble sort algorithm can be optimized by observing that the n-th pass finds the n-th largest element and puts it into its final place. So, the inner loop can avoid looking at the last n − 1 items when running for the n-th time:

<span id="mwARw"></span><span class="k" id="mwAR0">procedure</span><span class="w" id="mwAR4"> </span><span class="nf" id="mwAR8">bubbleSort</span><span class="p" id="mwASA">(</span><span class="n" id="mwASE">A</span><span class="w" id="mwASI"> </span><span class="o" id="mwASM">:</span><span class="w" id="mwASQ"> </span><span class="n" id="mwASU">list</span><span class="w" id="mwASY"> </span><span class="k" id="mwASc">of</span><span class="w" id="mwASg"> </span><span class="n" id="mwASk">sortable</span><span class="w" id="mwASo"> </span><span class="n" id="mwASs">items</span><span class="p" id="mwASw">)</span> <span class="w" id="mwAS0"> </span><span class="n" id="mwAS4">n</span><span class="w" id="mwAS8"> </span><span class="o" id="mwATA">:=</span><span class="w" id="mwATE"> </span><span class="nb" id="mwATI">length</span><span class="p" id="mwATM">(</span><span class="n" id="mwATQ">A</span><span class="p" id="mwATU">)</span> <span class="w" id="mwATY"> </span><span class="k" id="mwATc">repeat</span> <span class="w" id="mwATg"> </span><span class="n" id="mwATk">swapped</span><span class="w" id="mwATo"> </span><span class="o" id="mwATs">:=</span><span class="w" id="mwATw"> </span><span class="k" id="mwAT0">false</span> <span class="w" id="mwAT4"> </span><span class="k" id="mwAT8">for</span><span class="w" id="mwAUA"> </span><span class="n" id="mwAUE">i</span><span class="w" id="mwAUI"> </span><span class="o" id="mwAUM">:=</span><span class="w" id="mwAUQ"> </span><span class="mi" id="mwAUU">1</span><span class="w" id="mwAUY"> </span><span class="k" id="mwAUc">to</span><span class="w" id="mwAUg"> </span><span class="n" id="mwAUk">n</span><span class="w" id="mwAUo"> </span><span class="o" id="mwAUs">-</span><span class="w" id="mwAUw"> </span><span class="mi" id="mwAU0">1</span><span class="w" id="mwAU4"> </span><span class="n" id="mwAU8">inclusive</span><span class="w" id="mwAVA"> </span><span class="k" id="mwAVE">do</span> <span class="w" id="mwAVI"> </span><span class="k" id="mwAVM">if</span><span class="w" id="mwAVQ"> </span><span class="n" id="mwAVU">A</span><span class="p" id="mwAVY">[</span><span class="n" id="mwAVc">i</span><span class="w" id="mwAVg"> </span><span class="o" id="mwAVk">-</span><span class="w" id="mwAVo"> </span><span class="mi" id="mwAVs">1</span><span class="p" id="mwAVw">]</span><span class="w" id="mwAV0"> </span><span class="o" id="mwAV4">></span><span class="w" id="mwAV8"> </span><span class="n" id="mwAWA">A</span><span class="p" id="mwAWE">[</span><span class="n" id="mwAWI">i</span><span class="p" id="mwAWM">]</span><span class="w" id="mwAWQ"> </span><span class="k" id="mwAWU">then</span> <span class="w" id="mwAWY"> </span><span class="nb" id="mwAWc">swap</span><span class="p" id="mwAWg">(</span><span class="n" id="mwAWk">A</span><span class="p" id="mwAWo">[</span><span class="n" id="mwAWs">i</span><span class="w" id="mwAWw"> </span><span class="o" id="mwAW0">-</span><span class="w" id="mwAW4"> </span><span class="mi" id="mwAW8">1</span><span class="p" id="mwAXA">]</span><span class="o" id="mwAXE">,</span><span class="w" id="mwAXI"> </span><span class="n" id="mwAXM">A</span><span class="p" id="mwAXQ">[</span><span class="n" id="mwAXU">i</span><span class="p" id="mwAXY">])</span> <span class="w" id="mwAXc"> </span><span class="n" id="mwAXg">swapped</span><span class="w" id="mwAXk"> </span><span class="o" id="mwAXo">:=</span><span class="w" id="mwAXs"> </span><span class="k" id="mwAXw">true</span> <span class="w" id="mwAX0"> </span><span class="k" id="mwAX4">end</span><span class="w" id="mwAX8"> </span><span class="k" id="mwAYA">if</span> <span class="w" id="mwAYE"> </span><span class="k" id="mwAYI">end</span><span class="w" id="mwAYM"> </span><span class="k" id="mwAYQ">for</span> <span class="w" id="mwAYU"> </span><span class="n" id="mwAYY">n</span><span class="w" id="mwAYc"> </span><span class="o" id="mwAYg">:=</span><span class="w" id="mwAYk"> </span><span class="n" id="mwAYo">n</span><span class="w" id="mwAYs"> </span><span class="o" id="mwAYw">-</span><span class="w" id="mwAY0"> </span><span class="mi" id="mwAY4">1</span> <span class="w" id="mwAY8"> </span><span class="k" id="mwAZA">until</span><span class="w" id="mwAZE"> </span><span class="k" id="mwAZI">not</span><span class="w" id="mwAZM"> </span><span class="n" id="mwAZQ">swapped</span> <span class="k" id="mwAZU">end</span><span class="w" id="mwAZY"> </span><span class="k" id="mwAZc">procedure</span>

More generally, it can happen that more than one element is placed in its final position on a single pass. In particular, after every pass, all elements after the last swap are sorted, and do not need to be checked again. This allows us to skip over many elements, resulting in about a 50% improvement in the worst-case comparison count (though no improvement in swap counts), and adds very little complexity because the new code subsumes the swapped variable:

To accomplish this in pseudocode, the following can be written:

<span id="mwAZ0"></span><span class="k" id="mwAZ4">procedure</span><span class="w" id="mwAZ8"> </span><span class="nf" id="mwAaA">bubbleSort</span><span class="p" id="mwAaE">(</span><span class="n" id="mwAaI">A</span><span class="w" id="mwAaM"> </span><span class="o" id="mwAaQ">:</span><span class="w" id="mwAaU"> </span><span class="n" id="mwAaY">list</span><span class="w" id="mwAac"> </span><span class="k" id="mwAag">of</span><span class="w" id="mwAak"> </span><span class="n" id="mwAao">sortable</span><span class="w" id="mwAas"> </span><span class="n" id="mwAaw">items</span><span class="p" id="mwAa0">)</span> <span class="w" id="mwAa4"> </span><span class="n" id="mwAa8">n</span><span class="w" id="mwAbA"> </span><span class="o" id="mwAbE">:=</span><span class="w" id="mwAbI"> </span><span class="nb" id="mwAbM">length</span><span class="p" id="mwAbQ">(</span><span class="n" id="mwAbU">A</span><span class="p" id="mwAbY">)</span> <span class="w" id="mwAbc"> </span><span class="k" id="mwAbg">repeat</span> <span class="w" id="mwAbk"> </span><span class="n" id="mwAbo">newn</span><span class="w" id="mwAbs"> </span><span class="o" id="mwAbw">:=</span><span class="w" id="mwAb0"> </span><span class="mi" id="mwAb4">0</span> <span class="w" id="mwAb8"> </span><span class="k" id="mwAcA">for</span><span class="w" id="mwAcE"> </span><span class="n" id="mwAcI">i</span><span class="w" id="mwAcM"> </span><span class="o" id="mwAcQ">:=</span><span class="w" id="mwAcU"> </span><span class="mi" id="mwAcY">1</span><span class="w" id="mwAcc"> </span><span class="k" id="mwAcg">to</span><span class="w" id="mwAck"> </span><span class="n" id="mwAco">n</span><span class="w" id="mwAcs"> </span><span class="o" id="mwAcw">-</span><span class="w" id="mwAc0"> </span><span class="mi" id="mwAc4">1</span><span class="w" id="mwAc8"> </span><span class="n" id="mwAdA">inclusive</span><span class="w" id="mwAdE"> </span><span class="k" id="mwAdI">do</span> <span class="w" id="mwAdM"> </span><span class="k" id="mwAdQ">if</span><span class="w" id="mwAdU"> </span><span class="n" id="mwAdY">A</span><span class="p" id="mwAdc">[</span><span class="n" id="mwAdg">i</span><span class="w" id="mwAdk"> </span><span class="o" id="mwAdo">-</span><span class="w" id="mwAds"> </span><span class="mi" id="mwAdw">1</span><span class="p" id="mwAd0">]</span><span class="w" id="mwAd4"> </span><span class="o" id="mwAd8">></span><span class="w" id="mwAeA"> </span><span class="n" id="mwAeE">A</span><span class="p" id="mwAeI">[</span><span class="n" id="mwAeM">i</span><span class="p" id="mwAeQ">]</span><span class="w" id="mwAeU"> </span><span class="k" id="mwAeY">then</span> <span class="w" id="mwAec"> </span><span class="nb" id="mwAeg">swap</span><span class="p" id="mwAek">(</span><span class="n" id="mwAeo">A</span><span class="p" id="mwAes">[</span><span class="n" id="mwAew">i</span><span class="w" id="mwAe0"> </span><span class="o" id="mwAe4">-</span><span class="w" id="mwAe8"> </span><span class="mi" id="mwAfA">1</span><span class="p" id="mwAfE">]</span><span class="o" id="mwAfI">,</span><span class="w" id="mwAfM"> </span><span class="n" id="mwAfQ">A</span><span class="p" id="mwAfU">[</span><span class="n" id="mwAfY">i</span><span class="p" id="mwAfc">])</span> <span class="w" id="mwAfg"> </span><span class="n" id="mwAfk">newn</span><span class="w" id="mwAfo"> </span><span class="o" id="mwAfs">:=</span><span class="w" id="mwAfw"> </span><span class="n" id="mwAf0">i</span> <span class="w" id="mwAf4"> </span><span class="k" id="mwAf8">end</span><span class="w" id="mwAgA"> </span><span class="k" id="mwAgE">if</span> <span class="w" id="mwAgI"> </span><span class="k" id="mwAgM">end</span><span class="w" id="mwAgQ"> </span><span class="k" id="mwAgU">for</span> <span class="w" id="mwAgY"> </span><span class="n" id="mwAgc">n</span><span class="w" id="mwAgg"> </span><span class="o" id="mwAgk">:=</span><span class="w" id="mwAgo"> </span><span class="n" id="mwAgs">newn</span> <span class="w" id="mwAgw"> </span><span class="k" id="mwAg0">until</span><span class="w" id="mwAg4"> </span><span class="n" id="mwAg8">n</span><span class="w" id="mwAhA"> </span><span class="err" id="mwAhE">≤</span><span class="w" id="mwAhI"> </span><span class="mi" id="mwAhM">1</span> <span class="k" id="mwAhQ">end</span><span class="w" id="mwAhU"> </span><span class="k" id="mwAhY">procedure</span>

Alternate modifications, such as the cocktail shaker sort attempt to improve on the bubble sort performance while keeping the same idea of repeatedly comparing and swapping adjacent items.

Use

Although bubble sort is one of the simplest sorting algorithms to understand and implement, its O(n²) complexity means that its efficiency decreases dramatically on lists of more than a small number of elements. Even among simple O(n²) sorting algorithms, algorithms like insertion sort are usually considerably more efficient.

Due to its simplicity, bubble sort is often used to introduce the concept of an algorithm, or a sorting algorithm, to introductory computer science students. However, some educators such as Owen Astrachan have gone to great lengths to disparage bubble sort and its continued popularity in computer science education, recommending that it no longer even be taught.

The Jargon File, which famously calls bogosort "the archetypical [sic] perversely awful algorithm", also calls bubble sort "the generic bad algorithm". Donald Knuth, in The Art of Computer Programming, concluded that "the bubble sort seems to have nothing to recommend it, except a catchy name and the fact that it leads to some interesting theoretical problems", some of which he then discusses.

Bubble sort is asymptotically equivalent in running time to insertion sort in the worst case, but the two algorithms differ greatly in the number of swaps necessary. Experimental results such as those of Astrachan have also shown that insertion sort performs considerably better even on random lists. For these reasons, many modern algorithm textbooks avoid using the bubble sort algorithm in favor of insertion sort.

Bubble sort also interacts poorly with modern CPU hardware. It produces at least twice as many writes as insertion sort, twice as many cache misses, and asymptotically more branch mispredictions. Experiments by Astrachan sorting strings in Java show bubble sort to be roughly one-fifth as fast as an insertion sort and 70% as fast as a selection sort.

In computer graphics, bubble sort is popular for its capability to detect a very small error (like a swap of just two elements) in almost-sorted arrays and fix it with just linear complexity (2n). For example, it is used in a polygon filling algorithm, where bounding lines are sorted by their x coordinate at a specific scan line (a line parallel to the x axis), and with incrementing y, their order changes (two elements are swapped) only at intersections of two lines. Bubble sort is a stable sort algorithm, like insertion sort.

Variations

• Odd–even sort is a parallel version of bubble sort, for message-passing systems.
• Passes can be from right to left, rather than left to right. This is more efficient for lists with unsorted items added to the end.
• Cocktail shaker sort alternates leftwards and rightwards passes.
• Comb sort is a modification bubble sort in the same way shell sort modifies insertion sort

Debate over name

Bubble sort has been occasionally referred to as a "sinking sort".

For example, Donald Knuth describes the insertion of values at or towards their desired location as letting "[the value] settle to its proper level", and that "this method of sorting has sometimes been called the sifting or sinking technique.

This debate is perpetuated by the ease with which one may consider this algorithm from two different but equally valid perspectives:

1. The larger values might be regarded as heavier and therefore be seen to progressively sink to the bottom of the list
2. The smaller values might be regarded as lighter and therefore be seen to progressively bubble up to the top of the list.

In popular culture

In a 2007 interview, former Google CEO Eric Schmidt asked then-presidential candidate Barack Obama about the best way to sort one million integers; Obama paused for a moment and replied: "I think the bubble sort would be the wrong way to go."