Which algo is faster?

Which is the best sorting algorithm? If you've observed, the time complexity of Quicksort is O(n logn) in the best and average case scenarios and O(n^2) in the worst case. But since it has the upper hand in the average cases for most inputs, Quicksort is generally considered the “fastest” sorting algorithm.

How much money triggers IRS?

$10,000 Under the Bank Secrecy Act, various types of businesses are required to notify the IRS and other federal agencies whenever anyone engages...

Read More »

Last updated Jun 10, 2020

What's the best color to wear when gambling?

The Color Red Anything red is considered a lucky thing to wear at a casino, so you better search your closet or go on a shopping spree. The best...

Read More »

Last updated May 25, 2021

Promotion

Before you begin..

After you read the blog..

Why are Sorting Algorithms Important?

A quick Google search reveals that there are over 40 different sorting algorithms used in the computing world today. Crazy right?

Types of Sorting in Data Structures

Sorting Algorithms in Java vs C++

So without further ado, let's dive right in.

Top 10 Sorting Algorithms You Need To Know

10 Best Sorting Algorithms

1. Bubble Sort

Understanding Bubble Sort algorithm with a simple example

Bubble sort algorithm explained

Implementation in C++

Time Complexity:

Worst Case: O(n^2)

Average Case: O(n*logn)

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Also read: Time Complexity Simplified with Easy Examples

Use Cases

Try it yourself

Input:

n -> Size of array (n>1)

'n' array elements below

Output: A single line representing the required sum

2. Selection Sort

Still a bit fuzzy? Take a look at this awesome example below.

Understanding Selection Sort algorithm with an example

Selection sort algorithm explained

Seems easy right? Because it is.

Now go ahead and take a look at its basic C++-based implementation.

Time Complexity:

Worst Case: O(n*n)

Average Case: O(n*logn)

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Also read: Time Complexity Simplified with Easy Examples

Use Cases

Try it yourself

Input:

n -> Size of array (n>1)

'n' array elements below

Output: A single line representing the required difference

3. Insertion Sort

Understanding Insertion Sort algorithm with an example

Here's an example to help you understand insertion sort better:

Insertion sort algorithm explained

using namespace std; void Insertion_Sort(int vec[], int n){ int i, x, j; for (i = 1; i < n; i++){ x = vec[i]; j = i - 1; while (j >= 0 && vec[j] > x){ vec[j + 1] = vec[j]; j = j - 1; } vec[j + 1] = x; } } int main(){ int vec[] = { 25, 22, 27, 15, 19 }; int n = sizeof(vec) / sizeof(vec[0]); Insertion_Sort(vec, n); for (int i = 0; i < n; i++) cout << vec[i] << " "; return 0; } Insertion Sort Implementation

Time Complexity:

Worst Case: O(n*n)

Average Case: O(n*logn)

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Use Cases

This algorithm is stable and is quite fast when the list is nearly sorted. It is very efficient when it comes to sorting very small lists (example say 30 elements.)

Try it yourself

Q. Given a list of numbers with an odd number of elements, find the median? [Constraint: Use Insertion Sort]

Input:

n -> Size of array (n>0)

'n' array elements below

Output: A single line representing the required median.

P.S: Don't forget to share your approach with us in the comments below!

4. Quick Sort

Quick Sort is a divide and conquer algorithm. The intuitive idea behind quick sort is it picks an element as the pivot from a given array of elements and then partitions the array around the pivot element. Subsequently, it calls itself recursively and partitions the two subarrays thereafter.

Understanding Quick Sort algorithm with a visualization

How many legs should I put in a parlay?

A wager must have at least two selections, or “legs,” to be considered a parlay, with most betting sites setting the max number at 10 or 12 legs...

Read More »

Last updated Aug 18, 2021

What is the hardest sport to bet on?

Baseball. Baseball is the hardest sport to bet on, and it comes in at the top of the list. In spite of the fact that I love to bet on the American...

Read More »

Last updated Nov 19, 2022

Promotion

Quick sort algorithm explained

The logical steps involved in Quick Sort algorithm are as follows:

Pivot selection: Picks an element as the pivot (here, we choose the last element as the pivot) Picks an element as the pivot (here, we choose the last element as the pivot) Partitioning: The array is partitioned in a fashion such that all elements less than the pivot are in the left subarray while all elements strictly greater than the pivot element are stored in the right subarray. The array is partitioned in a fashion such that all elements less than the pivot are in the left subarray while all elements strictly greater than the pivot element are stored in the right subarray. Recursive call to Quicksort: Quicksort function is invoked again for the two subarrays created above and steps are repeated. Comments have been included in the implementation below to help you understand the Quick Sort algorithm better. #include using namespace std; int partition (int vec[], int lt, int rt){ int pivot = vec[rt]; // pivot int i = (lt - 1); for (int j = lt; j <= rt - 1; j++){ if (vec[j] < pivot){ i++; swap(vec[i], vec[j]); } } swap(vec[i + 1], vec[rt]); return (i + 1); } /* vec[] --> array to be sorted, lt --> Starting index, rt --> Ending index*/ void Quick_Sort(int vec[], int lt, int rt){ if (lt < rt){ /* mid is partitioning index, vec[p] is now at right place */ int mid = partition(vec, lt, rt); // Separately sort elements before // partition and after partition Quick_Sort(vec, lt, mid - 1); Quick_Sort(vec, mid + 1, rt); } } int main(){ int vec[] = {14, 21, 5, 2, 3, 19}; int n = sizeof(vec) / sizeof(vec[0]); Quick_Sort(vec, 0, n - 1); cout << "Sorted array: "; for (int i = 0; i < n; i++) cout << vec[i] << " "; return 0; } Quick Sort Implementation

Time Complexity:

Worst Case: O(n*n)

Average Case: O(n*logn)

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Use Cases

Quick Sort is probably more effective for datasets that fit in memory.

Quick Sort is appropriate for arrays since is an in-place sorting algorithm (i.e. it doesn’t require any extra storage)

Try it yourself

Q. Given a list of numbers with an odd/even number of elements, find the median? [Constraint: Use Quick Sort]

Input:

n -> Size of array (n>0)

'n' array elements below

Output: A single line representing the required median.

P.S: Need a hint? Drop a comment below.

5. Merge Sort

Merge Sort is a divide-and-conquer algorithm. In each iteration, merge sort divides the input array into two equal subarrays, calls itself recursively for the two subarrays, and finally merges the two sorted halves.

Understanding Merge Sort algorithm with a visualization

Merge sort algorithm explained

Now that you're familiar with the intuition behind merge sort, let's take a look at its implementation. #include using namespace std; void merge(long vec[], long lt, long m, long rt){ long n1 = m - lt + 1; long n2 = rt - m; long L[n1], R[n2]; for (long i = 0; i < n1; i++) L[i] = vec[lt + i]; for (long j = 0; j < n2; j++) R[j] = vec[m+1+j]; long i = 0, j = 0; long k = lt; while (i < n1 and j < n2) { if (L[i] <= R[j]) { vec[k] = L[i]; i++; } else { vec[k] = R[j]; j++; } k++; } while (i < n1) { vec[k] = L[i]; i++; k++; } while (j < n2) { vec[k] = R[j]; j++; k++; } } void Merge_Sort(long vec[],long lt,long rt){ if(lt>=rt) return; long m =lt+ (rt-lt)/2; Merge_Sort(vec,lt,m); Merge_Sort(vec,m+1,rt); merge(vec,lt,m,rt); } void printArray(long A[], long size){ for (long i = 0; i < size; i++) cout << A[i] << " "; } int main(){ long arr[] = {16, 19, 14, 20, 12, 13}; long arr_size = sizeof(arr) / sizeof(arr[0]); cout << "Unsorted array is: "; printArray(arr, arr_size); Merge_Sort(arr, 0, arr_size - 1); cout << "

Sorted array is: "; printArray(arr, arr_size); return 0; } Merge Sort Implementation

Time Complexity:

Worst Case: O(n*logn)

Average Case: O(n*logn)

Best case: O(n*logn)

Auxiliary Space Complexity: O(n)

Use Cases

Merge sort is quite fast in the case of linked lists.

It is widely used for external sorting where random access can be quite expensive compared to sequential access.

Try it yourself

Q. Find the intersection of two unsorted arrays [Constraint/Hint: Use Merge Sort]

Input:

n -> Size of array (n>1)

'n' array elements below

Output: An array representing the intersection of the two unsorted arrays.

Master Arrays, Linked lists, Stacks/Queues, Trees, and Graphs and build your career (with job guarantee) in Back End or Full Stack development. Here's how.

6. Counting Sort

Counting Sort is an interesting sorting technique primarily because it focuses on the frequency of unique elements between a specific range (something along the lines of hashing). It works by counting the number of elements having distinct key values and then building a sorted array after calculating the position of each unique element in the unsorted sequence. It stands apart from the algorithms listed above because it literally involves zero comparisons between the input data elements!

Understanding Counting Sort algorithm with an example

Counting sort algorithm explained

Now go ahead and quickly take a look at its implementation in C++ #include using namespace std; void print(long *vec, long n) { for(long i = 1; i<=n; i++) cout << vec[i] << " "; cout << " "; } long getMax(long vec[], long n) { long max = vec[1]; for(long i = 2; i<=n; i++) { if(vec[i] > max) max = vec[i]; } return max; } void countSort(long *vec, long n) { long output[n+1]; long max = getMax(vec, n); long count[max+1]; for(long i = 0; i<=max; i++) count[i] = 0; for(long i = 1; i <=n; i++) count[vec[i]]++; for(long i = 1; i<=max; i++) count[i] += count[i-1]; for(long i = n; i>=1; i--) { output[count[vec[i]]] = vec[i]; count[vec[i]] -= 1; } for(long i = 1; i<=n; i++) { vec[i] = output[i]; } } int main() { long n; cout << "Enter the size of array: "; cin >> n; long arr[n+1]; cout << "Enter elements:" << endl; for(long i = 1; i<=n; i++) cin >> arr[i]; cout << "Unsorted array: "; print(arr, n); countSort(arr, n); cout << "Sorted array: "; print(arr, n); } Counting Sort Implementation

Time Complexity:

Worst Case: O(n+k), where n is the size of input array and k is the count of unique elements in the array

Auxiliary Space Complexity: O(n+k)

Use Cases

Counting sort is quite efficient when it comes to sorting countable objects (such as bounded integers). It is also used when sorting is to be achieved in linear complexity.

Try it yourself

Q. Given an array of n input integers, return the absolute difference between the maximum and minimum elements of the array in linear time complexity.

Input:

n -> Size of array (n>1)

'n' array elements below

Output: A single line representing the required difference.

P.S: Don't forget to share your approach with us in the comments below.

Stop scrolling..

You're done with over 50% of the blog. Want to test your knowledge on how well you've understood sorting algorithms so far? Take these quizzes to know where you stand.

7. Radix Sort

As you saw earlier, counting sort stands apart because it's not a comparison-based sorting algorithm like Merge Sort or Bubble Sort, thereby reducing its time complexity to linear time. BUT, counting sort fails if the input array ranges from 1 to n^2 in which case its time complexity increases to O(n^2). The basic idea behind radix sorting is to extend the functionality of counting sort to get a better time-complexity when input array elements range from 1 till n^2.

Understanding Radix Sort with an example

Algorithm:

For each digit i where i varies from the least significant digit to the most significant digit of a number, sort input array using count sort algorithm according to the ith digit. Remember we use count sort because it is a stable sorting algorithm.

Example:

Radix sort algorithm explained

Thus we observe that radix sort utilizes counting sort as its subroutine throughout its execution. Now take a look at its C++ implementation. #include using namespace std; long getMax(long vec[], long n){ long maxval = vec[0]; for (long i = 1; i < n; i++) if (vec[i] > maxval) maxval = vec[i]; return maxval; } void Count_Sort(long vec[], long n, long x){ long res[n]; long i, count[10] = {0}; for (i = 0; i < n; i++) count[(vec[i] / x) % 10]++; for (i = 1; i < 10; i++) count[i] += count[i - 1]; for (i = n - 1; i >= 0; i--) { res[count[(vec[i] / x) % 10] - 1] = vec[i]; count[(vec[i] / x) % 10]--; } for (i = 0; i < n; i++) vec[i] = res[i]; } void Radix_Sort(long vec[], long n){ long m = getMax(vec, n); for (long x = 1; m / x > 0; x *= 10) Count_Sort(vec, n, x); } int main(){ long vec[] = { 53, 89, 150, 36, 633, 233 }; long n = sizeof(vec) / sizeof(vec[0]); Radix_Sort(vec, n); for(long i = 0; i < n; i++) cout << vec[i] << " "; return 0; } Radix Sort Implementation Time Complexity: O(d(n+b)), where b represents the base of array element (eg- 10 represents decimal) Auxiliary Space Complexity: O(n+d), where d is the maximum number of digits in an array element.

Use Cases

Radix sorting finds applications in parallel computing.

It is also used in the DC3 algorithm (Kärkkäinen-Sanders-Burkhardt) while making a suffix array.

Try it yourself:

Q. Given two sorted arrays(arr1[] and arr2[]) of size M and N of distinct elements. Given a value Sum. The problem is to count all pairs from both arrays whose sum is equal to Sum. Note: The pair has an element from each array. [Constraint: Use Radix Sort]

Input:

How do you gamble professionally?

7 Tips in Preparing for a Professional Gambling Career 1) Be sure about your conviction of becoming a professional gambler. ... 2) Learn about the...

Read More »

Last updated Jan 8, 2019

Is sports betting all luck?

Sports betting is a mixture of both luck and skill. Some people may find that they have been very lucky with a few games. However, luck always runs...

Read More »

Last updated Oct 27, 2020

Promotion

n -> Size of array (n>1)

'n' array elements below

Output: A single line representing the required number of pairs

P.S: Don't forget to share your approach with us in the comments below.

8. Bucket Sort

Bucket Sort is a comparison-based sorting technique that operates on array elements by dividing them into multiple buckets recursively and then sorting these buckets individually using a separate sorting algorithm altogether. Finally, the sorted buckets are re-combined to produce the sorted array.

Understanding Bucket Sort algorithm with pseudocode

We can probe further into the working of bucket sort by assuming that we've already created an array of multiple 'buckets' (lists). Elements are now inserted from the unsorted array into these "buckets" based on their properties. These buckets are finally sorted separately using the insertion sort algorithm as explained earlier.

Pseudocode:

Begin for i = 0 to size-1 insert array[i] into the bucket indexed (size * array[i]) done for i = 0 to size-1 sort bucket[i] using insertion sort done for i = 0 to size-1 Combine items of bucket[i] and insert in array in sorted order done End Well if you're still unsure about the bucket sort algorithm, go back and review the pseudocode one more time.

.

.

Done? All right. Now take a quick look at its implementation below.

#include #define pb push_back using namespace std; void Bucket_Sort(float arr[], int n){ vector bucket[n]; for (int i = 0; i < n; i++) { int bi = n * arr[i]; bucket[bi].pb(arr[i]); } for (int i = 0; i < n; i++) sort(bucket[i].begin(), bucket[i].end()); int pos = 0; for (int i = 0; i < n; i++) for (int j = 0; j < bucket[i].size(); j++) arr[pos++] = bucket[i][j]; } int main(){ float arr[]= { 0.474, 0.582, 0.452, 0.6194, 0.553, 0.9414 }; int n = sizeof(arr) / sizeof(arr[0]); Bucket_Sort(arr, n); cout << "Sorted array is "; for (int i = 0; i < n; i++) cout << arr[i] << " "; return 0; } Bucket Sort Implementation

Time Complexity:

Worst Case: O(n*n)

Average Case: O(n + k)

Best case: O(n + k)

Auxiliary Space Complexity: O(k), worst case

Use Cases

Bucket sorting is used when input is uniformly distributed over a range.

It is also used for floating point values.

Try it yourself

Q. You are given two arrays, A and B, of equal size N. The task is to find the minimum value of A[0] * B[0] + A[1] * B[1] +…+ A[N-1] * B[N-1], where shuffling of elements of arrays A and B is allowed. [Constraint: Use Bucket Sort]

Input:

n -> Size of array (n>1)

'n' array elements representing the first array

'n' array elements representing the second array

Output: A single line representing the required sum

P.S: Need help? Drop a comment below.

9. Comb Sort

Comb sort is quite interesting. In fact, it is an improvement over the bubble sort algorithm. If you've observed earlier, bubble sort compares adjacent elements for every iteration. But for comb sort, the items are compared and swapped by a large gap value. The gap value shrinks by a factor of 1.3 for each iteration until the gap value reaches 1, at which point it stops execution.

Understanding Comb Sort algorithm with a simple example

Comb sort algorithm explained

Pretty simple right? Well, let's have a look at it's C++ implementation:

#include using namespace std; void Comb_Sort(long *vec, long size) { long gap = size; bool f = true; while(gap != 1 || f == true) { gap = (gap)/1.3; if(gap<1) gap = 1; f = false; for(long i = 0; i< size - gap; i++) { if(vec[i] > vec[i+gap]) { swap(vec[i], vec[i+gap]); f = true; } } } } int main() { long arr[10]={ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; cout << "Array before Sorting: "; for(long i = 0; i < 10; i++) cout << arr[i] << " "; cout << endl; Comb_Sort(arr, 10); cout << "Array after Sorting: "; for(long i = 0; i < 10; i++) cout << arr[i] << " "; cout << endl; } Comb Sort Implementation

Time Complexity:

Worst Case: O(n^2)

Average Case: O(n^2/2^p), where p is a number of increment

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Use Cases

Comb Sort eliminates small values at the end of the list by using larger gaps. eliminates small values at the end of the list by using larger gaps. It is a significant improvement over Bubble Sort.

Try it yourself

Q. Given an array, find the most frequent element in it. If there are multiple elements that appear maximum number of times, print any one of them. [Constraint: Use Comb Sort]

Input:

n -> Size of array (n>0)

'n' array elements below

Output: A single line representing the element with maximum frequency.

P.S: Did you enjoy this sorting technique? Share your opinions below.

10. Shell Sort

Shell sort algorithm is an improvement over the insertion sort algorithm wherein we resort to diminishing partitions to sort our data. In each pass, we reduce the gap size to half of its previous value for each pass throughout the array. Thus for each iteration, the array elements are compared by the calculated gap value and swapped (if necessary).

Understanding Shell Sort algorithm with pseudocode

Start for gap = N / 2, where gap > 0 and gap updates to gap / 2: for i= gap to N – 1: for j = j-gap to 0, decrease by gap value: if arr[j+gap] >= arr[j] break else swap arr[j+gap] with arr[j] done done done End The idea of shell sort is that it permits the exchange of elements located far from each other. In Shell Sort, we make the array N-sorted for a large value of N. We then keep reducing the value of N until it becomes 1. An array is said to be N-sorted if all subarrays of every N’th element are sorted.

Here, gap size= floor(N/2) for each iteration

Finally, take a look at it's C++ implementation:

#include using namespace std; int Shell_Sort(int vec[], int n){ for (int gap = n/2; gap > 0; gap /= 2){ for (int i = gap; i < n; i ++ ){ int x = vec[i]; int j; for (j=i; j>=gap && vec[j-gap]>x;j-=gap) vec[j] = vec[j - gap]; vec[j] = x; } } return 0; } int main(){ int vec[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; int n = sizeof(vec)/sizeof(vec[0]), i; cout << "Unsorted array: "; for (int i=0; iSorted array: "; for (int i=0; iTime Complexity:

Worst Case: Depends on gap size

Average Case: Depends on gap size

Best case: O(n*logn)

Auxiliary Space Complexity: O(1)

Use Cases

Insertion sort does not perform well when the close elements are far apart. Shell sort helps reduce the distance between close elements. It is also used when recursion exceeds a limit. The bzip2 compressor compresses it.

Try it yourself

Q. Given an unsorted array of integers. Write a program to remove duplicates from the unsorted array. [Constraint: Use Shell Sort]

Input:

n -> Size of array (n>1)

'n' array elements below

Output: A single line representing the modified array.

Now that you've explored the Top 10 sorting algorithms, all that's left is to answer a few basic questions (just 3 in fact). This will hardly take a minute.

Q1. Which is the best sorting algorithm?

If you've observed, the time complexity of Quicksort is O(n logn) in the best and average case scenarios and O(n^2) in the worst case. But since it has the upper hand in the average cases for most inputs, Quicksort is generally considered the “fastest” sorting algorithm. At the end of the day though, the best sorting algorithm comes down to the nature of your input data (and who you ask).

Q2. What is the easiest sorting algorithm?

Bubble sort is widely recognized as the simplest sorting algorithm out there. Its basic idea is to scan through an entire array and compare adjacent elements and swap them (if necessary) until the list is sorted. Pretty simple right?

Q3. Which sorting algorithm would you prefer for nearly sorted lists?

When it comes to sorting nearly sorted data, insertion sort is the clear winner particularly because it's time complexity reduces to O(n) from a whopping O(n^2) on such a sample. On the other hand, merge sort or quick sort algorithms do not adapt well to nearly sorted data. Well, that's about it. At the end of the day, it's up to you to decide which sorting technique suits you the best. And yes, don't forget to try out the practice problems served alongside with each sorting technique.

How comfortable are you with sorting now?

Before you go for your next interview, be sure to know the answers to these commonly asked Sorting Algorithms questions. If you read this blog thoroughly, you're all set to get a perfect score. Ready to take the quiz?

Go beyond video-based certification courses and online bootcamps. Build the confidence you need to take on Data Structures and Algorithm questions in your next big interview and land your dream job as a Backend Developer or Full Stack Developer - Guaranteed! Find out how. Don't miss these free learning resources that are an absolute essential for all developers:

Found this article interesting? Show your love by upvoting this article.

We would also love to know the sorting technique that got you excited the most - let us know in the comments below. Also, if you enjoyed reading this article, don't forget to share it with your friends!

crio.do - 10 Best Sorting Algorithms You Must Know About - Crio.Do

What are withdrawal behaviors?

Withdrawn behavior is avoiding or not seeking out social contact. People who withdraw may actively avoid spending time with other people. Or, they...

Read More »

Last updated May 12, 2020

What does Bengals +2.5 mean?

Bengals point spread In this example, the Bengals are favored by 2.5 points, which means they'll have to win by a field goal or more to cover the...

Read More »

Last updated Nov 23, 2018

Promotion

Does martingale collar pinch neck?

When your dog tries to back out of the martingale, the collar tightens around their neck. If the collar is properly adjusted, it will tighten just...

Read More »

Last updated Oct 28, 2020

Promotion

How can I make money fast legally?

How to Make Money Online - 32 Proven Ways to Make Extra Money Fast Drive for Uber or Lyft. ... Become a market research participant. ... Sell old...

Read More »

Last updated Jun 29, 2019