>> [MUSIC PLAYING]
DOUG LLOYD: All right, so bubble sort is an algorithm
you can use to sort a set of elements.
Let's take a look at how it works.
>> So the basic idea behind bubble sort is this.
We generally want to move higher valued elements generally to the right,
and lower valued elements generally to the left, as we would expect.
We want the lower things to be at the beginning, and the higher things
to be at the end.
>> How do we do this?
Well in pseudocode code, we could say, let's
set a swap counter to a non-zero value.
We'll see why we do that in a second.
And then we repeat the following process until the swap counter is 0,
or until we make no swaps at all.
>> Reset the swap counter to 0 if it's not already 0.
Then look at every adjacent pair of elements.
If those two elements are not in order, swap them,
and add 1 to the swap counter.
If you're thinking about this before you visualize it,
notice that this will move lower valued elements to the left
and higher valued elements to the right, effectively doing what we want to do,
which is move those groups of elements in that way.
Let's visualize how this might look using our array
that we used to test out these algorithms.
We have an unsorted array here again, indicated by all of the elements
being in red.
And I set my swap counter to a nonzero value.
I arbitrarily chose negative 1-- it's not 0.
We want to repeat this process until the swap counter is 0.
This is why I set my swap counter to some non-zero value,
because otherwise the swap counter would be 0.
We wouldn't even begin the process of the algorithm.
So again, the steps are-- reset the swap counter
to 0, then look at every adjacent pair, and if they're out of order,
swap them, and add 1 to the swap counter.
So let's begin this process.
So the first thing we do is we set the swap counter to 0,
and then we start looking at each adjacent pair.
>> So we first start looking at 5 and 2.
We see that they are out of order and so we swap them.
And we add 1 to the swap counter.
So now our swap counter is 1, and 2 and 5 have been switched.
Now we repeat the process again.
>> We look at the next adjacent pair, 5 and 1-- they're also out of order,
so we swap them and add 1 to the swap counter.
Then we look at 5 and 3.
They are out of order, so we swap them and we add 1 to the swap counter.
Then we look at 5 and 6.
They're in order, so we don't actually need to swap anything this time.
Then we look at 6 and 4.
They're also out of order, so we swap them and we add 1 to the swap counter.
>> Now notice what's happened.
We've moved 6 all the way to the end.
So in selection sort, if you've seen that video, what we did was
we ended up moving the smallest elements in building
the sorted array essentially from left to right, smallest to largest.
In the case of bubble sort, if we're following this particular algorithm,
we're actually going to be building the sorted array from right
to left, largest to smallest.
We have effectively bubbled 6, the largest value, all the way to the end.
>> And so we can now declare that that is sorted,
and in future iterations-- going through the array again--
we don't have to consider 6 anymore.
We only have to consider the unsorted elements
when we're looking at adjacent pairs.
So we have finished one pass through bubble sort.
So now we go back to the question, repeat until the swap counter is 0.
Well the swap counter is 4, so we're going
to keep repeating this process again.
>> We're going to reset the swap counter to 0, and look at each adjacent pair.
So we start with 2 and 1-- they're out of order, so we swap them
and we add 1 to the swap counter.
2 and 3, they're in order.
We don't need to do anything.
3 and 5 are in order.
We don't need to do anything there.
>> 5 and 4, they are out of order, and so we
need to swap them and add 1 to the swap counter.
And now we've moved 5, the next largest element,
to the end of the unsorted portion.
So we can now call that part of the sorted portion.
>> Now you're looking at the screen and probably can tell,
as can I, that the array is sorted right now.
But we can't prove that yet.
We don't have a guarantee that it's sorted.
But this is where the swap counter's going to come into play.
>> So we've completed a pass.
The swap counter is 2.
So we're going to repeat this process again,
repeat until the swap counter is 0.
Reset the swap counter to 0.
So we'll reset it.
>> Now look at each adjacent pair.
That's in order, 1 and 2.
2 and 3 are in order.
3 and 4 are in order.
So at this point, notice we've completed looking at every adjacent pair,
but the swap counter is still 0.
>> If we don't have to switch any elements, then they
must be in order, by virtue of this process.
And so an efficiency of sorts, that we computer scientists love,
is we can now declare the entire array must
be sorted, because we didn't have to swap any elements.
That's pretty nice.
>> So what's the worst case scenario with bubble sort?
In the worst case the array is in completely reverse order,
and so we have to bubble each of the large elements all
the way across the array.
And we effectively also have to bubble all of the small elements back
all the way across the array, too.
So each of the n elements has to move across all of the other n elements.
So that's the worst case scenario.
In the best case scenario though, this is
slightly different from selection sort.
The array is already sorted when we go in.
We don't have to make any swaps on the first pass.
So we might have to look at fewer elements, right?
We don't have to repeat this process a number of times over.
>> So what does that mean?
So what's the worst case scenario for bubble sort, and what's
the best case scenario for bubble sort?
Did you guess this?
In the worst case you have to iterate across all the n elements n times.
So the worst case is n squared.
>> If the array is perfectly sorted though, you only
have to look at each of the elements once.
And if the swap counter is still 0, you can say this array is sorted.
And so in the best case, this is actually better than selection
sort-- it's omega of n.
>> I'm Doug Lloyd.
This is CS50.