# Binary Insertion Sort

• Difficulty Level : Easy
• Last Updated : 20 Jun, 2022

Binary insertion sort is a sorting algorithm which is similar to the insertion sort, but instead of using linear search to find the location where an element should be inserted, we use binary search. Thus, we reduce the comparative value of inserting a single element from O (N) to O (log N).

It is a flexible algorithm, which means it works faster when the same given members are already heavily sorted, i.e., the current location of the feature is closer to its actual location in the sorted list.

It is a stable filtering algorithm – elements with the same values ​​appear in the same sequence in the last order as they were in the first list.

### Applications of Binary Insertion sort:

• Binary insertion sort works best when the array has a lower number of items.
• When doing quick sort or merge sort, when the subarray size becomes smaller (say <= 25 elements), it is best to use a binary insertion sort.
• This algorithm also works when the cost of comparisons between keys is high enough. For example, if we want to filter multiple strings, the comparison performance of two strings will be higher.

### How Does Binary insertion sort Work?

• In the binary insertion sort mode, we divide the same members into two subarrays – filtered and unfiltered. The first element of the same members is in the organized subarray, and all other elements are unplanned.
• Then we iterate from the second element to the last. In the repetition of the i-th, we make the current object our “key”. This key is a feature that we should add to our existing list below.
• In order to do this, we first use a binary search on the sorted subarray below to find the location of an element larger than our key. Let’s call this position “pos.” We then right shift all the elements from pos to 1 and created Array[pos] = key.
• We can note that in every i-th multiplication, the left part of the array till (i – 1) is already sorted.

### Approach to implement Binary Insertion sort:

• Iterate the array from the second element to the last element.
• Store the current element A[i] in a variable key.
• Find the position of the element just greater than A[i] in the subarray from A to A[i-1] using binary search. Say this element is at index pos.
• Shift all the elements from index pos to i-1 towards the right.
• A[pos] = key. Below is the implementation for the above approach:

## C++

 `// C program for implementation of``// binary insertion sort``#include ``using` `namespace` `std;`` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int` `binarySearch(``int` `a[], ``int` `item,``                ``int` `low, ``int` `high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int` `mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void` `insertionSort(``int` `a[], ``int` `n)``{``    ``int` `i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``cout <<``"Sorted array: \n"``;``    ``for` `(i = 0; i < n; i++)``        ``cout <<``" "``<< a[i];`` ` `    ``return` `0;``}`` ` `// this code is contribution by shivanisinghss2110`

## C

 `// C program for implementation of ``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted ``// in a[low..high]``int` `binarySearch(``int` `a[], ``int` `item, ``                 ``int` `low, ``int` `high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ? ``                ``(low + 1) : low;`` ` `    ``int` `mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item, ``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low, ``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void` `insertionSort(``int` `a[], ``int` `n)``{``    ``int` `i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i) ``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc) ``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf``(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf``(``"%d "``, a[i]);`` ` `    ``return` `0;``}`

## Java

 `// Java Program implementing``// binary insertion sort`` ` `import` `java.util.Arrays;``class` `GFG ``{``   ` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``final` `int``[] arr = { ``37``, ``23``, ``0``,   ``17``, ``12``, ``72``,``                            ``31``, ``46``, ``100``, ``88``, ``54` `};`` ` `        ``new` `GFG().sort(arr);`` ` `        ``for` `(``int` `i = ``0``; i < arr.length; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}`` ` `    ``// Driver Code``    ``public` `void` `sort(``int` `array[])``    ``{``        ``for` `(``int` `i = ``1``; i < array.length; i++) ``        ``{``            ``int` `x = array[i];`` ` `            ``// Find location to insert``            ``// using binary search``            ``int` `j = Math.abs(``                ``Arrays.binarySearch(array, ``0``, ``                                    ``i, x) + ``1``);`` ` `            ``// Shifting array to one``            ``// location right``            ``System.arraycopy(array, j,``                             ``array, j + ``1``, i - j);`` ` `            ``// Placing element at its ``            ``// correct location``            ``array[j] = x;``        ``}``    ``}``}`` ` `// Code contributed by Mohit Gupta_OMG`

## Python3

 `# Python Program implementation``# of binary insertion sort`` ` ` ` `def` `binary_search(arr, val, start, end):``     ` `    ``# we need to distinugish whether we ``    ``# should insert before or after the ``    ``# left boundary. imagine  is the last ``    ``# step of the binary search and we need ``    ``# to decide where to insert -1``    ``if` `start ``=``=` `end:``        ``if` `arr[start] > val:``            ``return` `start``        ``else``:``            ``return` `start``+``1`` ` `    ``# this occurs if we are moving ``    ``# beyond left's boundary meaning ``    ``# the left boundary is the least ``    ``# position to find a number greater than val``    ``if` `start > end:``        ``return` `start`` ` `    ``mid ``=` `(start``+``end)``/``/``2``    ``if` `arr[mid] < val:``        ``return` `binary_search(arr, val, mid``+``1``, end)``    ``elif` `arr[mid] > val:``        ``return` `binary_search(arr, val, start, mid``-``1``)``    ``else``:``        ``return` `mid`` ` ` ` `def` `insertion_sort(arr):``    ``for` `i ``in` `range``(``1``, ``len``(arr)):``        ``val ``=` `arr[i]``        ``j ``=` `binary_search(arr, val, ``0``, i``-``1``)``        ``arr ``=` `arr[:j] ``+` `[val] ``+` `arr[j:i] ``+` `arr[i``+``1``:]``    ``return` `arr`` ` ` ` `print``(``"Sorted array:"``)``print``(insertion_sort([``37``, ``23``, ``0``, ``31``, ``22``, ``17``, ``12``, ``72``, ``31``, ``46``, ``100``, ``88``, ``54``]))`` ` `# Code contributed by Mohit Gupta_OMG`

## C#

 `// C# Program implementing``// binary insertion sort``using` `System;`` ` `class` `GFG {`` ` `    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 37, 23, 0,   17, 12, 72,``                      ``31, 46, 100, 88, 54 };`` ` `        ``sort(arr);`` ` `        ``for` `(``int` `i = 0; i < arr.Length; i++)``            ``Console.Write(arr[i] + ``" "``);``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `sort(``int``[] array)``    ``{``        ``for` `(``int` `i = 1; i < array.Length; i++)``        ``{``            ``int` `x = array[i];`` ` `            ``// Find location to insert using``            ``// binary search``            ``int` `j = Math.Abs(``                ``Array.BinarySearch(array, ``                                   ``0, i, x) + 1);`` ` `            ``// Shifting array to one location right``            ``System.Array.Copy(array, j, ``                              ``array, j + 1,``                              ``i - j);`` ` `            ``// Placing element at its correct``            ``// location``            ``array[j] = x;``        ``}``    ``}``}`` ` `// This code is contributed by nitin mittal.`

## PHP

 ` ``\$a``[``\$low``]) ? ``                       ``(``\$low` `+ 1) : ``\$low``; `` ` `    ``\$mid` `= (int)((``\$low` `+ ``\$high``) / 2); `` ` `    ``if``(``\$item` `== ``\$a``[``\$mid``]) ``        ``return` `\$mid` `+ 1; `` ` `    ``if``(``\$item` `> ``\$a``[``\$mid``]) ``        ``return` `binarySearch(``\$a``, ``\$item``, ``                            ``\$mid` `+ 1, ``\$high``); ``         ` `    ``return` `binarySearch(``\$a``, ``\$item``, ``\$low``, ``                            ``\$mid` `- 1); ``} `` ` `// Function to sort an array a of size 'n' ``function` `insertionSort(&``\$a``, ``\$n``) ``{ ``    ``\$i``; ``\$loc``; ``\$j``; ``\$k``; ``\$selected``; `` ` `    ``for` `(``\$i` `= 1; ``\$i` `< ``\$n``; ++``\$i``) ``    ``{ ``        ``\$j` `= ``\$i` `- 1; ``        ``\$selected` `= ``\$a``[``\$i``]; `` ` `        ``// find location where selected ``        ``// item should be inserted ``        ``\$loc` `= binarySearch(``\$a``, ``\$selected``, 0, ``\$j``); `` ` `        ``// Move all elements after location ``        ``// to create space ``        ``while` `(``\$j` `>= ``\$loc``) ``        ``{ ``            ``\$a``[``\$j` `+ 1] = ``\$a``[``\$j``]; ``            ``\$j``--; ``        ``} ``        ``\$a``[``\$j` `+ 1] = ``\$selected``; ``    ``} ``} `` ` `// Driver Code``\$a` `= ``array``(37, 23, 0, 17, 12, 72, ``           ``31, 46, 100, 88, 54); ``            ` `\$n` `= sizeof(``\$a``); `` ` `insertionSort(``\$a``, ``\$n``); `` ` `echo` `"Sorted array:\n"``; ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ``    ``echo` `"\$a[\$i] "``; `` ` `// This code is contributed by ``// Adesh Singh``?>`

## Javascript

 ```// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i]);`` ` `    ``r``// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i]);`` ` `    ``// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i]);`` ` `// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i]);``// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i]);``// C program for implementation of``// binary insertion sort``#include `` ` `// A binary search based function``// to find the position``// where item should be inserted``// in a[low..high]``int binarySearch(int a[], int item,``                ``int low, int high)``{``    ``if` `(high <= low)``        ``return` `(item > a[low]) ?``                ``(low + 1) : low;`` ` `    ``int mid = (low + high) / 2;`` ` `    ``if` `(item == a[mid])``        ``return` `mid + 1;`` ` `    ``if` `(item > a[mid])``        ``return` `binarySearch(a, item,``                            ``mid + 1, high);``    ``return` `binarySearch(a, item, low,``                        ``mid - 1);``}`` ` `// Function to sort an array a[] of size 'n'``void insertionSort(int a[], int n)``{``    ``int i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i)``    ``{``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc)``        ``{``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int main()``{``    ``int a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int n = sizeof(a) / sizeof(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf(``"%d "``, a[i])`

Output

```Sorted array:
0 12 17 23 31 37 46 54 72 88 100```

Time Complexity: The algorithm as a whole still has a running worst-case running time of O(n2) because of the series of swaps required for each insertion.

Another approach: Following is an iterative implementation of the above recursive code

## C++

 `#include ``using` `namespace` `std;`` ` `// iterative implementation``int` `binarySearch(``int` `a[], ``int` `item, ``int` `low, ``int` `high)``{``    ``while` `(low <= high) {``        ``int` `mid = low + (high - low) / 2;``        ``if` `(item == a[mid])``            ``return` `mid + 1;``        ``else` `if` `(item > a[mid])``            ``low = mid + 1;``        ``else``            ``high = mid - 1;``    ``}`` ` `    ``return` `low;``}`` ` `// Function to sort an array a[] of size 'n'``void` `insertionSort(``int` `a[], ``int` `n)``{``    ``int` `i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i) {``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc) {``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``cout <<``"Sorted array: \n"``;``    ``for` `(i = 0; i < n; i++)``        ``cout <<``" "``<< a[i];`` ` `    ``return` `0;``}`` ` `// This code is contributed by shivanisinghss2110.`

## C

 `#include `` ` `// iterative implementation``int` `binarySearch(``int` `a[], ``int` `item, ``int` `low, ``int` `high)``{``    ``while` `(low <= high) {``        ``int` `mid = low + (high - low) / 2;``        ``if` `(item == a[mid])``            ``return` `mid + 1;``        ``else` `if` `(item > a[mid])``            ``low = mid + 1;``        ``else``            ``high = mid - 1;``    ``}`` ` `    ``return` `low;``}`` ` `// Function to sort an array a[] of size 'n'``void` `insertionSort(``int` `a[], ``int` `n)``{``    ``int` `i, loc, j, k, selected;`` ` `    ``for` `(i = 1; i < n; ++i) {``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc) {``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `a[]``        ``= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a), i;`` ` `    ``insertionSort(a, n);`` ` `    ``printf``(``"Sorted array: \n"``);``    ``for` `(i = 0; i < n; i++)``        ``printf``(``"%d "``, a[i]);`` ` `    ``return` `0;``}``// contributed by tmeid`

## Java

 `import` `java.io.*;`` ` `class` `GFG {`` ` `// iterative implementation``static` `int` `binarySearch(``int` `a[], ``int` `item, ``int` `low, ``int` `high)``{``    ``while` `(low <= high) {``        ``int` `mid = low + (high - low) / ``2``;``        ``if` `(item == a[mid])``            ``return` `mid + ``1``;``        ``else` `if` `(item > a[mid])``            ``low = mid + ``1``;``        ``else``            ``high = mid - ``1``;``    ``}`` ` `    ``return` `low;``}`` ` `// Function to sort an array a[] of size 'n'``static` `void` `insertionSort(``int` `a[], ``int` `n)``{``    ``int` `i, loc, j, k, selected;`` ` `    ``for` `(i = ``1``; i < n; ++i) {``        ``j = i - ``1``;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, ``0``, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc) {``            ``a[j + ``1``] = a[j];``            ``j--;``        ``}``        ``a[j + ``1``] = selected;``    ``}``}`` ` `// Driver Code``public` `static` `void` `main (String[] args) ``{``    ``int` `a[]``        ``= { ``37``, ``23``, ``0``, ``17``, ``12``, ``72``, ``31``, ``46``, ``100``, ``88``, ``54` `};``    ``int` `n = a.length, i;`` ` `    ``insertionSort(a, n);`` ` `    ``System.out.println(``"Sorted array:"``);``    ``for` `(i = ``0``; i < n; i++)``        ``System.out.print(a[i] +``" "``);`` ` `}``}`` ` `// This code is contributed by shivanisinghss2110.`

## Python3

 `# iterative implementation``def` `binarySearch(a, item, low, high):``    ``while` `(low <``=` `high):``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``        ``if` `(item ``=``=` `a[mid]):``            ``return` `mid ``+` `1``        ``elif` `(item > a[mid]):``            ``low ``=` `mid ``+` `1``        ``else``:``            ``high ``=` `mid ``-` `1``    ``return` `low``     ` `# Function to sort an array a[] of size 'n'``def` `insertionSort(a, n):``    ``for` `i ``in` `range` `(n): ``        ``j ``=` `i ``-` `1``        ``selected ``=` `a[i]``         ` `        ``# find location where selected should be inseretd``        ``loc ``=` `binarySearch(a, selected, ``0``, j)``         ` `        ``# Move all elements after location to create space``        ``while` `(j >``=` `loc):``            ``a[j ``+` `1``] ``=` `a[j]``            ``j``-``=``1``        ``a[j ``+` `1``] ``=` `selected`` ` `# Driver Code``a ``=` `[``37``, ``23``, ``0``, ``17``, ``12``, ``72``, ``31``, ``46``, ``100``, ``88``, ``54``]``n ``=` `len``(a)``insertionSort(a, n)``print``(``"Sorted array: "``)``for` `i ``in` `range` `(n):``    ``print``(a[i], end``=``" "``)`` ` `# This code is contributed by shivanisinghss2110`

## C#

 `using` `System;`` ` `class` `GFG {`` ` `// iterative implementation``static` `int` `binarySearch(``int` `[]a, ``int` `item, ``int` `low, ``int` `high)``{``    ``while` `(low <= high) {``        ``int` `mid = low + (high - low) / 2;``        ``if` `(item == a[mid])``            ``return` `mid + 1;``        ``else` `if` `(item > a[mid])``            ``low = mid + 1;``        ``else``            ``high = mid - 1;``    ``}`` ` `    ``return` `low;``}`` ` `// Function to sort an array a[] of size 'n'``static` `void` `insertionSort(``int` `[]a, ``int` `n)``{``    ``int` `i, loc, j, selected;`` ` `    ``for` `(i = 1; i < n; ++i) {``        ``j = i - 1;``        ``selected = a[i];`` ` `        ``// find location where selected should be inseretd``        ``loc = binarySearch(a, selected, 0, j);`` ` `        ``// Move all elements after location to create space``        ``while` `(j >= loc) {``            ``a[j + 1] = a[j];``            ``j--;``        ``}``        ``a[j + 1] = selected;``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main (String[] args) ``{``    ``int` `[]a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };``    ``int` `n = a.Length, i;`` ` `    ``insertionSort(a, n);`` ` `    ``Console.WriteLine(``"Sorted array:"``);``    ``for` `(i = 0; i < n; i++)``        ``Console.Write(a[i] +``" "``);`` ` `}``}`` ` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

```Sorted array:
0 12 17 23 31 37 46 54 72 88 100```