Related Articles

QuickSort
Difficulty Level : Medium ● Last Updated : 28 Apr, 2021

Like Merge Sor t, QuickSor t is a Divide and Conquer algorithm. It picks an element as pivot

and par titions the given array around the picked pivot. There are many di erent versions

of quickSor t that pick pivot in di erent ways. 

1. Always pick rst element as pivot.

2. Always pick last element as pivot (implemented below)

3. Pick a random element as pivot.

4. Pick median as pivot.

The key process in quickSor t is par tition(). Target of par titions is, given an array and an

element x of array as pivot, put x at its correct position in sor ted array and put all smaller

elements (smaller than x) before x, and put all greater elements (greater than x) af ter x.

All this should be done in linear time.

Pseudo Code for recursive QuickSor t function : 

/* low --> Starting index, high --> Ending index */

quickSort(arr[], low, high)
{
if (low < high)
{
/* pi is partitioning index, arr[pi] is now
at right place */
pi = partition(arr, low, high);

quickSort(arr, low, pi - 1); // Before pi

quickSort(arr, pi + 1, high); // After pi
 }
}

Par tition Algorithm 

There can be many ways to do par tition, following pseudo code adopts the method given

in CLRS book. The logic is simple, we star t from the lef tmost element and keep track of

index of smaller (or equal to) elements as i. While traversing, if we nd a smaller

element, we swap current element with arr[i]. Other wise we ignore current element. 

/* low --> Starting index, high --> Ending index */

quickSort(arr[], low, high)
{
if (low < high)
{
/* pi is partitioning index, arr[pi] is now
at right place */
pi = partition(arr, low, high);

quickSort(arr, low, pi - 1); // Before pi

quickSort(arr, pi + 1, high); // After pi
}
}
Pseudo code for par tition()  

/* This function takes last element as pivot, places

the pivot element at its correct position in sorted
array, and places all smaller (smaller than pivot)
to left of pivot and all greater elements to right
of pivot */
partition (arr[], low, high)
{
// pivot (Element to be placed at right position)
pivot = arr[high];

i = (low - 1) // Index of smaller element and indicates the

// right position of pivot found so far

for (j = low; j <= high- 1; j++)

{
// If current element is smaller than the pivot
if (arr[j] < pivot)
{
i++; // increment index of smaller element
swap arr[i] and arr[j]
}
}
swap arr[i + 1] and arr[high])
return (i + 1)
}

Illustration of par tition() : 

arr[] = {10, 80, 30, 90, 40, 50, 70}

Indexes: 0 1 2 3 4 5 6

low = 0, high = 6, pivot = arr[h] = 70

Initialize index of smaller element, i = -1

Traverse elements from j = low to high-1

j = 0 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])
 i = 0
arr[] = {10, 80, 30, 90, 40, 50, 70} // No change as i and j
// are same

j = 1 : Since arr[j] > pivot, do nothing

// No change in i and arr[]

j = 2 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])

i = 1
arr[] = {10, 30, 80, 90, 40, 50, 70} // We swap 80 and 30

j = 3 : Since arr[j] > pivot, do nothing

// No change in i and arr[]

j = 4 : Since arr[j] <= pivot, do i++ and swap(arr[i], arr[j])

i = 2
arr[] = {10, 30, 40, 90, 80, 50, 70} // 80 and 40 Swapped
j = 5 : Since arr[j] <= pivot, do i++ and swap arr[i] with arr[j]
i = 3
arr[] = {10, 30, 40, 50, 80, 90, 70} // 90 and 50 Swapped

We come out of loop because j is now equal to high-1.

Finally we place pivot at correct position by swapping
arr[i+1] and arr[high] (or pivot)
arr[] = {10, 30, 40, 50, 70, 90, 80} // 80 and 70 Swapped

Now 70 is at its correct place. All elements smaller than

70 are before it and all elements greater than 70 are after
it.

Recommended: Please solve it on “PR ACTICE” rst, before moving on to the solution.

Implementation: 

Following are the implementations of QuickSor t:  

C++14
/* C++ implementation of QuickSort */
#include <bits/stdc++.h>
using namespace std;
 
// A utility function to swap two elements
void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}
 
/* This function takes last element as pivot, places
the pivot element at its correct position in sorted
array, and places all smaller (smaller than pivot)
to left of pivot and all greater elements to right
of pivot */
int partition (int arr[], int low, int high)
{
    int pivot = arr[high]; // pivot
    int i = (low - 1); // Index of smaller element and indicates the right po
 
    for (int j = low; j <= high - 1; j++)
    {
        // If current element is smaller than the pivot
        if (arr[j] < pivot)
        {
            i++; // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
 
/* The main function that implements QuickSort
arr[] --> Array to be sorted,
low --> Starting index,
high --> Ending index */
void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        /* pi is partitioning index, arr[p] is now
        at right place */
        int pi = partition(arr, low, high);
 
        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
 
/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i = 0; i < size; i++)
        cout << arr[i] << " ";
    cout << endl;
}
 
// Driver Code
int main()
{
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    cout << "Sorted array: \n";
    printArray(arr, n);
    return 0;
}
 
// This code is contributed by rathbhupendra

Java

// Java implementation of QuickSort

import java.io.*;
 
class GFG{
     
// A utility function to swap two elements
static void swap(int[] arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
/* This function takes last element as pivot, places
   the pivot element at its correct position in sorted
   array, and places all smaller (smaller than pivot)
   to left of pivot and all greater elements to right
   of pivot */
static int partition(int[] arr, int low, int high)
{
     
    // pivot
    int pivot = arr[high];
     
    // Index of smaller element and
    // indicates the right position
    // of pivot found so far
    int i = (low - 1);
 
    for(int j = low; j <= high - 1; j++)
    {
         
        // If current element is smaller
        // than the pivot
        if (arr[j] < pivot)
        {
             
            // Increment index of
            // smaller element
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return (i + 1);
}
 
/* The main function that implements QuickSort
          arr[] --> Array to be sorted,
          low --> Starting index,
          high --> Ending index
 */
static void quickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
         
        // pi is partitioning index, arr[p]
        // is now at right place
        int pi = partition(arr, low, high);
 
        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
 
// Function to print an array
static void printArray(int[] arr, int size)
{
    for(int i = 0; i < size; i++)
        System.out.print(arr[i] + " ");
         
    System.out.println();
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 10, 7, 8, 9, 1, 5 };
    int n = arr.length;
     
    quickSort(arr, 0, n - 1);
    System.out.println("Sorted array: ");
    printArray(arr, n);
}
}
 
// This code is contributed by Ayush Choudhary

P ython3

# Python3 implementation of QuickSort 

 
# This Function handles sorting part of quick sort
# start and end points to first and last element of
# an array respectively
def partition(start, end, array):
     
    # Initializing pivot's index to start
    pivot_index = start
    pivot = array[pivot_index]
     
    # This loop runs till start pointer crosses
    # end pointer, and when it does we swap the
    # pivot with element on end pointer
    while start < end:
         
        # Increment the start pointer till it finds an
        # element greater than  pivot
        while start < len(array) and array[start] <= pivot:
            start += 1
             
        # Decrement the end pointer till it finds an
        # element less than pivot
        while array[end] > pivot:
            end -= 1
         
        # If start and end have not crossed each other,
        # swap the numbers on start and end
        if(start < end):
            array[start], array[end] = array[end], array[start]
     
    # Swap pivot element with element on end pointer.
    # This puts pivot on its correct sorted place.
    array[end], array[pivot_index] = array[pivot_index], array[end]
    
    # Returning end pointer to divide the array into 2
    return end
     
# The main function that implements QuickSort
def quick_sort(start, end, array):
     
    if (start < end):
         
        # p is partitioning index, array[p]
        # is at right place
        p = partition(start, end, array)
         
        # Sort elements before partition
        # and after partition
        quick_sort(start, p - 1, array)
        quick_sort(p + 1, end, array)
         
# Driver code
array = [ 10, 7, 8, 9, 1, 5 ]
quick_sort(0, len(array) - 1, array)
 
print(f'Sorted array: {array}')
     
# This code is contributed by Adnan Aliakbar

Output

Sorted array:
1 5 7 8 9 10

Analysis of QuickSor t 

Time taken by QuickSor t, in general, can be written as following. 

T(n) = T(k) + T(n-k-1) + (n)

The rst two terms are for two recursive calls, the last term is for the par tition process. k

is the number of elements which are smaller than pivot. 

The time taken by QuickSor t depends upon the input array and par tition strategy.

Following are three cases.

Worst Case: The worst case occurs when the par tition process always picks greatest or

smallest element as pivot. If we consider above par tition strategy where last element is
always picked as pivot, the worst case would occur when the array is already sor ted in

increasing or decreasing order. Following is recurrence for worst case. 

T(n) = T(0) + T(n-1) + (n)

which is equivalent to
T(n) = T(n-1) + (n)

2
The solution of above recurrence is   (n ).

Best Case: The best case occurs when the par tition process always picks the middle

element as pivot. Following is recurrence for best case. 

T(n) = 2T(n/2) + (n)

The solution of above recurrence is  (nLogn). It can be solved using case 2 of Master

Theorem.

Average Case: 

To do average case analysis, we need to consider all possible permutation of array and

calculate time taken by ever y permutation which doesn’t look easy. 

We can get an idea of average case by considering the case when par tition puts O(n/9)

elements in one set and O(9n/10) elements in other set. Following is recurrence for this

case. 

T(n) = T(n/9) + T(9n/10) + (n)

Solution of above recurrence is also O(nLogn)

2
Although the worst case time complexity of QuickSor t is O(n ) which is more than many

other sor ting algorithms like Merge Sor t and Heap Sor t, QuickSor t is faster in practice,

because its inner loop can be e ciently implemented on most architectures, and in most

real-world data. QuickSor t can be implemented in di erent ways by changing the choice

of pivot, so that the worst case rarely occurs for a given type of data. However, merge sor t

is generally considered better when data is huge and stored in external storage. 

Is QuickSor t stable? 

The default implementation is not stable. However any sor ting algorithm can be made

stable by considering indexes as comparison parameter. 

Is QuickSor t In-place? 

A s per the broad de nition of in-place algorithm it quali es as an in-place sor ting

algorithm as it uses extra space only for storing recursive function calls but not for

manipulating the input. 

What is 3-Way QuickSor t? 

In simple QuickSor t algorithm, we select an element as pivot, par tition the array around

pivot and recur for subarrays on lef t and right of pivot. 

Consider an array which has many redundant elements. For example, {1, 4, 2, 4, 2, 4, 1, 2,

4, 1, 2, 2, 2, 2, 4, 1, 4, 4, 4}. If 4 is picked as pivot in Simple QuickSor t, we x only one 4 and

recursively process remaining occurrences. In 3 Way QuickSor t, an array arr[l..r] is

divided in 3 par ts: 

a) arr[l..i] elements less than pivot. 

b) arr[i+1..j-1] elements equal to pivot. 

c) arr[j..r] elements greater than pivot. 

See this for implementation.

How to implement QuickSor t for Linked Lists? 

QuickSor t on Singly Linked List 

QuickSor t on Doubly Linked List

Can we implement QuickSor t Iteratively? 

Yes, please refer Iterative Quick Sor t.

Why Quick Sor t is preferred over MergeSor t for sor ting Arrays 

Quick Sor t in its general form is an in-place sor t (i.e. it doesn’t require any extra storage)

whereas merge sor t requires O(N) extra storage, N denoting the array size which may be

quite expensive. Allocating and de-allocating the extra space used for merge sor t

increases the running time of the algorithm. Comparing average complexity we nd that

both type of sor ts have O(NlogN) average complexity but the constants di er. For arrays,

merge sor t loses due to the use of extra O(N) storage space.

Most practical implementations of Quick Sor t use randomized version. The randomized

version has expected time complexity of O(nLogn). The worst case is possible in

randomized version also, but worst case doesn’t occur for a par ticular pattern (like sor ted

array) and randomized Quick Sor t works well in practice.

Quick Sor t is also a cache friendly sor ting algorithm as it has good locality of reference

when used for arrays.

Quick Sor t is also tail recursive, therefore tail call optimizations is done.
Why MergeSor t is preferred over QuickSor t for Linked Lists? 

In case of linked lists the case is di erent mainly due to di erence in memor y allocation

of arrays and linked lists. Unlike arrays, linked list nodes may not be adjacent in memor y.

Unlike array, in linked list, we can inser t items in the middle in O(1) extra space and O(1)

time. Therefore merge operation of merge sor t can be implemented without extra space

for linked lists.

In arrays, we can do random access as elements are continuous in memor y. Let us say we

have an integer (4-byte) array A and let the address of A[0] be x then to access A[i], we

can directly access the memor y at (x + i*4). Unlike arrays, we can not do random access

in linked list. Quick Sor t requires a lot of this kind of access. In linked list to access i’th

index, we have to travel each and ever y node from the head to i’th node as we don’t have

continuous block of memor y. Therefore, the overhead increases for quick sor t. Merge

sor t accesses data sequentially and the need of random access is low. 

How to optimize QuickSor t so that it takes O(Log n) extra space in worst case? 

Please see QuickSor t Tail Call Optimization (Reducing worst case space to Log n )

https://youtu.be/PgBzjlCcFvc

Snapshots : 

 
 
 Quiz on QuickSor t

Recent Ar ticles on QuickSor t

Coding practice for sor ting.

References : 

http://en.wikipedia.org/wiki/Quicksor t

Other Sor ting Algorithms on GeeksforGeeks/GeeksQuiz: 

Selection Sor t, Bubble Sor t, Inser tion Sor t, Merge Sor t, Heap Sor t, QuickSor t, Radix Sor t,

Counting Sor t, Bucket Sor t, ShellSor t, Comb Sor t, Pigeonhole Sor t

Please write comments if you nd anything incorrect, or you want to share more

information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the impor tant DS A concepts

with the DSA Self Paced Course at a student-friendly price and become industr y ready. 

To complete your preparation from learning a language to DS Algo and many more, 

please refer Complete Inter view Preparation Course.

In case you wish to attend live classes with industr y exper ts, please refer DSA Live

Classes

Like 0

Previous Next

RECOMMENDED ARTICLES Page : 1 2 3 4

 When does the worst case of Quicksort occur?
01 18, Jan 11

QuickSort on Doubly Linked List

02 25, Apr 13

QuickSort on Singly Linked List

03 28, Jun 13

Can QuickSort be implemented in O(nLogn) worst case time complexity?

04 29, Jan 15

Ar ticle Contributed By :

GeeksforGeeks

Vote for di culty

Current di culty : Medium

Easy Normal Medium Hard Expert

Improved By : Palak Jain 5, UditChaudhary, lakshaygupta2807, rathbhupendra, ays14,

dhavaldhavalb588, code_ayush, adnanaliakbar99
Article Tags : Adobe, Goldman Sachs, HSBC, Qualcomm, Quick Sort, Samsung, SAP Labs,
Target Corporation, Divide and Conquer, Sorting
Practice Tags : Samsung, Goldman Sachs, Adobe, SAP Labs, Qualcomm, HSBC,
Target Corporation, Divide and Conquer, Sorting

Improve Article Report Issue

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.

Load Comments

5th Floor, A-118,

Sector-136, Noida, Uttar Pradesh - 201305
feedback@geeksforgeeks.org

Company Learn
About Us Algorithms
Careers Data Structures
Privacy Policy Languages
Contact Us CS Subjects
Copyright Policy Video Tutorials

Practice Contribute
Courses Write an Article
Company-wise Write Interview Experience
Topic-wise Internships
How to begin? Videos

@geeksforgeeks , Some rights reserved