Quicksort in Python

Introduction to Quicksort

Sorting is a principal activity in software engineering, and there are numerous algorithms that can be utilized to sort a rundown of elements. One of the most effective sorting algorithms is Quicksort, which is based on the divide-and-conquer strategy. Quicksort makes some average memories complexity of O(n log n) and is generally utilized practically speaking.

In this article, we will check the Quicksort algorithm in Python and examine its implementation, performance, and optimization techniques.

How Quicksort Works

The Quicksort algorithm works by partitioning an array into two sub-arrays, one containing elements less than a picked pivot element, and the other containing elements more noteworthy than or equivalent to the pivot element. The pivot element is picked to such an extent that it is in its last position in the sorted array after the partitioning.

The algorithm then recursively sorts the sub-arrays by applying a similar cycle to each sub-array. The recursion stops when a sub-array has less than two elements.

Code

def quicksort(arr):
    if len(arr) < 2:
        return arr
    pivot = arr[0]
    left = [x for x in arr[1:] if x < pivot]
    right = [x for x in arr[1:] if x >= pivot]
    return quicksort(left) + [pivot] + quicksort(right)

The quicksort function takes an array arr as input and returns a sorted array. The base case is the point at which the length of arr is under two, in which case arr is as of now sorted.

The pivot element is picked as the first element of arr. The sub-arrays are then produced by separating the elements that are more modest than the pivot into left, and the elements that are more noteworthy than or equivalent to the pivot into right.

The sorted sub-arrays are acquired by recursively calling quicksort on left and right. The sorted arrays are connected with the pivot element to get the last sorted array.

Choosing the Pivot Element

The decision of the pivot element can fundamentally affect the performance of the Quicksort calculation. Assuming the pivot element is picked ineffectively, the calculation might display horrible showing, and at times, it might try and show worst-case conduct with a time complexity of O(n^2).

A typical way to deal with choosing the pivot element is to choose the median of the first, middle, and last elements of the array. This approach will in general function admirably by and by and can forestall worst-case conduct.

Partitioning the Array

The partitioning step in Quicksort is urgent for the performance of the calculation. In the implementation above, we use list understandings to partition the array, which can be wasteful for enormous arrays.

An easy way to deal with partitioning is to utilize two indices to traverse the array from the two finishes and swap elements that are in some unacceptable sub-array. This approach can be more proficient for enormous arrays and is in many cases utilized by and by.

Recursion in Quicksort

The recursive idea of the Quicksort algorithm can prompt stack overflow errors for extremely enormous arrays. To keep away from this, it is feasible to utilize a tail-recursive implementation of the calculation, which optimizes the recursion by reusing the stack frame for the recursive call. Be that as it may, Python doesn't optimize tail recursion of course, so this procedure may not give huge performance benefits in Python.

Algorithm Implementation

Inputs:

A: an array of n elements

lo: the index of the first element of the sub-array to be sorted

hi: the index of the last element of the sub-array to be sorted

Quicksort Algorithm:

If lo is less than hi, then do the following:
- Call partition(A, lo, hi) and store the index of the pivot element in p.
- Recursively call quicksort(A, lo, p-1).
- Recursively call quicksort(A, p+1, hi).

Partition Algorithm:

Let pivot be the last element of the sub-array A[lo..hi].
Let i be the index of the first element of the sub-array.
For each j from lo to hi-1, do the following:
1. If A[j] <= pivot, then do the following:
  1. Increment i.
  2. Swap A[i] with A[j].
Swap A[i+1] with A[hi].
Return i+1.

Program Implementation

# Python program for Quicksort
def quicksort(arr, lo, hi):
    """
    Sorts the given array in ascending order using the Quicksort algorithm.

    Parameters:
    arr (list): The array to be sorted
    lo (int): The index of the first element in the sub-array to be sorted
    hi (int): The index of the last element in the sub-array to be sorted
    """
    if lo < hi:
        # Partition the array and get the index of the pivot element
        p = partition(arr, lo, hi)

        # Recursively sort the left and right partitions
        quicksort(arr, lo, p-1)
        quicksort(arr, p+1, hi)
def partition(arr, lo, hi):
    """
    Partitions the sub-array by selecting the last element as the pivot,
    and rearranging the array so that all elements to the left of the pivot
    are less than or equal to the pivot, and all elements to the right of the
    pivot are greater than the pivot.

    Parameters:
    arr (list): The array to be partitioned
    lo (int): The index of the first element in the sub-array to be partitioned
    hi (int): The index of the last element in the sub-array to be partitioned

    Returns:
    int: The index of the pivot element after partitioning
    """
    # Select the last element as the pivot
    pivot = arr[hi]
    i = lo - 1

    # Loop through the sub-array and partition it
    for j in range(lo, hi):
        if arr[j] <= pivot:
            # Move the element to the left partition
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    # Move the pivot element to its final position in the array
    arr[i+1], arr[hi] = arr[hi], arr[i+1]
    # Return the index of the pivot element
    return i+1
# Example usage
arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quicksort(arr, 0, n-1)
print("Sorted array:", arr)

Output:

Sorted array: [1, 5, 7, 8, 9, 10]

Time and Space Complexity of Quicksort

Time Complexity:

The average time complexity of Quicksort is O(n log n), where n is the number of elements in the array. Nonetheless, the worst-case time complexity is O(n^2), which happens when the pivot element is the littlest or biggest element in the array, and the sub-arrays are not uniformly adjusted.

Space complexity:

The space complexity of the Quicksort algorithm is O(log n) on average, because of the recursive idea of the calculation. Be that as it may, the worst-case space complexity is O(n), which happens when the recursive calls are not adjusted and make a long chain of stack frames.

Comparing Quicksort to Other Sorting Algorithms

Quicksort is one of the most productive sorting algorithms by and by, with an average time complexity of O(n log n) and great memory region. Nonetheless, it can display worst-case conduct with a time complexity of O(n^2), and it may not be the most ideal decision for little arrays or profoundly structured data. Other well known sorting algorithms incorporate Merge Sort, Heap Sort, and Insertion Sort. Merge Sort has a worst-case time complexity of O(n log n), yet it requires additional memory for consolidating the sub-arrays.

Heap Sort has a worst-case time complexity of O(n log n) and no additional memory prerequisites, yet it may not be as store well disposed as Quicksort. Insertion Sort has a time complexity of O(n^2) however is exceptionally effective for little arrays and to some extent sorted data. The decision of sorting algorithm relies upon the particular use case, the size and structure of the data, and the accessible assets.

Quicksort Optimization Techniques

There are a few techniques that can be utilized to optimize the Quicksort algorithm and work on its performance. A portion of these techniques include:

Randomized pivot selection: Rather than choosing the first element as the pivot, select a random element from the array. This can diminish the probability of worst-case conduct and work on the average performance of the algorithm.

Tail recursion: Utilize a tail-recursive implementation of Quicksort to optimize the recursion and keep away from stack overflow errors.

Hybrid algorithms: Utilize a hybrid algorithm calculation that joins Quicksort with one more sorting algorithm for little arrays or profoundly structured data. For example, use Insertion Sort for sub-arrays with under 10 elements.

Conclusion

Quicksort is a highly effective sorting algorithm that can sort enormous arrays in O(n log n) time on average. Nonetheless, it can show worst-case conduct with a time complexity of O(n^2) and may not be the most ideal decision for little arrays or profoundly structured data.

Next TopicRange of float in python

← prev next →