# C Program For Insertion Sort

**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.

__Characteristics of Insertion Sort:__

__Characteristics of Insertion Sort:__

- This algorithm is one of the simplest algorithm with simple implementation
- Basically, Insertion sort is efficient for small data values
- Insertion sort is adaptive in nature, i.e. it is appropriate for data sets which are already partially sorted.

__Working of Insertion Sort algorithm:__

Consider an example: arr[]: {12, 11, 13, 5, 6}

12 11 13 5 6

First Pass:

- Initially, the first two elements of the array are compared in insertion sort.

121113 5 6

- Here, 12 is greater than 11 hence they are not in the ascending order and 12 is not at its correct position. Thus, swap 11 and 12.
- So, for now 11 is stored in a sorted sub-array.

111213 5 6

Second Pass:

- Now, move to the next two elements and compare them

11 12135 6

- Here, 13 is greater than 12, thus both elements seems to be in ascending order, hence, no swapping will occur. 12 also stored in a sorted sub-array along with 11

Third Pass:

- Now, two elements are present in the sorted sub-array which are
11and12- Moving forward to the next two elements which are 13 and 5

11 12 1356

- Both 5 and 13 are not present at their correct place so swap them

11 12 5136

- After swapping, elements 12 and 5 are not sorted, thus swap again

11 51213 6

- Here, again 11 and 5 are not sorted, hence swap again

51112 13 6

- here, it is at its correct position

Fourth Pass:

- Now, the elements which are present in the sorted sub-array are
5, 11and12- Moving to the next two elements 13 and 6

5 11 12 136

- Clearly, they are not sorted, thus perform swap between both

5 11 12 613

- Now, 6 is smaller than 12, hence, swap again

5 11 61213

- Here, also swapping makes 11 and 6 unsorted hence, swap again

5 61112 13

- Finally, the array is completely sorted.

Illustrations:

__Insertion Sort Algorithm__

__Insertion Sort Algorithm__

To sort an array of size N in ascending order:

- Iterate from arr[1] to arr[N] over the array.
- Compare the current element (key) to its predecessor.
- 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.

Below is the implementation:

## C

`// C program for insertion sort` `#include <math.h>` `#include <stdio.h>` ` ` `/* Function to sort an array ` ` ` `using insertion sort*/` `void` `insertionSort(` `int` `arr[], ` `int` `n)` `{` ` ` `int` `i, key, j;` ` ` `for` `(i = 1; i < n; i++) ` ` ` `{` ` ` `key = arr[i];` ` ` `j = i - 1;` ` ` ` ` `/* Move elements of arr[0..i-1], ` ` ` `that are greater than key, ` ` ` `to one position ahead of ` ` ` `their current position */` ` ` `while` `(j >= 0 && arr[j] > key) ` ` ` `{` ` ` `arr[j + 1] = arr[j];` ` ` `j = j - 1;` ` ` `}` ` ` `arr[j + 1] = key;` ` ` `}` `}` ` ` `// A utility function to print ` `// an array of size n` `void` `printArray(` `int` `arr[], ` `int` `n)` `{` ` ` `int` `i;` ` ` `for` `(i = 0; i < n; i++)` ` ` `printf` `(` `"%d "` `, arr[i]);` ` ` `printf` `(` `"\n"` `);` `}` ` ` `// Driver code` `int` `main()` `{` ` ` `int` `arr[] = {12, 11, 13, 5, 6};` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` ` ` `insertionSort(arr, n);` ` ` `printArray(arr, n);` ` ` ` ` `return` `0;` `}` |

**Output:**

5 6 11 12 13

**Time Complexity:** O(N^2) **Auxiliary Space: **O(1)

**What are the Boundary Cases of Insertion Sort algorithm?**

Insertion sort takes maximum time to sort if elements are sorted in reverse order. And it takes minimum time (Order of n) when elements are already sorted.

**What are the Algorithmic Paradigm of Insertion Sort algorithm?**

Insertion Sort algorithm follows incremental approach.

**Is Insertion Sort an in-place sorting algorithm?**

Yes, insertion sort is an in-place sorting algorithm.

**Is Insertion Sort a stable algorithm?**

Yes, insertion sort is a stable sorting algorithm.

**When is the Insertion Sort algorithm used?**

Insertion sort is used when number of elements is small. It can also be useful when input array is almost sorted, only few elements are misplaced in complete big array.

**What is Binary Insertion Sort?**

We can use binary search to reduce the number of comparisons in normal insertion sort. Binary Insertion Sort uses binary search to find the proper location to insert the selected item at each iteration. In normal insertion, sorting takes O(i) (at ith iteration) in worst case. We can reduce it to O(logi) by using binary search. The algorithm, as a whole, still has a running worst case running time of O(n^2) because of the series of swaps required for each insertion. Refer this for implementation.

**How to implement Insertion Sort for Linked List?**

Below is simple insertion sort algorithm for linked list.

- Create an empty sorted (or result) list
- Traverse the given list, do following for every node.

- Insert current node in sorted way in sorted or result list.
- Change head of given linked list to head of sorted (or result) list.

Please refer complete article on Insertion Sort for more details!