>> [MUSIC PLAYING]
DOUG LLOYD: Selection sort is an algorithm that, as you might expect,
sorts a set of elements.
And algorithm recall is a step-by-step set
of instructions for completing a task.
>> In selection sort the basic idea is this,
find the smallest unsorted element and add it to the end of the sorted list.
Effectively what this does is build a sorted list, one element at a time.
Breaking it down to pseudocode we could state this algorithm
as follows, repeat this until no unsorted elements remain.
Search through the unsorted data to find the smallest value,
then swap the smallest value with the first element of the unsorted part.
>> It may help to visualize this, so let's take a look at this.
So this, I contend, is an unsorted array and I've
indicated it by indicating that all of the elements are colored red,
they are not yet sorted.
This is the entire unsorted part of the array.
>> So let's go through the steps of selection sort to sort this array.
So again, we're gonna repeat until no unsorted elements remain.
We're gonna search through the data to find the smallest value,
and then swap that value with the first element of the unsorted part.
>> Right now, again, the entire array is the unsorted part.
All of the red elements are unsorted.
So we search through and we find the smallest value.
We start at the beginning, we go to the end,
we find the smallest value is, one.
So that's part one.
And then part two, swap that value with the first element of the unsorted part,
or the first red element.
>> In this case that would be five, so we swap one and five.
When we do this, we can visually see that we've
moved the smallest valued element of the array, to the very beginning.
Effectively sorting that element.
>> And so we can indeed confirm and state that one, is sorted.
And so we'll indicate the sorted portion of our array, by coloring it blue.
>> Now we just repeat the process again.
We search through the unsorted part of the array to find the smallest element.
In this case, it's two.
>> We swap that with the first element of the unsorted part.
In this case two also happens to be the first element of the unsorted part.
So we swap two with itself, which really just leaves two
where it is, and it's sorted.
Continuing on, we search through to find the smallest element.
It's three.
We swap it with the first element, which is five.
And now three is sorted.
>> We search through again, and we find the smallest element is four.
We swap it with the first element of the unsorted part, and now four is sorted.
>> We find that five is the smallest element.
We swap it with the first element of the unsorted part.
And now five is sorted.
>> And then lastly, our unsorted part consists
of just a single element, so we search through
and we find that six is the smallest, and in fact, only element.
And then we can state that it is sorted.
And now we've switched our array from being completely unsorted
in red, to completely sorted in blue, using selection sort.
>> So what's the worst case scenario here?
Well in the absolute worst case, we have to look over
all of the elements of the array to find the smallest unsorted element,
and we have to repeat this process n times.
Once for each element of the array because we only, in this algorithm,
sort one element at time.
>> What's the best case scenario?
Well it's exactly the same, right?
We actually have to still step through every single element of the array
in order to confirm that it is, in fact, the smallest element.
>> So the worst case runtime, we have to repeat a process n times,
once for each of n elements.
And in the best case scenario, we have to do the same.
>> So thinking back to our computational complexity toolbox,
what do you think is the worst case runtime for selection sort?
What do you think is the best case runtime for selection sort?
>> Did you guess Big O of n squared, and Big Omega of n squared?
You'd be right.
Those are, in fact, the worst case and best case run
times, for selection sort.
>> I'm Doug Lloyd.
This is CS50.