Unit 4 – L11
Quick Sort
Dr Ashok Kumar Sahoo
Quicksort Algorithm
Given an array of n elements:
• If array only contains one element, return
• Else
– pick one element to use as pivot.
– Partition elements into two sub-arrays:
• Elements less than or equal to pivot
• Elements greater than pivot
– Recursively apply Quicksort on two sub-arrays
– Return results
Quicksort: Example
We are given array of n integers to sort:
40 20 10 80 60 50 7 30 100
Pick Pivot Element
There are a number of ways to pick the pivot element. In
this example, we will use the first element in the array:
40 20 10 80 60 50 7 30 100
Partitioning Array
• Given a pivot, partition the elements of the array
such that the resulting array consists of:
1. One sub-array that contains elements >= pivot
2. Another sub-array that contains elements < pivot
• The sub-arrays are stored in the original data
array.
• Partitioning loops through, swapping elements
below/above pivot.
Quicksort: Example
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
pivot_index = 0 40 20 10 80 60 50 7 30 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 60 50 7 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
5. Swap data[right] and data[pivot_index]
pivot_index = 0 40 20 10 30 7 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
right left
Quicksort: Example
1. While data[left] <= data[pivot]
++left
2. While data[right] > data[pivot]
--right
3. If left < right
swap data[left] and data[right]
4. While right> left, go to 1.
5. Swap data[right] and data[pivot_index]
pivot_index = 4 7 20 10 30 40 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
left right
Quicksort: Example
7 20 10 30 40 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
<= data[pivot] > data[pivot]
Recursion: Quicksort Sub-arrays
7 20 10 30 40 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
<= data[pivot] > data[pivot]
Quicksort Function
void quicksort(int x[], int left, int right)
{
int pos;
if(left<right)
{
pos=partition(x, left, right);
quicksort(x,left,pos-1);
quicksort(x,pos+1,right);
}
}
Quicksort ‘Partition’ Function
int partition(int x[],int left,int right){
int pivot,j,temp,i;
if(left<right){
pivot=left;
i=left;
j=right;
while(i<j){
while(x[i]<=x[pivot]&&i<right)i++;
while(x[j]>x[pivot])j--;
if(i<j){
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
}
temp=x[pivot];
x[pivot]=x[j];
x[j]=temp;
}
return j;
}
Quicksort ‘main’ Function
#include<stdio.h>
void quicksort(int x[],int,int);
int partition(int x[], int, int);
void main(){
int x[20],size,i;
printf("Enter size of the array: ");
scanf("%d",&size);
printf("Enter %d elements: ",size);
for(i=0;i<size;i++)
scanf("%d",&x[i]);
quicksort(x,0,size-1);
printf("Sorted elements: ");
for(i=0;i<size;i++)
printf(" %d",x[i]);
}
Quicksort - Complexity
T (n) T (k ) T (n k 1) n)
• For average case, we can assume that k≈n/2.
• The complexity of quick-sort now reduces to
T (n) 2T (n / 2) n)
T (n) n log n)
END
