# A tour of the top 5 sorting algorithms with Python code

I recently started a book-focused educational newsletter. Book Dives is a bi-weekly newsletter where for each new issue we dive into a non-fiction book. You’ll learn about the book’s core lessons and how to apply them in real life. You can

subscribe for it here.

Sorting is a skill that every software engineer and developer needs some knowledge of. Not only to pass coding interviews but as a general understanding of programming itself. The different sorting algorithms are a perfect showcase of how algorithm design can have such a strong effect on program complexity, speed, and efficiency.

Let’s take a tour of the top 6 sorting algorithms and see how we can implement them in Python!

# Bubble Sort

Bubble sort is the one usually taught in introductory CS classes since it clearly demonstrates how sort works while being simple and easy to understand. Bubble sort steps through the list and compares adjacent pairs of elements. The elements are swapped if they are in the wrong order. The pass through the unsorted portion of the list is repeated until the list is sorted. Because Bubble sort repeatedly passes through the unsorted part of the list, it has a worst case complexity of O(n²).

# Selection Sort

Selection sort is also quite simple but frequently outperforms bubble sort. If you are choosing between the two, it’s best to just default right to selection sort. With Selection sort, we divide our input list / array into two parts: the sublist of items already sorted and the sublist of items remaining to be sorted that make up the rest of the list. We first find the smallest element in the *unsorted sublist* and place it at the end of the *sorted sublist. *Thus*, *we are continuously grabbing the smallest unsorted element and placing it in sorted order* *in the* sorted sublist. *This process continues iteratively until the list is fully sorted.

# Insertion Sort

Insertion sort is both faster and well-arguably more simplistic than both bubble sort and selection sort. Funny enough, it’s how many people sort their cards when playing a card game! On each loop iteration, insertion sort removes one element from the array. It then finds the location where that element belongs within another *sorted* array and inserts it there. It repeats this process until no input elements remain.

# Merge Sort

Merge sort is a perfectly elegant example of a Divide and Conquer algorithm. It simple uses the 2 main steps of such an algorithm:

(1) Continuously *divide *the unsorted list until you have *N* sublists, where each sublist has 1 element that is “unsorted” and *N *is the number of elements in the original array.

(2) Repeatedly merge i.e *conquer *the sublists together 2 at a time to produce new sorted sublists until all elements have been fully merged into a single sorted array.

# Quick Sort

Quick sort is also a divide and conquer algorithm like merge sort. Although it’s a bit more complicated, in most standard implementations it performs significantly faster than merge sort and rarely reaches its worst case complexity of O(n²). It has 3 main steps:

(1) We first select an element which we will call the *pivot* from the array.

(2)* *Move all elements that are smaller than the pivot to the left of the pivot; move all elements that are larger than the pivot to the right of the pivot. This is called the partition operation.

(3) Recursively apply the above 2 steps separately to each of the sub-arrays of elements with smaller and bigger values than the last pivot.