Insertion Sort

11 May, 2022
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.
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.
Consider an example: arr[]: {12, 11, 13, 5, 6}
First Pass:
Initially, the first two elements of the array are compared in insertion sort.
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.
Second Pass:
 Now, move to the next two elements and compare them
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:
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
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
Both 5 and 13 are not present at their correct place so swap them
After swapping, elements 12 and 5 are not sorted, thus swap again
Here, again 11 and 5 are not sorted, hence swap again
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
Clearly, they are not sorted, thus perform swap between both
Now, 6 is smaller than 12, hence, swap again
Here, also swapping makes 11 and 6 unsorted hence, swap again
Finally, the array is completely sorted.
Illustrations:
 
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
Java
Python
C#
PHP
Javascript
// C++ program for insertion sort #include <bits/stdc++.h>using namespace std; // Function to sort an array using// insertion sortvoid 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 nvoid printArray(int arr[], int n){    int i;    for (i = 0; i < n; i++)        cout << arr[i] << " ";    cout << endl;} // Driver codeint 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 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 nvoid 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 program for implementation of Insertion Sortclass 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 program for implementation of Insertion Sort # Function to do insertion sortdef 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 abovearr = [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# program for implementation of Insertion Sortusing 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 program for insertion sort // Function to sort an array// using insertion sortfunction 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 nfunction 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.?>
<script>// Javascript program for insertion sort    // Function to sort an array using insertion sortfunction 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>
5 6 11 12 13 
Time Complexity: O(N^2) Auxiliary Space: O(1)
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. 
Insertion Sort algorithm follows incremental approach.
Yes, insertion sort is an in-place sorting algorithm.
Yes, insertion sort is a stable sorting algorithm.
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.
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.
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.
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.   
Insertion Sort | GeeksforGeeks - YouTubeGeeksforGeeks530K subscribersInsertion Sort | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 1:42•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=OGzPmgsI-pQ" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
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. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
ukasp
PIYUSHKUMAR19
PuneetChaurasia
rathbhupendra
theohollweg
mayanktyagi1709
parth_07
debugagrawal
kashishkumar2
Accenture
Cisco
Dell
Grofers
Juniper Networks
MAQ Software
Veritas
Sorting
MAQ Software
Juniper Networks
Cisco
Accenture
Dell
Veritas
Grofers
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.