Insertion Sorting

By Group 3
 What is Sorting?
• Sorting is the operation of arranging data in an ordered sequence,
ascending or descending.
• For example, you can sort a list of words alphabetically or by length. Or
sort statistical data from the smallest to the largest number.
 What is sorting by Insertion?
• Insertion sorting is a sorting mechanism where the sorted array is built
having one item at a time. It sorts the array by shifting elements one by
one.
• During insertion sort, the relative order of elements is not changed making
it a stable sorting algorithm.
• Insertion sorting works in a similar manner as we arrange a deck of cards.
 How Insertion sort is done
• We start by dividing the array in a sorted section and an unsorted section.
We put the first element as the only element in the sorted section, and the
rest of the array is the unsorted section.
• The first element in the unsorted section is the next element to be put into
the correct position.
• We copy the element to be placed into another variable so it doesn’t get
overwritten.
 How Insertion sort is done (Cont)
• If the previous position is more than the item being placed, copy the value
into the next position.
• If the item in the sorted section is less than the item to place, the item to
place goes after it in the array.
• If there are no more items in the sorted section to compare with, the item
to be placed must go at the front.
Example of an array sorted by Insertion
 How to sort in ascending order in C
#include<stdio.h> /*insertion sorting*/ /*display the sorted list*/
int main() for(i=1; i<=n-1; i++) printf("the sorted array
{ { is:");
int a[100], n, i, j, elm; for(j=i; j>0&& a[j-1]> a[j]; j--) for(i=0; i<n; i++)
printf("how many elements of /*for ascending order sorting*/ {
the array:"); { printf("%d \t", a[i]);
scanf("%d", &n); elm=a[j]; }
printf("Enter the elements of the a[j]=a[j-1]; return 0;
array:\n"); a[j-1]=elm; }
for(i=0; i<n; i++) }
{ }
scanf("%d", &a[i]);
}
 How to sort in descending order in C
#include<stdio.h> /*insertion sorting*/ /*display sorted list/array*/
int main() for(i=1; i<=n-1; i++) printf("the sorted array is:");
{ { for(i=0; i<n; i++)
int a[100], n, i, j, elm; for(j=0; j<=i&& a[j+1]< a[j]; j+ {
printf("how many elements +) printf("%d \t", a[i]);
of the array:"); /* for descending order sorting*/ }
scanf("%d", &n); { return 0;
printf("Enter the elements of elm=a[j];
the array:\n"); a[j]=a[j-1];
for(i=0; i<n; i++) a[j-1]=elm;
{ }
scanf("%d", &a[i]); }
}
 Insertion sort using functions
#include<stdio.h> for(i=0; i<size; i++)
#include<conio.h>  {
void insertion(int [ ], int );     printf("Enter %d element : ",i+1);
int main( )     scanf("%d",&arr[i]);
{  }
 int arr[30];  insertion(arr,size);
 int i,size;  printf("\n\t------- Insertion sorted elements using
 printf("\n\t------- Insertion sorting using function function -------\n\n");
-------\n\n"); for(i=0; i<size; i++)
 printf("Enter total no. of elements : ");     printf(" %d",arr[i]);
 scanf("%d",&size);  getch( );
 return 0;
}
 Insertion sort using functions (Cont)
void insertion(int arr[ ], int size)       tmp=arr[j];
{       arr[j]=arr[j+1];
 int i,j,tmp;       arr[j+1]=tmp;
 for(i=0; i<size; i++)   }
 {     else
   for(j=i-1; j>=0; j--)        break;
   {    }
    if(arr[j]>arr[j+1])  }
  { }
 Best times to use Insertion sort
• When number of elements is small.
• When you want a quick easy implementation because it is not hard to
code.
• When data sets are mostly sorted already, e.g., 1,2,4,6,3,2 .
 Advantages of Insertion sorting
• It can be easily computed.
• Best case complexity is of O(N) while the array is already sorted.
• Number of swaps reduced than bubble sort.
• For smaller values of N, insertion sort performs efficiently.
• Stable sort.
• Adaptive: total number of steps is reduced for partially sorted array.
• In-Place sort.
 Disadvantages of Insertion sorting
• It is less efficient on list containing more number of elements.
• As the elements increase, the program performance becomes slower.
• Insertion sort needs a large number of element shifts.
 Comparison with Bubble and Selection
sorting
Insertion Bubble Selection

Efficiency More than Selection

Complexity Most complex

Speed Faster than Bubble

Number of swap Least

Time complexity
 Insertion sort Time and Space
Complexity
• Time Complexity:  is a function describing the amount of time an algorithm takes
in terms of the amount of input to the algorithm.
• Best Case Sorted array as input, [ O(N) ]. And O(1) swaps.
• Worst Case: Reversely sorted, and when inner loop makes maximum comparison,
[ O(N2) ] . And O(N2) swaps.
• Average Case: [ O(N2) ] . And O(N2) swaps.
• Space Complexity: is a function describing the amount of memory (space) an
algorithm takes in terms of the amount of input to the algorithm
• [ auxiliary, O(1) ]. In-Place sort.
Time and Space Complexity between the
Sorting Algorithms
Sorting Algorithm Time Complexity Space Complexity

Best Case Average Case Worst Case Worst Case

Bubble sort O(N) O(N2) O(N2) O(1)

Selection sort O(N2) O(N2) O(N2) O(1)

Insertion sort O(N) O(N2) O(N2) O(1)

 Time and Space Complexity between the
Sorting Algorithms (Cont)
• Within almost sorted data, Bubble Sort and Insertion Sort require very few
swaps. However, Selection Sort requires the same amount of searching
process even within almost sorted data.
• The Space Complexity are all the same. That is because we are not using
much of the space with these algorithms.
• Conclusion: Insertion sort isn't a particularly efficient algorithm but it
is easy to understand and relatively straightforward to write up. However,
Insertion Sort is considered better than Bubble sort.
Any Questions?