Jyoti Gupta

23 Oct 2020

While there are dozens of sorting in Python that can make your code more robust and efficient, especially if you are exploring problem-solving with algorithms and data structures using Python, there are few primary ones that every beginner should be aware of. So let’s get to the chase and learn more about them.

Sorting can be used to solve a range of problems that coders generally face:

**Searching for Items**: Sorting a list before searching for a particular entry saves considerable time.**Finding Duplicates**: Similarly, sorting also makes it easy to quickly sift through lists and find duplicates, improving the quality of data.**Selecting Items**: Sorted lists (such as in ascending or descending orders) are always better precursors for data selection.**Analyzing Distribution Frequency**: Similarly, determining the frequency of a particular data set on a list is much quicker with sorting since both searching and selection are now faster.

Python has an in-built sorting function that can be called using sorted().

For instance, if you have an integer array with random numbers (comparable values), here is how the algorithm would work:

This built-in function for sorting in Python makes use of the Timsort algorithm, an advanced hybrid version of Insertion Sort and Merge Sort that are covered in the section below.

**Also Read：Why is Python Considered A High Level Programming Language**

Implementation of sorting algorithms can often prove to be time-consuming, especially if you are dealing in complex data analysis or sets. Depending on your use case, one sorting algorithm in Python can prove to be more efficient than others.

This is the primary reason why it is always advisable to time your sorting process (by using the proportional time between executions) while experimenting with various algorithms to know which one would perform the best at scale.

**Also Read：Python For Beginners With Examples**

Here’s a look at the top sorting algorithms that you can implement in Python right away:

One of the basic sorting algorithms, Bubble Sort compares adjacent entries in a list and keeps swapping them until they are in the correct order. To achieve this, the algorithm continuously passes through unsorted sections of lists. This essentially means that once the algorithm reaches the end of the list (n) it starts over and repeats itself up until the second last element (n-1).

Here is how you can implement this algorithm by using ‘while’ loop:

The final output of the Bubble sort would be:

`[1, 2, 3, 4, 5]`

The time complexity of this type of sort comes out to be O(n^2). This is because if there are n items in the array (list), there would be n iterations per item.

Instead of approaching the list head-on, the Insertion Sort segments the list into two sections - sorted and unsorted. The idea is to just iterate through the unsorted section and insert every list item into their correct position in the sorted list. Hence, the sorted list keeps increasing in size until all elements are sorted.

This algorithm can also be implemented by using the ‘while’ loop:

The final output of the Insertion sort would be:

`[5,15,17,21,30,36,56,519]`

Merge Sort has a bit of a complicated nature when it comes to dividing the lists. There are two primary steps in the algorithm:

- Let’s say the array that is to be sorted has N elements. The first step of the algorithm would be to continuously divide the unsorted list until the point where there are N sublists. This essentially means that every sublist has only one element.
- Next, the algorithm constantly mergers together all sublists, 2 sublists at a time. This process is repeated until all elements have been merged together to form a single and sorted array.

Here’s how you can implement the Merge Sort with Python

The final output of the Merge sort would be:

`[5,12,23,85,144]`

The premise of the Selection Sort algorithm is simple. It searches for the minimum value in the input array and moves it into the sorted array. The process is repeated until the entire array is sorted. This is done by dividing the input list or array into two parts - sorted and unsorted - and then constantly moving elements from the unsorted list into the sorted list.

To implement Selection Sort in Python, you can use the following code:

The final output of the Merge sort would be:

`[3,8,11,12,20]`

Heap sort is another sorting algorithm that works by segmenting arrays or lists into two parts - sorted and unsorted. The idea is to determine the largest element in the list by converting the unsorted part into a Heap data structure.

To implement heap sort, we will create two functions - a support function (to create the heap data structure) and the primary function (to implement the sort).

The final output of the Merge sort would be:

`[7,24,47,51,97]`

Quick sort is also based on the concept of dividing the input array or list. But it is often the most preferred sorting algorithm because it is potentially more efficient to use than Merge Sort and does not require any extra storage space. It begins by dividing the list and picking one value, known as the pivot. This value is considered to be in its correct sorting place. Naturally, all other list values that are smaller are moved to the left and the ones that are larger are moved to the right. The values are then recursively sorted until they are in the correct order.

Use the following code to implement the Quick sort algorithm:

The final output of the Quick sort would be:

`[3,7,10,22,41,61]`

**Click Here to Learn More On Python**

These algorithms are more than enough to help you get started with Data structures and algorithms using Python. To learn about how you can get started with learning Python through a structured course, visit this link.

Jyoti Gupta

23 Oct 2020

鏈接

關於我們

企業培訓

招募Xccelerate頂級人才

活動

網誌

所有課程

加入我們

Teach With Us

常見問題

未來企業家 X

校園大使計劃

未來教育基金

COVID-19 經濟復甦教育基金

Women in Tech Scholarship

一對一職業諮詢

地址

天后威非路道18號萬國寶通中心3樓 炮台山地鐵站: A出口步行5分鐘天后地鐵站: A2出口步行5分鐘