## What will we cover in this tutorial

**Selection sort** is one of the simplest sorting algorithms, which is a good algorithm to start with. While the algorithm is considered to be slow, it has the advantage of not using auxiliary space.

## Step 1: Understand the Selection Sort algorithm

The goal of sorting is to take an unsorted array of integers and sort it.

Example given below.

```
[97, 29, 53, 92, 42, 36, 12, 57, 90, 76, 85, 81, 12, 61, 45, 3, 83, 34, 7, 48]
to
[3, 7, 12, 12, 29, 34, 36, 42, 45, 48, 53, 57, 61, 76, 81, 83, 85, 90, 92, 97]
```

The algorithm is the most intuitive way of sorting a list.

It works as follows.

- Go through the list to be sorted and find the smallest element.
- Switch the smallest element with the first position.

If you started with the following list.

```
[97, 29, 53, 92, 42, 36, 12, 57, 90, 76, 85, 81, 12, 61, 45, 3, 83, 34, 7, 48]
```

You would now have this list.

```
[3, 29, 53, 92, 42, 36, 12, 57, 90, 76, 85, 81, 12, 61, 45, 97, 83, 34, 7, 48]
```

Notice, that now we have the smallest element in the front of the list, we know that the second smallest element must be somewhere in the list starting from the second position all the way to the end.

Hence, you can repeat step the above 2 steps on the list excluding the first element.

This will give you the following list.

```
[3, 7, 53, 92, 42, 36, 12, 57, 90, 76, 85, 81, 12, 61, 45, 97, 83, 34, 29, 48]
```

Now we have that the first two elements are sorted, while the rest of the list is not sorted.

Hence, we can repeat the two steps again on the unsorted part of the list.

If we continue this until the we reach the end of the list. This should give us a sorted list.

## Step 2: Implementation of Selection Sort

A beautiful thing about Selection Sort is that it does not use any auxiliary memory. If you are new to sorting, then this can be a big advantage if sorting large data sets.

The disadvantage of Selection Sort is the time complexity.

We will come back to that later.

The code of Selection Sort can be done in the following manner.

```
def selection_sort(list_to_sort):
for i in range(len(list_to_sort)):
index_of_min_value = i
for j in range(i + 1, len(list_to_sort)):
if list_to_sort[j] < list_to_sort[index_of_min_value]:
index_of_min_value = j
list_to_sort[i], list_to_sort[index_of_min_value] = list_to_sort[index_of_min_value], list_to_sort[i]
list_to_sort = [97, 29, 53, 92, 42, 36, 12, 57, 90, 76, 85, 81, 12, 61, 45, 3, 83, 34, 7, 48]
selection_sort(list_to_sort)
print(list_to_sort)
```

This will produce the correct output.

```
[3, 7, 12, 12, 29, 34, 36, 42, 45, 48, 53, 57, 61, 76, 81, 83, 85, 90, 92, 97]
```

## Step 3: The time complexity of Selection Sort algorithm

Now this is the sad part of this simple algorithm. It does not perform good. A sorting algorithm is considered efficient if it runs in **O(n log(n))**, which Selection Sort does not.

The simple time complexity analysis is as follows.

Assume we have a list of **n** unsorted integers. Then the first iteration of the list will make** n – 1** comparisons, the second iteration will make **n – 2** comparisons, and so forth all the way down to **1** comparison.

This is the sum of **1** to **n – 1**, which is found by this formula (n – 1)(n – 2)/2, which is** O(n^2)**.

Other than that the algorithm does **n** swapping of numbers. This is **O(n)**.

This combines the algorithm to **O(n + n^2) = O(n^2)**.

## Next Step

This should wake your appetite to understand how you can make more efficient sorting.

Another good example of a simple sorting algorithm is the Insertion Sort algorithm.

For more efficient algorithm you should check out the Merge Sort algorithm.