C Program For Insertion Sort

Insertion sort is an algorithm used to sort a collection of elements in ascending or descending order. The basic idea behind the algorithm is to divide the list into two parts: a sorted part and an unsorted part.

Initially, the sorted part contains only the first element of the list, while the rest of the list is in the unsorted part. The algorithm then iterates through each element in the unsorted part, picking one at a time, and inserts it into its correct position in the sorted part.

To do this, the algorithm compares the current element with each element in the sorted part, starting from the rightmost element. It continues to move to the left until it finds an element that is smaller (if sorting in ascending order) or larger (if sorting in descending order) than the current element.

Once the correct position has been found, the algorithm shifts all the elements to the right of that position to make room for the current element, and then inserts the current element into its correct position.

This process continues until all the elements in the unsorted part have been inserted into their correct positions in the sorted part, resulting in a fully sorted list.

One of the advantages of insertion sort is that it is an in-place sorting algorithm, which means that it does not require any additional storage space other than the original list. Additionally, it has a time complexity of O(n^2), which makes it suitable for small datasets, but not for large ones.

Overall, insertion sort is a simple, yet effective sorting algorithm that can be used for small datasets or as a part of more complex algorithms.

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.

12

11

13

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.

11

12

13

5

6

Second Pass:

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

11

12

13

5

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 11 and 12
• Moving forward to the next two elements which are 13 and 5

11

12

13

5

6

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

11

12

5

13

6

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

11

5

12

13

6

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

5

11

12

13

6

• here, it is at its correct position

Fourth Pass:

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

5

11

12

13

6

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

5

11

12

6

13

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

5

11

6

12

13

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

5

6

11

12

13

• Finally, the array is completely sorted.

Illustrations:

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?

The boundary cases of an algorithm refer to the input scenarios that are either the best-case or the worst-case for that algorithm.

For insertion sort, the best-case scenario occurs when the input array is already sorted, while the worst-case scenario occurs when the input array is sorted in reverse order.

•  Best-case scenario: When the input array is already sorted, each element in the unsorted part will be compared to the last element in the sorted part and will not need to shift any elements to the right. This means that the algorithm will only require one pass through the array, resulting in a time complexity of O(n), where n is the number of elements in the array.
•  Worst-case scenario: When the input array is sorted in reverse order, each element in the unsorted part will need to be compared to all the elements in the sorted part and will require shifting all the elements to the right. This means that the algorithm will require n^2 operations to sort the array, resulting in a time complexity of O(n^2).

Therefore, the performance of the insertion sort algorithm is highly dependent on the input scenario, and it is important to consider the boundary cases when evaluating the efficiency of the algorithm.

What are the Algorithmic Paradigm of Insertion Sort algorithm?

The algorithmic paradigm of an algorithm refers to the approach or methodology used to design and analyze the algorithm. The insertion sort algorithm uses the following algorithmic paradigms:

1.  Iterative: The insertion sort algorithm uses a loop to iterate through the array and insert each element into its correct position in the sorted part of the array.
2.  Divide and Conquer: The insertion sort algorithm divides the input array into two parts: a sorted part and an unsorted part. It then picks an element from the unsorted part and inserts it into the sorted part. This process is repeated until all the elements are in the sorted part.
3.  In-place: The insertion sort algorithm sorts the array in-place, meaning it does not require any additional storage space other than the original array.
4.  Stable: The insertion sort algorithm is a stable sorting algorithm, meaning it maintains the relative order of equal elements in the sorted output.

By using these algorithmic paradigms, the insertion sort algorithm is able to efficiently sort small to moderate sized arrays. However, it may not be the best choice for larger datasets due to its O(n^2) time complexity.

Is Insertion Sort an in-place sorting algorithm?

Yes, Insertion Sort is an in-place sorting algorithm, which means it sorts the elements of an array in the same memory space without using any extra space. The only additional space used is a few variables that store the current element being inserted and the position where the element should be inserted.

This is one of the main advantages of the insertion sort algorithm since it does not require any additional memory or data structures, making it suitable for sorting data on embedded systems or in situations where memory usage is a concern.

However, it is important to note that the time complexity of insertion sort is still O(n^2), which means that it may not be the best choice for large datasets. Other algorithms such as merge sort or quicksort have better time complexity for larger datasets, but they require additional memory space for their operations.

Is Insertion Sort a stable algorithm?

Yes, Insertion Sort is a stable sorting algorithm. A sorting algorithm is said to be stable if it maintains the relative order of equal elements in the sorted output as they appeared in the original input. In the case of Insertion Sort, when two elements have the same value, the algorithm always chooses the one that appears earlier in the input array first. This means that the relative order of equal elements is preserved throughout the sorting process, resulting in a stable output. The stability of Insertion Sort makes it useful in situations where preserving the order of equal elements is important, such as sorting a list of students by their grades, where it is important to maintain the order of students with the same grades.

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.