Insertion Sort

By,
Abhilash Ravichandran 14U201
Sai Kumar 14U244
Aravind Samy 14U208
Saravana Kumar 15U437
Amalashok 14U206
Madhan 14U224
Presentation Overview
• Introduction
• Example 1
• Animation
• Best, Worst and Average cases
• Visualisation
• Algorithm
• Advantages
• Day to Day Application
Presentation Overview contd…
• Relation to other sorting methods
• Example 2
• Stability and Performance analysis
• C Programming for Insertion Sort
• Example 3
• Example 4
• Conclusion
• Reference
Introduction
• It is a simple sorting algorithm which sorts the array by shifting
elements one by one.

•  It always maintains a sorted sublist in the lower positions of the list.

• Each new item is then “inserted” back into the previous sublist such
that the sorted sublist is one item larger.
Example 1
• The process by which the numbers are sorted is shown below:
• 3 7 4 9 5 2 6 1
• 3 7 4 9 5 2 6 1
• 3 7 4 9 5 2 6 1
• 3 4 7 9 5 2 6 1
• 3 4 7 9 5 2 6 1
• 3 4 5 7 9 2 6 1
• 2 3 4 5 7 9 6 1
• 2 3 4 5 6 7 9 1
• 1 2 3 4 5 6 7 9
• The underlined number is checked with the previous number and the
bold numbers are the ones that have been swapped.
Animation
• Animation showing insertion sort of 30 elements,
Best, Worst and Average cases
• Best Case
• The best case input is an array that is already sorted. The order is O(n).
• During each iteration, the first remaining element of the input is only
compared with the right-most element of the sorted subsection of the array.
• 1,2,3,4,5,6,7

• Worst Case
• The numbers are sorted in reverse order. Each element has to be checked by
all the numbers on its left-hand side. The order becomes O(n^2).
• 9,8,7,6,5,4,3
Best, Worst and Average cases
contd…
• Average cases
• The order for average cases is also quadratic therefore it is impractical to use
it to sort large array of numbers.
• It is still one of the fastest sorting methods for short array of numbers.
Visualisation
• There are two parts to the sort
• Sorted portion and
• Unsorted portion
• Initially the first element is included the sorted portion.
• Each element, from left to right, is checked and put in the sorted
portion.

• Note : The sorted portion must always remain in a sorted manner

each time while appending an element from the unsorted portion.
Algorithm
for i = 2 to length(A) // First element is initially in
the sorted section
x = A[i] ; // Inserting A[i] into the sorted
section
j = i – 1 ;
while (j > 0 and A[j] > x) // Checking if inserting
element is lower than the
adjacent element
A[j+1] = A[j] ; // Swapping the elements
j = j - 1 ;
A[j+1] = x ;
end while
end for
Advantages
• Simple implementation
• Efficient for small data sets and in practice compared to other
quadratic algorithms such as bubble or selection sort.
• Stable : Doesn’t change the relative order of the elements
• Online : Can sort an array as it receives it.
Day to Day Application
• People manually sort cards in a bridge hand whose method is similar
to the insertion method.
• Assuming the deck of cards to be unsorted section.
• As each card is picked, it is placed in the hand.
• Hand is similar to the sorted section and as each card is picked, it is
compared with other cards and it is placed accordingly.
Relation to other sorting methods
• Some divide and conquer algorithms such as quick sort and merge
sorts are used when the array to be sorted is very big.

• These methods make these large arrays into small sublists on which
insertion sort can be used, where insertion sort outperforms these
complex sorts.

• When writing to memory, selection sort is used over insertion sort.

Example 2
• Let L = [16,36,4,22,100,1,54] be an unsorted array.
• Let 16 be part of the sorted array and the rest of the numbers be part
of the unsorted array.
1. 16,36,4,22,100,1,54
2. 4,16,36,22,100,1,54
3. 4,16,22,36,100,1,54
4. 4,16,22,36,100,1,54
5. 1,4,16,22,36,100,54
6. 1,4,16,22,36,54,100
Stability and Performance analysis
• Insertion sort is a stable sort.
• It is evident from the algorithm that the insertion of the Key at its
appropriate position in the sorted sublist affects the position index of
the elements in the sublist, as long as the elements in the sorted
sublist are greater than the Key.
• When the elements are less than or equal to the Key, K, there is no
displacement of elements and this contributes to retaining the
original order of Keys which are equal in the sorted sublist.
C Programming for Insertion Sort
C Programming for Insertion Sort
Contd...
Example - 3
Consider X= 5,-10,1,50,-100 and using insertion sort align X in
ascending order.
• First Pass = -10 5 1 50 -100
• Second Pass = -10 1 5 50 -100
• Third Pass = -10 1 5 50 -100
• Fourth Pass = -100 -10 1 5 50
• Fifth Pass = -100 -10 1 5 50
Example 4
• Consider the list L={3¹,1,2¹,3²,3³,2²} where the repeated keys have been superscripted
with numbers indicative of their relative orders of occurrence. The keys for insertion.
• The passes of the insertion sort are below
Pass 1 (Insert 1) {[3¹] 1,2¹,3²,3³,2²}
After Pass 1 {[1 3¹] 2¹,3²,3³,2²}
Pass 2 (Insert 2) {[1 3¹ ] 2¹,3²,3³,2²}
After Pass 2 {[1 2¹ 3¹] 3²,3³,2²}
Pass 3 (Insert 3) {[1 2¹ 3¹ ] 3²,3³,2²}
After Pass 3 {[1 2¹ 3¹ 3²] 3³,2²}
Pass 4 (Insert 4) {[1 2¹ 3¹ 3²] 3³,2²}
After Pass 4 {[1 2¹ 3¹ 3² 3³] 2²}
Pass 5 (Insert 5) {[1 2¹ 3¹ 3² 3³] 2²}
After Pass 5 {[1 2¹ 2² 3¹ 3² 3³]}
• 1+2+3+…(n-1) = ͌ ͌ O(n²)

• Worst case performance of insertion sort – elements are sorted in

descending order.

• Best case complexity of insertion sort –

elements are sorted in ascending order and the complexity is given by

O(n)

• Average case performance of insertion sort –

• O(n²) complexity
Conclusion
Insertion is a very efficient algorithm for sorting small arrays.
 Insertion sort is very similar to selection sort, since after the kth
iteration, the first k elements in the array are in sorted order.
Insertion sort's advantage is that it only scans as many elements as
it needs in order to place the k + 1st element, while selection sort must
scan all remaining elements to find the k + 1st element.
Even while sorting large arrays, if they are split into small sublists it
can even outperform complex algorithms such as merge sort or quick
sort.
References
• Dr G A Vijayalakshmi Pai, “Data Structures and Algorithms”, Tata
McGraw Hill Publishing, 2008.
• A Chitra and P T Rajan, “Data Structures”, Vijay Nicole Imprints, 2008.
• Stackoverflow.com
• Theoryapp.com