Quicksort Algorithm
In this tutorial, you will learn about the quick sort algorithm and its
implementation in Python, Java, C, and C++.
Quicksort is a sorting algorithm
(h!ps://www.programiz.com/dsa/sorting-algorithm) based on the divide
and conquer approach where
1. An array is divided into subarrays by selecting a pivot element
(element selected from the array).
While dividing the array, the pivot element should be positioned in
such a way that elements less than pivot are kept on the le# side and
elements greater than pivot are on the right side of the pivot.
2. The le# and right subarrays are also divided using the same approach.
This process continues until each subarray contains a single element.
3. At this point, elements are already sorted. Finally, elements are
combined to form a sorted array.
Working of Quicksort Algorithm
1. Select the Pivot Element
There are different variations of quicksort where the pivot element is
selected from different positions. Here, we will be selecting the rightmost
element of the array as the pivot element.
Select a pivot element
2. Rearrange the Array
Now the elements of the array are rearranged so that elements that are
smaller than the pivot are put on the le# and the elements greater than
the pivot are put on the right.
Put all the smaller elements on the le! and greater on the right of pivot element
Here's how we rearrange the array:
1. A pointer is fixed at the pivot element. The pivot element is compared
with the elements beginning from the first index.
Comparison of pivot element with element beginning from the first index
2. If the element is greater than the pivot element, a second pointer is set
for that element.
If the element is greater than the pivot element, a second pointer is set for that
element.
3. Now, pivot is compared with other elements. If an element smaller
than the pivot element is reached, the smaller element is swapped
with the greater element found earlier.
Try hands-on Interview (h!ps://programiz.pro/course/python-interview-q
CODING utm_source=programiz-top-
Preparation with
PRO bar&utm_campaign=programiz&utm_medium=re
Programiz PRO
Thank you for printing our content at www.domain-name.com. Please check back soon for
36% OFF
Claim Discount Now
Search tutorials & examples
(/)
www.domain-name.com
Pivot is compared with other elements.
4. Again, the process is repeated to set the next greater element as the
second pointer. And, swap it with another smaller element.
The process is repeated to set the next greater element as the second pointer.
5. The process goes on until the second last element is reached.
The process goes on until the second last element is reached.
6. Finally, the pivot element is swapped with the second pointer.
Finally, the pivot element is swapped with the second pointer.
3. Divide Subarrays
Pivot elements are again chosen for the le" and the right sub-parts
separately. And, step 2 is repeated.
Select pivot element of in each half and put at correct place using recursion
The subarrays are divided until each subarray is formed of a single
element. At this point, the array is already sorted.
Quick Sort Algorithm
quickSort(array, leftmostIndex, rightmostIndex)
if (leftmostIndex < rightmostIndex)
pivotIndex <- partition(array,leftmostIndex, rightmostIndex)
quickSort(array, leftmostIndex, pivotIndex - 1)
quickSort(array, pivotIndex, rightmostIndex)
partition(array, leftmostIndex, rightmostIndex)
set rightmostIndex as pivotIndex
storeIndex <- leftmostIndex - 1
for i <- leftmostIndex + 1 to rightmostIndex
if element[i] < pivotElement
swap element[i] and element[storeIndex]
storeIndex++
swap pivotElement and element[storeIndex+1]
return storeIndex + 1
Visual Illustration of Quicksort Algorithm
You can understand the working of quicksort algorithm with the help of
the illustrations below.
Sorting the elements on the le! of pivot using recursion
Sorting the elements on the right of pivot using recursion
Quicksort Code in Python, Java, and C/C++
Python Java C C++
# Quick sort in Python
# 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
Quicksort Complexity
Time Complexity
Best O(n*log n)
Worst O(n2)
Average O(n*log n)
Space Complexity O(log n)
Stability No
1. Time Complexities
Worst Case Complexity [Big-O]: O(n2)
It occurs when the pivot element picked is either the greatest or the
smallest element.
This condition leads to the case in which the pivot element lies in an
extreme end of the sorted array. One sub-array is always empty and
another sub-array contains n - 1 elements. Thus, quicksort is called
only on this sub-array.
However, the quicksort algorithm has be$er performance for
sca$ered pivots.
Best Case Complexity [Big-omega]: O(n*log n)
It occurs when the pivot element is always the middle element or near
to the middle element.
Average Case Complexity [Big-theta]: O(n*log n)
It occurs when the above conditions do not occur.
2. Space Complexity
The space complexity for quicksort is O(log n) .
Quicksort Applications
Quicksort algorithm is used when
the programming language is good for recursion
time complexity ma$ers
space complexity ma$ers
Similar Sorting Algorithms
Insertion Sort (/dsa/insertion-sort)
Merge Sort (/dsa/merge-sort)
Selection Sort (/dsa/selection-sort)
Bucket Sort (/dsa/bucket-sort)
Previous Next Tutorial:
Tutorial:
(/dsa/merge- (/dsa/counting-
Counting
sort) sort)
Merge Sort
Sort
Share on:
(h$ps://www.facebook.com/sharer/sharer.php? (h$ps://twi$er.com/intent/twe
u=h$ps://www.programiz.com/dsa/quick-sort) text=Check%20this%20amazi
sort)
Did you find this article helpful?
Related Tutorials
DS & Algorithms DS & Algorithms
Insertion Sort Algorithm Selection Sort Algorithm
(/dsa/insertion-sort) (/dsa/selection-sort)
DS & Algorithms DS & Algorithms
Bubble Sort Binary Search
(/dsa/bubble-sort) (/dsa/binary-search)
