Skip to content

# Advanced Quick Sort (Hybrid Algorithm)

• Difficulty Level : Hard
• Last Updated : 04 Aug, 2021

Prerequisites: Insertion Sort, Quick Sort, Selection Sort
In this article, a Hybrid algorithm with the combination of quick sort and insertion sort is implemented. As the name suggests, the Hybrid algorithm combines more than one algorithm.
Why Hybrid algorithm:
Quicksort algorithm is efficient if the size of the input is very large. But, insertion sort is more efficient than quick sort in case of small arrays as the number of comparisons and swaps are less compared to quicksort. So we combine the two algorithms to sort efficiently using both approaches.
Note: Selectionsort algorithm can also be used to combine with quicksort. Though the time complexity is of O(N2), these algorithms prove to be efficient in this case because these are used only when the size of the array is less than a threshold value(10 in this article).

Dry run of the algorithm:

Let arr[] = {24, 97, 40, 67, 88, 85, 15, 66, 53, 44, 26, 48, 16, 52, 45, 23, 90, 18, 49, 80}

Example explanation

Approach: The idea is to use recursion and continuously find the size of the array. If the size is greater than the threshold value(10), then the quicksort function is called for that portion of the array. Else, insertion sort is called.
Below is the implementation of the Hybrid algorithm:

## C++

 `// C++ implementation of the above approach `   `#include` `using` `namespace` `std;`   `// Function to perform the insertion sort`   `void` `insertion_sort(``int` `arr[], ``int` `low, ``int` `n) ` `  ``{`   `    ``for``(``int` `i=low+1;ilow && arr[j-1]>val)` `      ``{` `        ``arr[j]= arr[j-1] ;` `      ``j-= 1;` `    ``}` `    ``arr[j]= val ;` `    ``} `   `  ``}`   `//The following two functions are used ` `// to perform quicksort on the array. `     `// Partition function for quicksort `   `int` `partition(``int` `arr[], ``int` `low, ``int` `high)` `{` `  ``int` `pivot = arr[high] ;` `  ``int` `i ,j;` `  ``i = low;` `  ``j = low;`   `  ``for` `(``int` `i = low; i < high; i++)` `     ``{` `      ``if``(arr[i] Quick + Insertion sort `   `void` `hybrid_quick_sort(``int` `arr[], ``int` `low, ``int` `high)` `{` `  ``while` `(low < high) ` `    ``{`   `    ``// If the size of the array is less ` `    ``// than threshold apply insertion sort ` `    ``// and stop recursion `   `    ``if` `(high-low + 1 < 10)` `      ``{` `        ``insertion_sort(arr, low, high);` `      ``break``;` `    ``}`   `    ``else` `      `  `        ``{` `          ``int` `pivot = partition(arr, low, high) ;`   `      ``// Optimised quicksort which works on ` `      ``// the smaller arrays first `   `      ``// If the left side of the pivot ` `      ``// is less than right, sort left part ` `      ``// and move to the right part of the array `   `      ``if` `(pivot-low

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {`   `    ``private` `static` `void` `insertionSort(``int` `a[], ``int` `low,` `                                     ``int` `high)` `    ``{` `        ``for` `(``int` `i = low + ``1``; i <= high; i++) {` `            ``for` `(``int` `j = i - ``1``; j >= low; j--) {` `                ``if` `(a[j] > a[j + ``1``]) {` `                    ``// Swap` `                    ``int` `temp = a[j];` `                    ``a[j] = a[j + ``1``];` `                    ``a[j + ``1``] = temp;` `                ``}` `                ``else` `                    ``break``;` `            ``}` `        ``}` `    ``}`   `    ``private` `static` `int` `partition(``int` `arr[], ``int` `low,` `                                ``int` `high)` `    ``{` `        ``int` `pivot = arr[high];` `        ``int` `i = low;` `        ``int` `j = low;`   `        ``while` `(i <= high) {` `            ``if` `(arr[i] > pivot)` `                ``i++;` `            ``else` `{` `                ``int` `temp = arr[i];` `                ``arr[i] = arr[j];` `                ``arr[j] = temp;` `                ``i++;` `                ``j++;` `            ``}` `        ``}` `        ``return` `j - ``1``;` `    ``}`   `    ``public` `static` `void` `hybridQuickSort(``int` `arr[], ``int` `low,` `                                       ``int` `high)` `    ``{` `        ``while` `(low < high) {` `            ``// Check if array size on which we will be working is less than 10` `            ``if` `(high - low < ``10``) {` `                ``insertionSort(arr, low, high);` `                ``break``;` `            ``}` `            ``else` `{` `                ``int` `pivot = partition(arr, low, high);`   `                ``// We will do recursion on small size` `                ``// subarray So we can check pivot - low  and` `                ``// pivot - high`   `                ``if` `(pivot - low < pivot - high) {` `                    ``hybridQuickSort(arr, low, pivot - ``1``);` `                    ``low = pivot + ``1``;` `                ``}` `                ``else` `{` `                    ``hybridQuickSort(arr, pivot + ``1``, high);` `                    ``high = pivot - ``1``;` `                ``}` `            ``}` `        ``}` `    ``}` `  `  `  ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `arr[]` `            ``= { ``24``, ``97``, ``40``, ``67``, ``88``, ``85``, ``15``, ``66``, ``53``, ``44``, ``26``,` `                ``48``, ``16``, ``52``, ``45``, ``23``, ``90``, ``18``, ``49``, ``80``, ``23` `};`   `        ``hybridQuickSort(arr, ``0``, arr.length - ``1``);` `        ``for` `(``int` `i : arr)` `            ``System.out.print(i + ``"  "``);` `    ``}` `}`   `// This code is contribute  by @mahi_07`

## Python3

 `# Python implementation of the above approach`   `# Function to perform the insertion sort` `def` `insertion_sort(arr, low, n):` `    ``for` `i ``in` `range``(low ``+` `1``, n ``+` `1``):` `        ``val ``=` `arr[i]` `        ``j ``=` `i` `        ``while` `j>low ``and` `arr[j``-``1``]>val:` `            ``arr[j]``=` `arr[j``-``1``]` `            ``j``-``=` `1` `        ``arr[j]``=` `val`   `# The following two functions are used ` `# to perform quicksort on the array. `   `# Partition function for quicksort` `def` `partition(arr, low, high):` `    ``pivot ``=` `arr[high]` `    ``i ``=` `j ``=` `low` `    ``for` `i ``in` `range``(low, high):` `        ``if` `arr[i] Quick + Insertion sort` `def` `hybrid_quick_sort(arr, low, high):` `    ``while` `low

Output

`15, 16, 18, 23, 23, 24, 26, 40, 44, 45, 48, 49, 52, 53, 66, 67, 80, 85, 88, 90, 97, `

Time Complexity: O(N^2)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :