Hoare’s vs Lomuto partition scheme in QuickSort

09 Jun, 2022
We have discussed the implementation of QuickSort using Lomuto partition scheme. Lomuto’s partition scheme is easy to implement as compared to Hoare scheme. This has inferior performance to Hoare’s QuickSort.
Lomuto’s Partition Scheme:
This algorithm works by assuming the pivot element as the last element. If any other element is given as a pivot element then swap it first with the last element. Now initialize two variables i as low and j also low,  iterate over the array and increment i when arr[j] <= pivot and swap arr[i] with arr[j] otherwise increment only i. After coming out from the loop swap arr[i] with arr[hi]. This i stores the pivot element.
partition(arr[], lo, hi) 
    pivot = arr[hi]
    i = lo     // place for swapping
    for j := lo to hi – 1 do
        if arr[j] <= pivot then
            i = i + 1 
            swap arr[i] with arr[j]
    swap arr[i] with arr[hi]
    return i
Refer QuickSort for details of this partitioning scheme. Below are implementations of this approach:-
C++
Java
Python3
C#
Javascript
/* C++ implementation QuickSort using Lomuto's partition   Scheme.*/#include<bits/stdc++.h>using namespace std; /* This function takes last element as pivot, places   the pivot element at its correct position in sorted    array, and places all smaller (smaller than pivot)   to left of pivot and all greater elements to right   of pivot */int partition(int arr[], int low, int high){    int pivot = arr[high];    // pivot    int i = (low - 1);  // Index of smaller element     for (int j = low; j <= high- 1; j++)    {        // If current element is smaller than or        // equal to pivot        if (arr[j] <= pivot)        {            i++;    // increment index of smaller element            swap(arr[i], arr[j]);        }    }    swap(arr[i + 1], arr[high]);    return (i + 1);} /* The main function that implements QuickSort arr[] --> Array to be sorted,  low  --> Starting index,  high  --> Ending index */void quickSort(int arr[], int low, int high){    if (low < high)    {        /* pi is partitioning index, arr[p] is now           at right place */        int pi = partition(arr, low, high);         // Separately sort elements before        // partition and after partition        quickSort(arr, low, pi - 1);        quickSort(arr, pi + 1, high);    }} /* Function to print an array */void printArray(int arr[], int size){    int i;    for (i=0; i < size; i++)        printf("%d ", arr[i]);    printf("\n");} // Driver program to test above functionsint main(){    int arr[] = {10, 7, 8, 9, 1, 5};    int n = sizeof(arr)/sizeof(arr[0]);    quickSort(arr, 0, n-1);    printf("Sorted array: \n");    printArray(arr, n);    return 0;}
// Java implementation QuickSort// using Lomuto's partition Schemeimport java.io.*; class GFG{static void Swap(int[] array,                 int position1,                 int position2){    // Swaps elements in an array         // Copy the first position's element    int temp = array[position1];         // Assign to the second element    array[position1] = array[position2];         // Assign to the first element    array[position2] = temp;} /* This function takes last element aspivot, places the pivot element at itscorrect position in sorted array, andplaces all smaller (smaller than pivot)to left of pivot and all greater elementsto right of pivot */static int partition(int []arr, int low,                                int high){    int pivot = arr[high];         // Index of smaller element    int i = (low - 1);     for (int j = low; j <= high- 1; j++)    {        // If current element is smaller        // than or equal to pivot        if (arr[j] <= pivot)        {            i++; // increment index of                 // smaller element            Swap(arr, i, j);        }    }    Swap(arr, i + 1, high);    return (i + 1);} /* The main function that   implements QuickSortarr[] --> Array to be sorted,low --> Starting index,high --> Ending index */static void quickSort(int []arr, int low,                                 int high){    if (low < high)    {        /* pi is partitioning index,        arr[p] is now at right place */        int pi = partition(arr, low, high);         // Separately sort elements before        // partition and after partition        quickSort(arr, low, pi - 1);        quickSort(arr, pi + 1, high);    }} /* Function to print an array */static void printArray(int []arr, int size){    int i;    for (i = 0; i < size; i++)    System.out.print(" " + arr[i]);    System.out.println();} // Driver Codestatic public void main (String[] args){    int []arr = {10, 7, 8, 9, 1, 5};    int n = arr.length;    quickSort(arr, 0, n-1);    System.out.println("Sorted array: ");    printArray(arr, n);}} // This code is contributed by vt_m.
''' Python3 implementation QuickSort using Lomuto's partitionScheme.''' ''' This function takes last element as pivot, placesthe pivot element at its correct position in sorted    array, and places all smaller (smaller than pivot)to left of pivot and all greater elements to rightof pivot '''def partition(arr, low, high):         # pivot    pivot = arr[high]         # Index of smaller element    i = (low - 1)    for j in range(low, high):                 # If current element is smaller than or        # equal to pivot        if (arr[j] <= pivot):                         # increment index of smaller element            i += 1            arr[i], arr[j] = arr[j], arr[i]    arr[i + 1], arr[high] = arr[high], arr[i + 1]    return (i + 1)     ''' The main function that implements QuickSortarr --> Array to be sorted,low --> Starting index,high --> Ending index '''def quickSort(arr, low, high):    if (low < high):                 ''' pi is partitioning index, arr[p] is now            at right place '''        pi = partition(arr, low, high)                 # Separately sort elements before        # partition and after partition        quickSort(arr, low, pi - 1)        quickSort(arr, pi + 1, high)         ''' Function to print an array '''def printArray(arr, size):         for i in range(size):        print(arr[i], end = " ")    print() # Driver code arr = [10, 7, 8, 9, 1, 5]n = len(arr)quickSort(arr, 0, n - 1)print("Sorted array:")printArray(arr, n)     # This code is contributed by SHUBHAMSINGH10
// C# implementation QuickSort// using Lomuto's partition Schemeusing System; class GFG{static void Swap(int[] array,                 int position1,                 int position2){    // Swaps elements in an array         // Copy the first position's element    int temp = array[position1];         // Assign to the second element    array[position1] = array[position2];         // Assign to the first element    array[position2] = temp;} /* This function takes last element aspivot, places the pivot element at itscorrect position in sorted array, andplaces all smaller (smaller than pivot)to left of pivot and all greater elementsto right of pivot */static int partition(int []arr, int low,                                int high){    int pivot = arr[high];         // Index of smaller element    int i = (low - 1);     for (int j = low; j <= high- 1; j++)    {        // If current element is smaller        // than or equal to pivot        if (arr[j] <= pivot)        {            i++; // increment index of                 // smaller element            Swap(arr, i, j);        }    }    Swap(arr, i + 1, high);    return (i + 1);} /* The main function that   implements QuickSortarr[] --> Array to be sorted,low --> Starting index,high --> Ending index */static void quickSort(int []arr, int low,                                 int high){    if (low < high)    {        /* pi is partitioning index,        arr[p] is now at right place */        int pi = partition(arr, low, high);         // Separately sort elements before        // partition and after partition        quickSort(arr, low, pi - 1);        quickSort(arr, pi + 1, high);    }} /* Function to print an array */static void printArray(int []arr, int size){    int i;    for (i = 0; i < size; i++)    Console.Write(" " + arr[i]);    Console.WriteLine();} // Driver Codestatic public void Main(){    int []arr = {10, 7, 8, 9, 1, 5};    int n = arr.Length;    quickSort(arr, 0, n-1);    Console.WriteLine("Sorted array: ");    printArray(arr, n);}} // This code is contributed by vt_m.
<script> // JavaScript implementation QuickSort// using Lomuto's partition Scheme function Swap(array, position1, position2){    // Swaps elements in an array          // Copy the first position's element    let temp = array[position1];          // Assign to the second element    array[position1] = array[position2];          // Assign to the first element    array[position2] = temp;}  /* This function takes last element aspivot, places the pivot element at itscorrect position in sorted array, andplaces all smaller (smaller than pivot)to left of pivot and all greater elementsto right of pivot */function partition(arr, low, high){    let pivot = arr[high];          // Index of smaller element    let i = (low - 1);      for (let j = low; j <= high- 1; j++)    {        // If current element is smaller        // than or equal to pivot        if (arr[j] <= pivot)        {            i++; // increment index of                 // smaller element            Swap(arr, i, j);        }    }    Swap(arr, i + 1, high);    return (i + 1);}  /* The main function that   implements QuickSortarr[] --> Array to be sorted,low --> Starting index,high --> Ending index */function quickSort(arr, low, high){    if (low < high)    {        /* pi is partitioning index,        arr[p] is now at right place */        let pi = partition(arr, low, high);          // Separately sort elements before        // partition and after partition        quickSort(arr, low, pi - 1);        quickSort(arr, pi + 1, high);    }}  /* Function to print an array */function printArray(arr, size){    let i;    for (i = 0; i < size; i++)    document.write(" " + arr[i]);    document.write("<br/>");} // Driver Code    let arr = [10, 7, 8, 9, 1, 5];    let n = arr.length;    quickSort(arr, 0, n-1);    document.write("Sorted array: ");    printArray(arr, n);   // This code is contributed by chinmoy1997pal.</script>
Sorted array: 
1 5 7 8 9 10 
Hoare’s Partition Scheme:
Hoare’s Partition Scheme works by initializing two indexes that start at two ends, the two indexes move toward each other until an inversion is (A smaller value on the left side and greater value on the right side) found. When an inversion is found, two values are swapped and the process is repeated.
Algorithm:
partition(arr[], lo, hi)
   pivot = arr[lo]
   i = lo - 1  // Initialize left index
   j = hi + 1  // Initialize right index

   // Find a value in left side greater
   // than pivot
   do
      i = i + 1
   while arr[i] < pivot

   // Find a value in right side smaller
   // than pivot
   do
      j--;
   while (arr[j] > pivot);

   if i >= j then 
      return j

   swap arr[i] with arr[j]
Below are implementations of this approach:- 
C++
Java
Python3
C#
Javascript
/* C++ implementation of QuickSort using Hoare's   partition scheme. */#include <bits/stdc++.h>using namespace std; /* This function takes first element as pivot, and places   all the elements smaller than the pivot on the left side   and all the elements greater than the pivot on   the right side. It returns the index of the last element   on the smaller side*/int partition(int arr[], int low, int high){    int pivot = arr[low];    int i = low - 1, j = high + 1;     while (true) {        // Find leftmost element greater than        // or equal to pivot        do {            i++;        } while (arr[i] < pivot);         // Find rightmost element smaller than        // or equal to pivot        do {            j--;        } while (arr[j] > pivot);         // If two pointers met.        if (i >= j)            return j;         swap(arr[i], arr[j]);    }} /* The main function that implements QuickSort arr[] --> Array to be sorted,  low  --> Starting index,  high  --> Ending index */void quickSort(int arr[], int low, int high){    if (low < high) {        /* pi is partitioning index, arr[p] is now           at right place */        int pi = partition(arr, low, high);         // Separately sort elements before        // partition and after partition        quickSort(arr, low, pi);        quickSort(arr, pi + 1, high);    }} /* Function to print an array */void printArray(int arr[], int n){    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);    printf("\n");} // Driver Codeint main(){    int arr[] = { 10, 7, 8, 9, 1, 5 };    int n = sizeof(arr) / sizeof(arr[0]);    quickSort(arr, 0, n - 1);    printf("Sorted array: \n");    printArray(arr, n);    return 0;}
// Java implementation of QuickSort// using Hoare's partition schemeimport java.io.*; class GFG {     /* This function takes first element as pivot, and       places all the elements smaller than the pivot on the       left side and all the elements greater than the pivot       on the right side. It returns the index of the last       element on the smaller side*/    static int partition(int[] arr, int low, int high)    {        int pivot = arr[low];        int i = low - 1, j = high + 1;         while (true) {            // Find leftmost element greater            // than or equal to pivot            do {                i++;            } while (arr[i] < pivot);             // Find rightmost element smaller            // than or equal to pivot            do {                j--;            } while (arr[j] > pivot);             // If two pointers met.            if (i >= j)                return j;            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;            // swap(arr[i], arr[j]);        }    }     /* The main function that       implements QuickSort    arr[] --> Array to be sorted,    low --> Starting index,    high --> Ending index */    static void quickSort(int[] arr, int low, int high)    {        if (low < high) {            /* pi is partitioning index,            arr[p] is now at right place */            int pi = partition(arr, low, high);             // Separately sort elements before            // partition and after partition            quickSort(arr, low, pi);            quickSort(arr, pi + 1, high);        }    }     /* Function to print an array */    static void printArray(int[] arr, int n)    {        for (int i = 0; i < n; i++)            System.out.print(" " + arr[i]);        System.out.println();    }     // Driver Code    static public void main(String[] args)    {        int[] arr = { 10, 7, 8, 9, 1, 5 };        int n = arr.length;        quickSort(arr, 0, n - 1);        System.out.println("Sorted array: ");        printArray(arr, n);    }} // This code is contributed by vt_m.
''' Python implementation of QuickSort using Hoare'spartition scheme. ''' ''' This function takes first element as pivot, and places      all the elements smaller than the pivot on the left side      and all the elements greater than the pivot on      the right side. It returns the index of the last element      on the smaller side '''  def partition(arr, low, high):     pivot = arr[low]    i = low - 1    j = high + 1     while (True):         # Find leftmost element greater than        # or equal to pivot        i += 1        while (arr[i] < pivot):            i += 1         # Find rightmost element smaller than        # or equal to pivot        j -= 1        while (arr[j] > pivot):            j -= 1         # If two pointers met.        if (i >= j):            return j         arr[i], arr[j] = arr[j], arr[i]  ''' The main function that implements QuickSortarr --> Array to be sorted,low --> Starting index,high --> Ending index '''  def quickSort(arr, low, high):    ''' pi is partitioning index, arr[p] is now    at right place '''    if (low < high):         pi = partition(arr, low, high)         # Separately sort elements before        # partition and after partition        quickSort(arr, low, pi)        quickSort(arr, pi + 1, high)  ''' Function to print an array '''  def printArray(arr, n):    for i in range(n):        print(arr[i], end=" ")    print()  # Driver codearr = [10, 7, 8, 9, 1, 5]n = len(arr)quickSort(arr, 0, n - 1)print("Sorted array:")printArray(arr, n) # This code is contributed by shubhamsingh10
// C# implementation of QuickSort// using Hoare's partition schemeusing System; class GFG {     /* This function takes first element as pivot, and       places all the elements smaller than the pivot on the       left side and all the elements greater than the pivot       on the right side. It returns the index of the last       element on the smaller side*/    static int partition(int[] arr, int low, int high)    {        int pivot = arr[low];        int i = low - 1, j = high + 1;         while (true) {            // Find leftmost element greater            // than or equal to pivot            do {                i++;            } while (arr[i] < pivot);             // Find rightmost element smaller            // than or equal to pivot            do {                j--;            } while (arr[j] > pivot);             // If two pointers met.            if (i >= j)                return j;            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;            // swap(arr[i], arr[j]);        }    }     /* The main function that       implements QuickSort    arr[] --> Array to be sorted,    low --> Starting index,    high --> Ending index */    static void quickSort(int[] arr, int low, int high)    {        if (low < high) {            /* pi is partitioning index,            arr[p] is now at right place */            int pi = partition(arr, low, high);             // Separately sort elements before            // partition and after partition            quickSort(arr, low, pi);            quickSort(arr, pi + 1, high);        }    }     /* Function to print an array */    static void printArray(int[] arr, int n)    {        for (int i = 0; i < n; i++)            Console.Write(" " + arr[i]);        Console.WriteLine();    }     // Driver Code    static public void Main()    {        int[] arr = { 10, 7, 8, 9, 1, 5 };        int n = arr.Length;        quickSort(arr, 0, n - 1);        Console.WriteLine("Sorted array: ");        printArray(arr, n);    }} // This code is contributed by vt_m.
<script>    // Javascript implementation of QuickSort    // using Hoare's partition scheme         /* This function takes first element as pivot, and       places all the elements smaller than the pivot on the       left side and all the elements greater than the pivot       on the right side. It returns the index of the last       element on the smaller side*/    function partition(arr, low, high)    {        let pivot = arr[low];        let i = low - 1, j = high + 1;          while (true) {            // Find leftmost element greater            // than or equal to pivot            do {                i++;            } while (arr[i] < pivot);              // Find rightmost element smaller            // than or equal to pivot            do {                j--;            } while (arr[j] > pivot);              // If two pointers met.            if (i >= j)                return j;            let temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;            // swap(arr[i], arr[j]);        }    }      /* The main function that       implements QuickSort    arr[] --> Array to be sorted,    low --> Starting index,    high --> Ending index */    function quickSort(arr, low, high)    {        if (low < high) {            /* pi is partitioning index,            arr[p] is now at right place */            let pi = partition(arr, low, high);              // Separately sort elements before            // partition and after partition            quickSort(arr, low, pi);            quickSort(arr, pi + 1, high);        }    }      /* Function to print an array */    function printArray(arr, n)    {        for (let i = 0; i < n; i++)            document.write(" " + arr[i]);        document.write("</br>");    }         let arr = [ 10, 7, 8, 9, 1, 5 ];    let n = arr.length;    quickSort(arr, 0, n - 1);    document.write("Sorted array: " + "</br>");    printArray(arr, n);     </script>
Sorted array: 
1 5 7 8 9 10 
Note : If we change Hoare’s partition to pick the last element as pivot, then the Hoare’s partition may cause QuickSort to go into in an infinite recursion. For example, {10, 5, 6, 20} and pivot is arr[high], then returned index will always be high and call to same QuickSort will be made. To handle a random pivot, we can always swap that random element with the first element and simply follow the above algorithm.Comparison: 
Hoare’s scheme is more efficient than Lomuto’s partition scheme because it does three times fewer swaps on average, and it creates efficient partitions even when all values are equal.Like Lomuto’s partition scheme, Hoare partitioning also causes Quick sort to degrade to O(n^2) when the input array is already sorted, it also doesn’t produce a stable sort.Note that in this scheme, the pivot’s final location is not necessarily at the index that was returned, and the next two segments that the main algorithm recurs on are (lo..p) and (p+1..hi) as opposed to (lo..p-1) and (p+1..hi) as in Lomuto’s scheme.Both Hoare’s Partition, as well as Lomuto’s partition, are unstable.
Hoare’s scheme is more efficient than Lomuto’s partition scheme because it does three times fewer swaps on average, and it creates efficient partitions even when all values are equal.
Like Lomuto’s partition scheme, Hoare partitioning also causes Quick sort to degrade to O(n^2) when the input array is already sorted, it also doesn’t produce a stable sort.
Note that in this scheme, the pivot’s final location is not necessarily at the index that was returned, and the next two segments that the main algorithm recurs on are (lo..p) and (p+1..hi) as opposed to (lo..p-1) and (p+1..hi) as in Lomuto’s scheme.
Both Hoare’s Partition, as well as Lomuto’s partition, are unstable.
Source : https://en.wikipedia.org/wiki/Quicksort#Hoare_partition_schemeThis article is contributed by Sahil Chhabra (akku). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
vt_m
SHUBHAMSINGH10
akuma36
chinmoy1997pal
aodennison
mukesh07
soubhikmitra98
geeky01adarsh
surinderdawra388
simmytarika5
samarthpandya134
abhishant24952
Quick Sort
Sorting
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.