Scribd
Upload
143 views13 pages

QuickSort (With Code in Python-C++-Java-C)

The document discusses the quicksort algorithm, which works by selecting a pivot element and partitioning the array such that elements smaller than the pivot are to its left and larger elements are to its right. It then recursively applies this process to the subarrays until each contains a single element, resulting in a fully sorted array. Code examples of quicksort are provided in Python, Java, and C/C++. Quicksort has average time complexity of O(n log n) but can degrade to O(n^2) in worst cases.

Uploaded by

Thee Kullatee
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
143 views13 pages

QuickSort (With Code in Python-C++-Java-C)

The document discusses the quicksort algorithm, which works by selecting a pivot element and partitioning the array such that elements smaller than the pivot are to its left and larger elements are to its right. It then recursively applies this process to the subarrays until each contains a single element, resulting in a fully sorted array. Code examples of quicksort are provided in Python, Java, and C/C++. Quicksort has average time complexity of O(n log n) but can degrade to O(n^2) in worst cases.

Uploaded by

Thee Kullatee
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 13

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)

You might also like