Dual pivot Quicksort using Python

Introduction

Dual-pivot Quicksort is a sophisticated sorting algorithm that improves the original Quicksort technique. The main idea behind this approach is to efficiently segment the input array by using two pivot items rather than just one. The dual-pivot approach for various input data sets greatly enhances the algorithm's performance. This method uses two pivot elements for more effective sorting than the standard Quicksort, which divides the array into two pieces, separating values smaller and greater than the pivot. A single pivot element is then selected. Dual-pivot Quicksort expands on this idea by choosing two pivot elements, commonly referred to as the left and right pivots.

The Dual-pivot Quicksort algorithm's fundamental steps are as follows:

Pick two pivot elements, often the array's leftmost and rightmost elements.
Initialize the i, k, and j pointers. J starts one position before the right pivot, while i and k start immediately after the left pivot.
Check if each member in the array is smaller than the left pivot by traversing it from left to right (with i). If so, replace it with the element at position k, then raise both i and k.
If an element is higher than or equal to the right pivot when traversing the array from left to right (with i), replace it with the element at the j-th position and decrease j. Keep going until j and i cross.
This guarantees that the pivot pieces are positioned precisely.
The sub-arrays located to the left and right of these pivot items are then repeatedly subjected to the Dual-pivot Quicksort algorithm.
To sort the full array, repeat the procedure for each sub-array.

Code implementation

def dual_pivot_quicksort(arr, low, high):
    if low < high:
        if arr[low] > arr[high]:
            arr[low], arr[high] = arr[high], arr[low]
        left_pivot, right_pivot = arr[low], arr[high]
        i = low + 1
        k = low + 1
        j = high - 1
        while i <= j:
            if arr[i] < left_pivot:
                arr[i], arr[k] = arr[k], arr[i]
                k += 1
            elif arr[i] >= right_pivot:
                while arr[j] > right_pivot and j >= i:
                    j -= 1
                arr[i], arr[j] = arr[j], arr[i]
                j -= 1
                if arr[i] < left_pivot:
                    arr[i], arr[k] = arr[k], arr[i]
                    k += 1
            i += 1
        k -= 1
        j += 1
        arr[low], arr[k] = arr[k], arr[low]
        arr[high], arr[j] = arr[j], arr[high]
        dual_pivot_quicksort(arr, low, k - 1)
        dual_pivot_quicksort(arr, k + 1, j - 1)
        dual_pivot_quicksort(arr, j + 1, high)
arr = [3, 6, 8, 10, 1, 2, 1]
dual_pivot_quicksort(arr, 0, len(arr) - 1)
print("Sorted array:", arr)

Output:

Sorted array: [1, 1, 2, 3, 6, 8, 10]

Key points about Dual-pivot Quicksort

Dual-pivot is effective. Because of its effectiveness, Quicksort frequently outperforms regular Quicksort, especially when working with larger datasets. This efficiency is attained by lowering the number of comparisons and swaps necessary to sort an array.
The algorithm's choice of the left and right pivots, or pivot components, is critical. The effectiveness of the algorithm depends on the pivot selection. Variations of the code I provided in the previous response utilize alternative pivot selection algorithms. Still, it initially chooses the leftmost and rightmost members in the array as pivots.
Elements below the left pivot, between the right and left pivots (inclusive), and above the right pivot are the three segments into which the algorithm divides the array.
Dual-pivot Quicksort has a worst-case time complexity of O(n2), which happens when the input data is already sorted or almost sorted. With an average time complexity of O(n log n), it performs much better overall and in practice.

Conclusion

Dual-pivot The Quicksort sorting algorithm improves on the original Quicksort technique. It is a strong option for sorting tasks since it drastically decreases the number of comparisons & swaps necessary to sort an array using two pivot elements. Due to the algorithm's average time complexity of O(n log n), it excels in handling small and large datasets. It's important to remember that in the worst situation, its time complexity can drop to O(n2). Dual-pivot Quicksort has a wide range of uses in programming languages and libraries despite not being a reliable sorting algorithm due to its speed and adaptability. Depending on the specifics of the data and the sorting requirements, it may be preferred over other sorting algorithms. Overall, Dual-pivot Quicksort achieves the best possible combination of effectiveness and simplicity, making it an invaluable tool for swiftly sorting various data.

Next Topicexecute_async_script driver method - Selenium Python

← prev next →