Hoare's vs. Lomuto partition scheme in QuickSort using Python

Sorting is a principal activity in computer science, and QuickSort is an unbelievably productive algorithm for this reason. This article investigates the idea of QuickSort involving Random Pivoting in Python. We'll investigate its key parts, beginning with an introduction to QuickSort.

What is QuickSort?

QuickSort is a famous sorting algorithm that falls under the class of comparison-based sorting. Created by Tony Hoare in 1960, QuickSort is known for its speed and effortlessness. It works by choosing a 'pivot' element from the array and partitioning different elements into two sub-arrays: those not exactly the pivot and those greater than the pivot. The cycle is then recursively applied to the sub-arrays until the whole array is sorted.

Random Pivoting

The decision of the pivot element incredibly impacts QuickSort's performance. Conventional QuickSort executions frequently select the first or last element as the pivot. Be that as it may, this approach can prompt failure in specific situations, for example, when the info data is sorted. This is where Random Pivoting comes in.

Random Pivoting utilizing Hoare Partitioning

Hoare Partitioning is an elective partitioning plan for QuickSort, which is more effective as far as trades contrasted with Lomuto Partitioning. Here is a Python program carrying out QuickSort with Random Pivoting utilizing Hoare Partitioning:

Algorithm:

Pick a pivot element from the array. For this situation, we will involve the first element as the pivot.
Initialize two pointers, i and j, i pointing to the first element and j pointing to the last element of the array.
Increment I until you find an element greater than or equivalent to the pivot.
Decrement j until you find an element not exactly equivalent to the pivot.
Swap the elements at i and j if i is not exactly equivalent to j. Continue this cycle until i is greater than j.
At the point when i becomes greater than j, it implies the pivot has arrived at its right position. Swap the pivot element with the element at index j.
Recursively apply QuickSort to the subarray to the left of the pivot (elements not exactly the pivot) and the subarray to the right of the pivot (elements greater than the pivot).
Repeat the cycle until the entire array is sorted.

Code

# Python program for Random Pivoting using Hoare Partitioning
import random

# Define the QuickSort function using Hoare Partitioning.
def quicksort_hoare(arr, low, high):
    # Base case: If the range is invalid or contains only one element, it's already sorted.
    if low < high:
        # Randomly select a pivot element within the specified range.
        pivot_index = random.randint(low, high)
        # Swap the pivot element with the first element.
        arr[pivot_index], arr[low] = arr[low], arr[pivot_index]
        pivot = arr[low]

        i = low - 1
        j = high + 1
        while True:
            i += 1
            while arr[i] < pivot:
                i += 1

            j -= 1
            while arr[j] > pivot:
                j -= 1

            if i >= j:
                break

            arr[i], arr[j] = arr[j], arr[i]

        pivot_index = j
        # Recursively sorts the subarrays to the left and right of the pivot element.
        quicksort_hoare(arr, low, pivot_index)
        quicksort_hoare(arr, pivot_index + 1, high)

my_list = [3, 6, 8, 10, 1, 2, 1]
print(" Original Array : ", my_list)
# Call the QuickSort function with the input list.
quicksort_hoare(my_list, 0, len(my_list) - 1)
# Printing the sorted list.
print("Sorted Array based on Hoare Partitioning : ", my_list)

Output:

Original Array : [3, 6, 8, 10, 1, 2, 1]
Sorted Array based on Hoare Partitioning : [1, 1, 2, 3, 6, 8, 10]

Time Complexity: QuickSort utilizing Hoare Partitioning has an average case time complexity of O(n log n) and a worst scenario time complexity of O(n^2).

Space Complexity: The space complexity is O(log n) because of the recursive capability calls and the stack space utilized, where 'n' is the number of components in the information exhibit.

Random Pivoting utilizing Lomuto Partitioning

Random Pivoting includes choosing a random element as the pivot. This randomness lessens the probability of experiencing the most pessimistic scenario situations and guarantees QuickSort's effectiveness across different data circulations. Here is a Python program executing QuickSort with Random Pivoting utilizing Lomuto Partitioning:

Algorithm:

Pick a pivot element from the array. For this situation, we will involve the last element as the pivot.
Initialize two pointers, i and j, to the first element of the array.
Increment j until you find an element greater than or equivalent to the pivot.
Decrement I until you find an element not exactly equivalent to the pivot.
Swap the elements at i and j if i is not exactly equivalent to j. Continue this cycle until i is greater than j.
Swap the pivot element with the element at index i, placing the pivot in its right position in the sorted array.
Recursively apply QuickSort to the subarray to the left of the pivot and the subarray to the right of the pivot (elements greater than the pivot).
Repeat the cycle until the entire array is sorted.

Code

# Python program for Random Pivoting using Lomuto Partitioning
import random

# Define the QuickSort function using Lomuto Partitioning.
def quicksort_lomuto(arr, low, high):
    # Base case: If the range is invalid or contains only one element, it's already sorted.
    if low < high:
        # Randomly select a pivot element within the specified range.
        pivot_index = random.randint(low, high)
        # Swap the pivot element with the last element.
        arr[pivot_index], arr[high] = arr[high], arr[pivot_index]
        pivot = arr[high]

        i = low - 1
        for j in range(low, high):
            if arr[j] < pivot:
                i += 1
                arr[i], arr[j] = arr[j], arr[i]

        arr[i + 1], arr[high] = arr[high], arr[i + 1]
        pivot_index = i + 1

        # Recursively sort the subarrays to the left and right of the pivot.
        quicksort_lomuto(arr, low, pivot_index - 1)
        quicksort_lomuto(arr, pivot_index + 1, high)

my_list = [3, 6, 8, 10, 1, 2, 1]
print(" Original Array: ", my_list)
# Call the QuickSort function with the input list.
quicksort_lomuto(my_list, 0, len(my_list) - 1)
# Print the sorted list.
print(" Sorted Array based on Lomuto Partitioning : ", my_list)

Output:

Original Array : [3, 6, 8, 10, 1, 2, 1]
Sorted Array based on Lomuto Partitioning : [1, 1, 2, 3, 6, 8, 10]

Time Complexity: QuickSort with Lomuto Partitioning has a worst-case time complexity of O(n2), an average time complexity of O(n log n), and a best-case time complexity of O(n log n).

Space Complexity: The space complexity of this execution is O(n) because of the recursive capability calls, where 'n' is the number of elements in the information exhibit.

Comparison

Lomuto Partitioning is more straightforward to execute and comprehend because of its effortlessness. Lomuto Partitioning is steady, meaning it keeps the overall control of equivalent components. Lomuto Partitioning requires a greater number of swaps than Hoare Partitioning, making it less productive concerning memory tasks. It will in general perform somewhat more slowly than Hoare Partitioning by and large.

Hoare Partitioning is more effective concerning time and swaps, making it quicker practically speaking. Hoare Partitioning isn't steady and may change the request for equivalent components. Hoare Partitioning is more intricate to comprehend and execute contrasted with Lomuto Partitioning.

Difference	QuickSort (Lomuto)	QuickSort (Hoare)
Performance:	Lomuto Partitioning moves a little more slowly.	Hoare Partitioning is a tiny bit quicker.
Stability:	Stable Lomuto Partitioning	It is unstable to use Hoare Partitioning.
Simplicity:	Implementing Lomuto Partitioning is simpler.	More difficult is Hoare Partitioning.
Swaps:	Lomuto Partitioning requires more swaps	Hoare Partitioning requires fewer swaps
Time Complexity (Worst Case):	Both have a worst-case time complexity of O(n^2)	Both have the same worst-case time complexity of O(n^2)
Time Complexity (Average Case):	Both have an average-case time complexity of O(n log n)	Both have the same average-case time complexity of O(n log n)
Time Complexity (Best Case):	Both have a best-case time complexity of O(n log n)	Both have the same best-case time complexity of O(n log n)
Space Complexity:	Lomuto Partitioning has a space complexity of O(n)	Hoare Partitioning has a space complexity of O(log n)
Use Cases:	Lomuto Partitioning is appropriate for all types of sorting.	For sorting that requires high efficiency, Hoare Partitioning is preferable.
Adaptability:	Lomuto Partitioning is suitable for various data distributions	Hoare Partitioning is best for more balanced data

Conclusion

In conclusion, QuickSort with Random Pivoting is a strong sorting method with numerous partitioning choices, Lomuto and Hoare being two conspicuous decisions. The two methodologies influence the randomness of pivot choice to improve QuickSort's performance and versatility across different data situations. The given Python programs, combined with point-by-point remarks, offer a thorough asset for those keen on investigating and carrying out these algorithms in their projects.

Next Topiciconphoto() method in Tkinter | Python

← prev next →