Bubble sort is an algorithm that compares adjacent elements in an array and swaps them if they are out of order, causing smaller values to "bubble" to the top. It repeats this process, making one pass through the array each time, for a total of N-1 passes where N is the number of elements, to fully sort the array. It uses a flag to detect if any swaps occurred to potentially stop early if the array is already sorted. While simple to implement, bubble sort has poor performance in general cases requiring up to N^2 comparisons and exchanges in the worst case.

1. Bubble Sort
 Compares adjacent array elements
– Exchanges their values if they are out of order
 Smaller values bubble up to the top of the array
– Larger values sink to the bottom

2. Bubble Sort (cont.)
 Example:
512354277 101
0 1 2 3 4 5
Swap42 77

3. Bubble Sort (cont.)
 Example:
512357742 101Swap35 77
0 1 2 3 4 5

4. Bubble Sort (cont.)
 Example:
512773542 101Swap12 77
0 1 2 3 4 5

5. Bubble Sort (cont.)
 Example:
577123542 101
No need to swap
0 1 2 3 4 5

6. Bubble Sort (cont.)
 Example:
577123542 101 Swap5 101
0 1 2 3 4 5

7. Bubble Sort (cont.)
 Example:
77123542 5 101
Largest value correctly placed
0 1 2 3 4 5

8. Bubble Sort (cont.)
• Notice that only the largest value is correctly
placed
• All other values are still out of order
• So we need to repeat this process
77123542 5 101
Largest value correctly placed
0 1 2 3 4 5

9. Bubble Sort (cont.)
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.

10. Bubble Sort (cont.)
77123542 5
0 1 2 3 4 5
101
5421235 77
0 1 2 3 4 5
101
4253512 77
0 1 2 3 4 5
101
4235512 77
0 1 2 3 4 5
101
4235125 77
0 1 2 3 4 5
101
N-1

11. Bubble Sort (cont.)
 What if the array was already sorted?
 What if only a few elements were out of place and after a couple of “bubble ups,”
the array was sorted?
 We want to be able to detect this and “stop early”!

12. Bubble Sort (cont.)
Using a Boolean “Flag”
 We can use a boolean variable to determine if any swapping occurred during the
“bubble up.”
 If no swapping occurred, then we know that the collection is already sorted!
 This boolean “flag” needs to be reset after each “bubble up.”

13. public static void BubbleSort( int [ ] num )
{
int j;
boolean flag = true; // set flag to true to begin first pass
int temp; //holding variable
while ( flag )
{
flag= false; //set flag to false awaiting a possible swap
for( j=0; j > num.length -1; j++ )
if ( num[ j ] > num[j+1] ) // change to > for ascending sort
{
temp = num[ j ]; //swap elements
num[ j ] = num[ j+1 ];
num[ j+1 ] = temp;
flag = true; //shows a swap occurred
}
}
}
}

14. Bubble Sort (cont.)
 Excellent performance in some cases
– But very poor performance in others!
 Works best when array is nearly sorted to begin with
 Worst case number of comparisons: n2
 Worst case number of exchanges: n2
 Best case occurs when the array is already sorted:
– n comparisons
– 0 exchanges