Design and Analysis of

Algorithm

Unit 2: Analysis of Algorithms(III)

Bucket Sort, Radix Sort and Counting Sort

Compiled By
Prof. Dharmesh R. Tank
CE\IT Department, LDRP-ITR
 Bucket Sort
• Bucket sort works by partitioning the
elements into buckets and the return the
result.
• Buckets are assigned based on each element’s
search key.
• Keys are distributed uniformly in interval [0, 1)
• To return the result, concatenate each bucket
and return as a single array.
 Bucket Sort
• Some variations
– Make enough buckets so that each will only hold
one element, use a count for duplicates
– Use fewer buckets and then sort the contents of
each bucket
– Radix sort (which I’ll demonstrate next)

• The more buckets you use, the faster the

algorithm will run but it uses more memory
 Bucket Sort
• Time complexity is reduced when the number of items
per bucket is evenly distributed and as close to 1 per
bucket as possible

• Buckets require extra space, so we are trading

increased space consumption for a lower time
complexity

• In fact Bucket Sort beats all other sorting routines in

time complexity but can require a lot of space
 Bucket Sort
Multiple items per bucket:
 Example Bucket Sort
1 78 / /
0 0
2 17 12 17/ 12 17/
1 1
3 39
2 23 21 26/ 2 21 23 26/
4 26
3 39/ 3 39/
5 72 / /
4 4
6 94 / /
5 5
7 21 68/ 68/
6 6
8 12
7 72 78/ 7 72 78/
9 23 / /
8 8
10 68 94/
9 94/ 9

Step 1 distribute Step 2 sorted

Step 3 combine
 Bucket Sort Algorithm
Create an array of M buckets where M is the
maximum element value

For each item in the array to be sorted

Increment the bucket count for the item value

Return concatenation of all the bucket values

 Pseudo Code
//init the variables
buckets = new array of size m
resultArray = new array of size array.length
resultIndex = 0

//set buckets to 0
For index = 0 to buckets.length-1
buckets[index] = 0

//increment each bucket based on how many items it contains

For index = 0 to array. length– 1
buckets[array[index]]++

//create the sorted array

For index = 0 to buckets. length-1
For elementCount = 0 to buckets[index]-1
resultArray[resultIndex++] = index
 Bucket Sort Complexity
• What is the time complexity?

• What is the space complexity?

– Is the data exchanged in-place?
– Does the algorithm require auxiliary storage?
Algorithm Worst Time Average Time Best Time Worst Space
Complexity Complexity Complexity (Auxiliary)

Bucket Sort O(n) O(n) O(n) O(m)

 Radix Sort
• Improves on bucket sort by reducing the
number of buckets
• Main idea
– Break key into “digit” representation key = id, id-1,
…, i2, i1
– "digit" can be a number in any base, a character, etc
• Radix sort executes a bucket sort for each
significant digit in the data-set
– 100’s would require 3 bucket sorts
– 100000’s would require 6 bucket sorts
Sort by keys
K0, K1, …, Kr-1

Most significant key Least significant key

 Arrangement of cards after first pass of an MSD sort

Suits:  <  <  < 

Face values: 2 < 3 < 4 < … < J < Q < K < A

(1) MSD sort first, e.g., bin sort, four bins 
LSD sort second, e.g., insertion sort

(2) LSD sort first, e.g., bin sort, 13 bins

2, 3, 4, …, 10, J, Q, K, A
MSD sort, e.g., bin sort four bins  
Arrangement of cards after first pass of LSD sort
 Radix Sort
Sort: 36 9 0 25 1 49 64 16 81 4

First Buckets:

Second Buckets:
Example: Radix sort- with decimal digits
1 178 910 910 139
2 139 321 321 178
3 326 572 326 294
4
5
572
294
 294
326
 139
368
 321
326
Sorted list

6 321 178 572 368

7 910 368 178 572
8 368 139 294 910

Input list LSB 2nd MSB

order
 Radix Sort Complexity
• What is the time complexity?

• What is the space complexity?

– Is the data exchanged in-place?
– Does the algorithm require auxiliary storage?
Algorithm Worst Time Average Time Best Time Worst Space
Complexity Complexity Complexity (Auxiliary)

Radix Sort O(nk) O(nk) O(nk) O(n+k)

 Counting Sort
Main idea:

1. For each key value i, i = 1,…,k, count the number of

times the keys occurs in the unsorted input array A.
Store results in an auxiliary array, C

2. Use these counts to compute the offset. Offseti is

used to calculate the location where the record with
key value i will be stored in the sorted output list B.

The offseti value has the location where the last keyi
 Pseudo Code
for i  1 to k
do C[i ]  0; Input: A [ 1 .. n ],
for j  1 to length[ A] A[J]  {1,2, . . . , k }
do C[ A[ j ]]  C[ A[ j ]]  1;
Output: B [ 1 .. n ],
for i  2 to k
sorted
do C[i ]  C[i ]  C[i  1];
for j  length[ A] downto 1 Uses C [ 1 .. k ],
do begin auxiliary storage
B[C[ A[ j ]]]  A[ j ];
C[ A[ j ]]  C[ A[ j ]]  1;
end - for
 Counting sort k = 6, length = 8
for i  1 to k
do C[i ]  0; A : 3, 6, 4, 1, 3, 4, 1, 4
for j  1 to length[ A]
Index : 0,1, 2, 3, 4, 5, 6 Count
do C[ A[ j ]]  C[ A[ j ]]  1; C : 0, 2, 0, 2, 3, 0, 1 of the
for i  2 to k digit
Cumulative Sum
do C[i ]  C[i ]  C[i  1]; C : 0, 2, 2, 4, 7, 7, 8
for j  length[ A] downto 1
A : 3, 6, 4, 1, 3, 4, 1, 4̂
do begin
B[C[ A[ j ]]]  A[ j ]; B: , , , , , , , ,
C[ A[ j ]]  C[ A[ j ]]  1; Index : 0,1, 2, 3, 4, 5, 6

end - for C : 0, 2, 2, 4, 6, 7, 8
Step 1
 Explanation of Counting sort

Þ B[C[A[j]]]=A[j]
Þ B[C[A[8]]]=A[8] A : 3, 6, 4, 1, 3, 4, 1, 4̂
Þ B[C[4]]=A[8]
B : , , , , , , 4,
Þ B[7]=A[8]=4
Index : 0,1, 2, 3, 4, 5, 6
C : 0, 2, 2, 4, 6, 7, 8
And

Þ C[A[j]]=C[A[j]]-1
Þ C[A[8]]=C[A[8]]-1
Þ C[4]=C[4]-1
Þ C[4]=7-1=6
 Example Counting sort
A : 3, 6, 4, 1, 3, 4, 1̂, 4 A : 3, 6, 4, 1, 3, 4̂, 1, 4

B : , 1, , , , , 4, B : , 1, , , , 4, 4,
Index : 0,1, 2, 3, 4, 5, 6
C : 0, 2, 2, 4, 6, 7, 8 C : 0, 1, 2, 4, 5, 7, 8
Step 2 Step 4

A : 3, 6, 4, 1, 3̂, 4, 1, 4 A : 3, 6, 4, 1̂, 3, 4, 1, 4

B : , 1, , 3, , 4, 4, B : 1, 1, , 3, , 4, 4,

C : 0, 1, 2, 3, 6, 7, 8 C : 0, 2, 3, 5, 7, 8
Step 3 Step 5
 Example Counting sort
A : 3, 6, 4̂, 1, 3, 4, 1, 4 A : 3, 6̂, 4, 1, 3, 4, 1, 4

B : 1, 1, , 3, 4, 4, 4, B : 1, 1, , 3, 4, 4, 4, 6

C : 0, 2, 3, 4, 7, 8 C : 0, 2, 3, 4, 7, 7

A : 3̂, 6, 4, 1, 3, 4, 1, 4

B : 1, 1, 3, 3, 4, 4, 4, 6

https://www.geeksforgeeks.org/counting-sort/
C : 0, 2, 2, 4, 7, 7
Example 2 for Counting sort
Example 2 for Counting sort
Example 2 for Counting sort
Example 2 for Counting sort
Example 2 for Counting sort
Example 2 for Counting sort
Example 2 for Counting sort
 Counting sort (Running Time)
for i  1 to k O(k )
do C[i ]  0;
for j  1 to length[ A] O(n)
do C[ A[ j ]]  C[ A[ j ]]  1;
for i  2 to k O(k )
do C[i ]  C[i ]  C[i  1];
for j  length[ A] downto 1 O(n)
do begin
B[C[ A[ j ]]]  A[ j ]; Worst, Average and Best
Case Time Complexity
C[ A[ j ]]  C[ A[ j ]]  1; O(n  k )
end - for
 Counting Sort Complexity
• What is the time complexity?

• What is the space complexity?

– Is the data exchanged in-place?
– Does the algorithm require auxiliary storage?
Algorithm Worst Time Average Time Best Time Worst Space
Complexity Complexity Complexity (Auxiliary)

Counting Sort O(n+k) O(n+k) O(n+k) O(k)

 Exercise
1. Sort the letters of word “EDUCATION” in
alphabetical order using Insertion Sort.
2. Sort the following data 50, 40, 20, 60, 80,
100, 45, 70, 105, 30, 90, 75 using Radix Sort.
3. Sort the following data 6, 0, 2, 0, 1, 3, 4, 6, 1,
3, 2 using Counting Sort.