# Python Program for QuickSort

• Difficulty Level : Medium
• Last Updated : 30 Sep, 2022

Just unlikely merge Sort, QuickSort is a divide and conquer algorithm. It picks an element as a pivot and partitions the given array around the picked pivot. There are many different versions of quickSort that pick pivot in different ways.

1. Always pick the first element as a pivot
2. Always pick the last element as a pivot
3. Pick a random element as a pivot
4. Pick median as a pivot

Here we will be picking the last element as a pivot. The key process in quickSort is partition(). Target of partitions is, given an array and an element ‘x’ of array as a pivot, put x at its correct position in a sorted array and put all smaller elements (smaller than x) before x, and put all greater elements (greater than x) after x. All this should be done in linear time.

Pseudo Code: Recursive QuickSort function

```// low  --> Starting index,
// high  --> Ending index
quickSort(arr[], low, high) {

// Till starting index is lesser than ending index
if (low < high) {

// pi is partitioning index,
// arr[p] is now at right place
pi = partition(arr, low, high);

// Before pi
quickSort(arr, low, pi - 1);
// After pi
quickSort(arr, pi + 1, high);
}
}```

## Python3

 `# Python program for implementation of Quicksort Sort` `# This implementation utilizes pivot as the last element in the nums list``# It has a pointer to keep track of the elements smaller than the pivot``# At the very end of partition() function, the pointer is swapped with the pivot``# to come up with a "sorted" nums relative to the pivot`  `# Function to find the partition position``def` `partition(array, low, high):` `    ``# choose the rightmost element as pivot``    ``pivot ``=` `array[high]` `    ``# pointer for greater element``    ``i ``=` `low ``-` `1` `    ``# traverse through all elements``    ``# compare each element with pivot``    ``for` `j ``in` `range``(low, high):``        ``if` `array[j] <``=` `pivot:` `            ``# If element smaller than pivot is found``            ``# swap it with the greater element pointed by i``            ``i ``=` `i ``+` `1` `            ``# Swapping element at i with element at j``            ``(array[i], array[j]) ``=` `(array[j], array[i])` `    ``# Swap the pivot element with the greater element specified by i``    ``(array[i ``+` `1``], array[high]) ``=` `(array[high], array[i ``+` `1``])` `    ``# Return the position from where partition is done``    ``return` `i ``+` `1` `# function to perform quicksort`  `def` `quickSort(array, low, high):``    ``if` `low < high:` `        ``# Find pivot element such that``        ``# element smaller than pivot are on the left``        ``# element greater than pivot are on the right``        ``pi ``=` `partition(array, low, high)` `        ``# Recursive call on the left of pivot``        ``quickSort(array, low, pi ``-` `1``)` `        ``# Recursive call on the right of pivot``        ``quickSort(array, pi ``+` `1``, high)`  `data ``=` `[``1``, ``7``, ``4``, ``1``, ``10``, ``9``, ``-``2``]``print``(``"Unsorted Array"``)``print``(data)` `size ``=` `len``(data)` `quickSort(data, ``0``, size ``-` `1``)` `print``(``'Sorted Array in Ascending Order:'``)``print``(data)`

Output

```Unsorted Array
[1, 7, 4, 1, 10, 9, -2]
Sorted Array in Ascending Order:
[-2, 1, 1, 4, 7, 9, 10]
```

Time Complexity: Worst case time complexity is O(N2) and average case time complexity is O(N log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up