C Program for Binary Insertion Sort
Last Updated :
23 Jul, 2025
Improve
We can use binary search to reduce the number of comparisons in normal insertion sort. Binary Insertion Sort find use binary search to find the proper location to insert the selected item at each iteration.
In normal insertion, sort it takes O(i) (at ith iteration) in worst case. we can reduce it to O(logi) by using binary search.
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[0] 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 program for implementation of
// binary insertion sort
#include <stdio.h>
// 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 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
int main()
{
int a[]
= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };
int n = sizeof(a) / sizeof(a[0]), i;
insertionSort(a, n);
printf("Sorted array: \n");
for (i = 0; i < n; i++)
printf("%d ", a[i]);
return 0;
}
// C program for implementation of// binary insertion sort// 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 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 Codeint main(){ int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = sizeof(a) / sizeof(a[0]), i; insertionSort(a, n); printf("Sorted array: \n"); for (i = 0; i < n; i++) printf("%d ", a[i]); return 0;}Output
Sorted array: 0 12 17 23 31 37 46 54 72 88 100
Time Complexity: O(n2)
Auxiliary space: O(1)
Iterative Approach:
Below is the implementation for the above approach:
#include <stdio.h>
// 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 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
int main()
{
int a[]
= { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };
int n = sizeof(a) / sizeof(a[0]), i;
insertionSort(a, n);
printf("Sorted array: \n");
for (i = 0; i < n; i++)
printf("%d ", a[i]);
return 0;
}
// contributed by tmeid
// iterative implementationint 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 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 Codeint main(){ int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = sizeof(a) / sizeof(a[0]), i; insertionSort(a, n); printf("Sorted array: \n"); for (i = 0; i < n; i++) printf("%d ", a[i]); return 0;}// contributed by tmeidOutput
Sorted array: 0 12 17 23 31 37 46 54 72 88 100
Time Complexity: O(n*log n)
Auxiliary space: O(n)
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
Please refer complete article on Binary Insertion Sort for more details!
