VISHWAKARMA INSTITUTE OF TECHNOLOGY

DEPARTMENT OF COMPUTER ENGINEERING

Data Structures

TOPIC Analysis of Insertion Sort, Bucket Sort and

Radix Sort for Best, Worst and Average Case

Pprfgfevppesented by
PRESENTED BY 
Group 14

GUIDED BY 
 CONTENT
 Insertion Sort
• Introduction
• Algorithm
• Pseudocode
• Analysis of Insertion sort
 Bucket Sort
• Introduction
• Algorithm
• Pseudocode
• Analysis of Insertion sort
 Radix Sort
• Introduction
• Algorithm
• Pseudocode
• Analysis of Insertion sort
 Comparison
 INSERTION SORT - INTRODUCTION

Insertion sort is a simple sorting algorithm that works

similar to the way you sort playing cards in your hands.
The array is virtually split into a sorted and an unsorted
part. Values from the unsorted part are picked and placed
at the correct position in the sorted part.
 INSERTION SORT - ALGORITHM

To sort an array of size n in ascending order:

1: Iterate from arr[1] to arr[n] over the array. 

2: Compare the current element (key) to its predecessor. 
3: If the key element is smaller than its predecessor,
compare it to the elements before. Move the greater
elements one position up to make space for the
swapped element.
INSERTION SORT – PSEUDOCODE

for i = 0 to n
key = A[i]
j=i–1
while j >= 0 and A[j] > key
A[j + 1] = A[j]
j=j–1
end while
A[j + 1] = key
end for
 INSERTION SORT - ANALYSIS

 Worst Case :

When the array is reversely sorted (in descending order),

Therefore,

Time Complexity = 2 + 4 + 6 + … + 2(n-1)

= 2n(n-1) / 2

Worst Case = O(n2)

 INSERTION SORT - ANALYSIS

 Average Case :

Time Complexity = O(n2)

 Best Case :

When the array is already sorted (in ascending order), i.e. no movements/swapping.

Therefore,

Time Complexity = O(n)

 BUCKET SORT - INTRODUCTION

Bucket Sort is a sorting algorithm in which the elements of the array

are distributed into several buckets. One bucket is capable of holding
more than one element simultaneously. Each bucket is then sorted
individually, using some other sorting algorithm, or by recursively
applying the same bucket sorting algorithm.

Finally, when each bucket has been sorted, they are then combined to
form the final and complete sorted array.

Bucket Sort is a stable sorting algorithm.

 BUCKET SORT - WORKING

define function bucketSort(arr[])

step 1: create n empty buckets (lists) //here n is the length of the input array

step 2: store the array elements into the buckets based on their values (described in step 3)

step 3: for i from 0 to n do

(a) bucket_index = int((n * arr[i]) / 10)
(b) store the element arr[i] at bucket[bucket_index]
 BUCKET SORT - WORKING

step 4: for i from 0 to length of bucket do:

(a) sort the elements stored inside bucket[i], using recursion or by some other sorting method

step 5: push the values stored in each bucket starting from lowest index to highest index to a new array/list

step 6: return the sorted array/list

BUCKET SORT - PSEUDOCODE
bucketSort(arr)
for i=0 to n
buckets.append([])
end for
for i in arr
bucket_index = int((n * arr[i]) / 10)
store the element arr[i] at buckets[bucket_index]
end for
for i=0 to number of buckets
sort individual bucket
end for
k=0
for i=0 to n
for j=0 to number of buckets
arr[k] = buckets[i][j]
k++
end for
end for
return arr
 BUCKET SORT - ANALYSIS

 Worst Case :

When there are elements of close range in the array, they are likely to be placed
in the same bucket. This may result in some buckets having more number of
elements than others.

It makes the complexity depend on the sorting algorithm used to sort the
elements of the bucket.

The complexity becomes even worse when the elements are in reverse order. If
insertion sort is used to sort elements of the bucket, then the

Time complexity = O(n2)

 BUCKET SORT - ANALYSIS

 Average Case :

It occurs when the elements are distributed randomly in the array. Even if the
elements are not distributed uniformly, bucket sort runs in linear time. It holds
true until the sum of the squares of the bucket sizes is linear in the total number
of elements.

Time complexity = O(n)

 BUCKET SORT - ANALYSIS

 Best Case :

It occurs when the elements are uniformly distributed in the buckets with a
nearly equal number of elements in each bucket.

The complexity becomes even better if the elements inside the buckets are
already sorted.

If insertion sort is used to sort elements of a bucket then the overall complexity
in the best case will be linear ie. O(n+k).

O(n) is the complexity for making the buckets and O(k) is the complexity for
sorting the elements of the bucket using algorithms having linear time
complexity at the best case.
 RADIX SORT - INTRODUCTION

Radix sort is a sorting technique that sorts the elements

digit to digit based on radix. It works on integer numbers.
To sort the elements of the string type, we can use their
hash value.

This sorting algorithm makes no comparison.

 RADIX SORT - ALGORITHM

define function radixSort(arr, n)

Step 1 : find the maximum number from the array

Step 2 : Iterate over all the digits of the number

Step 3 : Call the function countingSort(arr, n, i)

Step 4 : countingSort will sort the array from least

significant digit to most significant digit
RADIX SORT - PSEUDOCODE

radixSort(arr, n)

mx = arr[0]
for i = 1 to n-1
if mx < arr[i]
mx = arr[i]
i=1
q = mx/i
while q > 0
countingSort(arr, n, i)
i = i * 10
q = mx/i
 RADIX SORT - PSEUDOCODE

countingSort(arr, n, div)

let cnt[0...b] and tempArray[0...n] be new arrays

for i=0 to 9
cnt[i] = 0
for i=0 to n-1
cnt[(arr[i] / div) % 10] = cnt[(arr[i] / div) % 10] + 1
for i=1 to 9
cnt[i] = cnt[i-1] + cnt[i]
for i=n-1 down to 0
tempArray[cnt[(arr[i] / div) %10]] = arr[i]
cnt[(arr[i] / div) %10] = cnt[(arr[i] / div) %10] – 1
for i=0 to n-1
arr[i] = tempArray[i]
 RADIX SORT - ANALYSIS

 Worst Case :

The worst case in radix sort occurs when all elements have the same number of digits
except one element which has significantly large number of digits. If the number of
digits in the largest element is equal to n, then the runtime becomes O(n 2). The worst
case running time of Counting sort is O(n+b). If b=O(n), then the worst case running
time is O(n). Here, the counting Sort function is called for d times, where
d = logb(mx) + 1

Total worst case complexity of radix sort is O(logb(mx)(n+b))

 RADIX SORT - ANALYSIS

 Average Case :

Time complexity = O(D*(n+b))

 Best Case :

The best case occurs when all elements have the same number of digits. The
best case time complexity is O(d(n+b)). If b = O(n), then

Time complexity = O(nd)

 COMPARISON

Sorting Techniques Time Complexity

Best Case Average Case Worst Case

Insertion Sort O(n) O(n2) O(n2)
Bucket Sort O(n+k) O(n) O(n2)
Radix Sort O(nd) O(D*(n+b)) O(logb(mx)(n+b))
 REFERENCES

• https://iq.opengenus.org/insertion-sort-analysis/
• https://iq.opengenus.org/time-and-space-complexity-of-bucket-sort/
• https://iq.opengenus.org/time-and-space-complexity-of-radix-sort/
THANK
YOU