Insertion Sort – Data Structure and Algorithm Tutorials

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:

• 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, 5 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:

Pseudo Code of Insertion Sort

procedure insertionSort(arr):
    for i = 1 to n-1
        key = arr[i]
        j = i-1
        while j >= 0 and arr[j] > key
            swap arr[j+1] with arr[j]
            j = j - 1
        end while
    end for
end function

This algorithm sorts an array of items by repeatedly taking an element from the unsorted portion of the array and inserting it into its correct position in the sorted portion of the array.

1. The procedure takes a single argument, ‘A’, which is a list of sortable items.
2. The variable ‘n’ is assigned the length of the array A.
3. The outer for loop starts at index ‘1’ and runs for ‘n-1’ iterations, where ‘n’ is the length of the array.
4. The inner while loop starts at the current index i of the outer for loop and compares each element to its left neighbor. If an element is smaller than its left neighbor, the elements are swapped.
5. The inner while loop continues to move an element to the left as long as it is smaller than the element to its left.
6. Once the inner while loop is finished, the element at the current index is in its correct position in the sorted portion of the array.
7. The outer for loop continues iterating through the array until all elements are in their correct positions and the array is fully sorted.

Insertion Sort Algorithm – Iterative Approach

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 <bits/stdc++.h>
using namespace std;

// 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++)
        cout << arr[i] << " ";
    cout << endl;
}

// 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;
}
// This is code is contributed by rathbhupendra

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 program to test insertion sort */
int main()
{
    int arr[] = { 12, 11, 13, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);
    printArray(arr, n);

    return 0;
}

Java

// Java program for implementation of Insertion Sort
public class InsertionSort {
    /*Function to sort array using insertion sort*/
    void sort(int arr[])
    {
        int n = arr.length;
        for (int i = 1; i < n; ++i) {
            int key = arr[i];
            int 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 array of size n*/
    static void printArray(int arr[])
    {
        int n = arr.length;
        for (int i = 0; i < n; ++i)
            System.out.print(arr[i] + " ");

        System.out.println();
    }

    // Driver method
    public static void main(String args[])
    {
        int arr[] = { 12, 11, 13, 5, 6 };

        InsertionSort ob = new InsertionSort();
        ob.sort(arr);

        printArray(arr);
    }
};


/* This code is contributed by Rajat Mishra. */

Python

# Python program for implementation of Insertion Sort

# Function to do insertion sort
def insertionSort(arr):

    # Traverse through 1 to len(arr)
    for i in range(1, len(arr)):

        key = arr[i]

        # Move elements of arr[0..i-1], that are
        # greater than key, to one position ahead
        # of their current position
        j = i-1
        while j >= 0 and key < arr[j] :
                arr[j + 1] = arr[j]
                j -= 1
        arr[j + 1] = key


# Driver code to test above
arr = [12, 11, 13, 5, 6]
insertionSort(arr)
for i in range(len(arr)):
    print ("% d" % arr[i])

# This code is contributed by Mohit Kumra

C#

// C# program for implementation of Insertion Sort
using System;

class InsertionSort {

    // Function to sort array
    // using insertion sort
    void sort(int[] arr)
    {
        int n = arr.Length;
        for (int i = 1; i < n; ++i) {
            int key = arr[i];
            int 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
    // array of size n
    static void printArray(int[] arr)
    {
        int n = arr.Length;
        for (int i = 0; i < n; ++i)
            Console.Write(arr[i] + " ");

        Console.Write("\n");
    }

    // Driver Code
    public static void Main()
    {
        int[] arr = { 12, 11, 13, 5, 6 };
        InsertionSort ob = new InsertionSort();
        ob.sort(arr);
        printArray(arr);
    }
}

// This code is contributed by ChitraNayal.

PHP

<?php
// PHP program for insertion sort

// Function to sort an array
// using insertion sort
function insertionSort(&$arr, $n)
{
    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
function printArray(&$arr, $n)
{
    for ($i = 0; $i < $n; $i++)
        echo $arr[$i]." ";
    echo "\n";
}

// Driver Code
$arr = array(12, 11, 13, 5, 6);
$n = sizeof($arr);
insertionSort($arr, $n);
printArray($arr, $n);

// This code is contributed by ChitraNayal.
?>

Javascript

<script>
// Javascript program for insertion sort

// Function to sort an array using insertion sort
function insertionSort(arr, n)
{
    let 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
function printArray(arr, n)
{
    let i;
    for (i = 0; i < n; i++)
        document.write(arr[i] + " ");
    document.write("<br>");
}

// Driver code
    let arr = [12, 11, 13, 5, 6 ];
    let n = arr.length;

    insertionSort(arr, n);
    printArray(arr, n);

// This code is contributed by Mayank Tyagi

</script>

Output

5 6 11 12 13 

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

Insertion sort algorithm – Recursive Approach

1. Starting from the second element, traverse through the input array from left to right.
2. For each element, compare it with the elements in the sorted subarray to its left, starting from the rightmost element.
3. If an element in the sorted subarray is greater than the current element, shift that element one position to the right.
4. Repeat step 3 until you find an element that is less than or equal to the current element.
5. Insert the current element into the position immediately to the right of the element found in step 4.
6. Repeat steps 2-5 for all remaining elements in the unsorted subarray.

C++

#include <iostream>
#include <vector>

using namespace std;

void recursiveInsertionSort(vector<int>& arr, int n)
{
    // Base case: if the array has only one element, it is already sorted
    if (n <= 1) {
        return;
    }

    // Sort the first n-1 elements of the array recursively
    recursiveInsertionSort(arr, n - 1);

    // Insert the nth element into its correct position in the sorted subarray
    int last = arr[n - 1];
    int j = n - 2;

    // Shift elements to the right to make space for the nth element
    while (j >= 0 && arr[j] > last)
    {
        arr[j + 1] = arr[j];
        j--;
    }

    // Place the nth element in its correct position
    arr[j + 1] = last;
}

void printArray(vector<int>& arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main()
{
    vector<int> arr = {12, 11, 13, 5, 6};
    int n = arr.size();

    recursiveInsertionSort(arr, n);
    printArray(arr, n);

    return 0;
}

Java

// Java program to implement the above approach
import java.util.*;

public class Main {
    public static void
    recursiveInsertionSort(ArrayList<Integer> arr, int n)
    {
        // Base case: if the array has only one element, it
        // is already sorted
        if (n <= 1) {
            return;
        }

        // Sort the first n-1 elements of the array
        // recursively
        recursiveInsertionSort(arr, n - 1);

        // Insert the nth element into its correct position
        // in the sorted subarray
        int last = arr.get(n - 1);
        int j = n - 2;

        // Shift elements to the right to make space for the
        // nth element
        while (j >= 0 && arr.get(j) > last) {
            arr.set(j + 1, arr.get(j));
            j--;
        }

        // Place the nth element in its correct position
        arr.set(j + 1, last);
    }

    public static void printArray(ArrayList<Integer> arr,
                                  int n)
    {
        for (int i = 0; i < n; i++) {
            System.out.print(arr.get(i) + " ");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        ArrayList<Integer> arr = new ArrayList<Integer>(
            Arrays.asList(12, 11, 13, 5, 6));
        int n = arr.size();

        recursiveInsertionSort(arr, n);
        printArray(arr, n);
    }
}

// Contributed by adityasha4x71

Python3

from typing import List

def recursiveInsertionSort(arr: List[int], n: int) -> None:
    # Base case: if the array has only one element, it is already sorted
    if n <= 1:
        return

    # Sort the first n-1 elements of the array recursively
    recursiveInsertionSort(arr, n - 1)

    # Insert the nth element into its correct position in the sorted subarray
    last = arr[n - 1]
    j = n - 2

    # Shift elements to the right to make space for the nth element
    while j >= 0 and arr[j] > last:
        arr[j + 1] = arr[j]
        j -= 1

    # Place the nth element in its correct position
    arr[j + 1] = last

def printArray(arr: List[int], n: int) -> None:
    for i in range(n):
        print(arr[i], end=" ")
    print()

arr = [12, 11, 13, 5, 6]
n = len(arr)

recursiveInsertionSort(arr, n)
printArray(arr, n)

Javascript

// Recursive function to perform insertion sort on subarray arr[0..n-1]
function recursiveInsertionSort(arr, n) {
    // Base case: if the array has only one element, it is already sorted
    if (n <= 1) {
        return;
    }

    // Sort the first n-1 elements of the array recursively
    recursiveInsertionSort(arr, n - 1);

    // Insert the nth element into its correct position in the sorted subarray
    let last = arr[n - 1];
    let j = n - 2;

    // Shift elements to the right to make space for the nth element
    while (j >= 0 && arr[j] > last) {
        arr[j + 1] = arr[j];
        j--;
    }

    // Place the nth element in its correct position
    arr[j + 1] = last;
}

// Function to print the array in one line
function printArray(arr, n) {
    let output = "";
    for (let i = 0; i < n; i++) {
        output += arr[i] + " ";
    }
    console.log(output);
}

// Driver code
let arr = [12, 11, 13, 5, 6];
let n = arr.length;

// Sort the array using recursive insertion sort
recursiveInsertionSort(arr, n);

// Print the sorted array
printArray(arr, n);

C#

// Recursive C# program for insertion sort
using System;

class GFG
{

    // Recursive function to sort
    // an array using insertion sort
    static void Recursive_inserrtion_sort(int []a,
                                    int n)
    {
        // Base case
        if (n <= 1)
            return;

        // Sort first n-1 elements
        Recursive_inserrtion_sort(a, n - 1);

        // Insert last element at
        // its correct position
        // in sorted array.
        int last = a[n - 1];
        int j = n - 2;

        /* Move elements of arr[0..i-1],
        that are greater than key, to
        one position ahead of their
        current position */
        while (j >= 0 && a[j] > last)
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = last;
    }

    //Driver Code
    static void Main()
    {
        int[] arr = {12, 11, 13, 5, 6};

        Recursive_inserrtion_sort(arr, arr.Length);

        for(int i = 0; i < arr.Length; i++)
        {
            Console.Write(arr[i] + " ");
        }
    }
}

// This code is contributed by aeroabrar_31

Output

5 6 11 12 13 

Complexity Analysis of Insertion Sort:

Time Complexity of Insertion Sort

• The worst case time complexity of Insertion sort is O(N^2)
• The average case time complexity of Insertion sort is O(N^2)
• The time complexity of the best case is O(N).

Space Complexity of Insertion Sort

The auxiliary space complexity of Insertion Sort’s Recursive Approach is O(n) due to the recursion stack.

FAQs related to Insertion Sort

What are the Boundary Cases of the 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. 

Refer this for implementation.

Snapshots: Quiz on Insertion Sort

Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz
Selection Sort, Bubble Sort, Insertion Sort, Merge Sort, Heap Sort, QuickSort, Radix Sort, Counting Sort, Bucket Sort, ShellSort, Comb Sort

Coding practice for sorting.