QuickSort - Data Structure and Algorithm Tutorials - GeeksforGeeks

10/18/23, 11:54 PM QuickSort - Data Structure and Algorithm Tutorials - GeeksforGeeks
DSA for Beginners DSA Tutorial Data Structures Algorithms Array Strings Linked List Stack Queue Tree Graph Searching Sorting Recu
Write an Interview Experience

QuickSort – Data Structure and
QuickSort - Data Structure
and Algorithm Tutorials Algorithm Tutorials
Time and Space Complexity Read Discuss(170+) Courses Practice Video
Analysis of Quick Sort
Application and uses of QuickSort is a sorting algorithm based on the Divide and
Quicksort Conquer algorithm that picks an element as a pivot and
partitions the given array around the picked pivot by
QuickSort using different
languages placing the pivot in its correct position in the sorted array.
Iterative QuickSort
Different implementations
How does QuickSort work?
of QuickSort
The key process in quickSort is a partition(). The target of
Visualization of QuickSort
partitions is to place the pivot (any element can be chosen
to be a pivot) at its correct position in the sorted array and
Partitions in QuickSort
put all smaller elements to the left of the pivot, and all
Some problems on greater elements to the right of the pivot.
QuickSort
Partition is done recursively on each side of the pivot after
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and Got It !
the pivot isourplaced
understood in its& Privacy
Cookie Policy correct position and this finally
Policy
sorts the array.
Skip to content
https://www.geeksforgeeks.org/quick-sort/ 1/23
How Quicksort works
Choice of Pivot:
There are many different choices for picking pivots.
Always pick the first element as a pivot.

Always pick the last element as a pivot (implemented below)
Pick a random element as a pivot.
Pick the middle as the pivot.
Partition Algorithm:
The logic is simple, we start from the leftmost element and

keep track of the index of smaller (or equal) elements as i.
While traversing, if we find a smaller element, we swap
the current element with arr[i]. Otherwise, we ignore the
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and
current element.
understood our Cookie Policy & Privacy Policy
Skip to content
Let us understand the working of partition and the Quick Sort

algorithm with the help of the following example:
Consider: arr[] = {10, 80, 30, 90, 40}.
Compare 10 with the pivot and as it is less than pivot

arrange it accrodingly.
Partition in QuickSort: Compare pivot with 10
Compare 80 with the pivot. It is greater than pivot.
Compare 30 with pivot. It is less than pivot so arrange it

accordingly.
Skip to content
Compare 90 with the pivot. It is greater than the pivot.
Arrange the pivot in its correct position.
We use cookies to ensure you have the best browsing experience on in

Partition ourQuickSort:
website. By using
Place our in
pivot site,
itsyou acknowledge
correct position that you have read and
Skip to content
Illustration of Quicksort:
As the partition process is done recursively, it keeps on putting

the pivot in its actual position in the sorted array. Repeatedly
putting pivots in their actual position makes the array sorted.
Follow the below images to understand how the recursive

implementation of the partition algorithm helps to sort the array.
Initial partition on the main array:
Quicksort: Performing the partition
Partitioning of the subarrays:
Quicksort: Performing the partition
Skip to content
Code implementation of the Quick Sort:

C++
#include <bits/stdc++.h>
using namespace std;
int partition(int arr[],int low,int high)

{
//choose the pivot
int pivot=arr[high];
//Index of smaller element and Indicate
//the right position of pivot found so far
int i=(low-1);
for(int j=low;j<=high;j++)
{
//If current element is smaller than the pivot
if(arr[j]<pivot)
{
//Increment index of smaller element
i++;
swap(arr[i],arr[j]);
}
}
swap(arr[i+1],arr[high]);
return (i+1);
}
// The Quicksort function Implement
void quickSort(int arr[],int low,int high)

{
We use cookies to ensure you have the best browsing
//experience
when low on our
iswebsite.
less By usinghigh
than our site, you acknowledge that you have read and
understood our Cookie
if(low<high) Policy & Privacy Policy
{
// pi is the partition Skip to content
return index of pivot
int pi=partition(arr,low,high);
//Recursion Call
//smaller element than pivot goes left and
//higher element goes right
quickSort(arr,low,pi-1);
quickSort(arr,pi+1,high);
}
}
int main() {
int arr[]={10,7,8,9,1,5};
int n=sizeof(arr)/sizeof(arr[0]);
// Function call
quickSort(arr,0,n-1);
//Print the sorted array
cout<<"Sorted Array\n";
for(int i=0;i<n;i++)
{
cout<<arr[i]<<" ";
}
return 0;
}
// This Code is Contributed By Diwakar Jha
Java
// Java implementation of QuickSort

import java.io.*;
class GFG {
We use cookies to ensure you have the best browsing experience on our website.
// A utility functionBy using
toourswap
site, you
twoacknowledge
elements that you have read and
static void swap(int[] arr, int i, int j)
{
Skip to content
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 to left
// of pivot and all greater elements to right of pivo
static int partition(int[] arr, int low, int high)
{
// Choosing the 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 piv

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) {
Skip to content
// 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);
}
}
// To print sorted array
public static void printArr(int[] arr)
{
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
// Driver Code
public static void main(String[] args)
{
int[] arr = { 10, 7, 8, 9, 1, 5 };
int N = arr.length;
// Function call
quickSort(arr, 0, N - 1);
System.out.println("Sorted array:");
printArr(arr);
}
}
// This code is contributed by Ayush Choudhary

// Improved by Ajay Virmoti
Python3understood our Cookie Policy & Privacy Policy
# Python3 implementation
Skip toof QuickSort
content
# 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 + 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 +
# 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)
Skip to content
# Recursive call on the left of pivot

quicksort(array, low, pi - 1)
# Recursive call on the right of pivot

quicksort(array, pi + 1, high)
# Driver code
if __name__ == '__main__':
array = [10, 7, 8, 9, 1, 5]
N = len(array)
# Function call
quicksort(array, 0, N - 1)
print('Sorted array:')
for x in array:
print(x, end=" ")
# This code is contributed by Adnan Aliakbar
C#
// C# implementation of QuickSort
using System;
class GFG {
// A utility function to swap two elements

static void swap(int[] arr, int i, int j)
{
int temp = arr[i];
arr[i]
We use cookies to ensure you have the best browsing experience on our=website.
arr[j]; By using our site, you acknowledge that you have read and
understood our Cookie Policy
arr[j] & Privacy Policy
= temp;
}
Skip to content
// This function takes last element as pivot,

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

// 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 piv


i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return (i + 1);
}

// 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]

// Policy
understood our Cookie is now at right
& Privacy Policy place
int pi = partition(arr, low, high);
Skip to content
// Separately sort elements before

// and after partition index
}
}
// Driver Code
public static void Main()
{
int[] arr = { 10, 7, 8, 9, 1, 5 };
int N = arr.Length;
// Function call
Console.WriteLine("Sorted array:");
for (int i = 0; i < N; i++)
Console.Write(arr[i] + " ");
}
}
// This code is contributed by gfgking
Javascript
// Function to partition the array and return the partiti

function partition(arr, low, high) {
let pivot = arr[high];
// Index of smaller element and indicates the right p

let i = low - 1;
We use cookies to ensure you have the best browsing experience

for (leton jour=website.
low; By j using our site,
<= high - you
1;acknowledge
j++) { that you have read and
// If current element is smaller than the pivot
// Increment
Skip toindex of smaller element
content
i++;
[arr[i], arr[j]] = [arr[j], arr[i]]; // Swap
}
}
[arr[i + 1], arr[high]] = [arr[high], arr[i + 1]]; //

return i + 1; // Return the partition index
}

function quickSort(arr, low, high) {
if (low < high) {
// pi is the partitioning index, arr[pi] is now a
let pi = partition(arr, low, high);
// Separately sort elements before partition and

}
}
// Driver code
let arr = [10, 7, 8, 9, 1, 5];
let N = arr.length;
// Function call
console.log("Sorted array:");
console.log(arr.join(" "));
PHP
<?php
understood
// our
ThisCookie Policy & Privacy
Function takesPolicy
place last element as pivot
// Place the pivot as correct position
// In Sorted Array, and places all smaller to left
Skip to content
// of pivot and all greater element to its right of
function partition(&$arr,$low,$high)
{
// Choose the Pivot Element
$pivot= $arr[$high];

// The right position of pivot
$i=($low-1);
for($j=$low;$j<=$high-1;$j++)
{
if($arr[$j]<$pivot)
{
$i++;
list($arr[$i],$arr[$j])=array($arr[$j],$arr[$i]);
}
}
// Pivot element as correct position
list($arr[$i+1],$arr[$high])=array($arr[$high],$arr[$
return ($i+1);
}
// The main function that implement as QuickSort

// arr[]:- Array to be sorted
// low:- Starting Index
//high:- Ending Index
function quickSort(&$arr,$low,$high)
{
if($low<$high)
{
// pi is partition
$pi=
understood ourpartition($arr,$low,$high);
Cookie Policy & Privacy Policy
// Sort the array
// Before the partition of Element
Skip to content
quickSort($arr,$low,$pi-1);
// After the partition Element
quickSort($arr,$pi+1,$high);
}
}
// Driver Code
$arr= array(10,7,8,9,1,5);
$N=count($arr);
// Function Call
quickSort($arr,0,$N-1);
echo "Sorted Array:\n";
for($i=0;$i<$N;$i++)
{
echo $arr[$i]. " ";
}
//This code is contributed by Diwakar Jha
?>
Output
Sorted array:
1 5 7 8 9 10
Skip to content
Complexity Analysis of Quick Sort:
Time Complexity:
Best Case: Ω (N log (N))

The best-case scenario for quicksort occur when the pivot
chosen at the each step divides the array into roughly equal
halves.
In this case, the algorithm will make balanced partitions,
leading to efficient Sorting.
Average Case: θ ( N log (N))
Quicksort’s average-case performance is usually very good in
practice, making it one of the fastest sorting Algorithm.
Worst Case: O(N2)
The worst-case Scenario for Quicksort occur when the pivot at
each step consistently results in highly unbalanced partitions.
When the array is already sorted and the pivot is always
chosen as the smallest or largest element. To mitigate the
worst-case Scenario, various techniques are used such as
choosing a good pivot (e.g., median of three) and using
Randomized algorithm (Randomized Quicksort ) to shuffle the
element before sorting.
Auxiliary Space: O(1), if we don’t consider the recursive stack
space. If we consider the recursive stack space then, in the
worst case quicksort could make O(N).
Advantages of Quick Sort:

It is a divide-and-conquer algorithm that makes it easier to
solve problems. Skip to content
It is efficient on large data sets.

It has a low overhead, as it only requires a small amount of
memory to function.
Disadvantages of Quick Sort:

It has a worst-case time complexity of O(N2), which occurs
when the pivot is chosen poorly.
It is not a good choice for small data sets.
It is not a stable sort, meaning that if two elements have the
same key, their relative order will not be preserved in the
sorted output in case of quick sort, because here we are
swapping elements according to the pivot’s position (without
considering their original positions).
Feeling lost in the world of random DSA topics, wasting time

without progress? It's time for a change! Join our DSA course,
where we'll guide you on an exciting journey to master DSA
efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our
DSA course, trusted by over 100,000 geeks!
DSA in C++
DSA in Java
DSA in Python
DSA in JavaScript
Last Updated : 16 Oct, 2023 Skip to content 769

Recommended Problem
Quick Sort Solve Problem

Divide and Conquer Sorting +1 more
VMWare Amazon +11 more Submission count:

1.7L
Similar Reads
Generic Static Data
Implementation of Structure vs
QuickSort… Dynamic Data…
Application and When does the

uses of Quicksort worst case of
Quicksort occur?
QuickSort on QuickSort on
Doubly Linked List Singly Linked List
3-Way QuickSort QuickSort Tail Call

(Dutch National Optimization
Flag) (Reducing worst…
Why quicksort is C++ Program for

better than QuickSort
mergesort ?
Related Tutorials
Mathematical and Learn Data
Geometric
Structures with
Algorithms - Dat… Javascript | DSA…
Skip to content
Introduction to Introduction to Set

Max-Heap – Data – Data Structure
Structure and… and Algorithm…
Introduction to
Map – Data
Structure and…
Next
Time and Space Complexity

Analysis of Quick Sort
Article Contributed By :
GeeksforGeeks
Vote for difficulty

Current difficulty : Medium
Easy Normal Medium Hard Expert
Improved By : shikhar, Palak Jain 5, RishabhPrabhu,

lakshaygupta2807, UditChaudhary, rathbhupendra,
ays14, devi_johns, dhavaldhavalb588, code_ayush,
gfgking, adnanaliakbar99, sreenivasulureddyk19,
animeshdey, saurabhaniket2903, shreyasnaphad,
diwakarjha,
understood our Cookie kashishkumar2,
Policy & Privacy Policy harendrakumar123,
yatinpandit, navyan17xv, abgupta_18, dakshdictef,
saiyam99b1mq, Skip tomanishk4514,
content ajayvirmoti,
mridul_gfg, paras_tiwari_gfg, srije73z2

Article Tags : Adobe , Goldman Sachs , HSBC , Qualcomm ,
Quick Sort , Samsung , SAP Labs , Target Corporation ,
Divide and Conquer , DSA , Sorting
Practice Tags : Adobe, Goldman Sachs, HSBC, Qualcomm,
Samsung, SAP Labs, Target Corporation,
Divide and Conquer, Sorting
Improve Article Report Issue
Company Explore Languages DSA DSA Web

A-143, 9th Floor, Sovereign Corporate About Us Job-A-Thon Python Concepts Roadmaps Development
Tower, Sector-136, Noida, Uttar Pradesh - Hiring Data Structures DSA for HTML
201305 Legal Java
Challenge Beginners
feedback@geeksforgeeks.org Careers C++ Arrays CSS
Hack-A-Thon Basic DSA
In Media PHP Strings JavaScript
GfG Weekly Coding
Contact Us GoLang Linked List Bootstrap
Contest Problems
Advertise with SQL Algorithms ReactJS
Offline Classes DSA Roadmap
us R Language Searching AngularJS
(Delhi/NCR) by Sandeep
Placement Android Sorting Jain NodeJS
DSA in
Training Tutorial
JAVA/C++ Mathematical DSA with Express.js
Program
Master System Dynamic JavaScript Lodash
Design Programming Top 100 DSA
MasterPolicy
understood our Cookie Policy & Privacy CP Interview
Problems
Skip to content
All Cheat
Sheets
Computer Python Data DevOps Competitive System

Science Python Science & Git Programming Design
GATE CS Notes Programming ML AWS Top DSA for CP What is System
Examples Design
Operating Data Science Docker Top 50 Tree
Systems Django Tutorial With Python Problems Monolithic and
Kubernetes
Computer Python Projects Data Science Top 50 Graph Distributed SD
Azure
Network Python Tkinter For Beginner Problems Scalability in
GCP
Database OpenCV Python Machine Top 50 Array SD
Management Tutorial Learning Problems Databases in
System Python Tutorial Top 50 String SD
Software Interview Maths For Problems High Level
Engineering Question Machine Top 50 DP Design or HLD
Digital Logic Learning Problems Low Level
Design Pandas Tutorial Top 15 Design or LLD
Engineering NumPy Tutorial Websites for CP Top SD
Maths NLP Tutorial Interview
Questions
Deep Learning
Tutorial
Interview GfG School Commerce UPSC SSC/ Write & Earn

Corner CBSE Notes for Accountancy Polity Notes BANKING Write an Article
Company Wise Class 8 Business Geography SSC CGL Improve an
Preparation
We use cookies to ensure you have the best browsing experience on our website.CBSE Notes
By using our for
site, youStudies
acknowledge that you Notes
have read and Syllabus Article
Preparation for Class 9 Economics History Notes SBI PO Syllabus Pick Topics to
SDE Skip to content Write
Experienced CBSE Notes for Human Science and SBI Clerk Write Interview
Interviews Class 10 Resource Technology Syllabus Experience
Internship CBSE Notes for Management Notes IBPS PO Internships
Interviews Class 11 (HRM) Economics Syllabus
Competitive CBSE Notes for Management Notes IBPS Clerk
Programming Class 12 Income Tax Important Syllabus
Aptitude English Finance Topics in Ethics Aptitude
Preparation Grammar Statistics for UPSC Previous Questions
Economics Year Papers SSC CGL
Practice Papers
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved

QuickSort - Data Structure and Algorithm Tutorials - GeeksforGeeks

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

QuickSort - Data Structure and Algorithm Tutorials - GeeksforGeeks

Uploaded by

Copyright:

Available Formats

10/18/23, 11:54 PM QuickSort - Data Structure and Algorithm Tutorials - GeeksforGeeks

Write an Interview Experience

How Quicksort works

There are many different choices for picking pivots.

Always pick the first element as a pivot.

The logic is simple, we start from the leftmost element and

Let us understand the working of partition and the Quick Sort

Consider: arr[] = {10, 80, 30, 90, 40}.

Compare 10 with the pivot and as it is less than pivot

Partition in QuickSort: Compare pivot with 10

Compare 80 with the pivot. It is greater than pivot.

Partition in QuickSort: Compare pivot with 80

Compare 30 with pivot. It is less than pivot so arrange it

Partition in QuickSort: Compare pivot with 30

Compare 90 with the pivot. It is greater than the pivot.

Partition in QuickSort: Compare pivot with 90

Arrange the pivot in its correct position.

We use cookies to ensure you have the best browsing experience on in

As the partition process is done recursively, it keeps on putting

Follow the below images to understand how the recursive

Initial partition on the main array:

Quicksort: Performing the partition

Partitioning of the subarrays:

Code implementation of the Quick Sort:

int partition(int arr[],int low,int high)

// The Quicksort function Implement

void quickSort(int arr[],int low,int high)

// Java implementation of QuickSort

// This function takes last element as pivot,

// Index of smaller element and indicates

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

// If current element is smaller than the piv

// Increment index of smaller element

// The main function that implements QuickSort

// pi is partitioning index, arr[p]

// Separately sort elements before

// This code is contributed by Ayush Choudhary

# Function to find the partition position

# Choose the rightmost element as pivot

# Pointer for greater element

# Traverse through all elements

# If element smaller than pivot is found

# Swapping element at i with element at j

# Swap the pivot element with

# Return the position from where partition is done

# Function to perform quicksort

# Find pivot element such that

# Recursive call on the left of pivot

# Recursive call on the right of pivot

# This code is contributed by Adnan Aliakbar

// A utility function to swap two elements

// This function takes last element as pivot,

// Index of smaller element and indicates

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

// If current element is smaller than the piv

// Increment index of smaller element

// The main function that implements QuickSort

// pi is partitioning index, arr[p]

// Separately sort elements before

// This code is contributed by gfgking

// Function to partition the array and return the partiti

// Index of smaller element and indicates the right p

We use cookies to ensure you have the best browsing experience

[arr[i + 1], arr[high]] = [arr[high], arr[i + 1]]; //